Spring-02-Bean的生命周期

最新推荐文章于 2024-06-14 10:17:52 发布

yuan同学

最新推荐文章于 2024-06-14 10:17:52 发布

阅读量105

点赞数

分类专栏： spring 文章标签： spring java

本文链接：https://blog.csdn.net/weixin_43561060/article/details/115702552

版权

spring 专栏收录该内容

3 篇文章 0 订阅

订阅专栏

文章目录

bean的生命周期：指 bean创建-----初始化----销毁的过程
bean的生命周期是由容器进行管理的。
我们可以自定义 bean初始化和销毁方法: 容器在bean进行到当前生命周期的时候, 来调用自定义的初始化和销毁方法。如何定义和销毁(4种方式):

方式一

指定初始化和销毁方法之前在beanx.xml, 可以指定<init-method和destory-mothod>，现在用用注释如何做: 新建chapter07文件夹，在bean文件下建Bike

public class Bike {

   public Bike(){
       System.out.println("Bike..........constructor.........");
   }

   /**
    * 初始化
    */
   public void init(){
       System.out.println("Bike..........init................");
   }

   /**
    * 销毁
    */
   public void destroy(){
       System.out.println("Bike...........destroy............");
   }
}

创建配置类：Chapter07MainConfig

@Configuration
@ComponentScan(value = "com.bruce.chapter07")
public class Chapter07MainConfig {
	//通过Bean参数里面指定Bike中哪个方法是init，哪个是destroy
    @Bean(initMethod = "init", destroyMethod = "destroy")
   public Bike bike(){
       return new Bike();
   }

}

创建测试类：Chapter07MainTest

public class Chapter07MainTest {

    @Test
    public void test(){
        AnnotationConfigApplicationContext ctx = new AnnotationConfigApplicationContext(Chapter07MainConfig.class);
        System.out.println("容器创建完成........");
        ctx.close();
    }
}

在这里插入图片描述
由输出可以看出，容器在创建过程中，先是调用了bean的构造方法，才到init()方法，当容器销毁的时候，调用bean的destroy()方法。
额外：多实例Bean: 容器只负责初始化,但不会管理bean, 容器关闭不会调用销毁方法。

方式二

让Bean实现 InitializingBean 和 DisposableBean接口。
A, InitializingBean(定义初始化逻辑,可点进去看此类):afterPropertiesSet()方法:当beanFactory创建好对象,且把bean所有属性设置好之后,会调这个方法,相当于初始化方法。

B, DisposableBean(定义销毁逻辑,可点进去看此类):destory()方法,当bean销毁时,会把单实例bean进行销毁。

步骤：新建Train.java类, 实现 InitializingBean, DisposableBean 接口。

@Component //如果在Chapter07MainConfig里使用@Bean，则不需要声明
public class Train implements InitializingBean, DisposableBean {

    public Train(){
        System.out.println("Train.....constructor......");
    }

    @Override
    public void afterPropertiesSet() throws Exception {
        System.out.println("Train.....afterPropertiesSet......");
    }

    @Override
    public void destroy() throws Exception {
        System.out.println("Train.....destroy......");
    }
}

在配置类上加上@ComponentScan(value = “com.bruce.chapter07”)
执行测试用例输出：
在这里插入图片描述

方式三

可以使用JSR250规则定义的(java规范)两个注解来实现
@PostConstruct: 在Bean创建完成,且属于赋值完成后进行初始化,属于JDK规范的注解。
@PreDestroy: 在bean将被移除之前进行通知, 在容器销毁之前进行清理工作。
步骤:新建Jeep.java

@Component
public class Jeep {
    public Jeep(){
        System.out.println("Jeep.....constructor......");
    }

    //对象创建并赋值之后调用
    @PostConstruct
    public void init()  {
        System.out.println("Jeep.....afterPropertiesSet......");
    }

    //容器移除之前回调通知，销毁bean
    @PreDestroy
    public void destroy() throws Exception {
        System.out.println("Jeep.....destroy......");
    }
}

执行测试用例输出：
在这里插入图片描述

方式四

后置处理器,负责在初始化方法前后作用， BeanPostProcessor类[interface]: bean的后置处理器,在bean初始化之前调用进行拦截
作用:在bean初始化前后进行一些处理工作。
看下BeanPostProcessor的源码：

public interface BeanPostProcessor {
	/**
	*在初始化之前进行后置处理工作(在init-method之前),
	*什么时候调用:它任何初始化方法调用之前(比如在InitializingBean的afterPropertiesSet初始化之前,
	*或自定义init-method调用之前使用) 
	*/
	@Nullable
	default Object postProcessBeforeInitialization(Object bean, String beanName) throws BeansException {
		return bean;
	}
	
	/**
	*在初始化之后进行后置处理工作, 比如在InitializingBean的afterPropertiesSet()后
	*/
	@Nullable
	default Object postProcessAfterInitialization(Object bean, String beanName) throws BeansException {
		return bean;
	}

}

步骤: 新建后置处理器类BruceBeanPostProcessor

/**
 * 后置处理器：初始化前后进行处理工作
 * 将后置处理器加入到容器中
 */
@Component
public class BruceBeanPostProcessor implements BeanPostProcessor {
    @Override
    public Object postProcessBeforeInitialization(Object bean, String beanName) throws BeansException {
        System.out.println("postProcessBeforeInitialization..." + beanName + "----->" + bean);
        // 返回一个对象（传过来的对象），也可包装好再返回
        return bean;
    }

    @Override
    public Object postProcessAfterInitialization(Object bean, String beanName) throws BeansException {
        System.out.println("postProcessAfterInitialization..." + beanName + "----->" + bean);
        return bean;
    }
}

总结:bean的整个生命周期我们都能控制。
可以分析Bike的日志证明在init初始化之前调用了postProcessBeforeInitialization()
在这里插入图片描述

源码分析

BeanPostProcessor原理

可从容器类跟进顺序为:
AnnotationConfigApplicationContext–>refresh()–>
finishBeanFactoryInitialization(beanFactory)—>
beanFactory.preInstantiateSingletons()–>
760行getBean(beanName)—>
199行doGetBean(name, null, null, false)–>
317行createBean(beanName, mbd, args)–>
501行doCreateBean(beanName, mbdToUse, args)–>
541行createBeanInstance(beanName, mbd, args)(完成bean创建)–>
578行populateBean(beanName, mbd, instanceWrapper)(属性赋值)–>
579行initializeBean(beanName, exposedObject, mbd)(Bean初始化)->
1069行到1710行,后置处理器完成对init方法的前后处理.

最终得到如下如下
createBeanInstance(beanName, mbd, args)(完成bean创建)
populateBean(beanName, mbd, instanceWrapper); 给bean进行属性赋值
initializeBean() //初始化Bean方法内容如下,后置处理器对init方法的前后处理
{
applyBeanPostProcessorsBeforeInitialization(wrappedBean, beanName);
invokeInitMethods(beanName, wrappedBean, mbd) //执行自定义初始化
applyBeanPostProcessorsAfterInitialization(wrappedBean, beanName)
}
从以上分析不难发现,bean的生命周期为bean的创建, 初始化, 当容器关闭时对单实例的bean进行销毁。
在这里插入图片描述
在调用该后置处理器的方法的时候，就是遍历所有的处理器，包括自定义的。每个处理都会进去对bean进行处理。

ApplicationContextAwareProcessor实现分析

此类帮我们组建IOC容器,跟进ApplicationContextAwareProcessor我们发现, 这个后置处理器其实就是判断我们的bean有没有实现ApplicationContextAware 接口,并处理相应的逻辑,其实所有的后置处理器原理均如此。那么怎么组建呢? 只需要实现 ApplicationContextAware 接口
步骤:
1, 新建Plane.java

@Component
public class Plane implements ApplicationContextAware {

    private ApplicationContext applicationContext;

    public Plane(){
        System.out.println("Jeep.....constructor......");
    }

    //对象创建并赋值之后调用
    @PostConstruct
    public void init()  {
        System.out.println("Jeep.....afterPropertiesSet......");
    }

    //容器移除之前回调通知，销毁bean
    @PreDestroy
    public void destroy() throws Exception {
        System.out.println("Jeep.....destroy......");
    }
    
    /**
     * 给bean装载容器
     * @param applicationContext
     * @throws BeansException
     */
    @Override
    public void setApplicationContext(ApplicationContext applicationContext) throws BeansException {
    	// 容器初始化，将applicationContext传进来，那么其他方法就可使用到IOC容器了
    	// 这个功能是ApplicationContextAwareProcessor做的
        this.applicationContext = applicationContext;
    }
}

分析一下ApplicationContextAwareProcessor类的方法。
在这里插入图片描述

a,在创建Plane对象,还没初始化之前, 先判断是不是实现了ApplicationContextAware接口,
如果是的话就调用invokeAwareInterfaces方法, 并给里面注入值;
b,进入invokeAwareInterfaces()方法,判断是哪个aware, 如果是ApplicationContextAware, 就将当前的bean转成ApplicationContextAware类型, 调用setApplicationContext(), 把IOC容器注入到Plane里去;
在这里插入图片描述

BeanValidationPostProcess分析:数据校验

当对象创建完,给bean赋值后,在WEB用得特别多;把页面提交的值进行校验。
在这里插入图片描述

InitDestroyAnnotationBeanPostProcessor

此处理器用来处理@PostConstruct, @PreDestroy, 怎么知道这两注解是前后开始调用的呢, 就是 InitDestroyAnnotationBeanPostProcessor这个处理的。
在这里插入图片描述

总结

Spring底层对BeanPostProcessor的使用, 包括bean的赋值, 注入其它组件, 生命周期注解功能,@Async, 等等。

yuan同学

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
Spring-02-Bean的生命周期

bean的生命周期：指 bean创建-----初始化----销毁的过程bean的生命周期是由容器进行管理的。我们可以自定义 bean初始化和销毁方法: 容器在bean进行到当前生命周期的时候, 来调用自定义的初始化和销毁方法。如何定义和销毁(4种方式):方式一指定初始化和销毁方法之前在beanx.xml, 可以指定<init-method和destory-mothod>，现在用用注释如何做: 新建chapter07文件夹，在bean文件下建Bikepublic class
复制链接

扫一扫