Spring - Bean的实例化流程及生命周期_springboot的bean实例化

Bean的实例化流程及生命周期

一、Bean实例化基本流程

1.1 Bean实例化基本流程

从标签的配置到对象进入容器中，是怎么样的一个过程？

• Spring容器在进行初始化时，会将xml配置的<bean>的信息封装成一个BeanDefinition对象

  比如下面两段配置，会封装成两个BeanDefinition对象，因为这个信息在内存中也需要存储（并不是userService、userDao对象）

<bean id="userService"  class="com.zhangjingqi.service.impl.UserServiceImpl"/>

<bean id="userDao" class="com.zhangjingqi.dao.impl.UserDaoImpl"></bean>
1
2
3

• 所有的BeanDefinition对象存储到一个名为beanDefinitionMap的集合中去，Spring框架再对该Map进行遍历，使用反射创建Bean实例对象

  beanDefinitionMap集合就是在BeanFactory中进行维护，如下所示

  beanDefinitionMap的Value就是对当前配置的这个Bean的信息进行封装的

我们随意点开一个看一看，它的Value并不是一个userDao对象，而是一个，而是一个GenericBeanDefinition，说白了就是一个Bean标签信息

​ 只要将BeanDefinition注册到beanDefinitionMap这个Map中，Spring就会进行对应的Bean的实例化操作

• 创建好的Bean对象存储在一个名为singletonObjects的Map集合中，当调用getBean方法时，则最终从该Map集合中取出Bean实例对象返回。

  singletonObjects就是一个单例池 ，也是一个Map集合

  当我们调用getBean的时候，就是根据getBean方法参数去Map集合中取出对应的Value值

​ 当前的beanFactory是DefaultListableBeanFactory工厂对象，此对象中的各种属性，就是下图beanFactory下面的参数

​ DefaultListableBeanFactory对象内部维护着一个Map用于存储封装好的BeanDefinitionMap（在上面已经说到过了）

public class DefaultListableBeanFactory extends ... implements ... {
    //存储<bean>标签对应的BeanDefinition对象
    //key:是Bean的beanName，value:是Bean定义对象BeanDefinition
    private final Map<String, BeanDefinition> beanDefinitionMap;
}
1
2
3
4
5

1.2 总结

• 加载xml配置文件，解析获取配置中的每个<bean>的信息，封装成一个个的BeanDefinition对象

• 将BeanDefinition存储在一个名为beanDefinitionMap的Map<String,BeanDefinition>中

• ApplicationContext底层遍历beanDefinitionMap，创建Bean实例对象

• 创建好的Bean实例对象，被存储到一个名为singletonObjects的Map<String,Object>中

• 当执行applicationContext.getBean(beanName)时，从singletonObjects去匹配Bean实例返回

二、 Bean 后处理器

2.1 介绍

​ Spring的后处理器是Spring对外开发的重要扩展点，允许我们介入到Bean的整个实例化流程中来，以达到动态注册BeanDefinition，动态修改BeanDefinition，以及动态修改Bean的作用。

框架本身把一些功能封装好了，也有一些约定俗成的东西（按照他们的配置进行配置，最终就能完成响应的一些功能），但是有的时候我们需要自己介入到他的整个过程

Spring主要有两种后处理器：

• BeanFactoryPostProcessor：Bean工厂后处理器，在BeanDefinitionMap填充完毕，Bean实例化之前执行

• BeanPostProcessor：Bean后处理器，一般在Bean实例化之后，填充到单例池singletonObjects之前执行

2.2 BeanFactoryPostProcessor Bean工厂后处理器

BeanFactoryPostProcessor：Bean工厂后处理器，在BeanDefinitionMap填充完毕，Bean实例化之前执行

BeanFactoryPostProcessor是一个接口规范，实现了该接口的类只要交由Spring容器管理的话，那么Spring就会回调该接口的方法，用于对BeanDefinition注册和修改的功能。

@FunctionalInterface
public interface BeanFactoryPostProcessor {
    void postProcessBeanFactory(ConfigurableListableBeanFactory var1) throws BeansException;
}
1
2
3
4

2.2.1 入门

定义类MyBeanFactoryPostProcessor并实现接口BeanFactoryPostProcessor

public class MyBeanFactoryPostProcessor implements BeanFactoryPostProcessor {
    //方法对应的参数就是BeanFactory
    public void postProcessBeanFactory(ConfigurableListableBeanFactory beanFactory) throws BeansException {
        System.out.println("beanDefinitionMap填充完毕后回调该方法...");

    }
}
1
2
3
4
5
6
7

配置信息

<bean class="com.zhangjingqi.processor.MyBeanFactoryPostProcessor"></bean>
1

测试类

ClassPathXmlApplicationContext applicationContext = new ClassPathXmlApplicationContext("beans.xml");
1

那这个工厂后处理器有什么作用呢？看下面这个例子

配置文件

注意看userService对应的全限定名

<bean class="com.zhangjingqi.processor.MyBeanFactoryPostProcessor"></bean>

<bean id="userService"  class="com.zhangjingqi.service.impl.UserServiceImpl"/>
1
2
3

工厂后处理器

public class MyBeanFactoryPostProcessor implements BeanFactoryPostProcessor {
    //方法对应的参数就是BeanFactory
    public void postProcessBeanFactory(ConfigurableListableBeanFactory beanFactory) throws BeansException {
        System.out.println("beanDefinitionMap填充完毕后回调该方法...");
        //修改某一个beanDefinition
        // 说明：为了安全起见，并没有给我们提供getBeanDefinitionMap方法
        //      但是允许我们根据名字取获取某一个beanDefinition
        BeanDefinition beanDefinition = beanFactory.getBeanDefinition("userService");
        //userService全限定名是com.zhangjingqi.service.impl.UserServiceImpl
        //我们现在要改成com.zhangjingqi.dao.impl.UserDaoImpl
        beanDefinition.setBeanClassName("com.zhangjingqi.dao.impl.UserDaoImpl");

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

测试

发现已经不是UserServiceImpl，而是UserDaoImpl

//参数是一个xml配置文件
ClassPathXmlApplicationContext applicationContext = new ClassPathXmlApplicationContext("beans.xml");
Object userService = applicationContext.getBean("userService");
System.out.println(userService);
1
2
3
4

2.2.2 Bean工厂后处理器注册BeanDefinition

之前我们创建Bean是在对应的xml文件中进行添加Bean标签

现在我们换一种方式，将Bean的注册放在工厂后处理器中

Bean工厂后处理器注册BeanDefinition

    //方法对应的参数就是BeanFactory
    public void postProcessBeanFactory(ConfigurableListableBeanFactory beanFactory) throws BeansException {
        System.out.println("beanDefinitionMap填充完毕后回调该方法...");
//      注册BeanDefinition
        BeanDefinition beanDefinition = new RootBeanDefinition();
        beanDefinition.setBeanClassName("com.zhangjingqi.dao.impl.PersonDaoImpl");

//      ConfigurableListableBeanFactory内部没有注册BeanDefinition
//      beanFactory.registerSingleton();此方法是其放入到单例池当中
//      需要把ConfigurableListableBeanFactory类型强转为子类DefaultListableBeanFactory
        DefaultListableBeanFactory defaultListableBeanFactory = (DefaultListableBeanFactory)beanFactory;
        defaultListableBeanFactory.registerBeanDefinition("personDao",beanDefinition);
    }
1
2
3
4
5
6
7
8
9
10
11
12
13

测试

ClassPathXmlApplicationContext applicationContext = new ClassPathXmlApplicationContext("beans.xml");
Object personDao = applicationContext.getBean("personDao");
System.out.println(personDao);
1
2
3

2.2.3 BeanDefinitionRegistryPostProcessor专门注册BeanDefinition操作

Spring 提供了一个BeanFactoryPostProcessor的子接口BeanDefinitionRegistryPostProcessor专门用于注册BeanDefinition操作，不再需要强转参数，比较方便

public class MyBeanFactoryPostProcessor2 implements BeanDefinitionRegistryPostProcessor {

//  之前接口的方法
    public void postProcessBeanFactory(ConfigurableListableBeanFactory configurableListableBeanFactory) throws BeansException {
        System.out.println("MyBeanFactoryPostProcessor2的postProcessBeanFactory方法");
    }

//   BeanDefinitionRegistryPostProcessor接口的方法，专门用于注册BeanDefinition操作
    public void postProcessBeanDefinitionRegistry(BeanDefinitionRegistry beanDefinitionRegistry)
            throws BeansException {
        System.out.println("MyBeanFactoryPostProcessor2的postProcessBeanDefinitionRegistry");

        BeanDefinition beanDefinition = new RootBeanDefinition();

        beanDefinition.setBeanClassName("com.zhangjingqi.dao.impl.UserDaoImpl");

        beanDefinitionRegistry.registerBeanDefinition("userDao2", beanDefinition);
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19

执行顺序

2.2.4 完善实例化基本流程图

BeanDefinitionRegistryPostProcessor接口的实现类执行顺序要比其父类接口BeanFactoryPostProcessor的实现类的执行顺序靠前，如下图所示

2.3 BeanPostProcessor Bean后处理器

BeanPostProcessor：Bean后处理器，一般在Bean实例化之后，填充到单例池singletonObjects之前执行

Bean被实例化后，到最终缓存到名为singletonObjects单例池之前，中间会经过Bean的初始化过程

例如：属性的填充、初始方法init的执行等，其中有一个对外进行扩展的点BeanPostProcessor，我们称为Bean后处理。跟上面的Bean工厂后处理器相似，它也是一个接口，实现了该接口并被容器管理的BeanPostProcessor，会在流程节点上被Spring自动调用。

2.3.1 入门

BeanPostProcessor接口实现类代码

Bean实例化之后才执行下面的两个方法

参数： bean是当前被实例化的Bean**，**beanName是当前Bean实例在容器中的名称

返回值：当前Bean实例对象

public class MyBeanPostProcessor implements BeanPostProcessor {
//  先执行
    public Object postProcessBeforeInitialization(Object bean, String beanName) throws BeansException {
        System.out.println(bean+":postProcessBeforeInitialization:"+beanName);
        return bean;
    }

//  后执行
    public Object postProcessAfterInitialization(Object bean, String beanName) throws BeansException {
        System.out.println(bean+":postProcessAfterInitialization:"+beanName);
        return bean;
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13

配置文件信息

<bean class="com.zhangjingqi.factory.MyBeanPostProcessor"></bean>
1

然后我们再随便配置一个bean，否则没有效果

<bean id="userService" class="com.zhangjingqi.service.impl.UserServiceImpl"/>
1

测试信息

ClassPathXmlApplicationContext applicationContext = new ClassPathXmlApplicationContext("beans.xml");
1

2.3.2 before 与 after执行时机

由下图可得，执行顺序肯定是先before再after

那在before与after方法中间有哪些操作呢？

对应Bean的一些初始化方法

顺序：

①Bean先创建

②执行before方法

③执行Bean初始化操作

需要再Bean创建时指定 init-method="init"参数与参数值

或者是实现InitializingBean接口并重写afterPropertiesSet方法

如果都有的话，先执行afterPropertiesSet方法再执行init-method

<bean id="userDao"  init-method="init"
      class="com.zhangjingqi.dao.impl.UserDaoImpl"></bean>
1
2

public class UserDaoImpl implements UserDao, InitializingBean {
    public UserDaoImpl() {
        System.out.println("userDao实例化");
    }

    public void init() {
        System.out.println("init 初始化方法开始执行");
    }

    public void afterPropertiesSet() throws Exception {
        System.out.println("afterPropertiesSet");
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13

④执行after方法

2.3.3 对Bean方法进行执行时间日志增强

要求

• Bean的方法执行之前控制台打印当前时间
• Bean的方法执行之后控制台打印当前时间

• 对方法进行增强主要就是代理设计模式和包装设计模式；

• 由于Bean方法不确定，所以使用动态代理在运行期间执行增强操作；

• 在Bean实例创建完毕后，进入到单例池之前，使用Proxy代替真是的目标Bean

public class TimeLogBeanPostProcessor implements BeanPostProcessor {
    public Object postProcessAfterInitialization(Object bean, String beanName) throws BeansException {
        //     使用动态代理对目标Bean进行增强，返回proxy对象，进而存储到单例池当中
        Object proxyBean = Proxy.newProxyInstance(bean.getClass().getClassLoader(),
                bean.getClass().getInterfaces(),
                (Object proxy, Method method, Object[] args) -> {
                    long start = System.currentTimeMillis();
                    System.out.println("开始时间：" + new Date(start));
                    //执行目标方法
                    Object result = method.invoke(bean, args);
                    long end = System.currentTimeMillis();
                    System.out.println("结束时间：" + new Date(end));
                    return result;
                });
        //返回代理对象
        return proxyBean;

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

其实我感觉这个地方是有点难度的，但是在SpringBoot当中时非常简单的，可以看一下下面这篇文章SpringBoot——IOC与AOP_

2.3.4 完善实例化基本流程图

三、SpringBean 生命周期

生命周期：从 Bean 实例化之后，即通过反射创建出对象之后，到Bean成为一个完整对象，最终存储到单例池中

Spring Bean的生命周期大体上分为三个阶段

• Bean的实例化阶段

Spring框架会取出BeanDefinition的信息进行判断当前Bean的范围是否是singleton的，是否不是延迟加载的，是否不是FactoryBean等，最终将一个普通的singleton的Bean通过反射进行实例化

• Bean的初始化阶段

Bean创建之后还仅仅是个"半成品"，还需要对Bean实例的属性进行填充、执行一些Aware接口方法、执行BeanPostProcessor方法、执行InitializingBean接口的初始化方法、执行自定义初始化init方法等。该阶段是Spring最具技术含量和复杂度的阶段，Aop增强功能，后面要学习的Spring的注解功能等、spring高频面试题Bean的循环引用问题都是在这个阶段体现的；

• Bean的完成阶段

经过初始化阶段，Bean就成为了一个完整的Spring Bean，被存储到单例池singletonObjects中去了，即完成了Spring Bean的整个生命周期。

3.1 初始化过程

• Bean实例的属性填充

• Aware接口属性注入

  这一步的前提是实现Aware接口。

  实现框架提供好的一些扩展Aware接口，然后需要什么框架就通过Aware接口规定的一些方法给注入进去

• BeanPostProcessor的before()方法回调

• InitializingBean接口的初始化方法回调

• 自定义初始化方法init回调

• BeanPostProcessor的after()方法回调

后四步顺序我们在上面的代码中已经演示过了

3.1.1 Bean实例的属性注入

BeanDefinition中有对当前Bean实体的注入信息通过属性propertyValues进行了存储

例如UserService的属性信息，如下所示

类中设置两个属性

public class UserServiceImpl implements UserService  {

    private UserDao userDao;
    public void setUserDao(UserDao userDao) {
        this.userDao =userDao;
    }

    private String username;

    public void setUsername(String username) {
        this.username = username;
    }

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

    <bean id="userService" class="com.zhangjingqi.service.impl.UserServiceImpl">
        <property name="username" value="zhangjingqi"></property>
        <property name="userDao" ref="userDao"></property>
    </bean>

    <bean id="userDao" class="com.zhangjingqi.dao.impl.UserDaoImpl"></bean>

1
2
3
4
5
6
7

如下图所示

Spring在进行属性注入时，会分为如下几种情况：

• 注入普通属性，String、int或存储基本类型的集合时，直接通过set方法的反射设置进去
• 注入单向对象引用属性时，从容器中getBean获取后通过set方法反射设置进去，如果容器中没有，则先创建被注入对象Bean实例（完成整个生命周期）后，在进行注入操作

比如我们上面的程序中UserServiceImpl类创建依赖UserDao类，但是UserDao类不依赖UserServiceImpl类，这就是单项的

假如说我们创建UserServiceImpl的时候发现内部需要UserDao，但是我们从容器中并没有找到UserDao，那我们此时UserServiceImpl创建Bean的操作停止，开始创建UserDao的Bean，直到UserDao完全创建完成再开始UserServiceImpl的创建Bean的操作
1
2
3

• 注入双向对象引用属性时，就比较复杂了，涉及了循环引用（循环依赖）问

  循环引用：多个实体之间相互依赖并形成闭环的情况叫做“循环依赖”，也叫做“循环引用”

  比如说

  我们创建UserService接口的实例Bean，首先实例化Service，再初始化Service，但是UserService属性的填充需要UserDao，但是此时容器没有UserDao对象，所以我们要先创建一个UserDao对象

  UserDao实例化依然是UserDao初始化属性填充，但是此时需要UserService对象，但是我们的UserService对象并没有创建完毕，所以容器又去创建UserService对象，此时进入了死循环

  

  如下图所示，循环引用：

  

为了解决循环依赖的问题，Spring提供了三级缓存

3.1.2 三级缓存设计原理

Spring提供了三级缓存存储完整Bean实例和半成品Bean实例，用于解决循环依赖的问题

singletonObjects 单例池存储完整Bean

earlySingletonObjects 存储半成品对象，且当前对象已经被其他对象引用

singletonFactories 存储半成品对象，对象未被引用

public class DefaultSingletonBeanRegistry ... {
    //1、最终存储单例Bean成品的容器，即实例化和初始化都完成的Bean，称之为"一级缓存"
    Map<String, Object> singletonObjects = new ConcurrentHashMap(256);
    
    //2、早期Bean单例池，缓存半成品对象，且当前对象已经被其他对象引用了，称之为"二级缓存"
    Map<String, Object> earlySingletonObjects = new ConcurrentHashMap(16);
    
    //3、单例Bean的工厂池，缓存半成品对象，对象未被引用，使用时在通过工厂创建Bean，称之为"三级缓存"
    Map<String, ObjectFactory<?>> singletonFactories = new HashMap(16);
}
1
2
3
4
5
6
7
8
9
10

结合这张图，理由三级缓存原理再来看一下

• 创建UserServiceBean把UserService的引用存储到第三级缓存singletonFactories当中

但是在存储三级缓存的时候，并不是直接把创建好的UserService对象存进去，而是为UserService外面包一层（为UserService创建一个对应的ObjectFactory），并且在ObjectFactory类中的getObject方法中再return返回刚才创建好的UserService（只不过不是一个完整的Bean）

String是Key，我们定义的BeanName，而Value是ObjectFactory，不再是Bean了（包了一层ObjectFactory），真正用到UserService的时候，再调用ObjectFactory.getObject方法返回UserService对象

   Map<String, ObjectFactory<?>> singletonFactories = new HashMap(16);
1

三级缓存singletonFactories当中的Bean实际是未被别人引用的（创建完就扔进去了，别人还没有注入）

• 此时到了第二步但是在Service初始化的时候，需要判断容器中是否有UserDao对象

如今判断方式和之前不一样了，现在找的时候可以从第一级到三级缓存中寻找，挨个找，一级缓存没找找二级，二级没有找三级，然后发现都没有UserDao对象，所以就创建UserDao对象

此时创建的UserDao对象也向三级缓存中存放

• 此时我们就创建UserDao对象，但是需要注入属性UserService，此时需要从容器中寻找

  找的时候可以从第一级到三级缓存中寻找，挨个找，一级缓存没有找二级，二级没有找三级，最终在第三级缓存中找到UserService对象，调用ObjectFactory的getObject方法，最终把UserService的引用注入给UserDao

  与此同时再把Service从三级缓存当中移除掉，把其放入到二级缓存当中

  

• 之后再执行UserDao之后的生命之后，生成完整的UserDao的Bean

  此时UserDao的Bean要存储到一级缓存，将三级缓存中的UserDao进行删除

• UserDao完成之后回溯到UserService初始化注入UserDao操作，执行一些列操作后成为完整Bean

此时UserService填充完整的UserDao，从一级缓存中找到的

成为完整的Bean后，从二级缓存中删除UserService，将其加入到一级缓存之中

总结

• UserService 实例化对象，但尚未初始化，将UserService存储到三级缓存
• UserService 属性注入，需要UserDao，从缓存中获取，没有UserDao
• UserDao实例化对象，但尚未初始化，将UserDao存储到到三级缓存
• UserDao属性注入，需要UserService，从三级缓存获取UserService，UserService从三级缓存移入二级缓存
• UserDao执行其他生命周期过程，最终成为一个完成Bean，存储到一级缓存，删除二三级缓存
• UserService 注入UserDao
• UserService执行其他生命周期过程，最终成为一个完成Bean，存储到一级缓存，删除二三级缓存

3.2 常用的Aware接口

Aware接口是一种框架辅助属性注入的一种思想，其他框架中也可以看到类似的接口

框架具备高度封装性，我们接触到的一般都是业务代码，一个底层功能API不能轻易的获取到，但是这不意味着永远用不到这些对象，如果用到了，就可以使用框架提供的类似Aware的接口，让框架给我们注入该对象。

下面来测试一下

导包

        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-web</artifactId>
            <version>5.3.7</version>
        </dependency>

        <dependency>
            <groupId>javax.servlet</groupId>
            <artifactId>javax.servlet-api</artifactId>
            <version>4.0.1</version>
        </dependency>
1
2
3
4
5
6
7
8
9
10
11

四、Spring IOC整体流程总结

这张图很重要，最终流程图

从头到尾看一遍

• 第一张图

  此图流程具体详情在1.1与1.1中有详细说明

  Bean标签怎么变成Bean对象的呢？

  BeanDefinition Reader会读取xml文件中的Bean标签，每一个Bean标签的信息都抽取到外面封装成BeanDefinition对象（Bean定义对象），在此对象中存储的是Bean对象的一些信息，并不是我们要创建的Bean对象

  所有的BeanDefinition对象存储到beanDefinitionMap集合之中

  存完之后Spring会把此Map全部遍历一遍，取出每一个Definition，再从Definition中取出一些Bean相关信息，取出后通过反射创建对象

  把反射创建的对象存储到singletonObjects单例池之中

  我们最终getBean时就是从单例池中获取Bean

• 第二张图

  具体详情可以查看2.2

  之后我们讲了BeanFactory后处理器

BeanFactory后处理器是在beanDefinitionMap封装完毕之后，创建对象之前执行的

在这里我们可以进行BeanDefinition的修改，也可以进行BeanDefinition的注册

• 第三张图

具体详情可以查看 2.3

BeanPostProcessor：Bean后处理器，一般在Bean实例化之后，填充到单例池singletonObjects之前执行

Bean后处理器也是对功能的进行扩展

有两个方法before与after

• 最后一张图

  比之前多了一个bean的生命周期