Spring中bean的生命周期(笔记）

bean的生命周期，按照最重要五步

第一步：实例化bean,调用无参构造方法（通过BeanDefinition 利用反射实例化Bean对象 (无参数构造方法) 并通过推断构造方法...并放入三级缓存中 ..）

第二步：给bean属性赋值（调用set方法）（依赖注入循环依赖问题(三级缓存)）

第三步：初始化bean（会调用bean的init方法，注意，这个init需要自己去配自己写）

第四步：使用bean

第五步：销毁bean （需要调用destroy方法，需要自己写，自己配）

java 复制代码

public class User {

    private String username;


    public User() {
        System.out.println("第一步，无参构造执行");
    }

    public void setUserName(String username) {
        System.out.println("第二步，给构造方法中的属性赋值");
        this.username = username;
    }

    public void initBean()
    {
        System.out.println("第三步初始化Bean");
    }
-------------------------
    public void  destroy()
    {
        System.out.println("第五步销毁Bean");
    }
}

java 复制代码

<!--    手动指定初始化方法和销毁方法-->
    <bean id="userBean" class="com.bili.spirng.domain.User" init-method="initBean" destroy-method="destroy">
 在初始化之前执行，user方法都被调用了
        <property name="userName" value="cccccccc"></property>
    </bean>
</beans>

**七步：**在初始化的前和后

/**

* 第一步：实例化bean,调用无参构造方法

* 第二步：给bean属性赋值（调用set方法）
在这里会执行bean后处理器的Before方法

该接口的before和after方法里可以完成对bean属性的读取修改等..

* 第三步：初始化bean（会调用bean的init方法，注意，这个init需要自己去配自己写）
在这里会执行Bean后处理器的after方法

一般AOP是在这里实现的==>AbstractAutoProxyCreator()..

* --------------到这步就基本完成了-------------------

* 第四步：使用bean

* 第五步：销毁bean （需要调用destroy方法，需要自己写，自己配）

java 复制代码

<!--    强调这个处理器：将作用于整个当前配置文件的bean对象,会自己去调用，先自己写类-->
    <bean id="LogBeanPostProcessor" class="com.bili.spirng.domain.LogBeanPostProcessor"></bean>
</beans>

java 复制代码

/**
 * 日志后处理器
 * 这两个参数，第一个传入刚创建出来的bean对象，第二个参数传入bean的名称(会自己去传)
 * 但是你写好后还不行，还是得配进去让Spring管理器起来 注意一旦bean创建起来就会去自动执行，
比方说我们不需要再去user这个对象里面自己去配置before 以及 after 去调用
 */
public class LogBeanPostProcessor implements BeanPostProcessor {
    @Override
    public Object postProcessBeforeInitialization(Object bean, String beanName) throws BeansException {
        System.out.println("执行bean:"+beanName+"后处理器的before");
        return BeanPostProcessor.super.postProcessBeforeInitialization(bean, beanName);
    }

    @Override
    public Object postProcessAfterInitialization(Object bean, String beanName) throws BeansException {
        System.out.println("执行bean:"+beanName+"后处理器的after");
        return BeanPostProcessor.super.postProcessAfterInitialization(bean, beanName);
    }
}

十步：都是在检查是否对象实现了特定的接口，那么如果实现了，Spring会调用这个接口的方法

1.在bean后处理器before方法之前，会检查是否实现aware接口

2.在bean后处理器before方法之后, 检查Bean是否实现了InitializingBean接口

3.使用bean之后，或者销毁bean前

/**

* 第一步：实例化bean,调用无参构造方法

* 第二步：给bean属性赋值（调用set方法）

（新增）before方法之前：

这时候新实现了这三个之一的接口aware。每个对象都会去判断，如果说实现了，那我Spring就调用setBeanClassLoader，setBeanFactory或者setBeanName之一(这里我都写了)

**作用：**可以用来获取信息..

看你继承了哪个，重点并自己传入参数，假如说以后有个需求让你使用bean的名字那么我就去继承BeanNameAware去调用setBeanName的方法，那么spring已看你实现了接口，那我就去调这个方法，把这个名称传进去，不用我们人为传，就是传数据让你使用罢了吧。

在这里会执行bean后处理器的Before方法、

新增：before之后:执行InitializingBean（可以完成一些属性的赋值操作）

* 第三步：初始化bean（会调用bean的init方法，注意，这个init需要自己去配自己写）

在这里会执行Bean后处理器的after方法

* --------------到这步就基本完成了-------------------

* 第四步：使用bean

检查Bean是否实现了DispoableBean接口,并执行销毁方法

* 第五步：销毁bean （需要调用destroy方法，需要自己写，自己配）

* 以上都可以在某个点位执行你想要的结果

java 复制代码

public class User implements BeanFactoryAware , BeanClassLoaderAware, InitializingBean , DisposableBean {

    private String username;


    public User() {
        System.out.println("第一步，无参构造执行");
    }

    public void setUserName(String username) {

        this.username = username;
        System.out.println("第二步，给构造方法中的属性赋值 username:"+username);
    }

    public void initBean()
    {
        System.out.println("第三步初始化Bean");
    }

    public void  destroyBean()
    {
        System.out.println("第五步销毁Bean");
    }

    @Override
    public void setBeanFactory(BeanFactory beanFactory) throws BeansException {
        System.out.println("生产"+beanFactory);
    }

    @Override
    public void setBeanClassLoader(ClassLoader classLoader) {
        System.out.println(classLoader);
    }

    @Override
    public void afterPropertiesSet() throws Exception {
        System.out.println("init被调用了");
    }
    @Override
    public void destroy() throws Exception {
        System.out.println("销毁前");
    }
}

补充：

**- BeanPostProcessor后置处理器是对所有Bean的初始化前后进行拦截...

Aware InitializingBean等都是针对某个Bean的初始化前后做的处理...**