Spring Bean的生命周期（生命周期阶段和扩展点分开）

迷南。 2023-07-22 09:28 15阅读 0赞

Spring 有一些常用扩展点，了解Spring Bean的生命周期，能够对spring宏观有一定的认识，这里尝试答一下。

Spring Bean的生命周期分为四个阶段。这里将spring Bean的四个阶段添加部分常用扩展点便于理解。

## 一、spring bean 四个阶段 ##

1、实例化 instantiation（createBeanInstance）  
2、属性赋值 Populate (populateBean)  
3、初始化 Initialization(initializeBean)  
4、销毁 Destruction(ConfigurableApplicationContext\#close())

这个四个方法都放在AbstractAutowireCapableBeanFactory 中的doCreateBean的方法中，

protected Object doCreateBean(String beanName, RootBeanDefinition mbd, @Nullable Object[] args) throws BeanCreationException {
            BeanWrapper instanceWrapper = null;
            if (mbd.isSingleton()) {
                instanceWrapper = (BeanWrapper)this.factoryBeanInstanceCache.remove(beanName);
            }
    		//实例化
            if (instanceWrapper == null) {
                instanceWrapper = this.createBeanInstance(beanName, mbd, args);
            }
    	.......................
            try {
            	//属性赋值
                this.populateBean(beanName, mbd, instanceWrapper);
                //初始化
                exposedObject = this.initializeBean(beanName, exposedObject, mbd);
            } catch (Throwable var18) {
                if (var18 instanceof BeanCreationException && beanName.equals(((BeanCreationException)var18).getBeanName())) {
                    throw (BeanCreationException)var18;
                }
    
                throw new BeanCreationException(mbd.getResourceDescription(), beanName, "Initialization of bean failed", var18);
            }
    
       ...........
        }

## 二、spring bean中的两个重要接口 ##

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2ZhamluZ19mZWl5dWU_size_16_color_FFFFFF_t_70]

在四个过程中又Spring扩展中有两个很重要的接口，InstantiationAwareBeanPostProcessor和BeanPostProcessor。这两个接口实际是继承关系，但由于这两个接口在spring bean生命周期中的不同阶段是 不同接口本身的方法起作用所以这里将两个接口分开来看。

InstantiationAwareBeanPostProcessor 与BeanPostProcessor 之间的关系

public interface InstantiationAwareBeanPostProcessor extends BeanPostProcessor {
    ....
    }

**1、InstantiationAwareBeanPostProcessor 接口**

**（1）InstantiationAwareBeanPostProcessor 中的applyBeanPostProcessorsBeforeInstantiation 的接口**  
InstantiationAwareBeanPostProcessor调用地方依然在AbstractAutowireCapableBeanFactory 这类中 createBean方法

protected Object createBean(String beanName, RootBeanDefinition mbd, @Nullable Object[] args) throws BeanCreationException {
         ......
    
            Object beanInstance;
            try {
            
            //InstantiationAwareBeanPostProcessor 中的postProcessBeforeInstantiation方法
            
                beanInstance = this.resolveBeforeInstantiation(beanName, mbdToUse);
                if (beanInstance != null) {
                    return beanInstance;
                }
            } catch (Throwable var10) {
                throw new BeanCreationException(mbdToUse.getResourceDescription(), beanName, "BeanPostProcessor before instantiation of bean failed", var10);
            }
    
            try {
            
            //spring bean 1、实例化 、属性赋值、初始化 方法
            
                beanInstance = this.doCreateBean(beanName, mbdToUse, args);
                if (this.logger.isTraceEnabled()) {
                    this.logger.trace("Finished creating instance of bean '" + beanName + "'");
                }
    
                return beanInstance;
            } catch (ImplicitlyAppearedSingletonException | BeanCreationException var7) {
                throw var7;
            } catch (Throwable var8) {
                throw new BeanCreationException(mbdToUse.getResourceDescription(), beanName, "Unexpected exception during bean creation", var8);
            }
        }

InstantiationAwareBeanPostProcessor 中的resolveBeforeInstantiation

@Nullable
        protected Object resolveBeforeInstantiation(String beanName, RootBeanDefinition mbd) {
            Object bean = null;
            if (!Boolean.FALSE.equals(mbd.beforeInstantiationResolved)) {
                if (!mbd.isSynthetic() && this.hasInstantiationAwareBeanPostProcessors()) {
                    Class<?> targetType = this.determineTargetType(beanName, mbd);
                    if (targetType != null) {
                    
                    //在此方法中调用InstantiationAwareBeanPostProcessor 中postProcessBeforeInstantiation
                    
                        bean = this.applyBeanPostProcessorsBeforeInstantiation(targetType, beanName);
                        if (bean != null) {
                            bean = this.applyBeanPostProccessorsAfterInitialization(bean, beanName);
                        }
                    }
                }
    
                mbd.beforeInstantiationResolved = bean != null;
            }
    
            return bean;
        }

InstantiationAwareBeanPostProcessor 中的applyBeanPostProcessorsBeforeInstantiation

@Nullable
        protected Object applyBeanPostProcessorsBeforeInstantiation(Class<?> beanClass, String beanName) {
            Iterator var3 = this.getBeanPostProcessors().iterator();
    
            while(var3.hasNext()) {
                BeanPostProcessor bp = (BeanPostProcessor)var3.next();
                if (bp instanceof InstantiationAwareBeanPostProcessor) {
                
                //当判断接口中有有InstantiationAwareBeanPostProcessor则调用postProcessBeforeInstantiation
                
                    InstantiationAwareBeanPostProcessor ibp = (InstantiationAwareBeanPostProcessor)bp;
                    Object result = ibp.postProcessBeforeInstantiation(beanClass, beanName);
                    if (result != null) {
                        return result;
                    }
                }
            }
    
            return null;
        }

**（2）InstantiationAwareBeanPostProcessor 中的postProcessAfterInstantiation,postProcessProperties的接口**

InstantiationAwareBeanPostProcessor中的postProcessAfterInstantiation,postProcessProperties在AbstractAutowireCapableBeanFactory 这类中 createBean->populateBean 的接口中

protected void populateBean(String beanName, RootBeanDefinition mbd, @Nullable BeanWrapper bw) {
            .........
    
                    while(var5.hasNext()) {
                        BeanPostProcessor bp = (BeanPostProcessor)var5.next();
                        if (bp instanceof InstantiationAwareBeanPostProcessor) {
                            InstantiationAwareBeanPostProcessor ibp = (InstantiationAwareBeanPostProcessor)bp;
                            
                            //InstantiationAwareBeanPostProcessor 中调用postProcessAfterInstantiation方法
                            
                            if (!ibp.postProcessAfterInstantiation(bw.getWrappedInstance(), beanName)) {
                                continueWithPropertyPopulation = false;
                                break;
                            }
                        }
                    }
                }
    
                if (continueWithPropertyPopulation) {
                    PropertyValues pvs = mbd.hasPropertyValues() ? mbd.getPropertyValues() : null;
                    if (mbd.getResolvedAutowireMode() == 1 || mbd.getResolvedAutowireMode() == 2) {
                        MutablePropertyValues newPvs = new MutablePropertyValues((PropertyValues)pvs);
                        if (mbd.getResolvedAutowireMode() == 1) {
                            this.autowireByName(beanName, mbd, bw, newPvs);
                        }
    
                        if (mbd.getResolvedAutowireMode() == 2) {
                            this.autowireByType(beanName, mbd, bw, newPvs);
                        }
    
                        pvs = newPvs;
                    }
    
                    boolean hasInstAwareBpps = this.hasInstantiationAwareBeanPostProcessors();
                    boolean needsDepCheck = mbd.getDependencyCheck() != 0;
                    PropertyDescriptor[] filteredPds = null;
                    if (hasInstAwareBpps) {
                        if (pvs == null) {
                            pvs = mbd.getPropertyValues();
                        }
    
                        Iterator var9 = this.getBeanPostProcessors().iterator();
    
                        while(var9.hasNext()) {
                            BeanPostProcessor bp = (BeanPostProcessor)var9.next();
                            if (bp instanceof InstantiationAwareBeanPostProcessor) {
                                InstantiationAwareBeanPostProcessor ibp = (InstantiationAwareBeanPostProcessor)bp;
                                
                                //InstantiationAwareBeanPostProcessor  调用 postProcessProperties接口
                                
                                PropertyValues pvsToUse = ibp.postProcessProperties((PropertyValues)pvs, bw.getWrappedInstance(), beanName);
                                if (pvsToUse == null) {
                                    if (filteredPds == null) {
                                        filteredPds = this.filterPropertyDescriptorsForDependencyCheck(bw, mbd.allowCaching);
                                    }
    
                                    pvsToUse = ibp.postProcessPropertyValues((PropertyValues)pvs, filteredPds, bw.getWrappedInstance(), beanName);
                                    if (pvsToUse == null) {
                                        return;
                                    }
                                }
    
                                pvs = pvsToUse;
                            }
                        }
                    }
    
                    if (needsDepCheck) {
                        if (filteredPds == null) {
                            filteredPds = this.filterPropertyDescriptorsForDependencyCheck(bw, mbd.allowCaching);
                        }
    
                        this.checkDependencies(beanName, mbd, filteredPds, (PropertyValues)pvs);
                    }
    
                    if (pvs != null) {
                        this.applyPropertyValues(beanName, mbd, bw, (PropertyValues)pvs);
                    }
    
                }
            }
        }

**2、BeanPostProcessor接口**

调用BeanPostProcessor接口在AbstractAutowireCapableBeanFactory 这类中 createBean->  
initializeBean的接口中  
**(1)、BeanPostProcessor中的postProcessBeforeInitialization,postProcessAfterInitialization的接口**

protected Object initializeBean(String beanName, Object bean, @Nullable RootBeanDefinition mbd) {
            if (System.getSecurityManager() != null) {
                AccessController.doPrivileged(() -> {
                    this.invokeAwareMethods(beanName, bean);
                    return null;
                }, this.getAccessControlContext());
            } else {
                this.invokeAwareMethods(beanName, bean);
            }
    
            Object wrappedBean = bean;
            
            //BeanPostProcessor中的postProcessBeforeInitialization的调用
            
            if (mbd == null || !mbd.isSynthetic()) {
                wrappedBean = this.applyBeanPostProcessorsBeforeInitialization(bean, beanName);
            }
    
            try {
                this.invokeInitMethods(beanName, wrappedBean, mbd);
            } catch (Throwable var6) {
                throw new BeanCreationException(mbd != null ? mbd.getResourceDescription() : null, beanName, "Invocation of init method failed", var6);
            }
            
    		//BeanPostProcessor中postProcessAfterInitialization的调用
    		
            if (mbd == null || !mbd.isSynthetic()) {
                wrappedBean = this.applyBeanPostProcessorsAfterInitialization(wrappedBean, beanName);
            }
    
            return wrappedBean;
        }

## 三、Aware类型的接口 ##

Aware类型的接口主要是去Spring容器中的一些资源对应的资源。

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2ZhamluZ19mZWl5dWU_size_16_color_FFFFFF_t_70 1]

1、Ware接口的调用在AbstractAutowireCapableBeanFactory 这类中 createBean->  
initializeBean的接口中。

protected Object initializeBean(String beanName, Object bean, @Nullable RootBeanDefinition mbd) {
            if (System.getSecurityManager() != null) {
                AccessController.doPrivileged(() -> {
                    this.invokeAwareMethods(beanName, bean);
                    return null;
                }, this.getAccessControlContext());
            } else {
            //ware接口的调用
                this.invokeAwareMethods(beanName, bean);
            }
    
            Object wrappedBean = bean;
            if (mbd == null || !mbd.isSynthetic()) {
            
            //  //BeanPostProcessor中的postProcessBeforeInitialization的调用
            
                wrappedBean = this.applyBeanPostProcessorsBeforeInitialization(bean, beanName);
            }
    
            try {
                this.invokeInitMethods(beanName, wrappedBean, mbd);
            } catch (Throwable var6) {
                throw new BeanCreationException(mbd != null ? mbd.getResourceDescription() : null, beanName, "Invocation of init method failed", var6);
            }
    
            if (mbd == null || !mbd.isSynthetic()) {
            
            BeanPostProcessor中postProcessAfterInitialization的调用
            
                wrappedBean = this.applyBeanPostProcessorsAfterInitialization(wrappedBean, beanName);
            }
    
            return wrappedBean;
        }

AbstractAutowireCapableBeanFactory 这类中 createBean->  
initializeBean->invokeAwareMethods,根据不同ware类型在不同spring容器拿不同的东西。

private void invokeAwareMethods(String beanName, Object bean) {
            if (bean instanceof Aware) {
                if (bean instanceof BeanNameAware) {
                    ((BeanNameAware)bean).setBeanName(beanName);
                }
    
                if (bean instanceof BeanClassLoaderAware) {
                    ClassLoader bcl = this.getBeanClassLoader();
                    if (bcl != null) {
                        ((BeanClassLoaderAware)bean).setBeanClassLoader(bcl);
                    }
                }
    
                if (bean instanceof BeanFactoryAware) {
                    ((BeanFactoryAware)bean).setBeanFactory(this);
                }
            }
    
        }

简单的两个生命周期接口

## 四、初始化和销毁 ##

1、初始化，初始化同样在InitializingBean 对应生命周期的初始化阶段，在上面源码的invokeInitMethods(beanName, wrappedBean, mbd);方法中调用。

2、销毁阶段，销毁的调用在AbstractApplicationContext类中的close()方法作

public void close() {
            Object var1 = this.startupShutdownMonitor;
            synchronized(this.startupShutdownMonitor) {
                this.doClose();
                if (this.shutdownHook != null) {
                    try {
                        Runtime.getRuntime().removeShutdownHook(this.shutdownHook);
                    } catch (IllegalStateException var4) {
                        ;
                    }
                }
    
            }
        }

## 五、AbstractAutowireCapableBeanFactory 的父级入口 ##

我们调用测试的时候需要一些入口，AbstractAutowireCapableBeanFactory 的调用在AbstractApplicationContext 中refresh接口中，定义了BeanPostProcesser和普通单例之间的加载顺序。

public void refresh() throws BeansException, IllegalStateException {
            Object var1 = this.startupShutdownMonitor;
            synchronized(this.startupShutdownMonitor) {
                this.prepareRefresh();
                ConfigurableListableBeanFactory beanFactory = this.obtainFreshBeanFactory();
                this.prepareBeanFactory(beanFactory);
    
                try {
                    this.postProcessBeanFactory(beanFactory);
                    this.invokeBeanFactoryPostProcessors(beanFactory);
                    
                     //BeanPostProcesser调用初始点（BeanPostProcesser也是bean需要先将BeanPostProcesser进行注册）
                     
                    this.registerBeanPostProcessors(beanFactory);
                    this.initMessageSource();
                    this.initApplicationEventMulticaster();
                    this.onRefresh();
                    this.registerListeners();
                    
                    // 所有单例非懒加载Bean的调用点,例如controller,service类
                    
                    this.finishBeanFactoryInitialization(beanFactory);
                    this.finishRefresh();
                } catch (BeansException var9) {
                    if (this.logger.isWarnEnabled()) {
                        this.logger.warn("Exception encountered during context initialization - cancelling refresh attempt: " + var9);
                    }
    
                    this.destroyBeans();
                    this.cancelRefresh(var9);
                    throw var9;
                } finally {
                    this.resetCommonCaches();
                }
    
            }
        }

AbstractApplicationContext 中finishBeanFactoryInitialization是我们,例如controller,service类这种单例非懒加载的父级入口。

protected void finishBeanFactoryInitialization(ConfigurableListableBeanFactory beanFactory) {
            if (beanFactory.containsBean("conversionService") && beanFactory.isTypeMatch("conversionService", ConversionService.class)) {
            
            //从这beanFactory.getBean("conversionService", ConversionService.class) 
            //调用的AbstractAutowireCapableBeanFactory 进行初始化
            
                beanFactory.setConversionService((ConversionService)beanFactory.getBean("conversionService", ConversionService.class));
            }
    
            if (!beanFactory.hasEmbeddedValueResolver()) {
                beanFactory.addEmbeddedValueResolver((strVal) -> {
                    return this.getEnvironment().resolvePlaceholders(strVal);
                });
            }
    
            String[] weaverAwareNames = beanFactory.getBeanNamesForType(LoadTimeWeaverAware.class, false, false);
            String[] var3 = weaverAwareNames;
            int var4 = weaverAwareNames.length;
    
            for(int var5 = 0; var5 < var4; ++var5) {
                String weaverAwareName = var3[var5];
                this.getBean(weaverAwareName);
            }
    
            beanFactory.setTempClassLoader((ClassLoader)null);
            beanFactory.freezeConfiguration();
            beanFactory.preInstantiateSingletons();
        }

这是BeanPostProcesser也是bean需要先将BeanPostProcesser进行注册的入口

public static void registerBeanPostProcessors(ConfigurableListableBeanFactory beanFactory, AbstractApplicationContext applicationContext) {
            String[] postProcessorNames = beanFactory.getBeanNamesForType(BeanPostProcessor.class, true, false);
            int beanProcessorTargetCount = beanFactory.getBeanPostProcessorCount() + 1 + postProcessorNames.length;
            beanFactory.addBeanPostProcessor(new PostProcessorRegistrationDelegate.BeanPostProcessorChecker(beanFactory, beanProcessorTargetCount));
            List<BeanPostProcessor> priorityOrderedPostProcessors = new ArrayList();
            List<BeanPostProcessor> internalPostProcessors = new ArrayList();
            List<String> orderedPostProcessorNames = new ArrayList();
            List<String> nonOrderedPostProcessorNames = new ArrayList();
            String[] var8 = postProcessorNames;
            int var9 = postProcessorNames.length;
    
            String ppName;
            BeanPostProcessor pp;
            for(int var10 = 0; var10 < var9; ++var10) {
                ppName = var8[var10];
                
                //判断是否有实现PriorityOrdered，如果实现PriorityOrdered放到priorityOrderedPostProcessors
                if (beanFactory.isTypeMatch(ppName, PriorityOrdered.class)) {
                    pp = (BeanPostProcessor)beanFactory.getBean(ppName, BeanPostProcessor.class);
                    priorityOrderedPostProcessors.add(pp);
                    if (pp instanceof MergedBeanDefinitionPostProcessor) {
                        internalPostProcessors.add(pp);
                    }
                    
                        //判断是否有实现Ordered，如果实现PriorityOrdered放到orderedPostProcessorNames
                        
                } else if (beanFactory.isTypeMatch(ppName, Ordered.class)) {
                    orderedPostProcessorNames.add(ppName);
                } else {
                
                //既没有实现PriorityOrdered，也没有实现Ordered的类
                
                    nonOrderedPostProcessorNames.add(ppName);
                }
            }
    
        .......

BeanPostProcessor的启动时机。分为四个阶段，第一阶段context内置阶段、第二阶段priorityOrdered阶段、第三阶段Ordered阶段、第四阶段nonOrdered阶段。

、

BeanPostProcessor实例化时候，自动依赖注入根据类型获得需要注入的Bean时，会将某些符合条件的Bean（FactoryBean并且其FactoryBeanFactory已经实例化的）先实例化，如果此FacotryBean又依赖其他普通Bean，会导致该Bean提前启动，造成误伤（无法享受部分BeanPostProcessor的后处理，例如典型的auto-proxy）。可以将其提前启动类的始化方法加上static，或者将其移出单独为其创建一个配置类。

[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2ZhamluZ19mZWl5dWU_size_16_color_FFFFFF_t_70]: /images/20230528/990e31f52eb74a7eb8ffb977bd8e73a9.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2ZhamluZ19mZWl5dWU_size_16_color_FFFFFF_t_70 1]: /images/20230528/889e5034fb2c423d98be6be83fd0ed50.png