Spring源码解读--(单例Bean初始化过程、BeanPostProcessor/InitializingBean/Aware接口的加载顺序)

前置说明:

一、类与接口继承关系: public abstract class AbstractAutowireCapableBeanFactory

extends AbstractBeanFactory implements AutowireCapableBeanFactory

二、本文章说明的是单例、并且是第一次实例化，同时不涉及其他复杂情况产生Bean用以说明Spring产生一个简单Bean单例的过程。用以说明在Bean实例化过程中对BeanPostProcessor/InitializingBean/Aware接口的调用顺序

1、通过beanName获取Bean

类AbstractBeanFactory的方法: doGetBean(String name, @Nullable Class<T> requiredType,

@Nullable Object[] args, boolean typeCheckOnly);

如果类还没有创建并且是单例、类创建的实现:

                if(mbd.isSingleton()) {
                    sharedInstance = this.getSingleton(beanName, () -> {
                        try {
                            return this.createBean(beanName, mbd, args);
                        } catch (BeansException var5) {
                            this.destroySingleton(beanName);
                            throw var5;
                        }
                    });
                    bean = this.getObjectForBeanInstance(sharedInstance, name, beanName, mbd);
                }

mbd即为RootBeanDefinition实现的是BeanDefinition接口,BeanDefinition接口对应的就是在spring配置文件配置的Bean

即：

<bean id="car" name="car1" class="com.fev.Car"></bean>

this.getSingleton方法的知识点有单例三层缓存解决循环依赖，以及Lambda表达式，为了本文说明知识点的单一，暂时不展开说明，可搜索其他博文。

直接进入this.createBean(beanName, mbd, args)方法，就进入类AbstractAutowireCapableBeanFactory

在此方法调用真正实例化bean的方法-this.doCreateBean(beanName, mbdToUse, args);

Bean实例化一个空对象的代码为

BeanWrapper instanceWrapper = null;

        if(instanceWrapper == null) {
            instanceWrapper = this.createBeanInstance(beanName, mbd, args);
        }

Object bean = instanceWrapper.getWrappedInstance();

这些代码就是将(beanName, mbd, args)这些参数构建一个BeanWrapper .并产生一个空的Bean对象

Spring源码解读--(单例Bean初始化过程、BeanPostProcessor/InitializingBean/Aware接口的加载顺序)

之后就是通过方法this.populateBean(beanName, mbd, instanceWrapper)填充Bean的属性

debug运行此方法前

Spring源码解读--(单例Bean初始化过程、BeanPostProcessor/InitializingBean/Aware接口的加载顺序)

运行此方法后:

Spring源码解读--(单例Bean初始化过程、BeanPostProcessor/InitializingBean/Aware接口的加载顺序)

之后进入方法this.initializeBean(String beanName, Object bean, @Nullable RootBeanDefinition mbd);此方法为BeanPostProcessor/InitializingBean/Aware这三个接口的具体调用顺序:

源码:

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

        if(mbd == null || !mbd.isSynthetic()) {
            wrappedBean = this.applyBeanPostProcessorsAfterInitialization(wrappedBean, beanName);
        }

return wrappedBean;
}

由此可见，首先是运行Aware接口的方法this.invokeAwareMethods(beanName, bean);

之后通过方法 this.applyBeanPostProcessorsBeforeInitialization(bean, beanName);运行BeanPostProcessor的postProcessBeforeInitialization方法

源码:

public Object applyBeanPostProcessorsBeforeInitialization(Object existingBean, String beanName) throws BeansException {
Object result = existingBean;

        Object current;
        for(Iterator var4 = this.getBeanPostProcessors().iterator(); var4.hasNext(); result = current) {
            BeanPostProcessor processor = (BeanPostProcessor)var4.next();
            current = processor.postProcessBeforeInitialization(result, beanName);
            if(current == null) {
                return result;
            }
        }

return result;
}

然后运行方法this.invokeInitMethods(beanName, wrappedBean, mbd);执行InitializingBean接口的afterPropertiesSet方法.

源码：

boolean isInitializingBean = bean instanceof InitializingBean;
        if(isInitializingBean && (mbd == null || !mbd.isExternallyManagedInitMethod("afterPropertiesSet"))) {
            if(this.logger.isTraceEnabled()) {
                this.logger.trace("Invoking afterPropertiesSet() on bean with name '" + beanName + "'");
            }

            if(System.getSecurityManager() != null) {
                try {
                    AccessController.doPrivileged(() -> {
                        ((InitializingBean)bean).afterPropertiesSet();
                        return null;
                    }, this.getAccessControlContext());
                } catch (PrivilegedActionException var6) {
                    throw var6.getException();
                }
            } else {
                ((InitializingBean)bean).afterPropertiesSet();
            }
        }

最后通过方法wrappedBean = this.applyBeanPostProcessorsAfterInitialization(wrappedBean, beanName);

运行BeanPostProcessor接口的postProcessAfterInitialization(result, beanName)方法。

由此可见，这三个接口的调用顺序是Aware接口->BeanPostProcessor接口的postProcessBeforeInitialization方法->InitializingBean接口的afterPropertiesSet方法->BeanPostProcessor接口的postProcessAfterInitialization方法。

最后提一下的是：由BeanPostProcessor、InitializingBean接口的使用也可以知道，BeanPostProcessor接口是对你注入的所有Bean都有作用，而InitializingBea。Aware是对你实现了这个接口的Bean起作用

Spring源码解读--(单例Bean初始化过程、BeanPostProcessor/InitializingBean/Aware接口的加载顺序)

相关推荐