细读Spring源码（四）---什么是IOC？

往期回顾：

• 细读Spring源码（一）---refresh()方法概览

• 细读Spring源码（二）---关于Spring中用到的设计模式

• 细读Spring源码（三）---深度剖析动态代理底层原理

IOC是什么？看一下百度百科中的专家贡献，感觉写的还是比较简单明了，拿过来引用：

控制反转（Inversion of Control，缩写为IoC），是面向对象编程中的一种设计原则，可以用来减低计算机代码之间的耦合度。其中最常见的方式叫做依赖注入（Dependency Injection，简称DI），还有一种方式叫“依赖查找”（Dependency Lookup）。通过控制反转，对象在被创建的时候，由一个调控系统内所有对象的外界实体将其所依赖的对象的引用传递给它。也可以说，依赖被注入到对象中。

Class A中用到了Class B的对象b，一般情况下，需要在A的代码中显式的new一个B的对象。

采用依赖注入技术之后，A的代码只需要定义一个私有的B对象，不需要直接new来获得这个对象，而是通过相关的容器控制程序来将B对象在外部new出来并注入到A类里的引用中。而具体获取的方法、对象被获取时的状态由配置文件（如XML）来指定。

 

上面的解释中提到的容器，就是Spring，它负责管理所有的bean，同时维护了bean之间的依赖关系，使得开发人员不需要手动去new，而是定义好，按照容器约定的方式去使用即可。先看一张图，这是我总结的关于IOC的核心知识图谱，今天的文章就按照这张图中的顺序进行介绍~

 一、接口

ApplicationContext和BeanFactory中两个非常重要的接口，后面在源码中会详细介绍，这里先大概说一下：

BeanFactory是Spring中管理Bean的工厂，也是Spring内置的工厂，负责管理Bean从创建到销毁的整个生命周期，BeanFactory中管理的bean，可以在使用时进行创建；

ApplicationContext也是个接口，它继承了BeanFactory以及其他的几个接口（后面介绍），从而提供了比BeanFactory更加强大的功能，但是ApplcationContext中管理的bean，在容器初始化的时候就创建好了；

二、实现原理

我们知道创建一个对象的方式除了new之外，还可以通过动态代理、工厂模式等方式创建，而Spring中就是通过工厂模式+动态代理的方式实现bean的依赖注入，工厂模式和动态代理分别在细读Spring源码（二）---关于Spring中用到的设计模式和细读Spring源码（二）---关于Spring中用到的设计模式 中已经介绍过，其实最底层还是靠反射来支撑。

三、依赖注入DI（Dependency Injection）

依赖注入是IOC的实现方式，在Spring中有两种注入方式，基于XML和基于注解，虽然现在都是通过注解方式，但我觉得还是有必要说一下XML，毕竟spring源码还得从XML看起，更重要的是注解是对XML的优化方式，所以知道了XML，也就能更好地理解注解的方式了。

Talk is cheap，Show your my code！

3.1 基于XML的实现

首先，定义两个存在依赖关系的类DiOrder和DiProduct，前者依赖后者

1、DiProduct.java

package com.spring.reading.ioc.di;

import java.math.BigDecimal;

/**
 * @author: cyhua
 * @createTime: 2021/12/1
 * @description: 定义一个商品类
 */
public class DiProduct {

    /**
     * 商品id
     */
    private String productId;

    /**
     * 商品名称
     */
    private String productName;

    /**
     * 商品价格
     */
    private BigDecimal productPrice;

    public DiProduct() {
    }

    public String getProductId() {
        return productId;
    }

    public void setProductId(String productId) {
        this.productId = productId;
    }

    public String getProductName() {
        return productName;
    }

    public void setProductName(String productName) {
        this.productName = productName;
    }

    public BigDecimal getProductPrice() {
        return productPrice;
    }

    public void setProductPrice(BigDecimal productPrice) {
        this.productPrice = productPrice;
    }

    @Override
    public String toString() {
        StringBuilder sb = new StringBuilder("DiProduct={");
        sb.append("productId='").append(productId).append("'");
        sb.append(",productName='").append(productName).append("'");
        sb.append(",productPrice='").append(productPrice).append("'");
        sb.append("}");
        return sb.toString();
    }
}

2、DiOrder.Java

package com.spring.reading.ioc.di;

/**
 * @author: cyhua
 * @createTime: 2021/12/1
 * @description: 定义一个订单类
 */
public class DiOrder {

    /**
     * 订单编号
     */
    private String orderNumber;

    /**
     * 订单对应商品：依赖商品类
     */
    private DiProduct diProduct;

    /**
     * 商品个数
     */
    private int productNum;


    public DiOrder() {
    }

    public String getOrderNumber() {
        return orderNumber;
    }

    public void setOrderNumber(String orderNumber) {
        this.orderNumber = orderNumber;
    }

    public DiProduct getDiProduct() {
        return diProduct;
    }

    public void setDiProduct(DiProduct diProduct) {
        this.diProduct = diProduct;
    }

    public int getProductNum() {
        return productNum;
    }

    public void setProductNum(int productNum) {
        this.productNum = productNum;
    }

    @Override
    public String toString() {
        StringBuilder sb = new StringBuilder("DiOrder={");
        sb.append("orderNumber='").append(orderNumber).append("'");
        sb.append(",productNum='").append(productNum).append("'");
        sb.append(",diProduct='").append(diProduct).append("'");
        sb.append("}");
        return sb.toString();
    }
}

其次，在spring-di.xml中定义bean

3、spring-di.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-3.0.xsd">


    <!--定义一个name为diProduct的商品bean-->
    <bean id="diProduct" class="com.spring.reading.ioc.di.DiProduct">
        <property name="productId" value="1"/>
        <property name="productName" value="MacbookPro max"/>
        <property name="productPrice" value="26999"/>
    </bean>

    <!--定义一个name为diOrder的订单bean-->
    <bean id="diOrder" class="com.spring.reading.ioc.di.DiOrder">
        <property name="orderNumber" value="0123456789"/>
        <property name="diProduct" ref="diProduct"/>
        <property name="productNum" value="2"/>
    </bean>

</beans>

最后，通过diOrder获取订单对象，并打印里面的商品对象

4、测试类

package com.spring.reading.ioc.di;

import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;

/**
 * @author: cyhua
 * @createTime: 2021/12/1
 * @description: 测试基于XML的注入
 */
public class DiXmlCaller {

    public static void main(String[] args) {
        ApplicationContext applicationContext = new ClassPathXmlApplicationContext("spring-di.xml");
        DiOrder diOrder = (DiOrder) applicationContext.getBean("diOrder");
        System.out.println("商品详情：" + diOrder.getDiProduct());
        System.out.println("订单详情：" + diOrder);
    }
}

查看结果：

 可以看到，DiOrder依赖的DiProduct，已经完成自注入，通过diOrder实例能够获取到diProduct实例了。上面这种方式是基于get、set方法的注入，还可以通过有参构造函数注入，配置如下：

5、通过构造器填充属性

<!--定义一个name为diProduct的商品bean-->
    <bean id="diProduct1" class="com.spring.reading.ioc.di.DiProduct">
        <constructor-arg value="2"/>
        <constructor-arg value="iphone"/>
        <constructor-arg value="6000"/>
    </bean>

通过diProduct1获取并打印的结果如下：

 还可以通过byName和byType实现自动注入，而不需要通过property属性指定

6、通过byName自动装配依赖

 <!-- 通过byName自动装配DiProduct:会查找名称和属性名diProduct相同的bean-->
    <bean id="diOrder1" class="com.spring.reading.ioc.di.DiOrder" autowire="byName">
        <property name="orderNumber" value="0123456789-1"/>
        <property name="productNum" value="2"/>
    </bean>

修改的地方有以下两点：

• bean中增加autowire属性，value设置为byName
• 去掉name为diProduct的property配置

缺点：被依赖对象的bean名称必须和依赖对象中的属性值一致，就像在DiOrder中定义了名为diProduct的商品类，在xml中就要定义成diProduct，否则就找不到了！

7、通过byType自动装配依赖

<!-- 通过byType自动装配DiProduct:会查找类型与属性diProduct相同的bean进行自动装配,如果定义了多个类型相同的bean，则编译不通过 -->
    <bean id="diOrder2" class="com.spring.reading.ioc.di.DiOrder" autowire="byType">
        <property name="orderNumber" value="0123456789-1"/>
        <property name="productNum" value="2"/>
    </bean>

修改的地方有以下两点：

• bean中增加autowire属性，value设置为byType
• 去掉name为diProduct的property配置

缺点：被依赖对象只能创建一个bean，否则编译报错，就像上面的例子中，如果xml中定义两个DiProduct，即使名称不一样，通过byType自动装配的时候也会报错，报错信息如下：

Could not autowire. There is more than one bean of 'DiProduct' type. Beans: diProduct1,diProduct. Properties: 'diProduct'

上面是针对引用类型的注入方式，当配置的属性值较多时，可以通过引入外部文件的方式注入，比如数据库配置信息

8、通过外部文件注入属性

 <!--引入外部定义文件-->
    <bean class="org.springframework.beans.factory.config.PropertyPlaceholderConfigurer">
        <property name="locations">
            <list>
                <value>classpath:config/database.properties</value>
            </list>
        </property>
        <property name="fileEncoding" value="utf-8"/>
    </bean>

    <!--注入文件中定义的属性-->
    <bean id="dataSource" class="com.alibaba.druid.pool.DruidDataSource"
          destroy-method="close">
        <!-- 基本属性 url、user、password -->
        <property name="url" value="${spring.reading.jdbc.url}"/>
        <property name="username" value="${spring.reading.jdbc.username}"/>
        <property name="password" value="${spring.reading.jdbc.password}"/>
        <!-- 配置初始化大小、最小、最大 -->
        <property name="initialSize" value="${spring.reading.jdbc.initialSize}"/>
        <property name="minIdle" value="${spring.reading.jdbc.minIdle}"/>
        <property name="maxActive" value="${spring.reading.jdbc.maxActive}"/>
        <!-- 配置获取连接等待超时的时间 -->
        <property name="maxWait" value="${spring.reading.jdbc.maxWait}"/>
    </bean>

9、定义外部文件database.properties

spring.reading.jdbc.url=jdbc:mysql://localhost:3306/test?useUnicode=true&characterEncoding=utf8&allowMultiQueries=true
spring.reading.jdbc.username=test
spring.reading.jdbc.password=123
spring.reading.jdbc.initialSize=10
spring.reading.jdbc.minIdle=2000
spring.reading.jdbc.maxActive=50
spring.reading.jdbc.maxWait=6000

到这里，基于XML的依赖注入介绍的也差不多了，下面来介绍基于注解的实现方式

3.2 基于注解的实现

3.2.1 注解是什么？

简单来讲有三点：

• 注解是java中的特殊标记：@注解名称(属性名称=属性值，属性名称=属性值)
• 可以作用在类、属性和方法上
• 为了简化xml配置的一种发明

3.2.2 实现

 基于纯注解的实现需要下面几步：

• 创建配置类，配置要注入的Bean，如配置DiProduct
• 在依赖类中通过注解方式注入（基本类型使用$value注解，引用类型可以使用@Autowired、@Resource、@Qualifer）
• 开启包扫描，指定要扫描的包路径
• 通过创建AnnotationConfigApplicationContext获取bean 

下面直接上代码：

1、DiProduct.java

package com.spring.reading.ioc.di;

import java.math.BigDecimal;

/**
 * @author: cyhua
 * @createTime: 2021/12/1
 * @description: 定义一个商品类
 */
public class DiProduct {

    /**
     * 商品id
     */
    private String productId;

    /**
     * 商品名称
     */
    private String productName;

    /**
     * 商品价格
     */
    private BigDecimal productPrice;

    public DiProduct() {
    }

    public DiProduct(String productId, String productName, BigDecimal productPrice) {
        this.productId = productId;
        this.productName = productName;
        this.productPrice = productPrice;
    }

    public String getProductId() {
        return productId;
    }

    public void setProductId(String productId) {
        this.productId = productId;
    }

    public String getProductName() {
        return productName;
    }

    public void setProductName(String productName) {
        this.productName = productName;
    }

    public BigDecimal getProductPrice() {
        return productPrice;
    }

    public void setProductPrice(BigDecimal productPrice) {
        this.productPrice = productPrice;
    }

    @Override
    public String toString() {
        StringBuilder sb = new StringBuilder("DiProduct={");
        sb.append("productId='").append(productId).append("'");
        sb.append(",productName='").append(productName).append("'");
        sb.append(",productPrice='").append(productPrice).append("'");
        sb.append("}");
        return sb.toString();
    }
}

2、DiOrder.java

package com.spring.reading.ioc.di;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Value;

/**
 * @author: cyhua
 * @createTime: 2021/12/1
 * @description: 定义一个订单类
 */
public class DiOrder {

    /**
     * 订单编号
     */
    @Value("1234567890")
    private String orderNumber;

    /**
     * 订单对应商品：依赖商品类
     */
    @Autowired
    private DiProduct diProduct;

    /**
     * 商品个数
     */
    @Value("5")
    private int productNum;


    public DiOrder() {
    }

    public DiOrder(String orderNumber, DiProduct diProduct, int productNum) {
        this.orderNumber = orderNumber;
        this.diProduct = diProduct;
        this.productNum = productNum;
    }

    public String getOrderNumber() {
        return orderNumber;
    }

    public void setOrderNumber(String orderNumber) {
        this.orderNumber = orderNumber;
    }

    public DiProduct getDiProduct() {
        return diProduct;
    }

    public void setDiProduct(DiProduct diProduct) {
        this.diProduct = diProduct;
    }

    public int getProductNum() {
        return productNum;
    }

    public void setProductNum(int productNum) {
        this.productNum = productNum;
    }

    @Override
    public String toString() {
        StringBuilder sb = new StringBuilder("DiOrder={");
        sb.append("orderNumber='").append(orderNumber).append("'");
        sb.append(",productNum='").append(productNum).append("'");
        sb.append(",diProduct='").append(diProduct).append("'");
        sb.append("}");
        return sb.toString();
    }
}

上面的diProduct通过@Autowired注解注入，orderNumber和productNum通过@Value注解注入

3、DiConfig.java

package com.spring.reading.ioc.di;

import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;

import java.math.BigDecimal;

/**
 * @author: cyhua
 * @createTime: 2021/12/1
 * @description: 通过注解@Configuration定义配置类，
 */
@Configuration
public class DiConfig {

    @Bean
    public DiOrder diOrder() {
        return new DiOrder();
    }

    @Bean
    public DiProduct diProduct() {
        return new DiProduct("111", "康师傅泡面", new BigDecimal(20));
    }
}

关键点：

第13行，定义这是一个配置类

第16、21行，定义两个bean，默认beanName为方法名

4、测试类

package com.spring.reading.ioc.di;

import org.springframework.context.ApplicationContext;
import org.springframework.context.annotation.AnnotationConfigApplicationContext;
import org.springframework.context.annotation.ComponentScan;

/**
 * @author: cyhua
 * @createTime: 2021/12/1
 * @description: 测试基于注解的注入
 */
@ComponentScan(basePackages = "com.spring.reading.ioc")
public class DiAnnotationCaller {

    public static void main(String[] args) {
        ApplicationContext context = new AnnotationConfigApplicationContext(DiConfig.class);
        DiOrder diOrder = context.getBean("diOrder", DiOrder.class);
        System.out.println("商品详情：" + diOrder.getDiProduct());
        System.out.println("订单详情：" + diOrder);
    }
}

关键点：

第12行，开启注解扫描，配置要扫描的基础包

第16行，获取一个基于注解的引用上下文

5、查看结果

 与定义的符合，可以看到DiOrder类的属性值没有手动调用set或有参构造函数，通过使用几个注解就完成了自动注入，而且比起XML更加方便。

 3.2.3 注意点

下面来验证几个需要注意的点

1、@bean注解使用的beanName默认是方法名，如果方法名与属性名或要获取的名称不一致，则会报错

比如我将上面配置类中定义Diorder类的方法名改成diOrder1，执行结果如下：

2、@Autowired是通过类型注入，即在XML中介绍的额byType，如果同一个类有多个bean，则自动注入会失败

比如我在DiConfig类中再定义一个DiProduct类型的bean，执行结果如下：

如上图，会提示DiProduct的bean适配到了两个，这时候就可以通过@Autowired+@Qualifier结合的方式注入，优先根据beanType查找，当根据类型找到多个时，再通过@Qualifier按照指定beanName确定使用哪一个bean

3、当同一个类有多个bean时，通过@Autowired+@Qualifier结合的方式注入

只需要修改DiOrder中的注解即可，修改和执行结果如下：

5、通过注解@Resource替换@Autowired+@Qualifier，修改后执行结果如下：

 

 至此，两种DI方式基本差不多了，主要的总结都在上面的思维导图，看图比更直观，这里就不再赘述。

四、Bean管理

4.1 Bean的类型

Spring中的Bean分为普通Bean和FactoryBean，普通Bean的定义类型和返回类型一致，而FactoryBean的定义类型可能和返回类型不一致，因为FactoryBean它本身也是一个工厂，可以生产不同的Bean，开发者可以通过实现该接口重写里面个getObject接口决定返回什么类型的Bean。

4.2 Bean的创建过程

Spring中一个Bean的创建过程分为【创建实例，分配空间-->填充属性-->初始化Bean，将bean名称指向开辟的内存空间】，像我们平时直接通过new创建对象，很多细节都被隐藏在new的背后，而这背后的奥义在Spring中可以看到显示的实现，这也就是后面分析源码中重点讲解的内容，这里先提一下。

4.3 Bean的作用域

Bean的作用域有singleton、prototype、request、session等，前两者在设计模式那篇中已经介绍过，后两者是web应用中使用的，这里再简单总结一下这四个作用域：

• singleton：单例，sping默认的作用域，而且默认在容器启动过程中创建，但是如果设置成懒加载，则会在获取时才创建，相同的beanName在全局只有一个实例，当多个线程根据同一个beanName获取时，每次都能取同一个实例；
• prototype：多例，需要手动开启，每次通过同一个beanName获取时都会创建一个新的实例；
• request：请求，在一次http请求过程中只创建一个实例；
• session：会话，在一次回话期呢只创建一个实例；

4.4 Bean的生命周期

Spring中一个bean从创建到销毁需要经历的步骤如上图：

1. 创建实例：此时会在内存中给该bean开辟一块内存空间
2. 注入属性：通过set方法设置bean中的各个属性
3. 后置处理器前置处理：在初始化之前可以对bean做一些修改，比如修改修改某个属性等
4. 初始化：调用初始化方法，如果不指定初始化方法，则使用默认的
5. 后置处理器后置处理：在初始化之后做一些操作
6. 使用：此时一个bean就创建好了， 我们就能调用它里面的方法了
7. 销毁：当容器关闭时，bean会被销毁，同样可以自定义销毁的方法

下面通过一个例子来看一下Bean生命周期的实现：

4.5 测试Bean的生命周期

创建公共类，一个基本类LifeCycleVo.java和一个后置处理器类

1、LifeCycleVo.java

package com.spring.reading.lifecycle;

/**
 * @author: cyhua
 * @createTime: 2021/12/1
 * @description: 定义一个测试生命周期的类
 */
public class LifeCycleVo {

    /**
     * 定义当前阶段
     */
    private String description;

    /**
     * 无参构造方法，实例化
     */
    public LifeCycleVo() {
        System.out.println("第一步：创建bean");
    }

    /**
     * 自定义初始化方法
     */
    public void init() {
        System.out.println("第四步：初始化bean");
    }

    /**
     * 自定义销毁方法
     */
    public void destroy() {
        System.out.println("第七步：销毁bean");
    }

    public String getDescription() {
        return description;
    }

    public void setDescription(String description) {
        System.out.println("第二步：注入属性");
        this.description = description;
    }

    @Override
    public String toString() {
        return "LifeCycleVo{" +
                "description='" + description + '\'' +
                '}';
    }
}

2、LifeCycleBeanPost.java

package com.spring.reading.lifecycle;

import org.springframework.beans.BeansException;
import org.springframework.beans.factory.config.BeanPostProcessor;

/**
 * @author: cyhua‰
 * @createTime: 2021/11/26
 * @description: bean后置处理器，在初始化前后执行一些操作
 */
public class LifeCycleBeanPost implements BeanPostProcessor {

    @Override
    public Object postProcessBeforeInitialization(Object bean, String beanName) throws BeansException {
        System.out.println("第三步：初始化bean之前执行后置处理器");
        return BeanPostProcessor.super.postProcessBeforeInitialization(bean, beanName);
    }

    @Override
    public Object postProcessAfterInitialization(Object bean, String beanName) throws BeansException {
        System.out.println("第五步：初始化bean之后执行后置处理器");
        return BeanPostProcessor.super.postProcessAfterInitialization(bean, beanName);
    }
}

4.5.1 基于XML的实现

1、spring-lifecycle.xml中配置bean

<?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-3.0.xsd">


    <!--定义一个name为lifeCycleVo的bean-->
    <bean id="lifeCycleVo" class="com.spring.reading.lifecycle.LifeCycleVo" init-method="init" destroy-method="destroy">
        <property name="description" value="基于XML文件测试bean生命周期"/>
    </bean>

    <!--定义一个后置处理器-->
    <bean id="lifeCycleBeanPost" class="com.spring.reading.lifecycle.LifeCycleBeanPost"/>

</beans>

上面代码中的第9行，自定义初始化和销毁方法

2、测试类

package com.spring.reading.lifecycle;

import org.springframework.context.support.ClassPathXmlApplicationContext;

/**
 * @author: cyhua
 * @createTime: 2021/12/1
 * @description: 基于XML的声明周期测试类
 */
public class LifeBaseXmlCaller {

    public static void main(String[] args) {
        ClassPathXmlApplicationContext context = new ClassPathXmlApplicationContext("spring-lifecycle.xml");
        LifeCycleVo lifeCycleVo = (LifeCycleVo) context.getBean("lifeCycleVo");
        System.out.println("第六步：开始使用Bean \nlifeCycleVo=" + lifeCycleVo);
        context.close();
    }
}

3、查看效果

 

 七个步骤都成功执行，符合预期，binggo!!!

4.5.2 基于注解的实现方式

 1、LifeCycleConfig.java

package com.spring.reading.lifecycle;

import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;

/**
 * @author: cyhua
 * @createTime: 2021/12/1
 * @description: 创建配置类，通过注解注入bean
 */
@Configuration
public class LifeCycleConfig {

    @Bean(initMethod = "init", destroyMethod = "destroy")
    public LifeCycleVo lifeCycleVo() {
        LifeCycleVo lifeCycleVo = new LifeCycleVo();
        lifeCycleVo.setDescription("基于配置类测试bean生命周期");
        return lifeCycleVo;
    }

    @Bean
    public LifeCycleBeanPost lifeCycleBeanPost() {
        return new LifeCycleBeanPost();
    }
}

在注解@Bean中自定义初始化和销毁方法

2、测试类

package com.spring.reading.lifecycle;

import org.springframework.context.annotation.AnnotationConfigApplicationContext;
import org.springframework.context.annotation.ComponentScan;

/**
 * @author: cyhua
 * @createTime: 2021/12/1
 * @description: 基于XML的声明周期测试类
 */
@ComponentScan(basePackages = "com.spring.reading.lifecycle")
public class LifeBaseConfigCaller {

    public static void main(String[] args) {
        AnnotationConfigApplicationContext context = new AnnotationConfigApplicationContext(LifeCycleConfig.class);
        LifeCycleVo lifeCycleVo = (LifeCycleVo) context.getBean("lifeCycleVo");
        System.out.println("第六步：开始使用Bean \nlifeCycleVo=" + lifeCycleVo);
        context.close();
    }
}

3、查看效果

 同样成功执行，符合预期！

到此为止，spring中的IOC以及DI介绍的差不多了，本文只是读源码的一个前置条件，后面会跟源代码进行剖析，先知道怎么做，再去研究底层的实现机制。