SSM02-Spring中Bean的实例化与依赖注入

详细的描述了Spring中Bean的实例化与依赖注入。

Bean的实例化#

构造方法#

Spring创建Bean的时候调用无参构造。（有参构造会报错，私有无参也可以，底层使用了反射）

注意：Spring中的报错从下向上看，直到找到有用的信息。

注意：若不存在无参构造方法，会抛出异常：BeanCreationException

添加无参构造后：
运行结果：
这一节讨论的是直接按 class 配置、又没有提供构造参数时的实例化方式：容器需要找到可调用的无参构造器，再完成对象创建。补上无参构造器解决的是该配置下的实例化条件，并不意味着 Spring 一律禁止有参构造；后文的 constructor-arg 就是在显式描述构造参数。排查创建失败时应继续查看异常原因链，区分构造器选择、依赖缺失与初始化失败。

静态工厂#

创建对象不需要自己new，创建一个工厂创建对象达到解耦的效果

样例代码：

1
package wang.factory;
2

3
import wang.dao.Dao;
4
import wang.dao.impl.DaoImpl;
5

6
public class DaoFactory {
7
    public static Dao getDao() {
8
      System.out.println("factory set up ...");
9
        return new DaoImpl();
10
    }
11
}

配置文件添加如下代码：

1
<bean id="daoFactory" class="wang.factory.DaoFactory" factory-method="getDao"/>

主函数：

1
package wang;
2

3
import org.springframework.context.ApplicationContext;
4
import org.springframework.context.support.ClassPathXmlApplicationContext;
5
import wang.dao.Dao;
6

7
public class App3 {
8
    public static void main(String[] args) {
9
        ApplicationContext ctx = new ClassPathXmlApplicationContext("applicationContext.xml");
10
        Dao dao = (Dao) ctx.getBean("daoFactory");
11
        dao.save();
12
    }
13
}

运行结果：

这里 bean 的 class 指向 DaoFactory，factory-method 指向静态方法 getDao。容器调用这个方法取得它返回的 DaoImpl，并把该返回对象作为名称为 daoFactory 的 Bean 提供给应用。因此按 daoFactory 名称获取 Bean 的使用者拿到的是 Dao 类型的产品，而不是工厂本身；主函数再调用 dao.save()。对象创建逻辑被集中到工厂方法，调用者无需直接写出产品实现类的构造语句。

实例工厂#

工厂代码同上

配置文件修改为如下代码：

1
<bean id="daoFactorytemp" class="wang.factory.DaoFactory"/>                 <!-- 创建工厂bean -->
2
<bean id="daoFactory" factory-bean="daoFactorytemp" factory-method="getDao"/>
3
<!-- factory-bean指定工厂bean -->

第一行为一个无用的bean，改良后即为第四种方法

主函数不变

运行结果：

工厂方式的共同目标是让容器对外提供 Dao 产品，主函数继续按产品的 Bean 名称获取对象并调用 save()。实例工厂配置使用 factory-bean 找到工厂对象，再由 factory-method 指定生产方法；FactoryBean 方式则实现统一的 getObject() 与 getObjectType() 契约。使用 FactoryBean 时，普通名称取到产品，带 & 前缀的名称才取得工厂自身。两者都要正确提供创建逻辑，不能只凭调用端相同就认定配置已经等价。

FactoryBean（重要！）#

在第三种方法存在两个问题
一、factory-bean属性使用时会创建一个无用的Bean
二、factory-method属性方法名不固定，非动态实现

因此，对此方法做了改良

factory实现一个接口FactoryBean

工厂代码

1
package wang.factory;
2

3
import org.springframework.beans.factory.FactoryBean;
4
import wang.dao.Dao;
5
import wang.dao.impl.DaoImpl;
6

7
public class DaoFactoryBean implements FactoryBean<Dao> {
8
    // 代替原始实例工厂创建对象的方法
9
    @Override
10
    public Dao getObject() throws Exception {
11
        return new DaoImpl();
12
    }
13
    // 得到Bean的类型
14
    @Override
15
    public Class<?> getObjectType() {
16
        return Dao.class;
17
    }
18
    // 设置Bean是否单例子，return true为单例，false为非单例
19
    // 该方法一般不重写
20
    /*@Override
21
    public boolean isSingleton() {
22
        return true;
23
    }*/
24
}

配置文件修改为如下代码：

1
<bean id="daoFactory" class="wang.factory.DaoFactoryBean"/>

主函数不变

运行结果：

补充：Bean的生命周期#

控制生命周期#

方法一：#

控制方法代码：

1
public static DaoImpl implements Dao {
2
    public void save() {
3
        System.out.println("Dao save ... ")
4
    }
5
    public void init() {
6
        System.out.println("Dao init ... ")
7
    }
8
    public void destroy() {
9
        System.out.println("Dao destroy ... ")
10
    }
11
}

配置控制方法：

1
<bean id="Dao" class="wang.dao.impl.DaoImpl" init-method="init" destroy-method="destory"/>

方法二#

实现InitializingBean, DisposableBean接口

1
public static DaoImpl implements Dao, InitializingBean, DisposableBean {
2
    public void save() {
3
        System.out.println("Dao save ... ")
4
    }
5
    public void init() throws Exception {
6
        System.out.println("Dao init ... ")
7
    }
8
    public void destroy() throws Exception {
9
        System.out.println("Dao destroy ... ")
10
    }
11
}

生命周期#

初始化容器
1.创建对象（内存分配）
2.执行构造方法
3.执行属性注入( set操作）
4.执行bean初始化方法

使用bean
1.行业务操作

关闭/销毁容器
1.执行bean销毁方法

注：**销毁的时机：**容器关闭前触发bean的销毁
关闭容器方式：
手工关闭容器
ConfigurableApplicationContext接口close（）

操作注册关闭钩子，在虚拟机退出前先关闭容器再退出虚拟机
ConfigurableApplicationcontext接口registerShutdownHook （）操作

依赖注入#

setter注入#

引用类型#

详情见博客 SSM01-Spring中的Bean

步骤如下
1.在bean中定义引用类型属性并提供可访问的set方法
2.配置中使用property标签ref属性注入引用类型对象

简单类型#

步骤如下
1.在bean中定义引用类型属性并提供可访问的set方法
2.配置中使用property标签value属性注入简单类型数据

构造器注入#

引用类型（仅做了解）#

步骤如下
1.在bean中定义引用类型属性并提供可访问的构造方法
2.配置中使用constructor-arg标签ref属性注入引用类型对象

简单类型#

步骤如下
1.在bean中定义引用类型属性并提供可访问的set方法
2.配置中使用property标签value属性注入简单类型数据
注意：
配置中使用constructor-arg标签type属性设置按形参类型注入
配置中使用constructor-arg标签index属性设置按形参位置注入

依赖注入方式的选择（总结自黑马程序员，侵删）#

1.强制依赖使用构造器进行，使用setter注入有概率不进行注入导致null对象出现
2.可选依赖使用setter注入进行，灵活性强
3.Spring框架倡导使用构造器，第三方框架内部大多数采用构造器注入的形式进行数据初始化，相对严谨
4.如果有必要可以两者同时使用，使用构造器注入完成强制依赖的注入，使用setter注入完成可选依赖的注入
5.实际开发过程中还要根据实际情况分析，如果受控对象没有提供setter方法就必须使用构造器注入
6.自己开发的模块推荐使用setter注入

自动装配（优先级低于setter注入与构造器注入）#

IoC容器根据bean所依赖的资源在容器中自动查找并注入到bean中的过程称为自动装配

自动装配方式

按类型（常用）（不能对简单类型装配）#

1
<bean id="daoFactory" class="wang.dao.impl.DaoImpl" autowire="byType"/>

注意：需要set方法

注意：按类型（byType）时，同类型的应该只有一个bean，否则分不清。

按名称(set方法第一个字母改为小写的名称，即标椎的变量名)#

1
<bean id="daoFactory" class="wang.dao.impl.DaoImpl" autowire="byName"/>

注意：因为变量名与byName耦合度高，不建议使用。

按构造方法#

集合注入（主要学习格式）#

Dao接口

1
package wang.dao;
2

3
public interface DataDao {
4
    public void save();
5
}

Dao实现

1
package wang.dao.impl;
2

3
import wang.dao.DataDao;
4

5
import java.util.*;
6

7
public class DataDaoImpl implements DataDao {
8

9
    private int[] array;
10

11
    private List<String> list;
12

13
    private Set<String> set;
14

15
    private Map<String,String> map;
16

17
    private Properties properties;
18

19

20

21

22
    public void setArray(int[] array) {
23
        this.array = array;
24
    }
25

26
    public void setList(List<String> list) {
27
        this.list = list;
28
    }
29

30
    public void setSet(Set<String> set) {
31
        this.set = set;
32
    }
33

34
    public void setMap(Map<String, String> map) {
35
        this.map = map;
36
    }
37

38
    public void setProperties(Properties properties) {
39
        this.properties = properties;
40
    }
41

42

43

44

45
    public void save() {
46
        System.out.println("book dao save ...");
47

48
        System.out.println("遍历数组:" + Arrays.toString(array));
49

50
        System.out.println("遍历List" + list);
51

52
        System.out.println("遍历Set" + set);
53

54
        System.out.println("遍历Map" + map);
55

56
        System.out.println("遍历Properties" + properties);
57
    }
58
}

配置文件：

1
<?xml version="1.0" encoding="UTF-8"?>
2
<beans xmlns="http://www.springframework.org/schema/beans"
3
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
4
       xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd">
5
    <bean id="dataDao" class="wang.dao.impl.DataDaoImpl">
6
        <!--数组注入-->
7
        <property name="array">
8
            <array>
9
                <value>100</value>
10
                <value>200</value>
11
                <value>300</value>
12
            </array>
13
        </property>
14
        <!--list集合注入-->
15
        <property name="list">
16
            <list>
17
                <value>java</value>
18
                <value>c++</value>
19
                <value>python</value>
20
                <value>php</value>
21
            </list>
22
        </property>
23
        <!--set集合注入-->
24
        <property name="set">
25
            <set>
26
                <value>java</value>
27
                <value>python</value>
28
                <value>java</value>
29
                <value>php</value>
30
            </set>
31
        </property>
32
        <!--map集合注入-->
33
        <property name="map">
34
            <map>
35
                <entry key="country" value="china"/>
36
                <entry key="province" value="shanxi"/>
37
                <entry key="city" value="xian"/>
38
            </map>
39
        </property>
40
        <!--Properties注入-->
41
        <property name="properties">
42
            <props>
43
                <prop key="country">china</prop>
44
                <prop key="province">shanxi</prop>
45
                <prop key="city">xian</prop>
46
            </props>
47
        </property>
48
    </bean>
49
</beans>

主函数：

1
package wang.dao;
2

3
import org.springframework.context.ApplicationContext;
4
import org.springframework.context.support.ClassPathXmlApplicationContext;
5

6
public class App6 {
7
    public static void main(String[] args) {
8
        ApplicationContext ctx = new ClassPathXmlApplicationContext("applicationContext.xml");
9
        DataDao dataDao = (DataDao) ctx.getBean("dataDao");
10
        dataDao.save();
11
    }
12
}

运行结果：

DataDaoImpl 的五个 setter 分别接收数组、List、Set、Map 和 Properties。XML 中 array 与 list 保留配置的元素顺序，set 表达不重复元素，因此配置里重复的 java 不应成为两个独立集合元素；map 与 props 则把键对应到值。save() 会逐项打印这些已注入的属性，检查重点是容器类型与内容是否符合配置，而不是照着某个 Set、Map 或 Properties 的显示顺序判断注入是否正确。

第三方资源注入#

容器#

两种加载容器的方式#

1
ApplicationContext ctx = new ClassPathXmlApplicationContext("applicationContext.xml"); //推荐

1
ApplicationContext ctx = new FileSystemXmlApplicationContext("D:\\ssm\\ssm\\springtest\\springtest\\src\\main\\resources\\applicationContext.xml")  //绝对路径寻找

两种获取bean的方式#

1
Dao dao = (DataDao) ctx.getBean("dao");

1
Dao dao = ctx.getBean("dao", Dao.class);  //多个同种类型报错

对比ApplicationContext和BeanFactory#

BeanFactory是顶级接口的Bean是延迟加载

ApplicationContext是子接口（常用）也可以延迟加载，在bean中加入参数 lazy-init=“true” 即可

加载第三方Bean#

加载Properties文件#

步骤如下：

开启Context命名空间
使用context加载properties文件
使用属性占位符${}读取properties配置文件中的属性

样例代码如下：

1
<?xml version="1.0" encoding="UTF-8"?>
2
<beans xmlns="http://www.springframework.org/schema/beans"
3
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
4
       xmlns:context="http://www.springframework.org/schema/context"
5
       xsi:schemaLocation="
6
           http://www.springframework.org/schema/beans
7
           http://www.springframework.org/schema/beans/spring-beans.xsd
8
           http://www.springframework.org/schema/context
9
           http://www.springframework.org/schema/context/spring-context.xsd
10
            ">
11
    <!--步骤-->
12
    <!--1.开启命名空间-->
13
    <!--2.使用context加载properties文件-->
14
    <context:property-placeholder location="xxxx.properties"/>
15

16
    <!--3.使用属性占位符${}读取properties配置文件中的属性-->
17
    <bean class="xxxx">
18
        <property name="xxxx" value="${ 配置中的变量名称 }"/>
19
    </bean>
20
</beans>

注意：加载时可以关闭系统属性，因为系统属性的优先级高于

注意：多个配置文件用逗号隔开

注意：专业的写法加载所有配置文件如下

1
<!-- 加载properties文件标准格式 -->
2
<context:property-placeholder location="classpath:*.properties" system-properties-mode="NEVER"/>
3
<!-- 从类路径或jar包中搜索并加载properties文件
4
<context:property-placeholder location="classpath*:*.properties" system-properties-mode="NEVER"/>

总结（来自黑马程序员，侵删）#

容器相关#

Spring 容器加载配置、创建 Bean 与获取对象的路径

原理示意：类路径配置与文件系统配置分别交给相应的 ApplicationContext 实现读取，再由容器创建对象、装配依赖并执行初始化。应用按名称和类型获取 Bean；普通上下文通常在刷新时创建非懒加载单例，懒加载设置可推迟创建。关闭容器则为其管理的单例触发销毁回调，不应把所有作用域都理解成同样的生命周期。

bean相关#

受管单例 Bean 从实例化到容器关闭的生命周期

原理示意：Bean 先实例化，再接受依赖注入，随后执行初始化回调，之后才供应用使用；容器关闭时对受管单例执行销毁回调。XML 可以通过 init-method 与 destroy-method 指定方法，注解写法则标记相应方法。singleton 在容器内共享实例，prototype 每次请求可创建新实例，其完整销毁过程不由容器代管。

依赖注入相关#

依赖注入可以先按入口区分：setter 注入使用 property，构造器注入使用 constructor-arg；再按数据区分，ref 指向另一个 Bean，value 提供简单值。集合使用 array、list、set、map、props 描述内容。自动装配则让容器按规则寻找依赖，按类型时要解决候选歧义，按名称时要对应属性与 Bean 名称。选择方式应结合强制依赖与可选依赖，而不是把所有对象都机械地改成同一种装配形式。