Spring学习(一)---依赖注入和控制反转
本文内容纲要：
- Spring- 使用Spring管理Bean
- 配置Bean
- Spring容器
- Spring核心机制：依赖注入
- 设值注入
- 构造注入
Spring
Spring是一个从实际开发中抽出来的框架，因此它完成了大量开发中的通用步骤，留给开发者的仅仅是与特定应用相关的部分，从而大大提高了企业应用的开发效率。
Spring为企业应用的开发提供了一个轻量级的解决方案。该解决方案包括：基于依赖注入的核心机制、基于AOP的声明事务管理、与多种持久层技术的整合，以及优秀的Web MVC框架等。
使用Spring管理Bean
Spring核心容器就是一个超级大工厂，所有的对象（包括数据源、Hibernate SessionFactory等基础性资源）都会被当成Spring核心容器管理的对象--Spring把容器中的一切对象统称为Bean。
Spring容器中的Bean，与Java Bean不同（Java Bean必须遵守一些特定的规范），Spring对Bean没有任何要求。只要是一个Java类，Spring就可以管理该Java类，并将它当成Bean处理。
配置Bean
<bean id=”对象名” class=”全限定类名”> <property name=”属性名” ref=”被依赖的Bean的对象名” />
</bean>
Spring配置Bean时，class属性的值必须是Bean实现类的完整类名，不能是接口，不能是抽象类，否则Spring无法使用反射创建该类的实例。
**<property …/>**子元素用于作为<bean …/>元素的子元素，它驱动Spring在底层以反射执行一次setter方法。name属性决定执行哪个setter方法，而value或ref决定执行setter方法的传入参数。如果传入的参数是基本类型或者其包装类、String等类型。则使用value属性指定传入参数。如果以容器中其他Bean作为传入参数，则使用ref属性指定传入参数。
**<bean …/>**元素的作用是：默认驱动Spring在底层调用无参构造函数创建对象。
Spring框架只要看到<property …/>子元素，Spring框架就会在底层以反射方式执行一次setter方法。何时执行这个setter方法呢？
该Bean一旦创建处理，Spring会立即根据<property …/>子元素来执行setter方法。
通过Spring容器中访问容器中的Bean，ApplicationContext是Spring容器中最常用的接口。该接口有两个实现类：
ClassPathXmlApplicationContext：从类加载路径下搜索配置文件，并根据配置文件来创建Spring容器。
FileSystemXmlApplicationContext：从文件系统的相对路径或绝地路径下去搜索配置文件，并根据配置文件来创建Spring容器。
//创建Spring容器ApplicationContextctx = new ClassPathXmlApplicationContext(“配置文件名”);
Spring容器获取Bean对象主要有如下两个方法：
Object getBean(String id)：根据容器中Bean的id来获取指定的Bean，获取Bean之后需要进行强制类型转换。
T getBean(String name,Class
Spring框架最大的改变之一是程序不再使用new调用构造器创建Java对象，所有Java对象都由Spring容器负责创建。
Spring容器
Spring有两个核心接口:BeanFactory和ApplicationContext，其中ApplicationContext是BeanFactory的子接口。他们都可代表Spring容器，Spring容器是生成Bean实例的工厂，并管理容器中的Bean。
** Spring容器创建对象的时机**
** **默认为启动时创建Bean实例，为Bean配置一个bean，只创建一个对象，在底层使用了单例模式。
使用bean元素的属性 **lazy-init = “true”**延迟加载（懒加载），lazy-init 和scope = “singleton” 结合使用。
Bean配置一个bean元素，每次创建一个新的对象，而不是使用时一个对象时，需要为bean元素配置 scope = "prototype"
prototype：每次通过容器的getBean()方法获取prototype作用域的Bean时，都将产生一个新的Bean实例。
Spring核心机制：依赖注入
** 依赖注入**：简单的来说，A对象要调用B对象中的方法，也就可以说A依赖于B。
Spring框架的核心功能有两个：
①Spring容器作为超级大工厂，负责创建、管理所有的Java对象（Bean）
②Spring容器管理容器中Bean之间的依赖关系，Spring使用一种“依赖注入”的方式来管理Bean之间的依赖关系。
依赖注入是一种优秀的解耦方式。依赖注入让Spring的Bean以配置文件组织在一起，而不是以硬编码的方式耦合在一起。使用Spring框架，调用者获取被依赖对象的方式由原来的主动获取，变成了被动接受，被称为控制反转。
从Spring容器的角度来看，Spring容器负责将被依赖对象赋值给调用者的成员变量，相当于为调用者注入它依赖的实例，被称为依赖注入。
控制反转和依赖注入其实是同一个行为的两种表达方式，只是描述的角度不同而已。
举一个通俗易懂的例子
一个人（Java实例，调用者）需要斧头（Java实例，被依赖对象）来干活。
在原始社会，需要斧头的人（调用者）只能自己去磨一把斧头（被依赖对象）。对应的情形为：Java程序里的调用者自己创建被依赖对象，通常采用new关键字调用构造器创建一个被依赖对象。
进入工业社会，工厂出现了，斧头不再由普通人完成，而在工厂里被生成出来，此时需要斧头的人（调用者）找到工厂，购买斧头，无须关心斧头的制造过程。对应简单的工厂设计模式，调用者只需定位工厂，无须理会被依赖对象的具体实现过程。
进入共产主义社会，需要斧头的人甚至无须定义工厂，“坐等”社会提供即可。调用者无须关心被依赖对象的实现，无须理会工厂，等待Spring依赖注入。
依赖注入通常有两种
设值注入：IoC容器使用成员变量的setter方法来注入被依赖对象。
构造注入：IoC容器使用构造器来注入被依赖对象。
设值注入
这种注入方式简单，直观，在Spring的依赖注入中大量使用。
下面的例子集成了设值注入的各种情形，如为基本类型，数组，引用数组，List，Set，Map，和Properties属性注值。
public class Student { //标志属性
private int id;
//学生编号
private String stuNo;
//学生姓名
private String stuName;
//学生爱好
private String[] hobbys;
//喜欢的演员
private Actor[] actors;
//上过的学校
private List<String> schools;
//爱听的歌
private Set<String> songs;
//代课的老师
private List<Teacher> techers;
//选的课程
private Set<Course> course;
//联系方式
private Map<String,String> links;
//课程成绩
private Map<Course,String> scores;
//健康状况
private Properties health;
//省略了setter和getter方法
}
public class Actor {
private int id;
private String actName;
//省略了setter和getter方法
}
public class Teacher {
private int id;
private String teaNo;
private String teaName;
//省略了setter和getter方法
}
public class Course {
private int id;
private String courNo;
private String courName;
//省略了setter和getter方法
}
在application.xml配置文件中的配置
<?xml version="1.0" encoding="UTF-8"?><beans xmlns="http://www.springframework.org/schema/beans"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xsi:schemaLocation="http://www.springframework.org/schema/beans
http://www.springframework.org/schema/beans/spring-beans.xsd">
<!-- 创建teacher对象，并注入值-->
<bean id="teacher1" class="com.ghq.model.entity.Teacher">
<property name="id" value="1"/>
<property name="teaNo" value="t001"/>
<property name="teaName" value="杨教授"/>
</bean>
<bean id="teacher2" class="com.ghq.model.entity.Teacher">
<property name="id" value="2"/>
<property name="teaNo" value="t002"/>
<property name="teaName" value="李教授"/>
</bean>
<!-- 创建course对象，并注入值-->
<bean id="course1" class="com.ghq.model.entity.Course">
<property name="id" value="1"/>
<property name="courNo" value="c001"/>
<property name="courName" value="数据结构"/>
</bean>
<bean id="course2" class="com.ghq.model.entity.Course">
<property name="id" value="2"/>
<property name="courNo" value="c002"/>
<property name="courName" value="计算机网络"/>
</bean>
<!-- 创建actor对象，并注入值-->
<bean id="actor1" class="com.ghq.model.entity.Actor" >
<property name="id" value="1"/>
<property name="actName" value="薛之谦"/>
</bean>
<bean id="actor2" class="com.ghq.model.entity.Actor" >
<property name="id" value="2"/>
<property name="actName" value="周杰伦"/>
</bean>
<!-- 创建student对象，并注入值-->
<bean id="student" class="com.ghq.model.entity.Student">
<!-- 基本类型，String等赋值-->
<property name="id" value="1"/>
<property name="stuNo" value="s001"/>
<property name="stuName" value="张三"/>
<!-- 基本类型数组赋值-->
<property name="hobbys">
<array>
<value>睡觉</value>
<value>打游戏</value>
</array>
</property>
<!-- 引用类型数组赋值-->
<property name="actors">
<array>
<ref bean="actor1"/>
<ref bean="actor2"/>
</array>
</property>
<!-- list集合（基本类型）赋值-->
<property name="schools">
<list>
<value>清华大学</value>
<value>北京大学</value>
</list>
</property>
<!-- set集合（基本类型）赋值-->
<property name="songs">
<set>
<value>小苹果</value>
<value>我们不一样</value>
</set>
</property>
<!-- list集合（引用类型）赋值-->
<property name="techers">
<list>
<ref bean="teacher1"/>
<ref bean="teacher2"/>
</list>
</property>
<!-- set集合（引用类型）赋值-->
<property name="course">
<set>
<ref bean="course1"/>
<ref bean="course2"/>
</set>
</property>
<!-- map集合（基本类型）赋值-->
<property name="links">
<map>
<entry key="phone" value="1234567890"></entry>
<entry key="QQ" value="987654"></entry>
</map>
</property>
<!-- map集合（引用类型）赋值-->
<property name="scores">
<map>
<entry key-ref="course1" value="88"></entry>
<entry key-ref="course2" value="77"></entry>
</map>
</property>
<!-- Properties类型赋值-->
<property name="health">
<props>
<prop key="height">170</prop>
<prop key="weight">130</prop>
</props>
</property>
</bean>
</beans>
测试输出结果为
public class Test { public static void main(String[] args) {
ApplicationContext fac = new ClassPathXmlApplicationContext("application.xml");
Student stu = fac.getBean("student", Student.class);
System.out.println(stu.toString());
}
}
Student，Actor，Course，Teacher中均有toString方法，将属性一次性输出
运行结果为：
Student [id=1, stuNo=s001, stuName=张三, hobbys=[睡觉, 打游戏], actors=[Actor [id=1, actName=薛之谦], Actor [id=2, actName=周杰伦]], schools=[清华大学, 北京大学], songs=[小苹果, 我们不一样], techers=[Teacher [id=1, teaNo=t001, teaName=杨教授], Teacher [id=2, teaNo=t002, teaName=李教授]], course=[Course [id=1, courNo=c001, courName=数据结构], Course [id=2, courNo=c002, courName=计算机网络]], links={phone=1234567890, QQ=987654}, scores={Course [id=1, courNo=c001, courName=数据结构]=88, Course [id=2, courNo=c002, courName=计算机网络]=77}, health={height=170, weight=130}]构造注入
这种方式在构造实例时，已经为其完成了依赖关系的初始化。这种利用构造器来设置依赖关系的方式，称为构造注入。
通俗来讲就是通过Spring在底层以反射方式执行带指定参数的构造器，当执行带参数的构造器时，就可利用构造参数对成员变量执行初始化。
使用构造注入，在类中不用提供setter方法，提供带参数的构造器。
<bean id=”对象名” class=”全限定类名”> <constructor-arg ref=”参数” />
</bean>
本文内容总结：Spring，使用Spring管理Bean，配置Bean，Spring容器，Spring核心机制：依赖注入，设值注入，构造注入，
原文链接：https://www.cnblogs.com/ghq120/p/8327701.html
以上是 Spring学习(一)---依赖注入和控制反转 的全部内容， 来源链接： utcz.com/z/295927.html
