Spring IOC之Singleton Bean创建以及BeanPostProcessor调用源码分析（二）

一、版本

<dependency>
    <groupId>org.springframework</groupId>
    <artifactId>spring-context</artifactId>
    <version>4.3.12.RELEASE</version>
</dependency>

二、接口详解

2.1 什么是BeanPostProcessor？

BeanPostProcessor也称为Bean后置处理器，在Spring容器的创建过程中（具体为Bean初始化前后）会回调BeanPostProcessor中定义的两个方法。

public interface BeanPostProcessor {
    // 在bean初始化回调（例如InitializingBean的afterPropertiesSet或自定义init-method）之前调用
    Object postProcessBeforeInitialization(Object bean, String beanName) throws BeansException;

    // 在bean初始化回调（例如InitializingBeanafterPropertiesSet或自定义init-method）之后调用
    Object postProcessAfterInitialization(Object bean, String beanName) throws BeansException;
}

其中，可以向IOC容器添加多个BeanPostProcessor（后置处理器），默认情况下容器加载次序决定了BeanPostProcessor调用顺序，也可以实现Ordered{@code getOrder}改变调用次序，其中getOrder返回值越大优先级越高。

public interface Ordered {
    int HIGHEST_PRECEDENCE = Integer.MIN_VALUE;

    int LOWEST_PRECEDENCE = Integer.MAX_VALUE;

    int getOrder();
}

2.2 BeanPostProcessor有什么作用？

提出一个问题：假设需要在Spring初始化Bean之后做一些定制化逻辑，简单如记录下Bean的初始化记录，或针校验Bean逻辑，又或者是针对某类策略需要执行一些具体的业务逻辑，那么怎么做比较好呢？

其实，Spring在初始化Bean之后已经加入了一些钩子方法，方便开发一些特定的后置业务处理逻辑，这也提现了AOP思想，其中钩子包括：

• BeanPostProcessor
• InitializingBean和DisposableBean
• @PostConstruct、@PreDestroy
• @Bean(initMethod、destroyMethod)

总结作用为：在Bean对象在实例化和依赖注入完毕后，在显示调用初始化方法的前后添加特定的业务逻辑。

2.3 为什么要注册BeanPostProcessor？

所谓的注册，只不过是对当前上下文中所有的BeanPostProcessor进行一种集中式管理罢了, 为什么非得这么做呢?
因为上下文中BeanPostProcessor的数量不是一成不变的，Spring为了启动的正常，需要添加原生的BeanPostProcessor，程序员因为自己的需求也会添加不同数量的Bean后置处理器，因此需要这种策略，将上下文中所有的后置处理器进行统一的管理，方便回调。

三、IOC容器注册BeanPostProcessor的源码解析

3.1 IOC容器注册BeanPostProcessor的时序图

3.2 刷新IOC容器

目标类：AbstractApplicationContext

public void refresh() throws BeansException, IllegalStateException {
    synchronized (this.startupShutdownMonitor) {
    	...
    	
        // 调用容器中注册的Bean工厂处理器
        invokeBeanFactoryPostProcessors(beanFactory);
        // 注册拦截Bean创建的处理器
        registerBeanPostProcessors(beanFactory);

        ...
        
        // 实例化所有剩余的（非@Lazy）单例。
        finishBeanFactoryInitialization(beanFactory);

        ...
    }
}

3.3 调用注册LoadTimeWeaverAwareProcessor

目标类：AbstractApplicationContext
目的：注册LoadTimeWeaverAwareProcessor到Spring IOC容器

// 调用容器中注册的Bean工厂处理器
protected void invokeBeanFactoryPostProcessors(ConfigurableListableBeanFactory beanFactory) {
    PostProcessorRegistrationDelegate.invokeBeanFactoryPostProcessors(beanFactory, getBeanFactoryPostProcessors());

	// String LOAD_TIME_WEAVER_BEAN_NAME="loadTimeWeaver"
    // 注册容器是否包含loadTimeWeaver Bean，如果没有则注册
    // (如： 通过ConfigurationClassPostProcessor注册的@Bean方法)
    if (beanFactory.getTempClassLoader() == null && beanFactory.containsBean(LOAD_TIME_WEAVER_BEAN_NAME)) {
    	// LoadTimeWeaverAwareProcessor实现了BeanPostProcessor接口子类
        beanFactory.addBeanPostProcessor(new LoadTimeWeaverAwareProcessor(beanFactory));
        beanFactory.setTempClassLoader(new ContextTypeMatchClassLoader(beanFactory.getBeanClassLoader()));
    }
}

3.4 获取和注册BeanPostProcessor

目标类：PostProcessorRegistrationDelegate

public static void registerBeanPostProcessors(
        ConfigurableListableBeanFactory beanFactory, AbstractApplicationContext applicationContext) {
    // 根据类型获取BeanPostProcessor的Bean(包含多实例、单实例、以及其他Scope范围的Bean)
    String[] postProcessorNames = beanFactory.getBeanNamesForType(BeanPostProcessor.class, true, false);
    
    // 计算BeanPostProcessor数量, 然后创建BeanPostProcessorChecker添加到容器
    int beanProcessorTargetCount = beanFactory.getBeanPostProcessorCount() + 1 + postProcessorNames.length;
    beanFactory.addBeanPostProcessor(new BeanPostProcessorChecker(beanFactory, beanProcessorTargetCount));
    
    // 1. priorityOrderedPostProcessors: 实现了PriorityOrdered接口的BeanPostProcessor
    // 2. internalPostProcessors: 同时实现了PriorityOrdered和MergedBeanDefinitionPostProcessor 
    //    接口的BeanPostProcessor, 也就是Spring内部的BeanPostProcessor
    // 3. orderedPostProcessorNames: 实现了Ordered接口的BeanPostProcessor
    // 4. nonOrderedPostProcessorNames: 单纯的BeanPostProcessor
    // 注意: PriorityOrdered是继承Ordered的接口, 因此处理需要首先判断PriorityOrdered
    List<BeanPostProcessor> priorityOrderedPostProcessors = new ArrayList<BeanPostProcessor>();
    List<BeanPostProcessor> internalPostProcessors = new ArrayList<BeanPostProcessor>();
    List<String> orderedPostProcessorNames = new ArrayList<String>();
    List<String> nonOrderedPostProcessorNames = new ArrayList<String>();
    for (String ppName : postProcessorNames) {
    	// 首先处理PriorityOrdered, 因为PriorityOrdered是继承自Ordered的接口
        if (beanFactory.isTypeMatch(ppName, PriorityOrdered.class)) {
            BeanPostProcessor pp = beanFactory.getBean(ppName, BeanPostProcessor.class);
            priorityOrderedPostProcessors.add(pp);
            if (pp instanceof MergedBeanDefinitionPostProcessor) {
                internalPostProcessors.add(pp);
            }
        }
        else if (beanFactory.isTypeMatch(ppName, Ordered.class)) {
            orderedPostProcessorNames.add(ppName);
        }
        else {
            nonOrderedPostProcessorNames.add(ppName);
        }
    }
    
    // 根据优先级排序priorityOrderedPostProcessors
    sortPostProcessors(priorityOrderedPostProcessors, beanFactory);
    // 将priorityOrderedPostProcessors依次注册到beanFactory
    registerBeanPostProcessors(beanFactory, priorityOrderedPostProcessors);

    // 处理实现Ordered接口的BeanPostProcessor
    List<BeanPostProcessor> orderedPostProcessors = new ArrayList<BeanPostProcessor>();
    for (String ppName : orderedPostProcessorNames) {
        BeanPostProcessor pp = beanFactory.getBean(ppName, BeanPostProcessor.class);
        orderedPostProcessors.add(pp);
        // 如果是Spring内部的BeanPostProcessor,则注册到internalPostProcessors
        if (pp instanceof MergedBeanDefinitionPostProcessor) {
            internalPostProcessors.add(pp);
        }
    }
    // 根据优先级排序orderedPostProcessors
    sortPostProcessors(orderedPostProcessors, beanFactory);
    // 将orderedPostProcessors依次注册到beanFactory
    registerBeanPostProcessors(beanFactory, orderedPostProcessors);

    // 处理单纯的BeanPostProcessor
    List<BeanPostProcessor> nonOrderedPostProcessors = new ArrayList<BeanPostProcessor>();
    for (String ppName : nonOrderedPostProcessorNames) {
        BeanPostProcessor pp = beanFactory.getBean(ppName, BeanPostProcessor.class);
        nonOrderedPostProcessors.add(pp);
        // 如果是Spring内部的BeanPostProcessor,则注册到internalPostProcessors
        if (pp instanceof MergedBeanDefinitionPostProcessor) {
            internalPostProcessors.add(pp);
        }
    }
    // 无须排序,直接依次注册到beanFactory的末尾
    registerBeanPostProcessors(beanFactory, nonOrderedPostProcessors);

    // 根据优先级排序internalPostProcessors
    sortPostProcessors(internalPostProcessors, beanFactory);
    // 将internalPostProcessors依次注册到beanFactory容器
    registerBeanPostProcessors(beanFactory, internalPostProcessors);
    
    // 总结注册顺序（从尾到头, 因为是逆序调用）：
    // internalPostProcessors > nonOrderedPostProcessors > orderedPostProcessors > priorityOrderedPostProcessors
    
    // 重新注册用于检测内部Bean的BeanPostProcessor作为ApplicationListener, 将其移至处理器链的末尾（用于获取代理等）。
    // 注意：applicationContext为AbstractApplicationContext的实现IOC容器
    beanFactory.addBeanPostProcessor(new ApplicationListenerDetector(applicationContext));
}

3.5 注册BeanPostProcessor

目标类：PostProcessorRegistrationDelegate
作用：只是把BeanPostProcessor顺序注册到beanFactory容器

private static void registerBeanPostProcessors(
        ConfigurableListableBeanFactory beanFactory, List<BeanPostProcessor> postProcessors) {

    for (BeanPostProcessor postProcessor : postProcessors) {
        beanFactory.addBeanPostProcessor(postProcessor);
    }
}

3.6 注册BeanPostProcessor到beanFactory

目标类：AbstractBeanFactory

@Override
public void addBeanPostProcessor(BeanPostProcessor beanPostProcessor) {
    Assert.notNull(beanPostProcessor, "BeanPostProcessor must not be null");
    // 移除已注册的BeanPostProcessor, 原因是按照新规则排序添加
    this.beanPostProcessors.remove(beanPostProcessor);
    this.beanPostProcessors.add(beanPostProcessor);
    // 判断是否有InstantiationAwareBeanPostProcessor的BeanPostProcessor 
    if (beanPostProcessor instanceof InstantiationAwareBeanPostProcessor) {
        this.hasInstantiationAwareBeanPostProcessors = true;
    }
    // 判断是否存在DestructionAwareBeanPostProcessor的BeanPostProcessor
    if (beanPostProcessor instanceof DestructionAwareBeanPostProcessor) {
        this.hasDestructionAwareBeanPostProcessors = true;
    }
}

四、IOC容器调用BeanPostProcessor源码解析

4.1 IOC容器调用BeanPostProcessor的时序图

4.2 刷新IOC容器

目标类：AbstractApplicationContext

public void refresh() throws BeansException, IllegalStateException {
    synchronized (this.startupShutdownMonitor) {
    	...
    	
        // 调用容器中注册的Bean工厂处理器
        invokeBeanFactoryPostProcessors(beanFactory);
        // 注册拦截Bean创建的处理器
        registerBeanPostProcessors(beanFactory);

        ...
        
        // 实例化所有剩余的（非@Lazy）单例。
        finishBeanFactoryInitialization(beanFactory);

        ...
    }
}

4.3 完成BeanFactory的实例化

目标类：AbstractApplicationContext

protected void finishBeanFactoryInitialization(ConfigurableListableBeanFactory beanFactory) {
    // String CONVERSION_SERVICE_BEAN_NAME="conversionService"
    // 判断beanFactory是否存在类型转换服务conversionService, 如果存在则注册到beanFactory
    // 补充：ConversionService是用于类型转换的服务, 调用convert方法实现类型转换
    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));
    }
    
    // 注册Spring SPEL解析器EmbeddedValueResolver
    // 补充：StringValueResolver为SPEL解析器, 如#{1-1}、${app.port}
    if (!beanFactory.hasEmbeddedValueResolver()) {
        beanFactory.addEmbeddedValueResolver(new StringValueResolver() {
            @Override
            public String resolveStringValue(String strVal) {
                return getEnvironment().resolvePlaceholders(strVal);
            }
        });
    }

    // 目的：根据类型获取LoadTimeWeaverAware的Bean, 并且检测LoadTimeWeaverAware是否存在
    String[] weaverAwareNames = beanFactory.getBeanNamesForType(LoadTimeWeaverAware.class, false, false);
    for (String weaverAwareName : weaverAwareNames) {
        getBean(weaverAwareName);
    }

    //  停止使用临时ClassLoader进行类型匹配。
    beanFactory.setTempClassLoader(null);

    // 缓存Bean定义的元数据
    beanFactory.freezeConfiguration();

    // 初始化非Lazy的单实例
    beanFactory.preInstantiateSingletons();
}

4.4 DefaultListableBeanFactory初始化单实例

目标类：DefaultListableBeanFactory

@Override
public void preInstantiateSingletons() throws BeansException {
    if (this.logger.isDebugEnabled()) {
        this.logger.debug("Pre-instantiating singletons in " + this);
    }

    // beanDefinitionNames是配置文件配置的所有Bean名字
    List<String> beanNames = new ArrayList<String>(this.beanDefinitionNames);

    // 触发非Lazy的单实例初始化
    for (String beanName : beanNames) {
    	// 返回Bean的定义
        RootBeanDefinition bd = getMergedLocalBeanDefinition(beanName);
        // 非抽象类和非Lazy的单实例
        if (!bd.isAbstract() && bd.isSingleton() && !bd.isLazyInit()) {
        	// 如果是实现FactoryBean接口定义的Bean
            if (isFactoryBean(beanName)) {
            	// 获取FactoryBean的Bean, 获取方式为：&+Bean名字
                final FactoryBean<?> factory = (FactoryBean<?>) getBean(FACTORY_BEAN_PREFIX + beanName);
                boolean isEagerInit;
                if (System.getSecurityManager() != null && factory instanceof SmartFactoryBean) {
                    isEagerInit = AccessController.doPrivileged(new PrivilegedAction<Boolean>() {
                        @Override
                        public Boolean run() {
                            return ((SmartFactoryBean<?>) factory).isEagerInit();
                        }
                    }, getAccessControlContext());
                }
                else {
                	// 判断是否需要立即初始化
                    isEagerInit = factory instanceof SmartFactoryBean 
                                  && ((SmartFactoryBean<?>) factory).isEagerInit();
                }
                
                // 非Lazy单实例
                if (isEagerInit) {
                    getBean(beanName);
                }
            }
            else {
                getBean(beanName);
            }
        }
    }

    // 如果Bean实现了SmartInitializingSingleton, 则触发Bean的afterSingletonsInstantiated方法
    for (String beanName : beanNames) {
    	// 获取单实例,如果不是单实例则返回Null
        Object singletonInstance = getSingleton(beanName);
        if (singletonInstance instanceof SmartInitializingSingleton) {
            final SmartInitializingSingleton smartSingleton = (SmartInitializingSingleton) singletonInstance;
            if (System.getSecurityManager() != null) {
                AccessController.doPrivileged(new PrivilegedAction<Object>() {
                    @Override
                    public Object run() {
                        smartSingleton.afterSingletonsInstantiated();
                        return null;
                    }
                }, getAccessControlContext());
            }
            else {
            	// 调用单实例的SmartInitializingSingleton处理器
                smartSingleton.afterSingletonsInstantiated();
            }
        }
    }
}

4.5 AbstractBeanFactory获取单实例Bean

目标类：AbstractBeanFactory

@Override
public Object getBean(String name) throws BeansException {
    return doGetBean(name, null, null, false);
}

// 思路
// 1. 如果已缓存类型单实例, 则直接从缓存获取
// 2. 如果有集合其他ApplicationContext容器, 试图从继承容器获取， 获取到直接返回
// 3. 对Bean进行检查
// 4. 依赖项检查, 以及实例化依赖项
// 5. 单实例创建
// 6. 多实例创建
// 7. 其他Scope实例创建
// 8. Bean类型检查
// 9. 返回创建的实例对象
protected <T> T doGetBean(
        final String name, final Class<T> requiredType, final Object[] args, boolean typeCheckOnly)
        throws BeansException {
        
    // 返回Bean名称（去除工厂取消引用前缀：&, 并将别名解析为规范名称）
    final String beanName = transformedBeanName(name);
    Object bean;

    // singletonObjects     ： 单例对象缓存的ConcurrentHashMap
    // earlySingletonObjects： 早期单例对象缓存的HashMap
    // 调用结果：
    // 1. 检查Bean是否已经创建放入到容器中（即singletonObjects）, 有则返回
    // 2. 如果容器中不存在, 则创建单实例Bean加入到earlySingletonObjects
    // 目的在于解决单实例的循环依赖问题
    // 补充：后续的AbstractAutowireCapableBeanFactory{@Code doCreateBean}有
    //      调用removeSingletonIfCreatedForTypeCheckOnly移除
    Object sharedInstance = getSingleton(beanName);
    if (sharedInstance != null && args == null) {
        if (logger.isDebugEnabled()) {
            if (isSingletonCurrentlyInCreation(beanName)) {
                logger.debug("Returning eagerly cached instance of singleton bean '" + beanName +
                        "' that is not fully initialized yet - a consequence of a circular reference");
            }
            else {
                logger.debug("Returning cached instance of singleton bean '" + beanName + "'");
            }
        }
        // 从BeanInstance获取Bean的实例
        bean = getObjectForBeanInstance(sharedInstance, name, beanName, null);
    }
    // 如果是循环引用, 会导致创建失败
    else {
    	// 多实例创建抛出异常
        if (isPrototypeCurrentlyInCreation(beanName)) {
            throw new BeanCurrentlyInCreationException(beanName);
        }
        
        // 检查工厂中是否存在Bean的定义
        // 其中, parentBeanFactory为ClassPathXmlApplicationContext(configLocations, ApplicationContext parent)
        //      中的parent
        // 注意：ApplicationContext也是BeanFactory的一个实现类
        BeanFactory parentBeanFactory = getParentBeanFactory();
        if (parentBeanFactory != null && !containsBeanDefinition(beanName)) {
            // Not found -> check parent.
            String nameToLookup = originalBeanName(name);
            if (args != null) {
                // 传参创建Bean实例
                return (T) parentBeanFactory.getBean(nameToLookup, args);
            }
            else {
                // 无参创建Bean实例
                return parentBeanFactory.getBean(nameToLookup, requiredType);
            }
        }
        
        // 获取实例仅仅用于类型检查, 而不是为了使用实例
        if (!typeCheckOnly) {
            markBeanAsCreated(beanName);
        }

        try {
        	// 获取并且检查BeanDefinition
            final RootBeanDefinition mbd = getMergedLocalBeanDefinition(beanName);
            checkMergedBeanDefinition(mbd, beanName, args);
            
            // 获取Bean的依赖项, 也就是在创建Bean之前确保依赖项已经完成初始化
            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 + "'");
                    }
                    // 提前注册依赖项Bean,目的是：提前将其初始化
                    registerDependentBean(dep, beanName);
                    // 对依赖项进行初始化
                    getBean(dep);
                }
            }
            
            // 如果依赖项已经实例化完成, 那么创建单实例
            if (mbd.isSingleton()) {
                sharedInstance = getSingleton(beanName, new ObjectFactory<Object>() {
                    @Override
                    public Object getObject() throws BeansException {
                        try {
                        	// 创建单实例对象
                            return createBean(beanName, mbd, args);
                        }
                        catch (BeansException ex) {
                            // 从单例缓存中显式删除实例：创建过程可能急切地将其放置在该实例中，
                            // 以实现循环引用解析。还删除所有收到对该Bean的临时引用的Bean。
                            destroySingleton(beanName);
                            throw ex;
                        }
                    }
                });
                // 从BeanInstance获取Bean的实例
                bean = getObjectForBeanInstance(sharedInstance, name, beanName, mbd);
            }
            // 多实例创建
            else if (mbd.isPrototype()) {
                // It's a prototype -> create a new instance.
                Object prototypeInstance = null;
                try {
                    beforePrototypeCreation(beanName);
                    prototypeInstance = createBean(beanName, mbd, args);
                }
                finally {
                    afterPrototypeCreation(beanName);
                }
                bean = getObjectForBeanInstance(prototypeInstance, name, beanName, mbd);
            }
            // 其他Scope范围的实例
            else {
                String scopeName = mbd.getScope();
                final Scope scope = this.scopes.get(scopeName);
                if (scope == null) {
                    throw new IllegalStateException("No Scope registered for scope name '" + scopeName + "'");
                }
                try {
                    Object scopedInstance = scope.get(beanName, new ObjectFactory<Object>() {
                        @Override
                        public Object getObject() throws BeansException {
                            beforePrototypeCreation(beanName);
                            try {
                                return createBean(beanName, mbd, args);
                            }
                            finally {
                                afterPrototypeCreation(beanName);
                            }
                        }
                    });
                    bean = getObjectForBeanInstance(scopedInstance, name, beanName, mbd);
                }
                catch (IllegalStateException ex) {
                    throw new BeanCreationException(beanName,
                            "Scope '" + scopeName + "' is not active for the current thread; consider " +
                            "defining a scoped proxy for this bean if you intend to refer to it from a singleton",
                            ex);
                }
            }
        }
        catch (BeansException ex) {
            cleanupAfterBeanCreationFailure(beanName);
            throw ex;
        }
    }
    
    // 对类解析类型检查
    if (requiredType != null && bean != null && !requiredType.isInstance(bean)) {
        try {
        	// 调用类型转换TypeConverter工具,将实例转换为需要的类型实例
            return getTypeConverter().convertIfNecessary(bean, requiredType);
        }
        catch (TypeMismatchException ex) {
            if (logger.isDebugEnabled()) {
                logger.debug("Failed to convert bean '" + name + "' to required type '" +
                        ClassUtils.getQualifiedName(requiredType) + "'", ex);
            }
            throw new BeanNotOfRequiredTypeException(name, requiredType, bean.getClass());
        }
    }
    return (T) bean;
}

4.6 AbstractAutowireCapableBeanFactory单实例创建

目标类：AbstractAutowireCapableBeanFactory

// 思路
// 1. 如果没有动态解析到Bean的信息, 那么处于安全考虑克隆BeanDefinition
// 2. 检查重写方法是否存在
// 3. 检查是否有实现InstantiationAwareBeanPostProcessor的接口, 如果有则调用创建实例, 并且返回实例
// 4. 创建实例
// 5. 返回创建的实例
@Override
protected Object createBean(String beanName, RootBeanDefinition mbd, Object[] args) throws BeanCreationException {
    if (logger.isDebugEnabled()) {
        logger.debug("Creating instance of bean '" + beanName + "'");
    }
    RootBeanDefinition mbdToUse = mbd;
    
    // 如果共享BeanDefinition没有存储动态解析的类信息, 那么克隆其BeanDefinition
    // 目的：确保解析不冲突
    Class<?> resolvedClass = resolveBeanClass(mbd, beanName);
    if (resolvedClass != null && !mbd.hasBeanClass() && mbd.getBeanClassName() != null) {
        mbdToUse = new RootBeanDefinition(mbd);
        mbdToUse.setBeanClass(resolvedClass);
    }
    
    try {
    	// 验证并准备给定的重写方法, 检查是否存在具有指定名称的方法
    	// 如initMethod、destroyMethod等
        mbdToUse.prepareMethodOverrides();
    }
    catch (BeanDefinitionValidationException ex) {
        throw new BeanDefinitionStoreException(mbdToUse.getResourceDescription(),
                beanName, "Validation of method overrides failed", ex);
    }

    try {
        // 如果是实现InstantiationAwareBeanPostProcessor的Bean, 则直接调用创建, 然后返回
        // 补充：InstantiationAwareBeanPostProcessor是专用接口, 用于内部框架使用。
        // 作用是：禁止目标Bean的默认实例化，即给InstantiationAwareBeanPostProcessor的后置处理器创建Bean的机会, 
        //         一般用于池对象、AOP代理对象创建等应用。
        Object bean = resolveBeforeInstantiation(beanName, mbdToUse);
        if (bean != null) {
            return bean;
        }
    }
    catch (Throwable ex) {
        throw new BeanCreationException(mbdToUse.getResourceDescription(), beanName,
                "BeanPostProcessor before instantiation of bean failed", ex);
    }
    
    // 非InstantiationAwareBeanPostProcessor Bean
    Object beanInstance = doCreateBean(beanName, mbdToUse, args);
    if (logger.isDebugEnabled()) {
        logger.debug("Finished creating instance of bean '" + beanName + "'");
    }
    return beanInstance;
}

4.7 AbstractAutowireCapableBeanFactory单实例最终创建

目标类：AbstractAutowireCapableBeanFactory

// 思路
// 1. 获取Bean包装类
// 2. 应用包装类获取实例, 以及实例类型
// 3. 如果存在后置处理器, 则调用后置处理器合并BeanDefinition
// 4. 如果BeanDefinition为单实例且存在循环依赖, 则提前创建缓存起来
// 5. 对实例进行初始化后置处理
// 6. 移除依赖项
// 7. 封装Bean为DisposableBeanAdapter注册到BeanFactory
protected Object doCreateBean(final String beanName, final RootBeanDefinition mbd, final Object[] args)
        throws BeanCreationException {
    // Bean包装类, 即具有标准JavaBean操作能力, 如：
    // 1. 获得和设置属性值（单独或批量）的能力
   	// 2. 获取属性描述符
   	// 3. 并查询属性的可读性、可写性
    BeanWrapper instanceWrapper = null;
    if (mbd.isSingleton()) {
        instanceWrapper = this.factoryBeanInstanceCache.remove(beanName);
    }
    if (instanceWrapper == null) {
        instanceWrapper = createBeanInstance(beanName, mbd, args);
    }

    // 获取BeanWrapper中封装的Object对象, 其实就是Bean对象的实例
    // 以及获取BeanWrapper中封装的bean的Class
    final Object bean = (instanceWrapper != null ? instanceWrapper.getWrappedInstance() : null);
    Class<?> beanType = (instanceWrapper != null ? instanceWrapper.getWrappedClass() : null);
    mbd.resolvedTargetType = beanType;

    // 允许后处理器修改合并的bean定义
    synchronized (mbd.postProcessingLock) {
        if (!mbd.postProcessed) {
            try {
            	// Bean的生命周期之一。
            	// 如果Bean实现了MergedBeanDefinitionPostProcessor接口, 
            	//     那么将会调用postProcessMergedBeanDefinition方法
                applyMergedBeanDefinitionPostProcessors(mbd, beanType, beanName);
            }
            catch (Throwable ex) {
                throw new BeanCreationException(mbd.getResourceDescription(), beanName,
                        "Post-processing of merged bean definition failed", ex);
            }
            mbd.postProcessed = true;
        }
    }
    
    // 其中, 如果同时满足以下三个条件：
    // 1. RootBeanDefinition定义为单实例
    // 2. 开启了自动尝试解析Bean之间的循环依赖
    // 3. beanName为正在创建实例队列中
    // 那么, 表明Bean需要被加入到缓存的单例集合中, 也就是在这之前已经将Bean加入到需要待创建的单例集合中。
    boolean earlySingletonExposure = (mbd.isSingleton() && this.allowCircularReferences &&
            isSingletonCurrentlyInCreation(beanName));
    if (earlySingletonExposure) {
        if (logger.isDebugEnabled()) {
            logger.debug("Eagerly caching bean '" + beanName +
                    "' to allow for resolving potential circular references");
        }
         // addSingletonFactory会将beanName和ObjectFactory对象作为键值对保存到缓存的单例集合中
         // singletonObjects     ：单例对象缓存的ConcurrentHashMap
         // singletonFactories   ：单例工厂缓存的HashMap
         // earlySingletonObjects：早期单例对象缓存的HashMap
         // registeredSingletons ：一组已经注册的单例,按注册顺序排序LinkedHashSet
        addSingletonFactory(beanName, new ObjectFactory<Object>() {
            @Override
            public Object getObject() throws BeansException {
                return getEarlyBeanReference(beanName, mbd, bean);
            }
        });
    }
    
    Object exposedObject = bean;
    try {
    	// 使用BeanDefinition配置的属性值为BeanWrapper中Bean的字段赋值
        populateBean(beanName, mbd, instanceWrapper);
        if (exposedObject != null) {
        	// 使用工厂回调、初始化方法和Bean后处理器, 初始化给定的Bean实例
            exposedObject = initializeBean(beanName, exposedObject, mbd);
        }
    }
    catch (Throwable ex) {
        if (ex instanceof BeanCreationException && beanName.equals(((BeanCreationException) ex).getBeanName())) {
            throw (BeanCreationException) ex;
        }
        else {
            throw new BeanCreationException(
                    mbd.getResourceDescription(), beanName, "Initialization of bean failed", ex);
        }
    }
    
    if (earlySingletonExposure) {
    	// 如果单例Bean已经缓存了, 则直接获取
        Object earlySingletonReference = getSingleton(beanName, false);
        if (earlySingletonReference != null) {
        	// 如果相等则不操作
            if (exposedObject == bean) {
                exposedObject = earlySingletonReference;
            }
            // 循环依赖的判断：
            // 1. 在循环引用的情况下, 如果不允许注入原始DisposableBean实例（即注入的Bean的包装实例）。
            // 2. 依赖的Bean列表中, 存在需要创建Bean
            else if (!this.allowRawInjectionDespiteWrapping && hasDependentBean(beanName)) {
            	// 根据beanName获取所有依赖的Bean
                String[] dependentBeans = getDependentBeans(beanName);
                Set<String> actualDependentBeans = new LinkedHashSet<String>(dependentBeans.length);
                for (String dependentBean : dependentBeans) {
                	// 如果依赖项Bean没有创建完成, 则移除
                	// 原因是解决村换依赖的问题, 栗子: 
                	// 1. A -> B 且 B -> A, 即A和B相互依赖
                	// 2. 创建单实例A的时候, 
                	//        会先创建A放入earlySingletonObjects（AbstractBeanFactory{@Code doCreateBean}）
                	// 3. 其次, 检查到有依赖项B, 则实例化依赖的单实例, 缓存到earlySingletonObjects
                	// 4. 单例B已经创建完成, 则移除earlySingletonObjects中的依赖项A
                	// 5. 待单例A创建完成, 移除B的依赖项
                	// 6. 依赖项已完成创建
                    if (!removeSingletonIfCreatedForTypeCheckOnly(dependentBean)) {
                        actualDependentBeans.add(dependentBean);
                    }
                }
                // 如果移除已依赖项为空, 则抛出异常
                if (!actualDependentBeans.isEmpty()) {
                    throw new BeanCurrentlyInCreationException(beanName,
                            "Bean with name '" + beanName + "' has been injected into other beans [" +
                            StringUtils.collectionToCommaDelimitedString(actualDependentBeans) +
                            "] in its raw version as part of a circular reference, but has eventually been " +
                            "wrapped. This means that said other beans do not use the final version of the " +
                            "bean. This is often the result of over-eager type matching - consider using " +
                            "'getBeanNamesOfType' with the 'allowEagerInit' flag turned off, for example.");
                }
            }
        }
    }

    // Register bean as disposable.
    try {
    	// 将Bean封装为DisposableBeanAdapter注册到容器中
    	// 目的：避免二次解析
        registerDisposableBeanIfNecessary(beanName, bean, mbd);
    }
    catch (BeanDefinitionValidationException ex) {
        throw new BeanCreationException(
                mbd.getResourceDescription(), beanName, "Invalid destruction signature", ex);
    }
    
    return exposedObject;
}

4.8 BeanWrapper字段赋值

目标类：AbstractAutowireCapableBeanFactory

// 思路
// 1. 获取配置需要注入的属性
// 2. 初始化之前调用InstantiationAwareBeanPostProcessor的postProcessAfterInstantiation方法进行处理
// 3. 解析byName和byType的属性值
// 4. 如果Spring注册实现InstantiationAwareBeanPostProcessor接口的后置处理器, 且Bean需要检测的依赖项(除了忽略的属性),
//    则调用InstantiationAwareBeanPostProcessor{@Code postProcessPropertyValue)对属性进行检验校验处理, 
//    最后调用全部进行依赖项检验处理
// 5. 属性赋值
protected void populateBean(String beanName, RootBeanDefinition mbd, BeanWrapper bw) {
	// 获取配置的键值对。其中, xml为：<property>, 注解为@Value
	PropertyValues pvs = mbd.getPropertyValues();

	if (bw == null) {
		if (!pvs.isEmpty()) {
			throw new BeanCreationException(
					mbd.getResourceDescription(), beanName, "Cannot apply property values to null instance");
		}
		else {
			return;
		}
	}

	// 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.
	boolean continueWithPropertyPopulation = true;

	// 容器注册有实现InstantiationAwareBeanPostProcessor实现类的后置处理器, 也就是Spring内置后置处理器。
	// 在设置属性之前, 调用所有InstantiationAwareBeanPostProcessors都有机会修改Bean的状态
	if (!mbd.isSynthetic() && hasInstantiationAwareBeanPostProcessors()) {
		for (BeanPostProcessor bp : getBeanPostProcessors()) {
			if (bp instanceof InstantiationAwareBeanPostProcessor) {
				InstantiationAwareBeanPostProcessor ibp = (InstantiationAwareBeanPostProcessor) bp;
				if (!ibp.postProcessAfterInstantiation(bw.getWrappedInstance(), beanName)) {
					continueWithPropertyPopulation = false;
					break;
				}
			}
		}
	}
	
	// 如果内置后置处理器调用postProcessAfterInstantiation返回false, 则中断之后的操作
	if (!continueWithPropertyPopulation) {
		return;
	}
	
	// 注入方式为byName或者byType
	if (mbd.getResolvedAutowireMode() == RootBeanDefinition.AUTOWIRE_BY_NAME ||
			mbd.getResolvedAutowireMode() == RootBeanDefinition.AUTOWIRE_BY_TYPE) {
		MutablePropertyValues newPvs = new MutablePropertyValues(pvs);
		
		if (mbd.getResolvedAutowireMode() == RootBeanDefinition.AUTOWIRE_BY_NAME) {
			autowireByName(beanName, mbd, bw, newPvs);
		}
		
		if (mbd.getResolvedAutowireMode() == RootBeanDefinition.AUTOWIRE_BY_TYPE) {
			autowireByType(beanName, mbd, bw, newPvs);
		}

		pvs = newPvs;
	}

	// 判断是否有InstantiationAwareBeanPostProcessor后置处理器
	boolean hasInstAwareBpps = hasInstantiationAwareBeanPostProcessors();
	// 是否需要依赖检查
	boolean needsDepCheck = (mbd.getDependencyCheck() != RootBeanDefinition.DEPENDENCY_CHECK_NONE);

	if (hasInstAwareBpps || needsDepCheck) {
		// Bean依赖项检查
		// 首先, 获取Bean类型所有的依赖项，然后返回过滤忽略检测之后的依赖项
		PropertyDescriptor[] filteredPds = filterPropertyDescriptorsForDependencyCheck(bw, mbd.allowCaching);
		if (hasInstAwareBpps) {
			for (BeanPostProcessor bp : getBeanPostProcessors()) {
				if (bp instanceof InstantiationAwareBeanPostProcessor) {
					InstantiationAwareBeanPostProcessor ibp = (InstantiationAwareBeanPostProcessor) bp;
					// 调用Spring内部后置处理器的postProcessPropertyValues方法对Bean进行处理
					pvs = ibp.postProcessPropertyValues(pvs, filteredPds, bw.getWrappedInstance(), beanName);
					if (pvs == null) {
						return;
					}
				}
			}
		}
		// 没有后置处理器, 直接调用检测
		if (needsDepCheck) {
			checkDependencies(beanName, mbd, filteredPds, pvs);
		}
	}
	// 属性赋值
	applyPropertyValues(beanName, mbd, bw, pvs);
}

4.9 初始化Bean

目标类：AbstractAutowireCapableBeanFactory

// 思路
// 1. 如果Bean实现的Aware接口,则调用相应方法进行初始化
// 2. 调用后置处理器BeanPostProcessor的postProcessBeforeInitialization方法进行初始化
// 3. 调用自定义的initMethod方法进行初始化, 
//    或者调用InitializingBean的afterPropertiesSet方法(初始化方法没有注册为afterPropertiesSet)前提下
// 4. 调用后置处理器BeanPostProcessor的postProcessAfterInitialization方法进行初始化
protected Object initializeBean(final String beanName, final Object bean, RootBeanDefinition mbd) {
	if (System.getSecurityManager() != null) {
		AccessController.doPrivileged(new PrivilegedAction<Object>() {
			@Override
			public Object run() {
				invokeAwareMethods(beanName, bean);
				return null;
			}
		}, getAccessControlContext());
	}
	else {
		// 如果Bean有实现Aware接口的子接口, 则调用相应方法进行处理, 其中包括：
		// 1. BeanNameAware{@Code setBeanName}
		// 2. BeanClassLoaderAware{@Code setBeanClassLoader}
		// 3. BeanFactoryAware{@Code setBeanFactory}
		invokeAwareMethods(beanName, bean);
	}

	Object wrappedBean = bean;
	// synthetic是用户自定义的Bean
	if (mbd == null || !mbd.isSynthetic()) {
		// 调用后置处理器的BeanPostProcessor{@Code postProcessBeforeInitialization}进行处理
		wrappedBean = applyBeanPostProcessorsBeforeInitialization(wrappedBean, beanName);
	}

	try {
		// 1. 如果Bean有实现InitializingBean接口, 并且初始化方法没有注册为afterPropertiesSet, 
		//    则调用InitializingBean{@Code afterPropertiesSet}进行初始化
		// 2. 否则, 调用自定义的initMethod初始化实例
		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{@Code postProcessAfterInitialization}进行处理
		wrappedBean = applyBeanPostProcessorsAfterInitialization(wrappedBean, beanName);
	}
	return wrappedBean;
}

// 调用Aware方法进行初始化
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) {
			((BeanClassLoaderAware) bean).setBeanClassLoader(getBeanClassLoader());
		}
		if (bean instanceof BeanFactoryAware) {
			((BeanFactoryAware) bean).setBeanFactory(AbstractAutowireCapableBeanFactory.this);
		}
	}
}

// 调用方法进行初始化
protected void invokeInitMethods(String beanName, final Object bean, RootBeanDefinition mbd)
		throws Throwable {
	// 实现了InitializingBean接口的实例
	boolean isInitializingBean = (bean instanceof InitializingBean);
	// 如果初始化方法没有注册为afterPropertiesSet
	if (isInitializingBean && (mbd == null || !mbd.isExternallyManagedInitMethod("afterPropertiesSet"))) {
		if (logger.isDebugEnabled()) {
			logger.debug("Invoking afterPropertiesSet() on bean with name '" + beanName + "'");
		}
		if (System.getSecurityManager() != null) {
			try {
				AccessController.doPrivileged(new PrivilegedExceptionAction<Object>() {
					@Override
					public Object run() throws Exception {
						((InitializingBean) bean).afterPropertiesSet();
						return null;
					}
				}, getAccessControlContext());
			}
			catch (PrivilegedActionException pae) {
				throw pae.getException();
			}
		}
		else {
			// 调用InitializingBean的afterPropertiesSet进行初始化
			((InitializingBean) bean).afterPropertiesSet();
		}
	}

	if (mbd != null) {
		// 调用自定义方法进行初始化
		String initMethodName = mbd.getInitMethodName();
		if (initMethodName != null && !(isInitializingBean && "afterPropertiesSet".equals(initMethodName)) &&
				!mbd.isExternallyManagedInitMethod(initMethodName)) {
			invokeCustomInitMethod(beanName, bean, mbd);
		}
	}
}