SpringBean的生命周期

Original aspirationㅤ

已于 2023-04-06 22:25:29 修改

阅读量694

点赞数

分类专栏： Spring 笔记文章标签： java spring

于 2023-04-05 22:40:32 首次发布

版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。

本文链接：https://blog.csdn.net/qq_45763504/article/details/129978834

版权

笔记同时被 2 个专栏收录

23 篇文章 1 订阅

订阅专栏

6 篇文章 0 订阅

订阅专栏

目录

一、从源码角度分析

二、演示生命周期的流程

第一步：创建Person类

第二步：创建MyBeanPostProcessor

第三步：创建 MyInstantiationAwareBeanPostProcessor

第四步：创建 MyBeanFactoryPostProcessor

第五步：创建beans.xml

第六步：创建启动类

第八步：查看结果

三、流程总结

一、从源码角度分析

https://boardmix.cn/app/share/CAE.CK_43QwgASoQ5twAV7N8WWvHais6XuObfDAGQAE/jeIJDy

建议Debug 一遍，思路更加清晰

二、演示生命周期的流程

第一步：创建Person类

public class Person implements BeanNameAware, BeanFactoryAware, ApplicationContextAware,
                                 InitializingBean ,
                                    DisposableBean{

    private String name;
    private String address;
    private String phone;

    private String beanName;
    private BeanFactory beanFactory;
    private ApplicationContext applicationContext;

    // 无参构造，用于帮助类做初始化
    public Person() {
        System.out.println("【构造器】调用Person的构造器实例化");
    }

    public String getName(){return name;}
    public void setName(String name) {System.out.println("【注入属性】注入属性name");this.name = name;}
    public String getAddress() {return address;}
    public void setAddress(String address) {System.out.println("【注入属性】注入属性address");this.address = address;}
    public String getPhone() {return phone;}
    public void setPhone(String phone) {System.out.println("【注入属性】注入属性phone");this.phone = phone;}
    @Override
    public String toString() {
        return "Person{" +
                "name='" + name + '\'' +
                ", address='" + address + '\'' +
                ", phone=" + phone +
                ", beanFactory=" + beanFactory +
                ", beanName='" + beanName + '\'' +
                '}';
    }

    // 1、这是BeanNameAware接口方法
    @Override
    public void setBeanName(String name) {
        System.out.println("【BeanNameAware接口】调用BeanNameAware.setBeanName()\"");
        this.beanName = name;
    }
    // 2、这是BeanFactoryAware接口方法
    @Override
    public void setBeanFactory(BeanFactory beanFactory) throws BeansException {
        System.out.println("【BeanFactoryAware接口】调用BeanFactoryAware.setBeanFactory()");
        this.beanFactory = beanFactory;
    }
    // 3、ApplicationContextAware接口方法
    @Override
    public void setApplicationContext(ApplicationContext applicationContext) throws BeansException {
        System.out.println("【ApplicationContext接口】调用ApplicationContext.setBeanFactory()");
        this.applicationContext = applicationContext;
    }
    // 这是InitializingBean接口方法
    @Override
    public void afterPropertiesSet() throws Exception {
        System.out.println("【InitializingBean接口】调用InitializingBean.afterPropertiesSet()");
    }
    // 这是DiposibleBean接口方法
    @Override
    public void destroy() throws Exception {
        System.out.println("【DiposibleBean接口】调用DiposibleBean.destory()");
    }
    // 通过<bean>的init-method属性指定的初始化方法
    public void myInit(){
        System.out.println("【init-method】调用<bean>的init-method属性指定的初始化方法");
    }
    // 通过<bean>的destroy-method属性指定的初始化方法
    public void myDestory(){
        System.out.println("【destroy-method】调用<bean>的destroy-method属性指定的初始化方法");
    }
}

第二步：创建MyBeanPostProcessor

public class MyBeanPostProcessor implements BeanPostProcessor {
    public MyBeanPostProcessor() {
        super();
        System.out.println("这是BeanPostProcessor实现类构造器！！");
    }

    /**
     * 如上，BeanPostProcessor接口包括2个方法postProcessAfterInitialization和postProcessBeforeInitialization，
     * 这两个方法的第一个参数都是要处理的Bean对象，
     * 第二个参数都是Bean的name。返回值也都是要处理的Bean对象。
     * @param bean
     * @param beanName
     * @return
     * @throws BeansException
     */
    @Override
    public Object postProcessBeforeInitialization(Object bean, String beanName) throws BeansException {
        System.out.println("BeanPostProcessor接口方法postProcessAfterInitialization对属性进行更改！");
        return bean;
    }

    @Override
    public Object postProcessAfterInitialization(Object bean, String beanName) throws BeansException {
        System.out.println("BeanPostProcessor接口方法postProcessBeforeInitialization对属性进行更改！");
        return bean;
    }
    
}

第三步：创建 MyInstantiationAwareBeanPostProcessor


/**
 * InstantiationAwareBeanPostProcessor 接口本质是BeanPostProcessor的子接口，
 * 一般我们继承Spring为其提供的适配器类InstantiationAwareBeanPostProcessor Adapter来使用它，如下：
 **/
public class MyInstantiationAwareBeanPostProcessor extends InstantiationAwareBeanPostProcessorAdapter {
    public MyInstantiationAwareBeanPostProcessor() {
        super();
        System.out.println("这是InstantiationAwareBeanPostProcessorAdapter实现类构造器！！");
    }

    // 接口方法、实例化Bean之前调用
    @Override
    public Object postProcessBeforeInitialization(Object bean, String beanName) throws BeansException {
        System.out.println("InstantiationAwareBeanPostProcessor调用postProcessBeforeInstantiation方法");
        return bean;
    }
    // 接口方法、实例化Bean之后调用
    @Override
    public Object postProcessAfterInitialization(Object bean, String beanName) throws BeansException {
        System.out.println("InstantiationAwareBeanPostProcessor调用postProcessAfterInitialization方法");
        return bean;
    }
    // 接口方法、设置某个属性时调用
    @Override
    public PropertyValues postProcessProperties(PropertyValues pvs, Object bean, String beanName) throws BeansException {
        System.out.println("InstantiationAwareBeanPostProcessor调用postProcessPropertyValues方法");
        return pvs;
    }
}

第四步：创建 MyBeanFactoryPostProcessor

public class MyBeanFactoryPostProcessor implements BeanFactoryPostProcessor {
    public MyBeanFactoryPostProcessor() {
        super();
        System.out.println("这是BeanFactoryPostProcessor实现类构造器！！");
    }

    @Override
    public void postProcessBeanFactory(ConfigurableListableBeanFactory beanFactory) throws BeansException {
        System.out.println("BeanFactoryPostProcessor调用postProcessBeanFactory方法");
        BeanDefinition person = beanFactory.getBeanDefinition("person");
        person.getPropertyValues().addPropertyValue("phone","110");
    }
}

第五步：创建beans.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" xmlns:p="http://www.springframework.org/schema/p"
       xmlns:aop="http://www.springframework.org/schema/aop" xmlns:tx="http://www.springframework.org/schema/tx"
       xsi:schemaLocation="
            http://www.springframework.org/schema/beans
            http://www.springframework.org/schema/beans/spring-beans-3.2.xsd">

    <bean id="beanPostProcessor" class="com.atliyilin.reggie.ioc.MyBeanPostProcessor">
    </bean>

    <bean id="instantiationAwareBeanPostProcessor" class="com.atliyilin.reggie.ioc.MyInstantiationAwareBeanPostProcessor">
    </bean>

    <bean id="beanFactoryPostProcessor" class="com.atliyilin.reggie.ioc.MyBeanFactoryPostProcessor">
    </bean>

    <bean id="person" class="com.atliyilin.reggie.ioc.Person"
          init-method="myInit"
          destroy-method="myDestory"
          scope="singleton" p:name="张三" p:address="广州" p:phone="15900000000" />

</beans>

第六步：创建启动类

public class BeanLifeCycle {
    public static void main(String[] args) {
        System.out.println("现在开始初始化容器");
        ApplicationContext factory = new ClassPathXmlApplicationContext("com/atliyilin/reggie/ioc/beans.xml");
        System.out.println("容器初始化成功");
        //得到Preson，并使用
        Person person = factory.getBean("person",Person.class);
        System.out.println(person);
        System.out.println("现在开始关闭容器！");
        ((ClassPathXmlApplicationContext)factory).registerShutdownHook();
    }
}

第八步：查看结果

现在开始初始化容器
这是BeanFactoryPostProcessor实现类构造器！！
BeanFactoryPostProcessor调用postProcessBeanFactory方法
这是BeanPostProcessor实现类构造器！！
这是InstantiationAwareBeanPostProcessorAdapter实现类构造器！！
【构造器】调用Person的构造器实例化
InstantiationAwareBeanPostProcessor调用postProcessPropertyValues方法
【注入属性】注入属性address
【注入属性】注入属性name
【注入属性】注入属性phone
【BeanNameAware接口】调用BeanNameAware.setBeanName()"
【BeanFactoryAware接口】调用BeanFactoryAware.setBeanFactory()
【ApplicationContext接口】调用ApplicationContext.setBeanFactory()
BeanPostProcessor接口方法postProcessAfterInitialization对属性进行更改！
InstantiationAwareBeanPostProcessor调用postProcessBeforeInstantiation方法
【InitializingBean接口】调用InitializingBean.afterPropertiesSet()
【init-method】调用<bean>的init-method属性指定的初始化方法
BeanPostProcessor接口方法postProcessBeforeInitialization对属性进行更改！
InstantiationAwareBeanPostProcessor调用postProcessAfterInitialization方法
容器初始化成功
Person{name='张三', address='广州', phone=110, beanFactory=org.springframework.beans.factory.support.DefaultListableBeanFactory@9a7504c: defining beans [beanPostProcessor,instantiationAwareBeanPostProcessor,beanFactoryPostProcessor,person]; root of factory hierarchy, beanName='person'}
现在开始关闭容器！
【DiposibleBean接口】调用DiposibleBean.destory()
【destroy-method】调用<bean>的destroy-method属性指定的初始化方法

代码来自： http://www.cnblogs.com/zrtqsk/p/3735273.html

三、流程总结

总的来说，可以分为三个阶段，创建bean、初始化bean、销毁bean。4和步骤

一、创建bean

1、创建bean的时候，调用createBeanInstance（）方法创建bean的实例（没有属性的bean）。

2、然后就是初始化bean，初始化bean可以分为两个阶段，

（1）populationBean（）进行自定义属性赋值，

（2）然后调用invokeAwareMethods（）判断该注入哪种属性

如果这个Bean实现dao了BeanNameAware接口，会调用它实现的setBeanName(String beanId)方法，此处传递的是Spring配置文件中Bean的ID

如果这个Bean实现了BeanFactoryAware接口，会调用它实现的setBeanFactory()，传递的是Spring工厂本身（可以用这个方法获取到其他Bean）

如果这个Bean实现了ApplicationContextAware接口，会调用setApplicationContext(ApplicationContext)方法，传入Spring上下文

到此-普通bean的对象创建完成

二、初始化bean

3、如果这个Bean关联了BeanPostProcessor接口，将会调用postProcess BeforeInitialization(Object obj, String s)方法（前置处理方法），

然后判断是否实现了InitializingBean接口，如果实现了调用afterPropertiesSet（）进行属性值的设置，然后执行自定义初始化方法init-method，

最后调用调用postProcess afterInitialization(Object obj, String s)方法(后置处理方法)，

到此-AOP的实现完成

三、销毁bean

4、当Bean不再需要时，会经过清理阶段，如果Bean实现了DisposableBean接口，会调用其实现的destroy方法

最后，如果这个Bean的Spring配置中配置了destroy-method属性，指定了Bean的销毁方法，会自动调用其配置的销毁方法

到此-bean销毁完成

Original aspirationㅤ

关注

0
点赞
踩
1

收藏

觉得还不错? 一键收藏
1
评论
SpringBean的生命周期

SpringBean的生命周期
复制链接

扫一扫

专栏目录

评论 1

被折叠的条评论为什么被折叠?

到【灌水乐园】发言

查看更多评论

添加红包

成就一亿技术人!

hope_wisdom

发出的红包

实付元

使用余额支付

点击重新获取

扫码支付

钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。