SpringBean的生命周期

保持敬畏

已于 2023-09-26 18:03:52 修改

阅读量284

点赞数

分类专栏： Spring 5 文章标签： java 面试 sql

于 2023-09-23 18:05:15 首次发布

本文链接：https://blog.csdn.net/weixin_64939936/article/details/133210014

版权

Spring 5 专栏收录该内容

46 篇文章 0 订阅

订阅专栏

SpringBean的生命周期

SperingBean的生命周期是从Bean实例化之后，即通过反射创建出对象之后，到Bean成为一个完整对象，最终存储到单例池中，这个过程被称为Spring Bean的生命周期。Spring Bean的生命周期大体上分为三个阶段
- Bean的实例化阶段：Spring框架会取出BeanDefiniton的信息进行判断当前Bean的范围是否是singleton的，是否不是延迟加载的，是否不是FactoryBean等，最终将一个普通的singleton的Bean通过反射（加载类）进行实例化
- Bean的初始化阶段（着重研究）：Bean创建之后还仅仅是个半成品，还需要对Bean实例的属性进行填充、执行一些Aware接口方法、执行BeanPostProcessor方法，执行InitializingBean接口的初始化方法、执行自定义初始化init方法等。该阶段是Spring最具有技术含量和复杂程度的阶段，AOP增强功能，后面学习的Spring的注解功能等、spring高频面试题Bean的循环引用问题都是在这个阶段体现的
- Bean的完成阶段：经过初始化阶段，Bean就成为了一个完整的Spring Bean，被存储到单例池singletonObjects中，即完成了Spring Bean的整个生命周期。

Spring Bean的初始化阶段涉及过程

Bean实例属性的填充
Aware接口属性的注入
BeanPostProcessor的before（）方法回调
InitializingBean接口的初始化方法回调
自定义初始化方法init回调
BeanPostProcessor的after（）方法回调

Bean实例属性填充

BeanDefinition中对当前Bean实体的注入信息通过属性propertyValue进行了储存，例如UserService的属性信息如下

    <bean id="userService" class="com.example.Service.Impl.UserServiceImpl">
        <property name="userDAO" ref="userDAO"></property>
        <property name="name" value="hhhh"></property>
    </bean>
    <bean name="userDAO" class="com.example.DAO.Impl.UserDAOImpl"></bean>

属性注入的三种情况

注入普通属性，String，int或存储基本类型的集合时，直接通过set方法反射设置进去
- 上述属性name对应类中的set方法

注入单向对象引用属性时，从容器中getBean获取后通过set方法反射设置进去，如果容器中没有，则先创建被注入对象Bean实例（完成整个生命周期）后，再进行注入操作

上述UserDAO属性的注入
根据配置文件中bean的位置不同，进行的顺序也不一样
主要代码如下
UserServiceImpl类

package com.example.Service.Impl;

import com.example.DAO.UserDAO;
import com.example.Service.UserService;


public class UserServiceImpl implements UserService {
    public UserServiceImpl() {
        System.out.println("UserService对象创建");
    }

    private UserDAO userDAO;
    private String name;


    public void setName(String name) {
        this.name = name;
    }

    public void setUserDAO(UserDAO userDAO) {
        System.out.println("UserService执行注入UserDAO的操作:setDAO方法");
        this.userDAO = userDAO;
    }

    @Override
    public void show() {
        System.out.println("show~~~");
    }
}

UserDAOImpl类

package com.example.DAO.Impl;

import com.example.DAO.UserDAO;

public class UserDAOImpl implements UserDAO {

    public UserDAOImpl() {
        System.out.println("UserDAO对象创建");
    }
}

测试类

package com.example.Test;


import com.example.Service.UserService;
import org.springframework.context.support.ClassPathXmlApplicationContext;

public class TestApplicationContext {
    public static void main(String[] args) {
        ClassPathXmlApplicationContext context = new ClassPathXmlApplicationContext("application.xml");
        UserService UserServiceBean = (UserService) context.getBean(UserService.class);
    }
}

若配置文件中先创建UserADO的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.xsd">
    <bean class="com.example.PostProcessor.TimeLogBeanPostProcessor"></bean>
    <!--    <bean id="userService" class="com.example.Service.Impl.UserServiceImpl">-->
    <!--    </bean>-->
    <!--    <bean id="userDAO" class="com.example.DAO.Impl.UserDAOImpl">-->
    <!--    </bean>-->
    <!--    <alias name="userDAO" alias="xxx"/>-->
    <!--    <alias name="userDAO" alias="yyy"/>-->
    <bean name="userDAO" class="com.example.DAO.Impl.UserDAOImpl"></bean>
    <bean id="userService" class="com.example.Service.Impl.UserServiceImpl">
        <property name="userDAO" ref="userDAO"></property>
        <property name="name" value="hhhh"></property>
    </bean>

</beans>

测试类运行结果为
若配置文件中先创建UserService的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.xsd">
    <bean class="com.example.PostProcessor.TimeLogBeanPostProcessor"></bean>
    <!--    <bean id="userService" class="com.example.Service.Impl.UserServiceImpl">-->
    <!--    </bean>-->
    <!--    <bean id="userDAO" class="com.example.DAO.Impl.UserDAOImpl">-->
    <!--    </bean>-->
    <!--    <alias name="userDAO" alias="xxx"/>-->
    <!--    <alias name="userDAO" alias="yyy"/>-->

    <bean id="userService" class="com.example.Service.Impl.UserServiceImpl">
        <property name="userDAO" ref="userDAO"></property>
        <property name="name" value="hhhh"></property>
    </bean>
    <bean name="userDAO" class="com.example.DAO.Impl.UserDAOImpl"></bean>

</beans>

运行结果如下

注入双向对象引用属性时，就比较复杂了，涉及循环引用（循环依赖）问题，下面会详细阐释解决方案。
- 循环依赖
  - 多个实体之间相互依赖并形成闭环的情况叫做“循环依赖”，也叫“循环引用”
  - 上述流程图显示如果按照常规的方法来存储bean对象，则就会陷入死循环，因为在bean对象的创建过程中，还需要进行初始化的过程，上述有讲到bean的生命周期，当bean对象实例化完成之后，最终才会存放到单例池中，才完成交给Spring容器的功能。
- Spring提供了三级缓存存储完整Bean实例和半成品Bean实例，用于解决循环引用问题
- 在DefaultListableBeanFactory的上四级父类DefaultSingletonBeanResgisty中提供如下三个Map（分别存储不同状态下的Map）
  - ```
  public class DefaultSingletonBeanRegistry .......{
          .....
  // todo 最终存储单例Bean成品的容器，即实例化和初始化都完成的Bean，称之为’一级缓存‘
  private final Map<String, Object> singletonObjects=new ConcurrentHashMap(256);
  // todo 早期Bean单例池，缓存半成品对象，且当前对象已经被其它对象引用了，称之为‘二级缓存’
  private final Map<String, Object> earlySingletonObjects=new ConcurrentHashMap(16);
  // todo 单例Bean的工厂池，缓存半成品对象，对象未被引用，使用时再通过工厂创建Bean，称之为‘三级缓存’
  private final Map<String, ObjectFactory<?>>singletonFactories=new HashMap(16);
          .....
          }
```
- 上述流程图中的实例化Service/DAO存放在三级缓存中，将其包装为对应的ObjectFactory，在ObjectFactory的getObject（）方法中返回我们创建好的UserService/DAO,即上述流程图中的实例化Service/DAO，ObjectFactory是用来创建和管理Service/DAO对象的工厂类，而不是用来实例化Service/DAO对象的。被引用后，就会交给二级缓存，从三级换中移除。

对于上述流程图的描述（UserService和userDAO循环依赖的过程结合上述三级缓存描述）
- UserService实例化对象，但尚未完成初始化，将UserService存储到三级缓存中
- UserService属性注入，需要USerDAO，从缓存中获取，没有USerDAO
- USerDAO实例化对象，但尚未初始化，将UserDAO存储到三级缓存中
- USerDAO属性注入，需要UserService，从三级缓存中获取USerService，UserService从三级缓存移入到二级缓存
- UserDAO执行其它生命周期过程，最终成为一个完整的Bean，存储到一级缓存，删除二三级缓存
- UserService注入UserDAO
- UserService执行其它生命周期，最终成为一个完整的Bean，存储到一级缓存，删除二三级缓存

常用的Aware接口

Aware接口是一种框架辅助属性注入的一种思想，其它框架中也可以看见类似的接口，框架具有高度的封闭性，我们接触到的一般都是业务代码，一个底层的API代码不能轻易获取到，但这并不意味着永远用不到这些对象，如果用到了，就可以使用框架提供的类似Aware的接口，让框架给我们注入该对象

Aware接口	回调方法	作用
ApplicationContextAware	setApplicationContext(ApplicationContext applicationContext)	允许Bean获取ApplicationContext对象，从而可以访问Spring容器的各种功能。
BeanFactoryAware	setBeanFactory(BeanFactory beanFactory)	允许Bean获取BeanFactory对象，从而可以访问Spring容器的Bean工厂。
BeanNameAware	setBeanName(String name)	允许Bean获取自己在Spring容器中的名称。
ServletContextAware	setServletContext(ServletContext servletContext)	允许Bean获取ServletContext对象，从而可以访问Servlet容器的功能。

在Spring中，Aware接口的作用是让Bean能够感知和获取一些特定的功能或资源。通过实现Aware接口，并在对应的回调方法中接收相关的对象，Bean可以在运行时获取到Spring容器提供的一些重要信息或功能。

举个例子来说，如果一个Bean实现了ApplicationContextAware接口并实现了对应的回调方法，那么在Bean初始化的过程中，Spring容器会将ApplicationContext对象传递给该Bean。这样，该Bean就能够直接访问ApplicationContext，从而获取到Spring容器的各种功能，比如获取其他Bean、读取配置文件、发布事件等。这样的设计使得Bean能够更加灵活地与Spring容器进行交互，而不仅仅局限于自身的业务逻辑。

类似地，其他的Aware接口也提供了类似的功能，让Bean能够获取到BeanFactory、Bean的名称、国际化消息、资源加载器、应用程序事件发布器、运行时环境等等。通过实现这些Aware接口，Bean可以获取到所需的功能或资源，从而实现更加灵活和可扩展的功能。