Bean

以Bean为核心的IOC/DI机制：

总述理论核心：在spring中，所有的对象都会被spring核心容器管理。一切对象统称为Bean。

Spring容器可通过XML配置文件或者注解去管理这堆Bean。

（1）定义以及原理：

依赖注入（IOC/DI）：spring容器负责将被依赖对象赋值给调用者的成员变量–相当于为调用者注入它依赖的实例。

依赖关系：A对象需要调用B对象方法的情况–A依赖B。

简单工厂模式：调用者先找到被依赖对象的工厂，然后主动通过工厂去获取被依赖对象，最后再调用被依赖对象的方法。

调用者面向被依赖对象的接口编程；将被依赖对象的创建交给工厂；调用者通过工厂来获得被依赖组件。

缺点：调用组件需要主动通过工厂去获取被依赖对象，必然带来调用组件与被依赖对象工厂的耦合。（同样，我也不想知道你这个工厂存在，我只想要个依赖对象）

3.Spring框架下的依赖注入：框架为调用者注入它依赖的实例。

优点：程序无须例会被依赖对象的实现，也无须主动定位工厂。只需被动等待IOC容器分配依赖对象。

（2）应用：

依赖注入分为两种：[一]设值注入；[二]构造注入；

1. 设值注入：指IOC容器通过成员遍历的setter方法来注入被依赖对象。

使用方法：可见我们没有硬编码上去创建依赖对象

<?xml version="1.0" encoding="GBK"?>
<!-- Spring配置文件的根元素，使用spring-beans-4.0.xsd语义约束 -->
<beans xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
    xmlns="http://www.springframework.org/schema/beans"
    xsi:schemaLocation="http://www.springframework.org/schema/beans
    http://www.springframework.org/schema/beans/spring-beans-4.0.xsd">
    <!-- 配置chinese实例，其实现类是Chinese类 -->
    <bean id="chinese" class="com.fuzhu.Chinese">
        <!-- 驱动调用chinese的setAxe()方法，将容器中stoneAxe作为传入参数 -->
        <property name="axe" ref="stoneAxe"/>
    </bean>
    <!-- 配置Axe实例 -->
    <bean id="axe" class="com.fuzhu.Axe"/>

</beans>

 
 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

public class Chinese 
{
    private Axe axe;//定义个斧头引用
    // 设值注入所需的setter方法
    public void setAxe(Axe axe)
    {
        this.axe = axe;
    }
    // 实现依赖对象的方法useAxe方法
    public void useAxe()
    {
        // 调用axe的chop()方法，
        // 表明Chinese 对象依赖于axe对象
        System.out.println(axe.chop());
    }
}
//斧头类
public class Axe 
{
    public String chop()
    {
        return "石斧砍柴好慢";
    }
}
 
 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24

写个test类

public class BeanTest
{
    public static void main(String[] args)throws Exception
    {
        // 创建Spring容器
        ApplicationContext ctx = new
            ClassPathXmlApplicationContext("beans.xml");
        // 获取chinese 实例
        Chinese p = ctx.getBean("chinese" , Chinese.class);
        // 调用useAxe()方法
        p.useAxe();
    }
}
 
 
1
2
3
4
5
6
7
8
9
10
11
12
13

2. 构造注入：IOC容器使用构造器来注入被依赖对象。

在构造实例时，已经为其完成了依赖关系的初始化。本质就是当执行带参数的构造器时，就可利用构造器参数对成员变量执行初始化。《contructopr-arg… /》

使用方法：

<?xml version="1.0" encoding="GBK"?>
<beans xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
    xmlns="http://www.springframework.org/schema/beans"
    xsi:schemaLocation="http://www.springframework.org/schema/beans
    http://www.springframework.org/schema/beans/spring-beans-4.0.xsd">
    <!-- 配置chinese实例，其实现类是Chinese -->
    <bean id="chinese" class="com.fuzhu.Chinese">
        <!-- 下面只有一个constructor-arg子元素，
            驱动Spring调用Chinese带一个参数的构造器来创建对象 -->
        <constructor-arg ref="axe" type="com.fuzhu.Axe"/>
    </bean>
    <!-- 配置Axe实例-->
    <bean id="axe" class="com.fuzhu.StoneAxe"/>
</beans>

 
 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

public class Chinese 
{
    private Axe axe;
    // 构造注入所需的带参数的构造器
    public Chinese(Axe axe)
    {
        this.axe = axe;
    }
    // 实现依赖对象的方法useAxe()方法
    public void useAxe()
    {
        // 调用axe的chop()方法
        // 表明Chinese 对象依赖于axe对象
        System.out.println(axe.chop());
    }
}
public class  Axe
{
    public String chop()
    {
        return "石斧砍柴好慢";
    }
}
 
 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23

3. 注解注入装配： 以后再讲，其实是基于前两种注解方式实现的。

（3）IOC/DI依赖注入源码理解：（基于spring4.1.7）

重点理解两个过程：IoC容器初始化过程以及IoC容器依赖注入过程。

其实就是：资源定位、资源装载、资源解析、Bean生成，Bean注册、Bean依赖注入这几个过程（前五属于初始化过程）。方法：eclipse断点ClassPathXmlApplicationContext调用，不断跳进去，就看到spring执行栈了。

1. IoC容器初始化过程：

以上图思路进行详细讲述

初始化总过程：资源定位（确定工厂创建和bean的配置文件）—>资源装载（在文件系统路径上对IOC配置文件、bean配置进行加载）—>资源解析（解析bean配置，解析xml元素）—>生成bean（根据DOM资源解析成bean）—>在IoC容器中注册（交给IoC容器管理，还有依赖注入的权限）