bean的生命周期_Been Doing_bean的生命周期

大大的周 02-07 4608

六、bean的生命周期

https://liayun.blog.csdn.net/article/details/110670961

Bean 的初始化和销毁；

1、@Bean注解中使用init-method属性和destroy-method属性来指定初始化方法和销毁方法。

初始化和销毁方法的时机：

你有没有想过这样一个问题，初始化方法和销毁方法是在什么时候被调用的啊？

bean对象的初始化方法调用的时机：对象创建完成，如果对象中存在一些属性，并且这些属性也都赋好值之后，那么就会调用bean的初始化方法。对于单实例bean来说，在Spring容器创建完成后，Spring容器会自动调用bean的初始化方法；对于多实例bean来说，在每次获取bean对象的时候，调用bean的初始化方法。bean对象的销毁方法调用的时机：对于单实例bean来说，在容器关闭的时候，会调用bean的销毁方法；对于多实例bean来说，Spring容器不会管理这个bean，也就不会自动调用这个bean的销毁方法了。不过，小伙伴们可以手动调用多实例bean的销毁方法。 InitializingBean

多实例bean的生命周期不归Spring容器来管理，这里的DisposableBean接口中的方法是由Spring容器来调用的，所以如果一个多实例bean实现了DisposableBean接口是没有啥意义的，因为相应的方法根本不会被调用，当然了，在XML配置文件中指定了destroy方法，也是没有任何意义的。所以，在多实例bean情况下，Spring是不会自动调用bean的销毁方法的。

Spring中提供了一个InitializingBean接口，该接口为bean提供了属性初始化后的处理方法，它只包括afterPropertiesSet方法，凡是继承该接口的类，在bean的属性初始化后都会执行该方法。

//@Component public class Cat implements InitializingBean, DisposableBean { public Cat(){ System.out.println("Cat...constructor...构造器"); } @Override public void destroy() throws Exception { System.out.println("Cat...destroy...."); } @Override public void afterPropertiesSet() throws Exception { System.out.println("Cat...afterPropertiesSet..."); } } InitializingBean源码： protected void invokeInitMethods(String beanName, final Object bean, @Nullable RootBeanDefinition mbd) throws Throwable { boolean isInitializingBean = (bean instanceof InitializingBean); if (isInitializingBean && (mbd == null || !mbd.isExternallyManagedInitMethod("afterPropertiesSet"))) { if (logger.isTraceEnabled()) { logger.trace("Invoking afterPropertiesSet() on bean with name '" + beanName + "'"); } if (System.getSecurityManager() != null) { try { AccessController.doPrivileged((PrivilegedExceptionAction<Object>) () -> { ((InitializingBean) bean).afterPropertiesSet(); return null; }, getAccessControlContext()); } catch (PrivilegedActionException pae) { throw pae.getException(); } } else { ((InitializingBean) bean).afterPropertiesSet(); } } if (mbd != null && bean.getClass() != NullBean.class) { String initMethodName = mbd.getInitMethodName(); if (StringUtils.hasLength(initMethodName) && !(isInitializingBean && "afterPropertiesSet".equals(initMethodName)) && !mbd.isExternallyManagedInitMethod(initMethodName)) { invokeCustomInitMethod(beanName, bean, mbd); } } }

分析上述代码后，我们可以初步得出如下信息：

1、Spring为bean提供了两种初始化的方式，实现InitializingBean接口（也就是要实现该接口中的afterPropertiesSet方法），或者在配置文件或@Bean注解中通过init-method来指定，两种方式可以同时使用。

2、实现InitializingBean接口是直接调用afterPropertiesSet()方法，与通过反射调用init-method指定的方法相比，效率相对来说要高点。但是init-method方式消除了对Spring的依赖。

3、如果调用afterPropertiesSet方法时出错，那么就不会调用init-method指定的方法了。

小结

也就是说Spring为bean提供了两种初始化的方式，第一种方式是实现InitializingBean接口（也就是要实现该接口中的afterPropertiesSet方法），第二种方式是在配置文件或@Bean注解中通过init-method来指定，这两种方式可以同时使用，同时使用先调用afterPropertiesSet方法，后执行init-method指定的方法。

* 在Spring容器创建完成时，会自动调用单实例bean的构造方法，对单实例bean进行了实例化操作。 * * 多实例的bean在容器关闭的时候是不进行销毁的，也就是说你每次获取时，IOC容器帮你创建出对象交还给你， * 至于要什么时候销毁这是你自己的事，Spring容器压根就不会再管理这些多实例的bean了。 * * 单实例：在容器启动的时候创建对象； * 多实例：在每次获取的时候创建对象； * * 初始化： * 对象创建好，并赋值好，调用初始化方法； * * 销毁： * 单实例：容器关闭的时候； * 多实例：容器不会管理Bean，只是负责创建，容器不会调用销毁方法； * * 1、指定初始化和销毁的方法； * 2、通过Bean 实现InitializingBean和DisposableBean * InitializingBean(定义初始化逻辑) * DisposableBean（定义销毁逻辑）

2、@PostConstruct和@PreDestroy这俩注解

@PostConstruct：在bean创建完成并且属性赋值完成之后，来执行初始化方法@PreDestroy：在容器销毁bean之前通知我们进行清理工作 //@Component public class Dog { private Cat cat; public Dog(){ System.out.println("dog...constructor..构造器"); } public Cat getCat() { return cat; } public void setCat(Cat cat) { this.cat = cat; } //对象创建赋值之后调用 @PostConstruct public void init(){ System.out.println("dog...@PostConstruct..."); } //容器移除对象之前 @PreDestroy public void destory(){ System.out.println("dog...@PreDestroy..."); } }

3、通过让bean实现BeanPostProcessor接口

@Component public class MyBeanPostProcessor implements BeanPostProcessor, Ordered { @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; } @Override public int getOrder() { return 3; } }

通过以上这四种方式，我们就可以对bean的整个生命周期进行控制：

bean的实例化：调用bean的构造方法，我们可以在bean的无参构造方法中执行相应的逻辑。 bean的初始化：在初始化时，可以通过BeanPostProcessor的postProcessBeforeInitialization()方法和postProcessAfterInitialization()方法进行拦截，执行自定义的逻辑；通过@PostConstruct注解、InitializingBean和init-method来指定bean初始化前后执行的方法，在该方法中咱们可以执行自定义的逻辑。 bean的销毁：可以通过@PreDestroy注解、DisposableBean和destroy-method来指定bean在销毁前执行的方法，在该方法中咱们可以执行自定义的逻辑。

所以，通过上述四种方式，我们可以控制Spring中bean的整个生命周期。

BeanPostProcessor后置处理器作用

后置处理器可用于bean对象初始化前后进行逻辑增强。 Spring提供了BeanPostProcessor接口的很多实现类，例如AutowiredAnnotationBeanPostProcessor用于@Autowired注解的实现，AnnotationAwareAspectJAutoProxyCreator用于Spring AOP的动态代理等等。

除此之外，我们还可以自定义BeanPostProcessor接口的实现类，在其中写入咱们需要的逻辑。下面我会以AnnotationAwareAspectJAutoProxyCreator为例，简单说明一下后置处理器是怎样工作的。

我们都知道spring AOP的实现原理是动态代理，最终放入容器的是代理类的对象，而不是bean本身的对象，那么Spring是什么时候做到这一步的呢？就是在AnnotationAwareAspectJAutoProxyCreator后置处理器的postProcessAfterInitialization方法中，即bean对象初始化完成之后，后置处理器会判断该bean是否注册了切面，若是，则生成代理对象注入到容器中。这一部分的关键代码是在哪儿呢？我们定位到AbstractAutoProxyCreator抽象类中的postProcessAfterInitialization方法处便能看到了，如下所示。

这里请看：https://liayun.blog.csdn.net/article/details/110442093 这里是源码讲解。我这里直接拿过来结果吧。

在applyBeanPostProcessorsBeforeInitialization()方法中，会遍历所有BeanPostProcessor对象，然后依次执行所有BeanPostProcessor对象的postProcessBeforeInitialization()方法，一旦BeanPostProcessor对象的postProcessBeforeInitialization()方法返回null以后，则后面的BeanPostProcessor对象便不再执行了，而是直接退出for循环。这些都是我们看源码看到的。

看Spring源码，我们还看到了一个细节，在Spring中调用initializeBean()方法之前，还调用了populateBean()方法来为bean的属性赋值，这在上面我也已经说过了。

这里数属性填充工作：那么是怎样工作的那？就是调用populateBean（）方法

经过上面的一系列的跟踪源码分析，我们可以将关键代码的调用过程使用如下伪代码表述出来。

populateBean(beanName, mbd, instanceWrapper); // 给bean进行属性赋值 initializeBean(beanName, exposedObject, mbd) { applyBeanPostProcessorsBeforeInitialization(wrappedBean, beanName); invokeInitMethods(beanName, wrappedBean, mbd); // 执行自定义初始化 applyBeanPostProcessorsAfterInitialization(wrappedBean, beanName); }

也就是说，在Spring中，调用initializeBean()方法之前，调用了populateBean()方法为bean的属性赋值，为bean的属性赋好值之后，再调用initializeBean()方法进行初始化。

在initializeBean()中，调用自定义的初始化方法（即invokeInitMethods()）之前，调用了applyBeanPostProcessorsBeforeInitialization()方法，而在调用自定义的初始化方法之后，又调用了applyBeanPostProcessorsAfterInitialization()方法。至此，整个bean的初始化过程就这样结束了。

概述

如果我们现在自定义的组件中需要用到Spring底层的一些组件，比如ApplicationContext（IOC容器）、底层的BeanFactory等等，那么该怎么办呢？先说说自定义的组件中能不能用Spring底层的一些组件吧？既然都这样说了，那么肯定是能够的。

回到主题，自定义的组件要想使用Spring容器底层的一些组件，比如ApplicationContext（IOC容器）、底层的BeanFactory等等，那么只需要让自定义组件实现XxxAware接口即可。此时，Spring在创建对象的时候，会调用XxxAware接口中定义的方法注入相关的组件。

XxxAware接口概览

其实，我们之前使用过XxxAware接口，例如，我们之前创建的Dog类，就实现了ApplicationContextAware接口，Dog类的源码如下所示。

package com.meimeixia.bean; import javax.annotation.PostConstruct; import javax.annotation.PreDestroy; import org.springframework.beans.BeansException; import org.springframework.context.ApplicationContext; import org.springframework.context.ApplicationContextAware; import org.springframework.stereotype.Component; /** * ApplicationContextAwareProcessor这个类的作用是可以帮我们在组件里面注入IOC容器， * 怎么注入呢？我们想要IOC容器的话，比如我们这个Dog组件，只需要实现ApplicationContextAware接口就行 * * @author liayun * */ @Component public class Dog implements ApplicationContextAware { private ApplicationContext applicationContext; public Dog() { System.out.println("dog constructor..."); } // 在对象创建完成并且属性赋值完成之后调用 @PostConstruct public void init() { // 在这儿打个断点调试一下 System.out.println("dog...@PostConstruct..."); } // 在容器销毁（移除）对象之前调用 @PreDestroy public void destory() { System.out.println("dog...@PreDestroy..."); } @Override public void setApplicationContext(ApplicationContext applicationContext) throws BeansException { // 在这儿打个断点调试一下 // TODO Auto-generated method stub this.applicationContext = applicationContext; } }

从以上Dog类的源码中可以看出，实现ApplicationContextAware接口的话，需要实现setApplicationContext()方法。在IOC容器启动并创建Dog对象时，Spring会调用setApplicationContext()方法，并且会将ApplicationContext对象传入到setApplicationContext()方法中，我们只需要在Dog类中定义一个ApplicationContext类型的成员变量来接收setApplicationContext()方法中的参数，那么便可以在Dog类的其他方法中使用ApplicationContext对象了。

其实，在Spring中，类似于ApplicationContextAware接口的设计有很多，本质上，Spring中形如XxxAware这样的接口都继承了Aware接口，我们来看下Aware接口的源码，如下所示。接下来，我们看看都有哪些接口继承了Aware接口，如下所示。

XxxAware接口案例

接下来，我们就挑选几个常用的XxxAware接口来简单的说明一下。

ApplicationContextAware接口使用的比较多，我们先来说说这个接口，通过ApplicationContextAware接口我们可以获取到IOC容器。

首先，我们创建一个Red类，它得实现ApplicationContextAware接口，并在实现的setApplicationContext()方法中将ApplicationContext输出，如下所示。

package com.meimeixia.bean; import org.springframework.beans.BeansException; import org.springframework.context.ApplicationContext; import org.springframework.context.ApplicationContextAware; /** * 以Red类为例来讲解ApplicationContextAware接口、BeanNameAware接口以及EmbeddedValueResolverAware接口 * @author liayun * */ public class Red implements ApplicationContextAware { private ApplicationContext applicationContext; @Override public void setApplicationContext(ApplicationContext applicationContext) throws BeansException { System.out.println("传入的IOC：" + applicationContext); this.applicationContext = applicationContext; } }

其实，我们也可以让Red类同时实现几个XxxAware接口，例如，使Red类再实现一个BeanNameAware接口，我们可以通过BeanNameAware接口获取到当前bean在Spring容器中的名称，如下所示。

当然了，我们可以再让Red类实现一个EmbeddedValueResolverAware接口，我们通过EmbeddedValueResolverAware接口能够获取到String值解析器，如下所示。

package com.meimeixia.bean; import org.springframework.beans.BeansException; import org.springframework.beans.factory.BeanNameAware; import org.springframework.context.ApplicationContext; import org.springframework.context.ApplicationContextAware; import org.springframework.context.EmbeddedValueResolverAware; import org.springframework.util.StringValueResolver; /** * 以Red类为例来讲解ApplicationContextAware接口、BeanNameAware接口以及EmbeddedValueResolverAware接口 * @author liayun * */ public class Red implements ApplicationContextAware, BeanNameAware, EmbeddedValueResolverAware { private ApplicationContext applicationContext; @Override public void setApplicationContext(ApplicationContext applicationContext) throws BeansException { System.out.println("传入的IOC：" + applicationContext); this.applicationContext = applicationContext; } /** * 参数name：IOC容器创建当前对象时，为这个对象起的名字 */ @Override public void setBeanName(String name) { System.out.println("当前bean的名字：" + name); } /** * 参数resolver：IOC容器启动时会自动地将这个String值的解析器传递过来给我们 */ @Override public void setEmbeddedValueResolver(StringValueResolver resolver) { String resolveStringValue = resolver.resolveStringValue("你好，${os.name}，我的年龄是#{20*18}"); System.out.println("解析的字符串：" + resolveStringValue); } }

IOC容器启动时会自动地将String值的解析器（即StringValueResolver）传递过来给我们用，咱们可以用它来解析一些字符串，解析哪些字符串呢？比如包含#{}这样的字符串。我们可以看一下StringValueResolver类的源码，如下所示。

接着，我们需要在Red类上标注@Component注解将该类添加到IOC容器中，如下所示。

@Component public class Red implements ApplicationContextAware, BeanNameAware, EmbeddedValueResolverAware {

最后，运行IOCTest_Autowired类中的test02()方法，输出的结果信息如下所示。

XxxAware原理

XxxAware接口的底层原理是由XxxAwareProcessor实现类实现的，也就是说每一个XxxAware接口都有它自己对应的XxxAwareProcessor实现类。例如，我们这里以ApplicationContextAware接口为例，ApplicationContextAware接口的底层原理就是由ApplicationContextAwareProcessor类实现的。从ApplicationContextAwareProcessor类的源码可以看出，其实现了BeanPostProcessor接口，本质上是一个后置处理器。