Spring Bean 生命周源码解析

2021-02-02  本文已影响0人  繁书_

Spring Bean生命周期

前言

在使用Spring框架进行开发，一般我们都会将项目中的Bean托管给Spring，也就是俗称的IOC

被Spring管理的单例(singleton)Bean 从创建到销毁，中间的过程都会有完整的生命周期，原型(prototype)Bean只有创建的生命周期没有销毁的生命周期，因为Spring在创建完原型Bean之后就不再有Bean的控制权，而是交由用户控制

文中主要结合源码分析单例Bean 的生命周期

1. 流程

启动Spring

public class BeanLifecycleAnalyse {
    public static void main(String[] args) {
        AnnotationConfigApplicationContext applicationContext = new AnnotationConfigApplicationContext();
      
        applicationContext.refresh();
        applicationContext.close();
    }

}

Spring启动要调用ApplicationContent的refresh()方法

public void refresh() throws BeansException, IllegalStateException {
        synchronized (this.startupShutdownMonitor) {
            // Prepare this context for refreshing.
            prepareRefresh();

            // Tell the subclass to refresh the internal bean factory.
            ConfigurableListableBeanFactory beanFactory = obtainFreshBeanFactory();

            // Prepare the bean factory for use in this context.
            prepareBeanFactory(beanFactory);

            try {
                // Allows post-processing of the bean factory in context subclasses.
                postProcessBeanFactory(beanFactory);

                // Invoke factory processors registered as beans in the context.
                invokeBeanFactoryPostProcessors(beanFactory);

                // Register bean processors that intercept bean creation.
                registerBeanPostProcessors(beanFactory);

                // Initialize message source for this context.
                initMessageSource();

                // Initialize event multicaster for this context.
                initApplicationEventMulticaster();

                // Initialize other special beans in specific context subclasses.
                onRefresh();

                // Check for listener beans and register them.
                registerListeners();

                // Instantiate all remaining (non-lazy-init) singletons.
                // 初始化单例对象
                finishBeanFactoryInitialization(beanFactory);

                // Last step: publish corresponding event.
                finishRefresh();
            }

            catch (BeansException ex) {
                if (logger.isWarnEnabled()) {
                    logger.warn("Exception encountered during context initialization - " +
                            "cancelling refresh attempt: " + ex);
                }

                // Destroy already created singletons to avoid dangling resources.
                destroyBeans();

                // Reset 'active' flag.
                cancelRefresh(ex);

                // Propagate exception to caller.
                throw ex;
            }

            finally {
                // Reset common introspection caches in Spring's core, since we
                // might not ever need metadata for singleton beans anymore...
                resetCommonCaches();
            }
        }
    }

finishBeanFactoryInitialization内部主要进行Bean初始化相关内容

AbstractApplcationContent#finishBeanFactoryInitialization() 源码

protected void finishBeanFactoryInitialization(ConfigurableListableBeanFactory beanFactory) {
        // Initialize conversion service for this context.
        if (beanFactory.containsBean(CONVERSION_SERVICE_BEAN_NAME) &&
                beanFactory.isTypeMatch(CONVERSION_SERVICE_BEAN_NAME, ConversionService.class)) {
            beanFactory.setConversionService(
                    beanFactory.getBean(CONVERSION_SERVICE_BEAN_NAME, ConversionService.class));
        }

        // Register a default embedded value resolver if no bean post-processor
        // (such as a PropertyPlaceholderConfigurer bean) registered any before:
        // at this point, primarily for resolution in annotation attribute values.
        if (!beanFactory.hasEmbeddedValueResolver()) {
            beanFactory.addEmbeddedValueResolver(strVal -> getEnvironment().resolvePlaceholders(strVal));
        }

        // Initialize LoadTimeWeaverAware beans early to allow for registering their transformers early.
        String[] weaverAwareNames = beanFactory.getBeanNamesForType(LoadTimeWeaverAware.class, false, false);
        for (String weaverAwareName : weaverAwareNames) {
            getBean(weaverAwareName);
        }

        // Stop using the temporary ClassLoader for type matching.
        beanFactory.setTempClassLoader(null);

        // Allow for caching all bean definition metadata, not expecting further changes.
        beanFactory.freezeConfiguration();

        // Instantiate all remaining (non-lazy-init) singletons.
        // 创建单例Bean
        beanFactory.preInstantiateSingletons();
    }

在 preIntaniateSingletons中会依次按照BeanDefinition的顺序依次初始化Bean
DefaultListableBeanFactory#preIntaniateSingletons() 源码

@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...
        // 根据BeanDefinition的顺序初始化单例对象
        for (String beanName : beanNames) {
            RootBeanDefinition bd = getMergedLocalBeanDefinition(beanName);
            if (!bd.isAbstract() && bd.isSingleton() && !bd.isLazyInit()) {
                if (isFactoryBean(beanName)) {
                    Object bean = getBean(FACTORY_BEAN_PREFIX + beanName);
                    if (bean instanceof FactoryBean) {
                        final FactoryBean<?> factory = (FactoryBean<?>) bean;
                        boolean isEagerInit;
                        if (System.getSecurityManager() != null && factory instanceof SmartFactoryBean) {
                            isEagerInit = AccessController.doPrivileged((PrivilegedAction<Boolean>)
                                            ((SmartFactoryBean<?>) factory)::isEagerInit,
                                    getAccessControlContext());
                        }
                        else {
                            isEagerInit = (factory instanceof SmartFactoryBean &&
                                    ((SmartFactoryBean<?>) factory).isEagerInit());
                        }
                        if (isEagerInit) {
                            getBean(beanName);
                        }
                    }
                }
                else {
                    getBean(beanName);
                }
            }
        }

        // Trigger post-initialization callback for all applicable beans...
        for (String beanName : beanNames) {
            Object singletonInstance = getSingleton(beanName);
            if (singletonInstance instanceof SmartInitializingSingleton) {
                smartSingleton.afterSingletonsInstantiated();
            }
        }
    }

2. AbstractAutowireCapableBeanFactory#createBean()

createBean方法内部就是实例化Bean逻辑的开始

源码中只保留实例化Bean的逻辑

protected Object createBean(String beanName, RootBeanDefinition mbd, @Nullable Object[] args)
            throws BeanCreationException {
        RootBeanDefinition mbdToUse = mbd;
            // ...省略其他代码....

            // Give BeanPostProcessors a chance to return a proxy instead of the target bean instance.
            Object bean = resolveBeforeInstantiation(beanName, mbdToUse);
            if (bean != null) {
                return bean;
            }
            
            // 实例化Bean
            Object beanInstance = doCreateBean(beanName, mbdToUse, args);
            if (logger.isTraceEnabled()) {
                logger.trace("Finished creating instance of bean '" + beanName + "'");
            }
            return beanInstance;
    }

3. 实例化前阶段

源码中 resolveBeforeInstantiation 方法属于实例化前阶段，该阶段会查找Spring中的类型为InstantiationAwareBeanPostProcessor 的BeanPostProcessor，并调用postProcessBeforeInstantiation() 方法进行实例化前置处理

源码

AbstractAutowireCapableBeanFactory#applyBeanPostProcessorsBeforeInstantiation()

    protected Object applyBeanPostProcessorsBeforeInstantiation(Class<?> beanClass, String beanName) {
        for (BeanPostProcessor bp : getBeanPostProcessors()) {
            if (bp instanceof InstantiationAwareBeanPostProcessor) {
                InstantiationAwareBeanPostProcessor ibp = (InstantiationAwareBeanPostProcessor) bp;
                Object result = ibp.postProcessBeforeInstantiation(beanClass, beanName);
                if (result != null) {
                    return result;
                }
            }
        }
        return null;
    }

InstantiationAwareBeanPostProcessor 结构

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;
    }

    
    
    default PropertyValues postProcessProperties(PropertyValues pvs, Object bean, String beanName)
            throws BeansException {

        return null;
    }

    
    default PropertyValues postProcessPropertyValues(
            PropertyValues pvs, PropertyDescriptor[] pds, Object bean, String beanName) throws BeansException {

        return pvs;
    }
}

在createBean方法中可以看到，如果该接口的方法返回值不为空，则直接将该对象返回不进行下面的实例化和初始化逻辑，一般该方法用于返回代理对象

4. 实例化阶段

doCreateBean() 源码

protected Object doCreateBean(final String beanName, final RootBeanDefinition mbd, final @Nullable Object[] args)
            throws BeanCreationException {
    
        // ...省略其他代码.....

        // Instantiate the bean.
        BeanWrapper instanceWrapper = null;
        if (mbd.isSingleton()) {
            instanceWrapper = this.factoryBeanInstanceCache.remove(beanName);
        }
        if (instanceWrapper == null) {
            // 创建Bean实例
            instanceWrapper = createBeanInstance(beanName, mbd, args);
        }
        final Object bean = instanceWrapper.getWrappedInstance();
        Class<?> beanType = instanceWrapper.getWrappedClass();
        if (beanType != NullBean.class) {
            mbd.resolvedTargetType = beanType;
        }

        // Initialize the bean instance.
        Object exposedObject = bean;
    
        // 对Bean进行属性填充
        populateBean(beanName, mbd, instanceWrapper);
        // 初始化Bean
        exposedObject = initializeBean(beanName, exposedObject, mbd);

        return exposedObject;
    }

createBeanInstance会创建Bean实例并返回

createBeanInstance 源码

protected BeanWrapper createBeanInstance(String beanName, RootBeanDefinition mbd, @Nullable Object[] args) {
        // Make sure bean class is actually resolved at this point.
        Class<?> beanClass = resolveBeanClass(mbd, beanName);

        Supplier<?> instanceSupplier = mbd.getInstanceSupplier();
        if (instanceSupplier != null) {
            return obtainFromSupplier(instanceSupplier, beanName);
        }

        if (mbd.getFactoryMethodName() != null) {
            return instantiateUsingFactoryMethod(beanName, mbd, args);
        }

        // Candidate constructors for autowiring?
        // 选取构造器
        Constructor<?>[] ctors = determineConstructorsFromBeanPostProcessors(beanClass, beanName);
        if (ctors != null || mbd.getResolvedAutowireMode() == AUTOWIRE_CONSTRUCTOR ||
                mbd.hasConstructorArgumentValues() || !ObjectUtils.isEmpty(args)) {
            return autowireConstructor(beanName, mbd, ctors, args);
        }

        // Preferred constructors for default construction?
        ctors = mbd.getPreferredConstructors();
        if (ctors != null) {
            return autowireConstructor(beanName, mbd, ctors, null);
        }

        // No special handling: simply use no-arg constructor.
        return instantiateBean(beanName, mbd);
    }

该方法主要确定该调用Bean中的哪个构造方法进行实例化

determineConstructorsFromBeanPostProcessors方法内部会获取类型为SmartInstantiationAwareBeanPostProcessor 的BeanPostProcessor，并执行其determineCandidateConstructors方法, 该方法会返回构造方法数组，实现该接口可以自由选取使用哪个构造方法

4. 属性填充

populateBean方法内部会将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.
        // 实例化后置处理
        if (!mbd.isSynthetic() && hasInstantiationAwareBeanPostProcessors()) {
            for (BeanPostProcessor bp : getBeanPostProcessors()) {
                if (bp instanceof InstantiationAwareBeanPostProcessor) {
                    InstantiationAwareBeanPostProcessor ibp = (InstantiationAwareBeanPostProcessor) bp;
                    if (!ibp.postProcessAfterInstantiation(bw.getWrappedInstance(), beanName)) {
                        return;
                    }
                }
            }
        }

        boolean hasInstAwareBpps = hasInstantiationAwareBeanPostProcessors();
        boolean needsDepCheck = (mbd.getDependencyCheck() != AbstractBeanDefinition.DEPENDENCY_CHECK_NONE);

        PropertyDescriptor[] filteredPds = null;
        if (hasInstAwareBpps) {
            if (pvs == null) {
                pvs = mbd.getPropertyValues();
            }
            
            // 属性处理
            for (BeanPostProcessor bp : getBeanPostProcessors()) {
                if (bp instanceof InstantiationAwareBeanPostProcessor) {
                    InstantiationAwareBeanPostProcessor ibp = (InstantiationAwareBeanPostProcessor) bp;
                    PropertyValues pvsToUse = ibp.postProcessProperties(pvs, bw.getWrappedInstance(), beanName);
                    if (pvsToUse == null) {
                        if (filteredPds == null) {
                            filteredPds = filterPropertyDescriptorsForDependencyCheck(bw, mbd.allowCaching);
                        }
                        pvsToUse = ibp.postProcessPropertyValues(pvs, filteredPds, bw.getWrappedInstance(), beanName);
                        if (pvsToUse == null) {
                            return;
                        }
                    }
                    pvs = pvsToUse;
                }
            }
        }

        if (pvs != null) {
            // 属性填充
            applyPropertyValues(beanName, mbd, bw, pvs);
        }
    }

  1. 属性填充前

    属性填充前进行 实例化后置处理 InstantiationAwareBeanPostProcessor#postProcessAfterInstantiation
    调用 InstantiationAwareBeanPostProcessor#postProcessProperties 对属性进行定制操作

  2. 属性填充

    执行applyPropertyValues 内部实际调用的字段的setter方法进行变量赋值

5. 初始化

初始化逻辑在initializeBean() 方法中

源码

protected Object initializeBean(final String beanName, final Object bean, @Nullable RootBeanDefinition mbd) {
        
        // 回调Aware接口
        invokeAwareMethods(beanName, bean);
        
        Object wrappedBean = bean;
        if (mbd == null || !mbd.isSynthetic()) {
            // BeanPostProcessor 初始化前置处理
            wrappedBean = applyBeanPostProcessorsBeforeInitialization(wrappedBean, beanName);
        }

        try {
            // 执行初始化方法
            invokeInitMethods(beanName, wrappedBean, mbd);
        }
        catch (Throwable ex) {
            throw new BeanCreationException(
                    (mbd != null ? mbd.getResourceDescription() : null),
                    beanName, "Invocation of init method failed", ex);
        }
        if (mbd == null || !mbd.isSynthetic()) {
            // BeanPostProcessor初始化后置处理
            wrappedBean = applyBeanPostProcessorsAfterInitialization(wrappedBean, beanName);
        }

        return wrappedBean;
}

通过源码可以看到初始化分为三个阶段 初始化前，初始化，初始化后

  1. 初始化前

    初始化前执行 invokeAwareMethods方法来回调各个Aware接口的方法，并进行前置处理

    invokeAwareMethods 源码

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

    Spring中一共有九个Aware接口，这里的方法只会执行前三个，后续的六个在前置处理applyBeanPostProcessorsBeforeInitialization方法中

    applyBeanPostProcessorsBeforeInitialization源码

    @Override
 public Object applyBeanPostProcessorsBeforeInitialization(Object existingBean, String beanName)
         throws BeansException {

     Object result = existingBean;
     for (BeanPostProcessor processor : getBeanPostProcessors()) {
         Object current = processor.postProcessBeforeInitialization(result, beanName);
         if (current == null) {
             return result;
         }
         result = current;
     }
     return result;
}

    通过对这段代码debug，可以看到Spring内置了六个BeanPostProcessor，其中剩下六个Aware接口的回调都由第一个ApplicationContextAwareProcessor处理

    ApplicationContextAwareProcessor 源码

    class ApplicationContextAwareProcessor implements BeanPostProcessor {

 private final ConfigurableApplicationContext applicationContext;

 private final StringValueResolver embeddedValueResolver;


 /**
  * Create a new ApplicationContextAwareProcessor for the given context.
  */
 public ApplicationContextAwareProcessor(ConfigurableApplicationContext applicationContext) {
     this.applicationContext = applicationContext;
     this.embeddedValueResolver = new EmbeddedValueResolver(applicationContext.getBeanFactory());
 }


 @Override
 @Nullable
 public Object postProcessBeforeInitialization(Object bean, String beanName) throws BeansException {
        
        // ...省略其他代码...
     invokeAwareInterfaces(bean);

     return bean;
 }

 private void invokeAwareInterfaces(Object bean) {
     if (bean instanceof EnvironmentAware) {
         ((EnvironmentAware) bean).setEnvironment(this.applicationContext.getEnvironment());
     }
     if (bean instanceof EmbeddedValueResolverAware) {
         ((EmbeddedValueResolverAware) bean).setEmbeddedValueResolver(this.embeddedValueResolver);
     }
     if (bean instanceof ResourceLoaderAware) {
         ((ResourceLoaderAware) bean).setResourceLoader(this.applicationContext);
     }
     if (bean instanceof ApplicationEventPublisherAware) {
         ((ApplicationEventPublisherAware) bean).setApplicationEventPublisher(this.applicationContext);
     }
     if (bean instanceof MessageSourceAware) {
         ((MessageSourceAware) bean).setMessageSource(this.applicationContext);
     }
     if (bean instanceof ApplicationContextAware) {
         ((ApplicationContextAware) bean).setApplicationContext(this.applicationContext);
     }
 }

}

    通过源码可以看出来在前置处理方法postProcessBeforeInitialization中会依次调用六个Aware接口进行回调

    BeanProcessor集合中还有一个CommonAnnotationBeanPostProcessor类，在这个类中的前置方法处理还会调用注解@PostConstruct标注的方法

  2. 初始化阶段

    初始化会依次调用InitializingBean#afterPropertiesSet 方法和自定义的initMethod

    invokeInitMethods 源码

    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 + "'");
         }
         
            // 如果实现InitializingBean接口，此处会回调afterPropertiesSet方法
         ((InitializingBean) bean).afterPropertiesSet();
     }

     // 执行initMethod
     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. 初始化后阶段

执行BeanPostProcessor的后置处理

applyBeanPostProcessorsAfterInitialization源码

@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;
 }

这一阶段会依次执行各个BeanPostProcessor的后置处理方法postProcessAfterInitialization，通过实现该接口可以实现对Bean的自定义处理

6.所有Bean初始化后

在所有的Bean都经历过上述过程后，Bean已经初始化完成，所有的Bean都已经准备好使用

此时在DefaultListableBeanFactory#preInstantiateSingletons中会进行最后一步回调


    public void preInstantiateSingletons() throws BeansException {
        
        // ....省略实例化和初始化代码
        
        // Trigger post-initialization callback for all applicable beans...
        for (String beanName : beanNames) {
            Object singletonInstance = getSingleton(beanName);
            if (singletonInstance instanceof SmartInitializingSingleton) {
                final SmartInitializingSingleton smartSingleton = (SmartInitializingSingleton) singletonInstance;
                if (System.getSecurityManager() != null) {
                    AccessController.doPrivileged((PrivilegedAction<Object>) () -> {
                        smartSingleton.afterSingletonsInstantiated();
                        return null;
                    }, getAccessControlContext());
                }
                else {
                    smartSingleton.afterSingletonsInstantiated();
                }
            }
        }
    }

源码中会循环已经初始化完成的Bean，如果该Bean实现了SmartInitializingSingleton接口则进行afterSingletonsInstantiated方法的回调

这一步和上述初始化流程不同，初始化时是挨个实例化Bean并初始化。这一步是等待所有Bean全部初始化完成，所有Bean都已经是可使用的状态

实现这一接口可以对Bean进行最后的定制操作或其他操作

7.销毁阶段

在Spring应用上下文关闭时，会对Spring中的对象依次进行销毁

销毁操作在 DisposableBeanAdapter#destroy 方法中

源码

    public void destroy() {
        
        // 销毁前置处理
        if (!CollectionUtils.isEmpty(this.beanPostProcessors)) {
            for (DestructionAwareBeanPostProcessor processor : this.beanPostProcessors) {
                processor.postProcessBeforeDestruction(this.bean, this.beanName);
            }
        }

        if (this.invokeDisposableBean) {
            try {
                // 执行接口销毁方法
                ((DisposableBean) this.bean).destroy();
            }
        }

        if (this.destroyMethod != null) {
            // 执行自定义destroyMethod
            invokeCustomDestroyMethod(this.destroyMethod);
        }
        else if (this.destroyMethodName != null) {
            Method methodToInvoke = determineDestroyMethod(this.destroyMethodName);
            if (methodToInvoke != null) {
                invokeCustomDestroyMethod(ClassUtils.getInterfaceMethodIfPossible(methodToInvoke));
            }
        }
    }

销毁流程和初始化流程类似 分为销毁前和销毁阶段

  1. 销毁前

    调用DestructionAwareBeanPostProcessor#destroy 方法，进行前置处理，被@PreDestroy标注的方法也会在这一阶段由CommonAnnotationBeanPostProcessor#postProcessBeforeDestruction 方法执行(该方法由其父类InitDestroyAnnotationBeanPostProcessor实现)

  2. 销毁阶段

    如果Bean实现了DestructionAwareBeanPostProcessor接口，则调用其destroy方法

    如果指定了Bean的destroyMethod则执行其销毁方法

总结

Bean生命周期流程

上一篇下一篇

猜你喜欢

热点阅读