SpringBean生命周期及扩展点
SpringBoot Bean的生命周期
总体上实例化 -> 属性填充 -> 初始化 -> 注册销毁方法-> 使用 -> 销毁
在其过程中还隐藏着几个问题:
- 什么时候进行依赖注入,几种不同的注入方式(setter注入,构造器注入,字段注入)如何实现
- 存在哪些拓展点，在哪些场景使用，最佳实践
- Spring AOP在如何返回代理对象
- 什么是循环依赖，如何解决循环依赖
- 从Bean的扩展点扩大到Spring中的扩展点
源码解析大概过程
先从源码来看一下从IOC容器启动到Bean创建的主要流程
ps：图是从某个大佬博客复制的
本文springboot版本为3.4.7
以DefaultListableBeanFactory#preInstantiateSingletons()方法作为入口,对Bean实例化过程进行解析
-
入口：实例化非懒加载（非 lazy-init ）单例Bean
DefaultListableBeanFactory#preInstantiateSingletons()方法@Override public void preInstantiateSingletons() throws BeansException { if (logger.isTraceEnabled()) { logger.trace("Pre-instantiating singletons in " + this); } // Iterate over a copy to allow for init methods which in turn register new bean definitions. // While this may not be part of the regular factory bootstrap, it does otherwise work fine. List<String> beanNames = new ArrayList<>(this.beanDefinitionNames); // Trigger initialization of all non-lazy singleton beans... List<CompletableFuture<?>> futures = new ArrayList<>(); this.preInstantiationThread.set(PreInstantiation.MAIN); this.mainThreadPrefix = getThreadNamePrefix(); try { for (String beanName : beanNames) { RootBeanDefinition mbd = getMergedLocalBeanDefinition(beanName); if (!mbd.isAbstract() && mbd.isSingleton()) { // 核心方法 异步初始化Bean? CompletableFuture<?> future = preInstantiateSingleton(beanName, mbd); if (future != null) { futures.add(future); } } } } finally { this.mainThreadPrefix = null; this.preInstantiationThread.remove(); } if (!futures.isEmpty()) { try { // 等待编排任务执行 CompletableFuture.allOf(futures.toArray(new CompletableFuture<?>[0])).join(); } catch (CompletionException ex) { ReflectionUtils.rethrowRuntimeException(ex.getCause()); } } ........ } @Nullable private CompletableFuture<?> preInstantiateSingleton(String beanName, RootBeanDefinition mbd) { //判断,进行异步初始化 if (mbd.isBackgroundInit()) { ............ } } // 加载非惰性Bean if (!mbd.isLazyInit()) { try { // 核心方法 instantiateSingleton(beanName); } catch (BeanCurrentlyInCreationException ex) { logger.info("Bean '" + beanName + "' marked for pre-instantiation (not lazy-init) " + "but currently initialized by other thread - skipping it in mainline thread"); } } return null; } private void instantiateSingleton(String beanName) { if (isFactoryBean(beanName)) { Object bean = getBean(FACTORY_BEAN_PREFIX + beanName); if (bean instanceof SmartFactoryBean<?> smartFactoryBean && smartFactoryBean.isEagerInit()) { getBean(beanName); } } else { 调用getBean getBean(beanName); } }- springboot 3.x中允许进行Bean的异步初始化?
-
org.springframework.beans.factory.support.DefaultListableBeanFactory#getBean() ->
org.springframework.beans.factory.support.AbstractBeanFactory#doGetBean()
spring中do+____才是正在执行逻辑的代码块返回指定 bean 的实例，该实例可以是共享的或独立的。 参数： name – 要检索的 bean 的名称 requiredType – 要检索的 bean 的所需类型 args – 使用显式参数创建 bean 实例时使用的参数（仅在创建新实例时适用，而不是检索现有实例时适用） typeCheckOnly – 获取实例是否用于类型检查，而不是用于实际使用 返回： Bean 的一个实例 抛出： BeansException – 如果无法创建 bean protected <T> T doGetBean( String name, @Nullable Class<T> requiredType, @Nullable Object[] args, boolean typeCheckOnly) throws BeansException { // 转换类名 String beanName = transformedBeanName(name); Object bean; // 判断能否从缓存中获取(解决循环依赖) // Eagerly check singleton cache for manually registered singletons. Object sharedInstance = getSingleton(beanName); if (sharedInstance != null && args == null) { if (logger.isTraceEnabled()) { if (isSingletonCurrentlyInCreation(beanName)) { logger.trace("Returning eagerly cached instance of singleton bean '" + beanName + "' that is not fully initialized yet - a consequence of a circular reference"); } else { logger.trace("Returning cached instance of singleton bean '" + beanName + "'"); } } bean = getObjectForBeanInstance(sharedInstance, name, beanName, null); } else { // Fail if we're already creating this bean instance: // We're assumably within a circular reference. if (isPrototypeCurrentlyInCreation(beanName)) { throw new BeanCurrentlyInCreationException(beanName); } // Check if bean definition exists in this factory. // 检查父容器 BeanFactory parentBeanFactory = getParentBeanFactory(); if (parentBeanFactory != null && !containsBeanDefinition(beanName)) { // Not found -> check parent. String nameToLookup = originalBeanName(name); if (parentBeanFactory instanceof AbstractBeanFactory) { return ((AbstractBeanFactory) parentBeanFactory).doGetBean( nameToLookup, requiredType, args, typeCheckOnly); } else if (args != null) { // Delegation to parent with explicit args. return (T) parentBeanFactory.getBean(nameToLookup, args); } else if (requiredType != null) { // No args -> delegate to standard getBean method. return parentBeanFactory.getBean(nameToLookup, requiredType); } else { return (T) parentBeanFactory.getBean(nameToLookup); } } if (!typeCheckOnly) { markBeanAsCreated(beanName); } try { RootBeanDefinition mbd = getMergedLocalBeanDefinition(beanName); checkMergedBeanDefinition(mbd, beanName, args); // Guarantee initialization of beans that the current bean depends on. // 解决当前bean所依赖的bean 未初始化同样通过getBean String[] dependsOn = mbd.getDependsOn(); if (dependsOn != null) { for (String dep : dependsOn) { if (isDependent(beanName, dep)) { throw new BeanCreationException(mbd.getResourceDescription(), beanName, "Circular depends-on relationship between '" + beanName + "' and '" + dep + "'"); } registerDependentBean(dep, beanName); try { getBean(dep); } catch (NoSuchBeanDefinitionException ex) { throw new BeanCreationException(mbd.getResourceDescription(), beanName, "'" + beanName + "' depends on missing bean '" + dep + "'", ex); } } } // Create bean instance. if (mbd.isSingleton()) { // 如果是单例 先从缓存中获取 缓存中不存在则创建 sharedInstance = getSingleton(beanName, () -> { try { return createBean(beanName, mbd, args); } catch (BeansException ex) { // Explicitly remove instance from singleton cache: It might have been put there // eagerly by the creation process, to allow for circular reference resolution. // Also remove any beans that received a temporary reference to the bean. destroySingleton(beanName); throw ex; } }); bean = getObjectForBeanInstance(sharedInstance, name, beanName, mbd); } else if (mbd.isPrototype()) { // It's a prototype -> create a new instance. // 原型Bean则每次都创建prototype实例 Object prototypeInstance = null; try { beforePrototypeCreation(beanName); prototypeInstance = createBean(beanName, mbd, args); } finally { afterPrototypeCreation(beanName); } bean = getObjectForBeanInstance(prototypeInstance, name, beanName, mbd); } else { ......... } } catch (BeansException ex) { cleanupAfterBeanCreationFailure(beanName); throw ex; } } // Check if required type matches the type of the actual bean instance. ....... return (T) bean; } -
org/springframework/beans/factory/support/AbstractAutowireCapableBeanFactory # createBean()
@Override protected Object createBean(String beanName, RootBeanDefinition mbd, @Nullable Object[] args) throws BeanCreationException { ........ try { // Give BeanPostProcessors a chance to return a proxy instead of the target bean instance. // 扩展点1 : Bean实例化前 Object bean = resolveBeforeInstantiation(beanName, mbdToUse); // 返回的bean不为空,说明返回了一个代理对象,不走后续流程 if (bean != null) { return bean; } } catch (Throwable ex) { .... } try { // 核心方法 Object beanInstance = doCreateBean(beanName, mbdToUse, args); if (logger.isTraceEnabled()) { logger.trace("Finished creating instance of bean '" + beanName + "'"); } return beanInstance; } catch (BeanCreationException | ImplicitlyAppearedSingletonException ex) { ..... } catch (Throwable ex) { ..... } } @Nullable protected Object resolveBeforeInstantiation(String beanName, RootBeanDefinition mbd) { Object bean = null; if (!Boolean.FALSE.equals(mbd.beforeInstantiationResolved)) { // Make sure bean class is actually resolved at this point. if (!mbd.isSynthetic() && hasInstantiationAwareBeanPostProcessors()) { Class<?> targetType = determineTargetType(beanName, mbd); if (targetType != null) { // 实例化前的后置处理器 bean = applyBeanPostProcessorsBeforeInstantiation(targetType, beanName); if (bean != null) { // 正常bean为null,不为空则直接调用初始化之后的方法。但是这样的话就不会走正常spring创建Bean的流程了，会直接返回这个bean对象 bean = applyBeanPostProcessorsAfterInitialization(bean, beanName); } } } mbd.beforeInstantiationResolved = (bean != null); } return bean; } -
doCreateBean() 真正创建Bean的方法
protected Object doCreateBean(String beanName, RootBeanDefinition mbd, @Nullable Object[] args) throws BeanCreationException { // Instantiate the bean. 实例化Bean BeanWrapper instanceWrapper = null; if (mbd.isSingleton()) { instanceWrapper = this.factoryBeanInstanceCache.remove(beanName); } if (instanceWrapper == null) { // 反射调用构造方法 instanceWrapper = createBeanInstance(beanName, mbd, args); } Object bean = instanceWrapper.getWrappedInstance(); Class<?> beanType = instanceWrapper.getWrappedClass(); if (beanType != NullBean.class) { mbd.resolvedTargetType = beanType; } // Allow post-processors to modify the merged bean definition. // 对一些元信息做了收集维护处理，如@Autowire、@Resource、@PostConstruct 和 @PreDestroy等，为后续属性注入做准备。 synchronized (mbd.postProcessingLock) { if (!mbd.postProcessed) { try { // 也是一个扩展点 不过多赘述 applyMergedBeanDefinitionPostProcessors(mbd, beanType, beanName); } catch (Throwable ex) { throw new BeanCreationException(mbd.getResourceDescription(), beanName, "Post-processing of merged bean definition failed", ex); } mbd.markAsPostProcessed(); } } // Eagerly cache singletons to be able to resolve circular references // even when triggered by lifecycle interfaces like BeanFactoryAware. // 解决循环依赖: 如果当前创建的是单例bean，并且允许循环依赖，并且还在创建过程中，那么则提早暴露Bean boolean earlySingletonExposure = (mbd.isSingleton() && this.allowCircularReferences && isSingletonCurrentlyInCreation(beanName)); if (earlySingletonExposure) { if (logger.isTraceEnabled()) { logger.trace("Eagerly caching bean '" + beanName + "' to allow for resolving potential circular references"); } // 添加到三级缓存中,此时bean还未完成属性注入简单对象 addSingletonFactory(beanName, () -> getEarlyBeanReference(beanName, mbd, bean)); } // Initialize the bean instance. Object exposedObject = bean; try { // 属性注入 populateBean(beanName, mbd, instanceWrapper); // 初始化 exposedObject = initializeBean(beanName, exposedObject, mbd); } catch (Throwable ex) { if (ex instanceof BeanCreationException bce && beanName.equals(bce.getBeanName())) { throw bce; } else { throw new BeanCreationException(mbd.getResourceDescription(), beanName, ex.getMessage(), ex); } } if (earlySingletonExposure) { ..... } // Register bean as disposable. 注册销毁方法 try { registerDisposableBeanIfNecessary(beanName, bean, mbd); } catch (BeanDefinitionValidationException ex) { throw new BeanCreationException( mbd.getResourceDescription(), beanName, "Invalid destruction signature", ex); } return exposedObject; }接下来详细看下属性注入、初始化及销毁方法注册
-
属性注入
org.springframework.beans.factory.support.AbstractAutowireCapableBeanFactory # populateBean使用 Bean 定义中的属性值填充给定 BeanWrapper 中的 Bean 实例 protected void populateBean(String beanName, RootBeanDefinition mbd, @Nullable BeanWrapper bw) { ..... // Give any InstantiationAwareBeanPostProcessors the opportunity to modify the // state of the bean before properties are set. This can be used, for example, // to support styles of field injection. // 扩展点2 Bean实例化后,属性注入前 if (!mbd.isSynthetic() && hasInstantiationAwareBeanPostProcessors()) { for (InstantiationAwareBeanPostProcessor bp : getBeanPostProcessorCache().instantiationAware) { if (!bp.postProcessAfterInstantiation(bw.getWrappedInstance(), beanName)) { return; } } } PropertyValues pvs = (mbd.hasPropertyValues() ? mbd.getPropertyValues() : null); int resolvedAutowireMode = mbd.getResolvedAutowireMode(); // 依赖注入 if (resolvedAutowireMode == AUTOWIRE_BY_NAME || resolvedAutowireMode == AUTOWIRE_BY_TYPE) { MutablePropertyValues newPvs = new MutablePropertyValues(pvs); // Add property values based on autowire by name if applicable. if (resolvedAutowireMode == AUTOWIRE_BY_NAME) { autowireByName(beanName, mbd, bw, newPvs); } // Add property values based on autowire by type if applicable. if (resolvedAutowireMode == AUTOWIRE_BY_TYPE) { autowireByType(beanName, mbd, bw, newPvs); } pvs = newPvs; } if (hasInstantiationAwareBeanPostProcessors()) { if (pvs == null) { pvs = mbd.getPropertyValues(); } for (InstantiationAwareBeanPostProcessor bp : getBeanPostProcessorCache().instantiationAware) { // 调BeanPostProcessor 分别解析 @Autowired. @Resource、 @Value， 得到属性值 // 也是扩展点，同样作用于属性注入前，不详细介绍 PropertyValues pvsToUse = bp.postProcessProperties(pvs, bw.getWrappedInstance(), beanName); if (pvsToUse == null) { return; } pvs = pvsToUse; } } boolean needsDepCheck = (mbd.getDependencyCheck() != AbstractBeanDefinition.DEPENDENCY_CHECK_NONE); if (needsDepCheck) { PropertyDescriptor[] filteredPds = filterPropertyDescriptorsForDependencyCheck(bw, mbd.allowCaching); checkDependencies(beanName, mbd, filteredPds, pvs); } if (pvs != null) { // 属性注入 applyPropertyValues(beanName, mbd, bw, pvs); } } -
初始化
org.springframework.beans.factory.support.AbstractAutowireCapableBeanFactory # initializeBean()protected Object initializeBean(String beanName, Object bean, @Nullable RootBeanDefinition mbd) { // Aware执行 invokeAwareMethods(beanName, bean); Object wrappedBean = bean; if (mbd == null || !mbd.isSynthetic()) { // 扩展点3：初始化前 wrappedBean = applyBeanPostProcessorsBeforeInitialization(wrappedBean, beanName); } try { // 扩展点4：初始化时 invokeInitMethods(beanName, wrappedBean, mbd); } catch (Throwable ex) { throw new BeanCreationException( (mbd != null ? mbd.getResourceDescription() : null), beanName, ex.getMessage(), ex); } if (mbd == null || !mbd.isSynthetic()) { // 扩展点5: 初始化后(AOP返回代理对象的地方) wrappedBean = applyBeanPostProcessorsAfterInitialization(wrappedBean, beanName); } return wrappedBean; } -
销毁方法注册
// 销毁容器 Bean 名称到一次性实例。 private final Map<String, DisposableBean> disposableBeans = new LinkedHashMap<>(); protected void registerDisposableBeanIfNecessary(String beanName, Object bean, RootBeanDefinition mbd) { // 扩展点6 Bean销毁时 if (!mbd.isPrototype() && requiresDestruction(bean, mbd)) { if (mbd.isSingleton()) { // Register a DisposableBean implementation that performs all destruction // work for the given bean: DestructionAwareBeanPostProcessors, // DisposableBean interface, custom destroy method. // 将bean包装为DisposableBeanAdapter对象放入销毁容器 registerDisposableBean(beanName, new DisposableBeanAdapter对象放入销毁容器( bean, beanName, mbd, getBeanPostProcessorCache().destructionAware)); } else { // A bean with a custom scope... Scope scope = this.scopes.get(mbd.getScope()); if (scope == null) { throw new IllegalStateException("No Scope registered for scope name '" + mbd.getScope() + "'"); } scope.registerDestructionCallback(beanName, new DisposableBeanAdapter( bean, beanName, mbd, getBeanPostProcessorCache().destructionAware)); } } }DisposableBeanAdapter类继承了DisposableBean接口
class DisposableBeanAdapter implements DisposableBean, Runnable, Serializable { }
-
具体生命周期及扩展点
生命周期
- 实例化
- 属性注入
- 初始化
- 注册销毁方法
详细:
实例化前 -> 实例化(调用类构造函数生成类实例) -> 实例化后 ->初始化前(依赖注入后) -> 初始化 -> 初始化后 -> 注册销毁方法 -> 使用 -> 销毁
实际创建指定的 bean。此时已经进行了创建前处理，例如，检查 postProcessBeforeInstantiation 回调。
区分默认 Bean 实例化、使用工厂方法和自动装配构造函数。
参数：
beanName – 豆子的名称 mbd – Bean 的合并 Bean 定义 args – 用于构造函数或工厂方法调用的显式参数
返回：
Bean 的新实例
抛出：
BeanCreationException – 如果无法创建 bean
另请参见：
instantiateBean, instantiateUsingFactoryMethod, autowireConstructor
// 真正创建Bean的方法
protected Object doCreateBean(String beanName, RootBeanDefinition mbd, @Nullable Object[] args)
throws BeanCreationException {
// Instantiate the bean. 创建Bean实例
BeanWrapper instanceWrapper = null;
if (mbd.isSingleton()) {
instanceWrapper = this.factoryBeanInstanceCache.remove(beanName);
}
if (instanceWrapper == null) {
instanceWrapper = createBeanInstance(beanName, mbd, args);
}
Object bean = instanceWrapper.getWrappedInstance();
Class<?> beanType = instanceWrapper.getWrappedClass();
if (beanType != NullBean.class) {
mbd.resolvedTargetType = beanType;
}
// Allow post-processors to modify the merged bean definition. 实例化后的后置处理
.....
// Eagerly cache singletons to be able to resolve circular references
// even when triggered by lifecycle interfaces like BeanFactoryAware.
// 解决循环依赖
......
// Initialize the bean instance.
Object exposedObject = bean;
try {
// Bean属性注入
populateBean(beanName, mbd, instanceWrapper);
// 初始化Bean
exposedObject = initializeBean(beanName, exposedObject, mbd);
}
catch (Throwable ex) {
if (ex instanceof BeanCreationException bce && beanName.equals(bce.getBeanName())) {
throw bce;
}
else {
throw new BeanCreationException(mbd.getResourceDescription(), beanName, ex.getMessage(), ex);
}
}
// Register bean as disposable. 注册销毁方法
try {
registerDisposableBeanIfNecessary(beanName, bean, mbd);
}
catch (BeanDefinitionValidationException ex) {
throw new BeanCreationException(
mbd.getResourceDescription(), beanName, "Invalid destruction signature", ex);
}
return exposedObject;
}
另外在org.springframework.beans.factory.BeanFactory 类注解中也有关于生命周期的说明
Bean 工厂实现应尽可能支持标准的 Bean 生命周期接口。完整的初始化方法集及其标准顺序为：
BeanNameAware 的 setBeanName
BeanClassLoaderAware 的 setBeanClassLoader
BeanFactory 的 setBeanFactory
EnvironmentAware 的 setEnvironment
EmbeddedValueResolverAware 的 setEmbeddedValueResolver
ResourceLoaderAware setResourceLoader 的（仅在应用程序上下文中运行时适用）
ApplicationEventPublisherAware setApplicationEventPublisher 的（仅在应用程序上下文中运行时适用）
MessageSourceAware setMessageSource 的（仅在应用程序上下文中运行时适用）
ApplicationContextAware setApplicationContext 的（仅在应用程序上下文中运行时适用）
ServletContextAware setServletContext 的（仅在 Web 应用程序上下文中运行时适用）
postProcessBeforeInitialization BeanPostProcessors 的方法
初始化 Bean 的 afterPropertiesSet
自定义 init-method 定义
postProcessAfterInitialization BeanPostProcessors 的方法
在 Bean 工厂关闭时，以下生命周期方法适用：
postProcessBeforeDestruction DestructionAwareBeanPostProcessors 的方法
DisposableBean 的 destroy
自定义 destroy-method 定义
public interface BeanFactory {
........
}
扩展点
扩展点1:实例化前（构造方法调用前）
应用场景: 返回代理对象,替代原创建的Bean
@Nullable
protected Object resolveBeforeInstantiation(String beanName, RootBeanDefinition mbd) {
Object bean = null;
if (!Boolean.FALSE.equals(mbd.beforeInstantiationResolved)) {
// Make sure bean class is actually resolved at this point.
if (!mbd.isSynthetic() && hasInstantiationAwareBeanPostProcessors()) {
Class<?> targetType = determineTargetType(beanName, mbd);
if (targetType != null) {
// 实例化前的后置处理器
bean = applyBeanPostProcessorsBeforeInstantiation(targetType, beanName);
if (bean != null) {
// 正常bean为null,不为空则直接调用初始化之后的方法。但是这样的话就不会走正常spring创建Bean的流程了，会直接返回这个bean对象
bean = applyBeanPostProcessorsAfterInitialization(bean, beanName);
}
}
}
mbd.beforeInstantiationResolved = (bean != null);
}
return bean;
}
样例:
@Component("myInstantiationAwareBeanPostProcessor")
public class MyInstantiationAwareBeanPostProcessor implements InstantiationAwareBeanPostProcessor {
private static final Logger log = LoggerFactory.getLogger(MyInstantiationAwareBeanPostProcessor.class);
@Override
public Object postProcessBeforeInstantiation(Class<?> beanClass, String beanName) throws BeansException {
// log.info("{} , {}",beanClass.toString(), beanName);
if(beanClass == MyBeanTwo.class || beanName == "myBeanTwo"){
// System.out.println("MyInstantiationAwareBeanPostProcessor创建Bean");
return new MyBeanTwo("MyInstantiationAwareBeanPostProcessor创建的Bean");
}
return null;
}
}
通过实现InstantiationAwareBeanPostProcessor接口，实现postProcessBeforeInstantiation方法，所有的Bean在实例化前都会经过这个方法，该接口继承了BeanPostProcessor接口
public interface InstantiationAwareBeanPostProcessor extends BeanPostProcessor {
@Nullable
default Object postProcessBeforeInstantiation(Class<?> beanClass, String beanName) throws BeansException {
return null;
}
default boolean postProcessAfterInstantiation(Object bean, String beanName) throws BeansException {
return true;
}
@Nullable
default PropertyValues postProcessProperties(PropertyValues pvs, Object bean, String beanName)
throws BeansException {
return pvs;
}
}
扩展点2：实例化后（属性注入前）
应用场景: 自定义Bean的属性注入
在设置属性之前，给任何 InstantiationAwareBeanPostProcessors 修改 Bean 状态的机会。例如，这可用于支持字段注入的样式。
protected void populateBean(String beanName, RootBeanDefinition mbd, @Nullable BeanWrapper bw) {
.....
if (!mbd.isSynthetic() && hasInstantiationAwareBeanPostProcessors()) {
for (InstantiationAwareBeanPostProcessor bp : getBeanPostProcessorCache().instantiationAware) {
// 返回true继续后续的属性注入流程（默认行为）,false则跳过
if (!bp.postProcessAfterInstantiation(bw.getWrappedInstance(), beanName)) {
return;
}
}
}
......
}
样例:
通过实现InstantiationAwareBeanPostProcessor接口，实现postProcessAfterInstantiation方法
abstract class AutoWiredTest {
private String name;
public String getName() {
return name;
}
public AutoWiredTest(String name){
this.name = name;
}
}
@Component("autoWiredTestOne")
public class AutoWiredTestOne extends AutoWiredTest {
public AutoWiredTestOne(){
super("AutoWiredTestOne");
}
}
public class AutoWiredTestTwo extends AutoWiredTest {
public AutoWiredTestTwo() {
super("AutoWiredTwo");
}
}
@Component("myBeanTwo")
public class MyBeanTwo {
@Autowired // 自动注入
private AutoWiredTest autoWiredTest;
}
@Component("myInstantiationAwareBeanPostProcessor")
public class MyInstantiationAwareBeanPostProcessor implements InstantiationAwareBeanPostProcessor {
// 模拟配置
private static Integer flag = 0;
@Override
public boolean postProcessAfterInstantiation(Object bean, String beanName) throws BeansException {
if(bean instanceof MyBeanTwo || beanName == "myBeanTwo"){
// 模拟配置
if(flag == 0){
// 1. 获取目标字段
try {
log.info("实例化后-----");
Field field = MyBeanTwo.class.getDeclaredField("autoWiredTest");
// 2. 解除私有字段访问限制
field.setAccessible(true);
AutoWiredTestTwo dependency = new AutoWiredTestTwo();
// 4. 反射注入依赖
field.set(bean, dependency);
} catch (NoSuchFieldException e) {
throw new RuntimeException(e);
} catch (IllegalAccessException e) {
throw new RuntimeException(e);
}
return false;
}
}
return true;
}
}
代码中flag模拟我们的配置文件中的配置，原本在Bean("myBeanTwo")中根据spring的自动注入，其属性注入的实例应为AutoWiredTestOne的实例，而通过实例化的后置拦截器可以将其替换为AutoWiredTestTwo类实例
该扩展点也可用在加密属性进行解密后再注入等场景
扩展点3：初始化前(属性注入后)
org.springframework.beans.factory.support.AbstractAutowireCapableBeanFactory # applyBeanPostProcessorsBeforeInitialization()
@Override
public Object applyBeanPostProcessorsBeforeInitialization(Object existingBean, String beanName)
throws BeansException {
Object result = existingBean;
for (BeanPostProcessor processor : getBeanPostProcessors()) {
// 调用后置处理器的初始化前方法
// CommonAnnotationBeanPostProcessor处理器处理@PostConstruct注解修饰方法
Object current = processor.postProcessBeforeInitialization(result, beanName);
if (current == null) {
return result;
}
result = current;
}
return result;
}
扩展点4: 初始化时
org.springframework.beans.factory.support.AbstractAutowireCapableBeanFactory # invokeInitMethods()
protected void invokeInitMethods(String beanName, Object bean, @Nullable RootBeanDefinition mbd)
throws Throwable {
boolean isInitializingBean = (bean instanceof InitializingBean);
if (isInitializingBean && (mbd == null || !mbd.hasAnyExternallyManagedInitMethod("afterPropertiesSet"))) {
if (logger.isTraceEnabled()) {
logger.trace("Invoking afterPropertiesSet() on bean with name '" + beanName + "'");
}
// 实现InitializingBean接口的afterPropertiesSet
((InitializingBean) bean).afterPropertiesSet();
}
if (mbd != null && bean.getClass() != NullBean.class) {
String[] initMethodNames = mbd.getInitMethodNames();
if (initMethodNames != null) {
for (String initMethodName : initMethodNames) {
if (StringUtils.hasLength(initMethodName) &&
!(isInitializingBean && "afterPropertiesSet".equals(initMethodName)) &&
!mbd.hasAnyExternallyManagedInitMethod(initMethodName)) {
// 执行自定义的@Bean(initMethod = "****")注解中声明的方法
invokeCustomInitMethod(beanName, bean, mbd, initMethodName);
}
}
}
}
}
扩展点5: 初始化后
@Override
public Object applyBeanPostProcessorsAfterInitialization(Object existingBean, String beanName)
throws BeansException {
Object result = existingBean;
// 后置处理器的后置方法
for (BeanPostProcessor processor : getBeanPostProcessors()) {
Object current = processor.postProcessAfterInitialization(result, beanName);
if (current == null) {
return result;
}
result = current;
}
return result;
}
扩展点6：Bean销毁时
应用场景：资源关闭，如数据库链接，线程池
在注册销毁方法时，会通过方法去判断该Bean是否存在销毁方法
org.springframework.beans.factory.support.AbstractBeanFactory # requiresDestruction()
/*确定给定的 Bean 是否需要在关闭时销毁。
**默认实现检查 DisposableBean 接口以及指定的 destroy 方法和已注册的 DestructionAwareBeanPostProcessors。*/
protected boolean requiresDestruction(Object bean, RootBeanDefinition mbd) {
return (bean.getClass() != NullBean.class && (DisposableBeanAdapter.hasDestroyMethod(bean, mbd) ||
(hasDestructionAwareBeanPostProcessors() && DisposableBeanAdapter.hasApplicableProcessors(
bean, getBeanPostProcessorCache().destructionAware))));
}
// 判断是否继承DisposableBean，是否@Bean#destroyMethod设置默认值
public static boolean hasDestroyMethod(Object bean, RootBeanDefinition beanDefinition) {
return (bean instanceof DisposableBean， ||
inferDestroyMethodsIfNecessary(bean.getClass(), beanDefinition) != null);
}
// CommonAnnotationBeanPostProcessor处理器，处理@PreDestroy注解
public static boolean hasApplicableProcessors(Object bean, List<DestructionAwareBeanPostProcessor> postProcessors) {
if (!CollectionUtils.isEmpty(postProcessors)) {
for (DestructionAwareBeanPostProcessor processor : postProcessors) {
if (processor.requiresDestruction(bean)) {
return true;
}
}
}
return false;
}
在spring容器关闭时会调用
org.springframework.context.support.AbstractApplicationContext # destroyBeans()方法 -> org.springframework.beans.factory.support.DefaultSingletonBeanRegistry # destroySingletons()
public void destroySingletons() {
if (logger.isTraceEnabled()) {
logger.trace("Destroying singletons in " + this);
}
this.singletonsCurrentlyInDestruction = true;
String[] disposableBeanNames;
synchronized (this.disposableBeans) {
disposableBeanNames = StringUtils.toStringArray(this.disposableBeans.keySet());
}
for (int i = disposableBeanNames.length - 1; i >= 0; i--) {
destroySingleton(disposableBeanNames[i]);
}
this.containedBeanMap.clear();
this.dependentBeanMap.clear();
this.dependenciesForBeanMap.clear();
this.singletonLock.lock();
try {
// 清理三级缓存
clearSingletonCache();
}
finally {
this.singletonLock.unlock();
}
}
然后调用org.springframework.beans.factory.support.DefaultSingletonBeanRegistry #
protected void destroyBean(String beanName, @Nullable DisposableBean bean) {
// Trigger destruction of dependent beans first...
// 销毁依赖的Bean
// Actually destroy the bean now...
if (bean != null) {
try {
// 该对象就是注册销毁方法时放入map的DisposableBean类对象
bean.destroy();
}
catch (Throwable ex) {
if (logger.isWarnEnabled()) {
logger.warn("Destruction of bean with name '" + beanName + "' threw an exception", ex);
}
}
}
// Trigger destruction of contained beans...
// 销毁包含的Bean
...
// Remove destroyed bean from other beans' dependencies.
// 从其他 Bean 的依赖项中删除已销毁的 bean。
synchronized (this.dependentBeanMap) {
for (Iterator<Map.Entry<String, Set<String>>> it = this.dependentBeanMap.entrySet().iterator(); it.hasNext();) {
Map.Entry<String, Set<String>> entry = it.next();
Set<String> dependenciesToClean = entry.getValue();
dependenciesToClean.remove(beanName);
if (dependenciesToClean.isEmpty()) {
it.remove();
}
}
}
// Remove destroyed bean's prepared dependency information.
this.dependenciesForBeanMap.remove(beanName);
}
扩展点3-6样例
Bean
public class MyBean implements InitializingBean, DisposableBean {
private static Logger log = LoggerFactory.getLogger(MyBean.class);
private String name;
public MyBean(String name) {
this.name = name;
}
@Override
public void afterPropertiesSet() throws Exception {
log.info("MyBean afterPropertiesSet");
}
public void init(){
log.info("MyBean init");
}
@PostConstruct
public void postConstruct(){
log.info("MyBean postConstruct");
}
@PreDestroy
public void preDestroy(){
log.info("MyBean preDestroy");
}
@Override
public void destroy() throws Exception {
log.info("MyBean destroy");
}
public void destroyMethod(){
log.info("MyBean destroyMethod");
}
}
配置类:
@Configuration(value = "bean_test_beanConfig")
public class BeanConfig {
private static Logger log = LoggerFactory.getLogger(BeanConfig.class);
@Bean(name = "myBean", initMethod = "init", destroyMethod = "destroyMethod")
public MyBean myBean() {
return new MyBean("tom");
}
}
后置处理器
// Bean初始化前后后置处理器 对所有的Bean执行
@Component
public class MyBeanPostProcessor implements BeanPostProcessor {
private static final Logger log = LoggerFactory.getLogger(MyBeanPostProcessor.class);
@Override
public Object postProcessBeforeInitialization(Object bean, String beanName) throws BeansException {
// log.info("初始化前-----");
if(bean instanceof MyBean || beanName == "myBean") {
log.info("这是myBean");
log.info("---- postProcessBeforeInitialization ---");
}
return bean;
}
@Override
public Object postProcessAfterInitialization(Object bean, String beanName) throws BeansException {
// log.info("初始化后-----");
if(bean instanceof MyBean){
log.info("这是myBean");
log.info("---- postProcessAfterInitialization --- ");
}
return bean;
}
}
输出:
这是myBean
---- postProcessBeforeInitialization ---
MyBean postConstruct
MyBean afterPropertiesSet
MyBean init
这是myBean
---- postProcessAfterInitialization ---
// 销毁
MyBean preDestroy
MyBean destroy
MyBean destroyMethod
浙公网安备 33010602011771号