当前位置:   article > 正文

Spring - Bean的实例化流程及生命周期_springboot的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的信息进行封装的

image-20230605135938405

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

image-20230605140333446

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

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

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

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

image-20230605140037210

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

image-20230605143319758

​ 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实例返回

image-20230605145506928

二、 Bean 后处理器

2.1 介绍

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

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

Spring主要有两种后处理器

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

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

2.2 BeanFactoryPostProcessor Bean工厂后处理器

BeanFactoryPostProcessorBean工厂后处理器,在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

image-20230605152809082

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

配置文件

注意看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

image-20230605154146828

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

image-20230605160422799

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

执行顺序

image-20230605162953015

2.2.4 完善实例化基本流程图

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

image-20230605163304002

2.3 BeanPostProcessor Bean后处理器

BeanPostProcessorBean后处理器,一般在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

image-20230605202459396

2.3.2 before 与 after执行时机

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

image-20230605202459396

那在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

image-20230605204450140

④执行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 完善实例化基本流程图

image-20230605211520347

三、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

如下图所示

image-20230606100900921

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对象,此时进入了死循环

    image-20230606104841879

    如下图所示,循环引用:

    image-20230606104445215

为了解决循环依赖的问题,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当中

image-20230606142605246

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

image-20230606112512833

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

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

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

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

image-20230606104841879

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

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

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

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

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

    image-20230606142956749

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

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

image-20230606144227122

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

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

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

image-20230606144633447

总结

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

image-20230606140138311

image-20230606114607735

3.2 常用的Aware接口

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

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

Aware接口回调方法作用
ServletContextAwaresetServletContext(ServletContext context)Spring框架回调方法注入ServletContext对象,web环境下才生效
BeanFactoryAwaresetBeanFactory(BeanFactory factory)Spring框架回调方法注入beanFactory对象
BeanNameAwaresetBeanName(String beanName)Spring框架回调方法注入当前Bean在容器中的beanName
ApplicationContextAwaresetApplicationContext(ApplicationContext applicationContext)Spring框架回调方法注入applicationContext对象

下面来测试一下

导包

        <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整体流程总结

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

image-20230606153750630

从头到尾看一遍

  • 第一张图

    此图流程具体详情在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

image-20230605145506928

  • 第二张图

    具体详情可以查看2.2

    之后我们讲了BeanFactory后处理器

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

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

image-20230606155018885

  • 第三张图

具体详情可以查看 2.3

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

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

有两个方法before与after

image-20230606155353947

  • 最后一张图

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

image-20230606153750630

声明:本文内容由网友自发贡献,不代表【wpsshop博客】立场,版权归原作者所有,本站不承担相应法律责任。如您发现有侵权的内容,请联系我们。转载请注明出处:https://www.wpsshop.cn/w/知新_RL/article/detail/66316
推荐阅读
相关标签
  

闽ICP备14008679号