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容器管理,还有依赖注入的权限)

这里写图片描述


阅读更多
换一批

没有更多推荐了,返回首页