Spring之Bean容器源码理解，Spring4.3.12.RELEASE版本

1、Spring容器创建以及初始化过程。Spring容器的refresh()，是容器的创建以及刷新功能。整个容器就是通过refresh()方法运行完成以后，实现容器创建、以及将所有的bean创建对象、初始化完成。this();是做预处理操作，register(annotatedClasses);是做解析操作。

package com.bie.main;

import org.springframework.context.annotation.AnnotationConfigApplicationContext;

import com.bie.config.SpringApplicationConfig;

/**
 * 
 *
 * @Title: SpringTransactionApplication.java
 * @Package com.bie.main
 * @Description: TODO
 * @author biehl
 * @date 2019年12月19日
 * @version V1.0
 *
 */
public class SpringTransactionApplication {

    public static void main(String[] args) {
        // 创建IOC容器,new一个IOC容器。
        AnnotationConfigApplicationContext ac = new AnnotationConfigApplicationContext(SpringApplicationConfig.class);

        ac.close();
    }

}

new AnnotationConfigApplicationContext(SpringApplicationConfig.class);点击进去，打好断点。

启动主启动类，进入断点。

点击Step Into(F5)进入断点。

prepareRefresh();刷新前的预处理工作。

@Override
public void refresh() throws BeansException, IllegalStateException {
    // 线程安全的锁机制
    synchronized (this.startupShutdownMonitor) {
        // Prepare this context for refreshing.
        // 刷新前的预处理工作。
        prepareRefresh();
    
        // Tell the subclass to refresh the internal bean factory.
        // 获取Bean工厂
        ConfigurableListableBeanFactory beanFactory = obtainFreshBeanFactory();

        // Prepare the bean factory for use in this context.
        // 对Bean工作做预处理操作，对beanFactory做一些设置
        prepareBeanFactory(beanFactory);

        try {
            // Allows post-processing of the bean factory in context subclasses.
            // BeanFactory准备工作完成后进行的后置处理工作。
            postProcessBeanFactory(beanFactory);

            // Invoke factory processors registered as beans in the context.
            // 注册BeanFactoryPostProcessors即注册bean工厂的后置处理器，核心作用，就是执行beanFactoryPostProcessors的方法
            invokeBeanFactoryPostProcessors(beanFactory);

            // Register bean processors that intercept bean creation.
            // 注册BeanPostProcessors，注册bean的后置处理器。
            // 后置处理器是拦截bean的创建过程的。
            registerBeanPostProcessors(beanFactory);

            // Initialize message source for this context.
            // 初始化MessageSource组件（在SpringMVC中做国际化功能、消息绑定、消息解析功能的）。
            initMessageSource();

            // Initialize event multicaster for this context.
            // Spring容器创建，初始化事件派发器等。
            initApplicationEventMulticaster();

            // Initialize other special beans in specific context subclasses.
            // 留给子容器（即子类），在子容器中初始化剩下指定的bean。
            onRefresh();

            // Check for listener beans and register them.
            // Spring容器创建监听器等。检查监听器或者注册监听器，给容器中将所有项目里面的ApplicationListener注册进来。
            registerListeners();

            // Instantiate all remaining (non-lazy-init) singletons.
            // 初始化所有剩下的单实例bean。Spring容器创建，创建Bean准备。
            finishBeanFactoryInitialization(beanFactory);

            // Last step: publish corresponding event.
            // 完成工厂的刷新工作。完成BeanFactory的初始化创建工作。此步骤完成，相当于IOC容器创建完成。
            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();
        }
    }
}

 如下所示：

点击Step Into(F5)进入。prepareRefresh(); 刷新前的预处理工作。

this.scanner.clearCache();清理缓存的工作。super.prepareRefresh();点击Step Into(F5)进入。

protected void prepareRefresh() {
    // 记录时间
    this.startupDate = System.currentTimeMillis();
    // 容器已经关闭了吗，设置为false
    this.closed.set(false);
    // 容器是否已经被激活，设置为true
    this.active.set(true);

    // 打印容器刷新日志
    if (logger.isInfoEnabled()) {
        logger.info("Refreshing " + this);
    }

    // Initialize any placeholder property sources in the context environment
    // 初始化一些属性设置
    initPropertySources();

    // Validate that all properties marked as required are resolvable
    // see ConfigurablePropertyResolver#setRequiredProperties
    // 对自定义属性进行属性校验的。检验属性是否合法。
    getEnvironment().validateRequiredProperties();

    // Allow for the collection of early ApplicationEvents,
    // to be published once the multicaster is available...
    // 创建一个集合，保存容器中一些早期的事件，如果有事件发生存入这个集合中，方便在合适的时候使用事件派发器进行派发事件。
    this.earlyApplicationEvents = new LinkedHashSet<ApplicationEvent>();
}

如下所示：

点击Step Into(F5)进入。initPropertySources();初始化属性设置。

发现这个方法initPropertySources()是空的，是留给子类做事情的。子类自定义个性化的属性设置方法（自定义的时候有用哦）。

走到下一步，getEnvironment().validateRequiredProperties();对自定义属性进行属性校验的。

点击Step Into(F5)进入。getEnvironment().validateRequiredProperties();自定义属性进行校验。

Step Over(F6)出去，再点击Step Into(F5)进入validateRequiredProperties();

this.propertyResolver.validateRequiredProperties();属性解析器进行校验，自己可以点击Step Into(F5)进入看看。

点击Step Over(F6)下一步，创建一个集合，保存容器中一些早期的事件，如果有事件发生存入这个集合中，方便在合适的时候使用事件派发器进行派发事件。

2、点击Step Over(F6)下一步，直到ConfigurableListableBeanFactory beanFactory = obtainFreshBeanFactory();

点击Step Into(F5)进入obtainFreshBeanFactory();

refreshBeanFactory();刷新Bean工厂。

protected ConfigurableListableBeanFactory obtainFreshBeanFactory() {
    // 刷新即创建Bean工厂（此时是创建了Bean工厂）
    refreshBeanFactory();
    // 获取Bean工厂
    ConfigurableListableBeanFactory beanFactory = getBeanFactory();
    // 打印容器刷新日志
    if (logger.isDebugEnabled()) {
        logger.debug("Bean factory for " + getDisplayName() + ": " + beanFactory);
    }
    // 返回Bean工厂
    return beanFactory;
}

如下所示：

点击Step Into(F5)进入refreshBeanFactory();

// 定义beanFactory，这个Bean工厂对象
private final DefaultListableBeanFactory beanFactory;

// GenericApplicationContext无参构造器，创建对象的时候，创建Bean工厂this.beanFactory
public GenericApplicationContext() {
    this.beanFactory = new DefaultListableBeanFactory();
}

@Override
protected final void refreshBeanFactory() throws IllegalStateException {
    if (!this.refreshed.compareAndSet(false, true)) {
        throw new IllegalStateException(
                "GenericApplicationContext does not support multiple refresh attempts: just call 'refresh' once");
    }
    // 给Bean工厂设置序列号id，序列化id标识
    this.beanFactory.setSerializationId(getId());
}

如下所示：

点击Step Over(F6)下一步，走到ConfigurableListableBeanFactory beanFactory = getBeanFactory();

点击Step Into(F5)进入getBeanFactory();

将上一步refreshBeanFactory();创建的Bean工厂返回回来。返回刚才GenericApplicationContext创建的Bean工厂对象。

Step Over(F6)下一步，走到ConfigurableListableBeanFactory beanFactory = getBeanFactory();

Step Over(F6)下一步，走到ConfigurableListableBeanFactory beanFactory = obtainFreshBeanFactory();获取到Bean工厂对象。将创建的Bean工厂返回给beanFactory ，默认叫做DefaultListableBeanFactory。

3、对Bean工作做预处理操作，对beanFactory做一些设置prepareBeanFactory(beanFactory);

点击Step Into(F5)进入prepareBeanFactory(beanFactory);

protected void prepareBeanFactory(ConfigurableListableBeanFactory beanFactory) {
    // Tell the internal bean factory to use the context's class loader etc.
    // 把类加载器放入到beanFactory中
    beanFactory.setBeanClassLoader(getClassLoader());
    // 把表达式语言解析器放入到beanFactory中
    beanFactory.setBeanExpressionResolver(new StandardBeanExpressionResolver(beanFactory.getBeanClassLoader()));
    // 
    beanFactory.addPropertyEditorRegistrar(new ResourceEditorRegistrar(this, getEnvironment()));

    // Configure the bean factory with context callbacks.
    // 把BeanPostProcessor后置处理器放入到beanFactory中。添加部分BeanPostProcessor到beanFactory中，如ApplicationContextAwareProcessor。
    beanFactory.addBeanPostProcessor(new ApplicationContextAwareProcessor(this));
    // 设置忽略的自动装配的接口EnvironmentAware。即这些接口的实现类，不能通过这些接口类型自动注入哦。
    beanFactory.ignoreDependencyInterface(EnvironmentAware.class);
    // 设置忽略的自动装配的接口EmbeddedValueResolverAware
    beanFactory.ignoreDependencyInterface(EmbeddedValueResolverAware.class);
    // 设置忽略的自动装配的接口ResourceLoaderAware
    beanFactory.ignoreDependencyInterface(ResourceLoaderAware.class);
    // 设置忽略的自动装配的接口ApplicationEventPublisherAware
    beanFactory.ignoreDependencyInterface(ApplicationEventPublisherAware.class);
    // 设置忽略的自动装配的接口MessageSourceAware
    beanFactory.ignoreDependencyInterface(MessageSourceAware.class);
    // 设置忽略的自动装配的接口ApplicationContextAware
    beanFactory.ignoreDependencyInterface(ApplicationContextAware.class);

    // BeanFactory interface not registered as resolvable type in a plain factory.
    // MessageSource registered (and found for autowiring) as a bean.
    // 注册可以解析的自动装配BeanFactory。所谓的可以解析的自动装配即可以在任何组件中写@Autowired进行自动装配。
    beanFactory.registerResolvableDependency(BeanFactory.class, beanFactory);
    // 注册可以解析的自动装配ResourceLoader
    beanFactory.registerResolvableDependency(ResourceLoader.class, this);
    // 注册可以解析的自动装配ApplicationEventPublisher
    beanFactory.registerResolvableDependency(ApplicationEventPublisher.class, this);
    // 注册可以解析的自动装配ApplicationContext
    beanFactory.registerResolvableDependency(ApplicationContext.class, this);

    // Register early post-processor for detecting inner beans as ApplicationListeners.
    // 设置后置处理器ApplicationListenerDetector到beanFactory中。
    beanFactory.addBeanPostProcessor(new ApplicationListenerDetector(this));

    // Detect a LoadTimeWeaver and prepare for weaving, if found.
    // LOAD_TIME_WEAVER_BEAN_NAME=loadTimeWeaver。添加编译时的AspectJ的支持。默认是运行时的动态代理。
    if (beanFactory.containsBean(LOAD_TIME_WEAVER_BEAN_NAME)) {
        beanFactory.addBeanPostProcessor(new LoadTimeWeaverAwareProcessor(beanFactory));
        // Set a temporary ClassLoader for type matching.
        beanFactory.setTempClassLoader(new ContextTypeMatchClassLoader(beanFactory.getBeanClassLoader()));
    }

    // Register default environment beans.
    // ENVIRONMENT_BEAN_NAME=environment。给容器中注册一些能用的组件，key=environment，值是当前的环境对象。
    if (!beanFactory.containsLocalBean(ENVIRONMENT_BEAN_NAME)) {
        beanFactory.registerSingleton(ENVIRONMENT_BEAN_NAME, getEnvironment());
    }
    // SYSTEM_PROPERTIES_BEAN_NAME = systemProperties。给容器中注册组件，key=systemProperties，值是当前的系统配置。
    if (!beanFactory.containsLocalBean(SYSTEM_PROPERTIES_BEAN_NAME)) {
        beanFactory.registerSingleton(SYSTEM_PROPERTIES_BEAN_NAME, getEnvironment().getSystemProperties());
    }
    // SYSTEM_ENVIRONMENT_BEAN_NAME = systemEnvironment。给容器中注册组件，key=systemEnvironment，值是当前的系统环境对象。
    if (!beanFactory.containsLocalBean(SYSTEM_ENVIRONMENT_BEAN_NAME)) {
        beanFactory.registerSingleton(SYSTEM_ENVIRONMENT_BEAN_NAME, getEnvironment().getSystemEnvironment());
    }
}

如下所示：

4、Step Over(F6)下一步，直到运行到postProcessBeanFactory(beanFactory);

点击Step Into(F5)进入postProcessBeanFactory(beanFactory); BeanFactory准备工作完成后进行的后置处理工作。

postProcessBeanFactory(beanFactory);方法也是一个空实现的，留给子类进行实现，在beanFactory创建并准备好以后，可以重写该postProcessBeanFactory(beanFactory);方法的。对beanFactory做更进一步的设置。子类通过重写这个方法来在BeanFactory创建并预准备完成以后做进一步的设置。

Step Over(F6)下一步，再点击Step Into(F5)走到postProcessBeanFactory(beanFactory);

注意：以上四步是BeanFactory的创建以及预准备工作。

5、继续执行Step Over(F6)下一步，走到invokeBeanFactoryPostProcessors(beanFactory);

Spring容器创建，执行BeanFactoryPostProcessor（即BeanFactory的后置处理器，在BeanFactory标准初始化之后执行的，而标准初始化即上四步流程）。两个接口，BeanFactoryPostProcessor接口，BeanDefinitionRegistryPostProcessor是BeanFactoryPostProcessor接口的子接口。

点击Step Into(F5)进入invokeBeanFactoryPostProcessors(beanFactory);

// 核心作用，就是执行beanFactoryPostProcessors的方法
protected void invokeBeanFactoryPostProcessors(ConfigurableListableBeanFactory beanFactory) {
    // 执行BeanFactoryPostProcessor的方法。getBeanFactoryPostProcessors()获取到beanFactoryPostProcessors。
    PostProcessorRegistrationDelegate.invokeBeanFactoryPostProcessors(beanFactory, getBeanFactoryPostProcessors());

    // Detect a LoadTimeWeaver and prepare for weaving, if found in the meantime
    // (e.g. through an @Bean method registered by ConfigurationClassPostProcessor)
    if (beanFactory.getTempClassLoader() == null && beanFactory.containsBean(LOAD_TIME_WEAVER_BEAN_NAME)) {
        beanFactory.addBeanPostProcessor(new LoadTimeWeaverAwareProcessor(beanFactory));
        beanFactory.setTempClassLoader(new ContextTypeMatchClassLoader(beanFactory.getBeanClassLoader()));
    }
}

如下所示：

点击Step Into(F5)进入，PostProcessorRegistrationDelegate.invokeBeanFactoryPostProcessors(beanFactory, getBeanFactoryPostProcessors());

先获取到beanFactoryPostProcessors。Step Over(F6)下一步走到PostProcessorRegistrationDelegate.invokeBeanFactoryPostProcessors(beanFactory, getBeanFactoryPostProcessors());

执行invokeBeanFactoryPostProcessors方法，点击Step Into(F5)进入。

执行BeanFactoryPostProcessor的方法，即PostProcessorRegistrationDelegate.invokeBeanFactoryPostProcessors()方法。

// 从容器中获取到所有的获取到beanFactoryPostProcessors
public static void invokeBeanFactoryPostProcessors(
        ConfigurableListableBeanFactory beanFactory, List<BeanFactoryPostProcessor> beanFactoryPostProcessors) {

    // Invoke BeanDefinitionRegistryPostProcessors first, if any.
    // 定义一个set集合存放processedBeans。
    Set<String> processedBeans = new HashSet<String>();
    
    // 首先判断Bean工厂是否是BeanDefinitionRegistry类型的。DefaultListableBeanFactory就是BeanDefinitionRegistry类型的。
    if (beanFactory instanceof BeanDefinitionRegistry) {
        // 将DefaultListableBeanFactory类型，强制转换为BeanDefinitionRegistry类型的。
        BeanDefinitionRegistry registry = (BeanDefinitionRegistry) beanFactory;
        // 创建一个List集合，保存regularPostProcessors
        List<BeanFactoryPostProcessor> regularPostProcessors = new LinkedList<BeanFactoryPostProcessor>();
        // 创建一个List集合，保存registryProcessors
        List<BeanDefinitionRegistryPostProcessor> registryProcessors = new LinkedList<BeanDefinitionRegistryPostProcessor>();

        // 遍历参数传递的beanFactoryPostProcessors，即上一步获取到的beanFactoryPostProcessors
        for (BeanFactoryPostProcessor postProcessor : beanFactoryPostProcessors) {
            // 如果postProcessor是BeanDefinitionRegistryPostProcessor类型的
            if (postProcessor instanceof BeanDefinitionRegistryPostProcessor) {
                // 将postProcessor转换为BeanDefinitionRegistryPostProcessor类型的。
                BeanDefinitionRegistryPostProcessor registryProcessor =
                        (BeanDefinitionRegistryPostProcessor) postProcessor;
                // 将DefaultListableBeanFactory类型，强制转换为BeanDefinitionRegistry类型的。写入到registryProcessor
                registryProcessor.postProcessBeanDefinitionRegistry(registry);
                // 将registryProcessor添加到registryProcessors
                registryProcessors.add(registryProcessor);
            }
            else {
                // 否则将postProcessor添加到regularPostProcessors
                regularPostProcessors.add(postProcessor);
            }
        }

        // Do not initialize FactoryBeans here: We need to leave all regular beans
        // uninitialized to let the bean factory post-processors apply to them!
        // Separate between BeanDefinitionRegistryPostProcessors that implement
        // PriorityOrdered, Ordered, and the rest.
        // 定义一个List集合currentRegistryProcessors
        List<BeanDefinitionRegistryPostProcessor> currentRegistryProcessors = new ArrayList<BeanDefinitionRegistryPostProcessor>();

        // First, invoke the BeanDefinitionRegistryPostProcessors that implement PriorityOrdered.
        // 第一步、获取到所有的BeanDefinitionRegistryPostProcessor类型的。BeanDefinitionRegistryPostProcessor是BeanFactoryPostProcessor接口的子接口。
        // BeanDefinitionRegistryPostProcessor子接口具有最高优先级
        // 首先执行实现了PriorityOrdered优先级接口的BeanDefinitionRegistryPostProcessor
        String[] postProcessorNames =
                beanFactory.getBeanNamesForType(BeanDefinitionRegistryPostProcessor.class, true, false);
        // 遍历获取到的这种BeanDefinitionRegistryPostProcessor类型的
        for (String ppName : postProcessorNames) {
            // 判断是否实现了PriorityOrdered优先级排序的接口。优先级排序有三种情况，这是第一种。
            if (beanFactory.isTypeMatch(ppName, PriorityOrdered.class)) {
                // 将ppName添加到currentRegistryProcessors集合中
                currentRegistryProcessors.add(beanFactory.getBean(ppName, BeanDefinitionRegistryPostProcessor.class));
                // 将ppName保存到全局的processedBeans集合中
                processedBeans.add(ppName);
            }
        }
        // 按照优先级进行排序操作
        sortPostProcessors(currentRegistryProcessors, beanFactory);
        // 将currentRegistryProcessors添加到集合registryProcessors中
        registryProcessors.addAll(currentRegistryProcessors);
        // 执行，调用方法遍历循环执行postProcessor.postProcessBeanDefinitionRegistry(registry);
        // 首先执行实现了PriorityOrdered优先级接口的BeanDefinitionRegistryPostProcessor
        invokeBeanDefinitionRegistryPostProcessors(currentRegistryProcessors, registry);
        // 清除currentRegistryProcessors集合里面的内容
        currentRegistryProcessors.clear();

        // Next, invoke the BeanDefinitionRegistryPostProcessors that implement Ordered.
        // 第二步，获取到所有的BeanDefinitionRegistryPostProcessor类型的。BeanDefinitionRegistryPostProcessor是BeanFactoryPostProcessor接口的子接口。
        // 再执行实现了Ordered顺序接口的BeanDefinitionRegistryPostProcessor
        postProcessorNames = beanFactory.getBeanNamesForType(BeanDefinitionRegistryPostProcessor.class, true, false);
        // 遍历获取到的这种BeanDefinitionRegistryPostProcessor类型的
        for (String ppName : postProcessorNames) {
            // 如果processedBeans里面不包含ppName，并且判断是否实现了Ordered顺序的接口。
            if (!processedBeans.contains(ppName) && beanFactory.isTypeMatch(ppName, Ordered.class)) {
                // // 将ppName添加到currentRegistryProcessors集合中
                currentRegistryProcessors.add(beanFactory.getBean(ppName, BeanDefinitionRegistryPostProcessor.class));
                // 将ppName保存到全局的processedBeans集合中
                processedBeans.add(ppName);
            }
        }
        // 按照顺序进行排序操作
        sortPostProcessors(currentRegistryProcessors, beanFactory);
        // 将currentRegistryProcessors添加到集合registryProcessors中
        registryProcessors.addAll(currentRegistryProcessors);
        // 执行，调用方法遍历循环执行postProcessor.postProcessBeanDefinitionRegistry(registry);
        // 再执行实现了Ordered顺序接口的BeanDefinitionRegistryPostProcessor
        invokeBeanDefinitionRegistryPostProcessors(currentRegistryProcessors, registry);
        // 清除currentRegistryProcessors集合里面的内容
        currentRegistryProcessors.clear();

        // Finally, invoke all other BeanDefinitionRegistryPostProcessors until no further ones appear.
        // 最后，执行所有未实现接口的任何优先级接口或者顺序接口的BeanDefinitionRegistryPostProcessor
        // 定义变量reiterate为true
        boolean reiterate = true;
        // 循环执行
        while (reiterate) {
            // 设置变量为false
            reiterate = false;
            // 获取到所有的BeanDefinitionRegistryPostProcessor类型的。BeanDefinitionRegistryPostProcessor是BeanFactoryPostProcessor接口的子接口。
            postProcessorNames = beanFactory.getBeanNamesForType(BeanDefinitionRegistryPostProcessor.class, true, false);
            // 循环遍历postProcessorNames
            for (String ppName : postProcessorNames) {
                // 如果processedBeans不包含ppName
                if (!processedBeans.contains(ppName)) {
                    // // 将ppName添加到currentRegistryProcessors集合中
                    currentRegistryProcessors.add(beanFactory.getBean(ppName, BeanDefinitionRegistryPostProcessor.class));
                    // 将ppName保存到全局的processedBeans集合中
                    processedBeans.add(ppName);
                    // 将变量reiterate设置为true
                    reiterate = true;
                }
            }
            // 按照未实现接口的进行排序操作
            sortPostProcessors(currentRegistryProcessors, beanFactory);
            // 将currentRegistryProcessors添加到集合registryProcessors中
            registryProcessors.addAll(currentRegistryProcessors);
            // 执行，调用方法遍历循环执行postProcessor.postProcessBeanDefinitionRegistry(registry);
            // 未实现PriorityOrdered优先级接口、Ordered顺序接口的
            invokeBeanDefinitionRegistryPostProcessors(currentRegistryProcessors, registry);
            // 清除currentRegistryProcessors集合里面的内容
            currentRegistryProcessors.clear();
        }

        // Now, invoke the postProcessBeanFactory callback of all processors handled so far.
        // 调用invokeBeanFactoryPostProcessors方法，循环遍历postProcessor.postProcessBeanFactory(beanFactory);
        invokeBeanFactoryPostProcessors(registryProcessors, beanFactory);
        // 用invokeBeanFactoryPostProcessors方法，循环遍历postProcessor.postProcessBeanFactory(beanFactory);
        invokeBeanFactoryPostProcessors(regularPostProcessors, beanFactory);
    }

    else {
        // Invoke factory processors registered with the context instance.
        // 否则，执行beanFactoryPostProcessors
        invokeBeanFactoryPostProcessors(beanFactoryPostProcessors, beanFactory);
    }

    // Do not initialize FactoryBeans here: We need to leave all regular beans
    // uninitialized to let the bean factory post-processors apply to them!
    // 获取到BeanFactoryPostProcessor方法。在bean工厂中按照类型获取到BeanFactoryPostProcessor。
    // 下面的流程和上面的流程一致。
    String[] postProcessorNames =
            beanFactory.getBeanNamesForType(BeanFactoryPostProcessor.class, true, false);

    // Separate between BeanFactoryPostProcessors that implement PriorityOrdered,
    // Ordered, and the rest.
    // 创建List集合BeanFactoryPostProcessor
    List<BeanFactoryPostProcessor> priorityOrderedPostProcessors = new ArrayList<BeanFactoryPostProcessor>();
    // 创建List集合orderedPostProcessorNames
    List<String> orderedPostProcessorNames = new ArrayList<String>();
    // 创建List集合nonOrderedPostProcessorNames
    List<String> nonOrderedPostProcessorNames = new ArrayList<String>();
    // 循环遍历postProcessorNames
    for (String ppName : postProcessorNames) {
        // 如果processedBeans包含了ppName，跳过
        if (processedBeans.contains(ppName)) {
            // skip - already processed in first phase above
        }
        // 否则，如果beanFactory是PriorityOrdered优先级顺序接口类型的。实现PriorityOrdered优先级接口的放入到priorityOrderedPostProcessors集合中。
        else if (beanFactory.isTypeMatch(ppName, PriorityOrdered.class)) {
            priorityOrderedPostProcessors.add(beanFactory.getBean(ppName, BeanFactoryPostProcessor.class));
        }
        // 否则，如果beanFactory是Ordered顺序接口类型的。实现Ordered顺序接口的放入到orderedPostProcessorNames集合中
        else if (beanFactory.isTypeMatch(ppName, Ordered.class)) {
            orderedPostProcessorNames.add(ppName);
        }
        else {
            // 否则，如果都不是，将ppName添加到nonOrderedPostProcessorNames。为实现接口的放到nonOrderedPostProcessorNames集合中。
            nonOrderedPostProcessorNames.add(ppName);
        }
    }

    // First, invoke the BeanFactoryPostProcessors that implement PriorityOrdered.
    // 按照优先级进行排序操作
    sortPostProcessors(priorityOrderedPostProcessors, beanFactory);
    // 执行，调用方法遍历循环执行postProcessor.postProcessBeanFactory(beanFactory);
    // 首先执行实现了PriorityOrdered优先级接口的BeanFactoryPostProcessor
    invokeBeanFactoryPostProcessors(priorityOrderedPostProcessors, beanFactory);

    // Next, invoke the BeanFactoryPostProcessors that implement Ordered.
    // 实现Ordered顺序接口的遍历添加到orderedPostProcessors集合中
    List<BeanFactoryPostProcessor> orderedPostProcessors = new ArrayList<BeanFactoryPostProcessor>();
    for (String postProcessorName : orderedPostProcessorNames) {
        orderedPostProcessors.add(beanFactory.getBean(postProcessorName, BeanFactoryPostProcessor.class));
    }
    // 按照顺序进行排序操作
    sortPostProcessors(orderedPostProcessors, beanFactory);
    // 执行，调用方法遍历循环执行postProcessor.postProcessBeanFactory(beanFactory);
    // 首先执行实现了Ordered顺序接口的BeanFactoryPostProcessor
    invokeBeanFactoryPostProcessors(orderedPostProcessors, beanFactory);

    // Finally, invoke all other BeanFactoryPostProcessors.
    // 最后，未实现PriorityOrdered接口、Ordered顺序接口的遍历添加到orderedPostProcessors集合中
    List<BeanFactoryPostProcessor> nonOrderedPostProcessors = new ArrayList<BeanFactoryPostProcessor>();
    for (String postProcessorName : nonOrderedPostProcessorNames) {
        nonOrderedPostProcessors.add(beanFactory.getBean(postProcessorName, BeanFactoryPostProcessor.class));
    }
    invokeBeanFactoryPostProcessors(nonOrderedPostProcessors, beanFactory);

    // Clear cached merged bean definitions since the post-processors might have
    // modified the original metadata, e.g. replacing placeholders in values...
    beanFactory.clearMetadataCache();
}

如下所示：

Step Over(F6)下一步，直到运行到invokeBeanFactoryPostProcessors(beanFactory);继续走Step Over(F6)下一步，走到registerBeanPostProcessors(beanFactory);

6、点击Step Into(F5)进入registerBeanPostProcessors(beanFactory);

注册BeanPostProcessors，注册bean的后置处理器。后置处理器是拦截bean的创建过程的。

点击Step Into(F5)进入registerBeanPostProcessors(beanFactory); 

Step Into(F5)进入PostProcessorRegistrationDelegate.registerBeanPostProcessors(beanFactory, this);调用此方法进行注册。

// 注册Bean的后置处理器，在Bean工厂中保存了Bean的后置处理器，而先不执行。
public static void registerBeanPostProcessors(
        ConfigurableListableBeanFactory beanFactory, AbstractApplicationContext applicationContext) {
    // 不同接口类型的BeanPostProcessor，在bean创建前后执行时机是不一样的。
    // BeanPostProcessor接口。
    // DestructionAwareBeanPostProcessor接口。
    // InstantiationAwareBeanPostProcessor接口、SmartInstantiationAwareBeanPostProcessor接口。SmartInstantiationAwareBeanPostProcessor接口是的InstantiationAwareBeanPostProcessor子接口
    // MergedBeanDefinitionPostProcessor接口。
    // 根据类型从容器中获取BeanPostProcessor类型的（即后置处理器）。
    String[] postProcessorNames = beanFactory.getBeanNamesForType(BeanPostProcessor.class, true, false);

    // Register BeanPostProcessorChecker that logs an info message when
    // a bean is created during BeanPostProcessor instantiation, i.e. when
    // a bean is not eligible for getting processed by all BeanPostProcessors.
    // 统计获取beanFactory里面的BeanPostProcessor后置处理器的数量
    int beanProcessorTargetCount = beanFactory.getBeanPostProcessorCount() + 1 + postProcessorNames.length;
    // 将BeanPostProcessorChecker后置处理器添加到bean工厂中。这个后置处理器是检查BeanPostProcessor的
    beanFactory.addBeanPostProcessor(new BeanPostProcessorChecker(beanFactory, beanProcessorTargetCount));

    
    // Separate between BeanPostProcessors that implement PriorityOrdered,
    // Ordered, and the rest.
    // 后置处理器都默认可以通过PriorityOrdered接口、Ordered接口来指定优先级。
    // 定义集合priorityOrderedPostProcessors
    List<BeanPostProcessor> priorityOrderedPostProcessors = new ArrayList<BeanPostProcessor>();
    // 定义集合internalPostProcessors
    List<BeanPostProcessor> internalPostProcessors = new ArrayList<BeanPostProcessor>();
    // 定义集合orderedPostProcessorNames
    List<String> orderedPostProcessorNames = new ArrayList<String>();
    // 定义集合nonOrderedPostProcessorNames
    List<String> nonOrderedPostProcessorNames = new ArrayList<String>();
    // 遍历获取到的postProcessorNames后置处理器的名称
    for (String ppName : postProcessorNames) {
        // 判断如果有PriorityOrdered优先级接口的
        if (beanFactory.isTypeMatch(ppName, PriorityOrdered.class)) {
            // 从beanFactory获取到ppName
            BeanPostProcessor pp = beanFactory.getBean(ppName, BeanPostProcessor.class);
            // 将获取到的pp放入到集合中
            priorityOrderedPostProcessors.add(pp);
            // 如果pp是这种类型的MergedBeanDefinitionPostProcessor
            if (pp instanceof MergedBeanDefinitionPostProcessor) {
                // 将pp添加到internalPostProcessors集合中
                internalPostProcessors.add(pp);
            }
        }
        // 否则，如果有Ordered顺序接口优先级的
        else if (beanFactory.isTypeMatch(ppName, Ordered.class)) {
            // 将ppName添加到orderedPostProcessorNames集合中
            orderedPostProcessorNames.add(ppName);
        }
        else {
            // 否则，未实现PriorityOrdered、Ordered接口的。将ppName添加到nonOrderedPostProcessorNames集合中
            nonOrderedPostProcessorNames.add(ppName);
        }
    }

    // First, register the BeanPostProcessors that implement PriorityOrdered.
    // 按照优先级接口的进行排序操作
    sortPostProcessors(priorityOrderedPostProcessors, beanFactory);
    // 调用registerBeanPostProcessors方法，循环遍历beanFactory.addBeanPostProcessor(postProcessor);方法。即注册bean的后置处理器。
    // 先注册PriorityOrdered优先级接口的BeanPostProcessor。把每一个BeanPostProcessor添加到BeanFactory中。
    registerBeanPostProcessors(beanFactory, priorityOrderedPostProcessors);

    // Next, register the BeanPostProcessors that implement Ordered.
    // 定义集合orderedPostProcessors
    List<BeanPostProcessor> orderedPostProcessors = new ArrayList<BeanPostProcessor>();
    // 遍历获取到的实现Ordered接口的后置处理器
    for (String ppName : orderedPostProcessorNames) {
        // 从beanFactory获取到ppName
        BeanPostProcessor pp = beanFactory.getBean(ppName, BeanPostProcessor.class);
        // 将获取到的pp放入到集合中
        orderedPostProcessors.add(pp);
        // 如果pp是这种类型的MergedBeanDefinitionPostProcessor
        if (pp instanceof MergedBeanDefinitionPostProcessor) {
            // 将pp添加到internalPostProcessors集合中
            internalPostProcessors.add(pp);
        }
    }
    // 按照顺序接口的进行排序操作
    sortPostProcessors(orderedPostProcessors, beanFactory);
    // 再注册Ordered接口的BeanPostProcessor。把每一个BeanPostProcessor添加到BeanFactory中。
    registerBeanPostProcessors(beanFactory, orderedPostProcessors);

    // Now, register all regular BeanPostProcessors.
    List<BeanPostProcessor> nonOrderedPostProcessors = new ArrayList<BeanPostProcessor>();
    for (String ppName : nonOrderedPostProcessorNames) {
        // 从beanFactory获取到ppName
        BeanPostProcessor pp = beanFactory.getBean(ppName, BeanPostProcessor.class);
        // 将获取到的pp放入到集合中
        nonOrderedPostProcessors.add(pp);
        // 如果pp是这种类型的MergedBeanDefinitionPostProcessor
        if (pp instanceof MergedBeanDefinitionPostProcessor) {
            // 将pp添加到internalPostProcessors集合中
            internalPostProcessors.add(pp);
        }
    }
    // 最后注册未实现任何优先级接口的BeanPostProcessor。把每一个BeanPostProcessor添加到BeanFactory中。
    registerBeanPostProcessors(beanFactory, nonOrderedPostProcessors);

    // Finally, re-register all internal BeanPostProcessors.
    // 按照internal的进行排序操作
    sortPostProcessors(internalPostProcessors, beanFactory);
    // 最终注册MergedBeanDefinitionPostProcessor，这种类型的后置处理器
    registerBeanPostProcessors(beanFactory, internalPostProcessors);

    // Re-register post-processor for detecting inner beans as ApplicationListeners,
    // moving it to the end of the processor chain (for picking up proxies etc).
    // 新增了一个后置处理器ApplicationListenerDetector，这个后置处理器在bean创建完成以后检查是否是ApplicationListener
    // 如果是this.applicationContext.addApplicationListener((ApplicationListener<?>) bean);
    beanFactory.addBeanPostProcessor(new ApplicationListenerDetector(applicationContext));
}

如下所示：

7、Step Over(F6)下一步，直到走到initMessageSource();

Spring容器创建，初始化MessageSource。初始化MessageSource组件（在SpringMVC中做国际化功能、消息绑定、消息解析功能的）。

然后点击Step Into(F5)进入initMessageSource();

// MessageSource取出国际化配置文件中的某个key的值，能按照区域信息获取。
protected void initMessageSource() {
    // 获取到Bean工厂
    ConfigurableListableBeanFactory beanFactory = getBeanFactory();
    // MESSAGE_SOURCE_BEAN_NAME = "messageSource";
    // 判断Bean工厂中是否存在id=messageSource。看容器中是否有id=messageSource的组件。
    if (beanFactory.containsLocalBean(MESSAGE_SOURCE_BEAN_NAME)) {
        // 如果有从beanFactory中获取到MessageSource的组件，赋值给messageSource属性
        this.messageSource = beanFactory.getBean(MESSAGE_SOURCE_BEAN_NAME, MessageSource.class);
        // Make MessageSource aware of parent MessageSource.
        if (this.parent != null && this.messageSource instanceof HierarchicalMessageSource) {
            HierarchicalMessageSource hms = (HierarchicalMessageSource) this.messageSource;
            if (hms.getParentMessageSource() == null) {
                // Only set parent context as parent MessageSource if no parent MessageSource
                // registered already.
                hms.setParentMessageSource(getInternalParentMessageSource());
            }
        }
        if (logger.isDebugEnabled()) {
            logger.debug("Using MessageSource [" + this.messageSource + "]");
        }
    }
    else {
        // Use empty MessageSource to be able to accept getMessage calls.
        // 如果Bean工厂中没有MessageSource组件，则创建一个默认的DelegatingMessageSource。
        DelegatingMessageSource dms = new DelegatingMessageSource();
        // 
        dms.setParentMessageSource(getInternalParentMessageSource());
        this.messageSource = dms;
        // 将创建好的MessageSource注册到容器中。以后获取国际化配置文件的值的时候，可以自动注入MessageSource
        beanFactory.registerSingleton(MESSAGE_SOURCE_BEAN_NAME, this.messageSource);
        // 打印日志信息
        if (logger.isDebugEnabled()) {
            logger.debug("Unable to locate MessageSource with name '" + MESSAGE_SOURCE_BEAN_NAME +
                    "': using default [" + this.messageSource + "]");
        }
    }
}

如下所示：

8、Step Over(F6)下一步，直到走到initApplicationEventMulticaster();Spring容器创建，初始化事件派发器、监听器等。

点击Step Into(F5)进入initApplicationEventMulticaster();

protected void initApplicationEventMulticaster() {
    // 获取到Bean工厂
    ConfigurableListableBeanFactory beanFactory = getBeanFactory();
    // APPLICATION_EVENT_MULTICASTER_BEAN_NAME = "applicationEventMulticaster";
    // 判断bean工厂中是否包含applicationEventMulticaster组件，
    if (beanFactory.containsLocalBean(APPLICATION_EVENT_MULTICASTER_BEAN_NAME)) {
        // 从Bean工厂中获取applicationEventMulticaster的ApplicationEventMulticaster组件。可以自定义事件派发器的，在此可以进行获取。
        this.applicationEventMulticaster =
                beanFactory.getBean(APPLICATION_EVENT_MULTICASTER_BEAN_NAME, ApplicationEventMulticaster.class);
        // 打印日志信息
        if (logger.isDebugEnabled()) {
            logger.debug("Using ApplicationEventMulticaster [" + this.applicationEventMulticaster + "]");
        }
    }
    else {
        // 如果没有配置事件派发器。创建一个简单的事件派发器。用来帮助我们派发事件
        this.applicationEventMulticaster = new SimpleApplicationEventMulticaster(beanFactory);
        // 将事件派发器注册到容器中，其他组件可以自动注入该组件。将创建的ApplicationEventMulticaster组件添加到bean工厂中即容器中，以后其他组件直接自动注入即可。
        beanFactory.registerSingleton(APPLICATION_EVENT_MULTICASTER_BEAN_NAME, this.applicationEventMulticaster);
        // 打印日志信息
        if (logger.isDebugEnabled()) {
            logger.debug("Unable to locate ApplicationEventMulticaster with name '" +
                    APPLICATION_EVENT_MULTICASTER_BEAN_NAME +
                    "': using default [" + this.applicationEventMulticaster + "]");
        }
    }
}

如下所示：

9、Step Over(F6)下一步，直到走到onRefresh(); 留给子容器（即子类），在子容器中初始化剩下指定的bean。

点击Step Into(F5)进入onRefresh();

onRefresh();空实现，这个是留给子类的，如果子类有需要刷新的，可以重写onRefresh();刷新方法。子类重写这个方法，在容器刷新的时候可以自定义逻辑。

10、Step Over(F6)下一步，直到走到registerListeners();

检查监听器或者注册监听器，给容器中将所有项目里面的ApplicationListener注册进来。

点击Step Into(F5)进入registerListeners();

protected void registerListeners() {
    // Register statically specified listeners first.
    // 获取到所有的applicationListeners，然后添加到事件派发器中。
    for (ApplicationListener<?> listener : getApplicationListeners()) {
        getApplicationEventMulticaster().addApplicationListener(listener);
    }

    // Do not initialize FactoryBeans here: We need to leave all regular beans
    // uninitialized to let post-processors apply to them!
    // 或者从容器中根据类型获取到所有的ApplicationListener类型的bean组件
    String[] listenerBeanNames = getBeanNamesForType(ApplicationListener.class, true, false);
    // 循环遍历ApplicationListener类型的bean组件。
    for (String listenerBeanName : listenerBeanNames) {
        // 将每个监听器添加到事件派发器中。
        getApplicationEventMulticaster().addApplicationListenerBean(listenerBeanName);
    }

    // Publish early application events now that we finally have a multicaster...
    // 派发之前步骤产生的事件
    // 获取到之前产生的事件
    Set<ApplicationEvent> earlyEventsToProcess = this.earlyApplicationEvents;
    // 然后将之前产生的事件置为空null
    this.earlyApplicationEvents = null;
    // 如果之前产生的事件不为空
    if (earlyEventsToProcess != null) {
        // 循环遍历
        for (ApplicationEvent earlyEvent : earlyEventsToProcess) {
            getApplicationEventMulticaster().multicastEvent(earlyEvent);
        }
    }
}

如下所示：

11、Step Over(F6)下一步，直到走到finishBeanFactoryInitialization(beanFactory);初始化所有剩下的单实例bean。Spring容器创建，创建Bean准备。

点击Step Into(F5)进入finishBeanFactoryInitialization(beanFactory);

protected void finishBeanFactoryInitialization(ConfigurableListableBeanFactory beanFactory) {
    // Initialize conversion service for this context.
    // CONVERSION_SERVICE_BEAN_NAME = "conversionService";
    // 和类型转换组件相关的代码
    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(new StringValueResolver() {
            @Override
            public String resolveStringValue(String strVal) {
                return getEnvironment().resolvePlaceholders(strVal);
            }
        });
    }

    // Initialize LoadTimeWeaverAware beans early to allow for registering their transformers early.
    // 和AspectJ相关的代码
    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();
}

如下所示：

Step Over(F6)下一步，直到走到beanFactory.preInstantiateSingletons();初始化剩下的单实例bean。

@Override
public void preInstantiateSingletons() throws BeansException {
    // 打印日志信息
    if (this.logger.isDebugEnabled()) {
        this.logger.debug("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.
    // 获取到所有的bean的定义信息，有的bean在之前的步骤已经创建完毕
    List<String> beanNames = new ArrayList<String>(this.beanDefinitionNames);

    // Trigger initialization of all non-lazy singleton beans...
    // 遍历拿到的所有bean的定义信息。获取容器中的所有bean，依次进行初始化和创建对象操作。
    for (String beanName : beanNames) {
        // 获取到bean的定义信息。
        RootBeanDefinition bd = getMergedLocalBeanDefinition(beanName);
        // 判断该bean是否是抽象的，并且是单实例的，并且是否是懒加载的。
        if (!bd.isAbstract() && bd.isSingleton() && !bd.isLazyInit()) {
            // 不是抽象的、是单实例的、不是懒加载的。
            // 判断是否是FactoryBean类型的。是否是工厂bean
            if (isFactoryBean(beanName)) {
                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());
                }
                if (isEagerInit) {
                    getBean(beanName);
                }
            }
            else {
                // 如果不是实现FactoryBean的Bean，即不是工厂bean，调用getBean(beanName);方法创建对象
                getBean(beanName);
            }
        }
    }

    // Trigger post-initialization callback for all applicable beans...
    // 触发初始化后置的回调方法。
    // 循环遍历
    for (String beanName : beanNames) {
        // 获取到所有的bean对象。
        Object singletonInstance = getSingleton(beanName);
        // 判断该对象是否是SmartInitializingSingleton类型的，是否实现了SmartInitializingSingleton接口。
        if (singletonInstance instanceof SmartInitializingSingleton) {
            // 检查所有的bean是否是SmartInitializingSingleton接口的，如果是，执行smartSingleton.afterSingletonsInstantiated();
            final SmartInitializingSingleton smartSingleton = (SmartInitializingSingleton) singletonInstance;
            if (System.getSecurityManager() != null) {
                AccessController.doPrivileged(new PrivilegedAction<Object>() {
                    @Override
                    public Object run() {
                        smartSingleton.afterSingletonsInstantiated();
                        return null;
                    }
                }, getAccessControlContext());
            }
            else {
                // 
                smartSingleton.afterSingletonsInstantiated();
            }
        }
    }
}





// isFactoryBean是上面方法引用的。
@Override
public boolean isFactoryBean(String name) throws NoSuchBeanDefinitionException {
    String beanName = transformedBeanName(name);

    Object beanInstance = getSingleton(beanName, false);
    if (beanInstance != null) {
        // 判断是否是实现FactoryBean接口的Bean，是就返回true
        return (beanInstance instanceof FactoryBean);
    }
    else if (containsSingleton(beanName)) {
        // null instance registered
        // 如果不是实现FactoryBean的Bean，返回false
        return false;
    }

    // No singleton instance found -> check bean definition.
    if (!containsBeanDefinition(beanName) && getParentBeanFactory() instanceof ConfigurableBeanFactory) {
        // No bean definition found in this factory -> delegate to parent.
        return ((ConfigurableBeanFactory) getParentBeanFactory()).isFactoryBean(name);
    }

    return isFactoryBean(beanName, getMergedLocalBeanDefinition(beanName));
}

如下所示：

点击Step Into(F5)进入beanFactory.preInstantiateSingletons();

如下所示：

Step Over(F6)下一步，直到走到getBean(beanName);可以在此处打上断点，然后跳过默认创建的bean组件，走到自己创建的bean组件。

点击Step Into(F5)进入getBean(beanName);此处的getBean(beanName)，就是测试的时候写的ac.getBean();的这个方法哦。

点击Step Into(F5)进入doGetBean(name, null, null, false);

@SuppressWarnings("unchecked")
protected <T> T doGetBean(
        final String name, final Class<T> requiredType, final Object[] args, boolean typeCheckOnly)
        throws BeansException {

    // 获取到参数传递进去的name
    final String beanName = transformedBeanName(name);
    // 定义Object类型的变量bean
    Object bean;

    // Eagerly check singleton cache for manually registered singletons.
    // 如果之前已经有bean被创建成功就会被缓存起来。
    // 这里先获取bean组件，sharedInstance是指共享的bean。
    // 先获取缓存中保存的单实例Bean，如果能获取到说明这个bean之前被创建过（所有创建过的单实例bean都会被缓存起来的）。
    // private final Map<String, Object> singletonObjects = new ConcurrentHashMap<String, Object>(256);缓存所有的单实例bean，按照bean的名称和bean的实例对象。
    // 从缓存中获取单实例bean对象实例
    Object sharedInstance = getSingleton(beanName);
    // 如果从缓存中获取到了bean实例对象
    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 + "'");
            }
        }
        // 按照类型从容器中获取到对应的bean实例
        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.
        // 缓存中获取不到，开始Bean的创建对象流程。首先获取到父工厂，看是否存在父工厂。
        BeanFactory parentBeanFactory = getParentBeanFactory();
        // 如果有父工厂的话
        if (parentBeanFactory != null && !containsBeanDefinition(beanName)) {
            // Not found -> check parent.
            String nameToLookup = originalBeanName(name);
            if (args != null) {
                // Delegation to parent with explicit args.
                return (T) parentBeanFactory.getBean(nameToLookup, args);
            }
            else {
                // No args -> delegate to standard getBean method.
                return parentBeanFactory.getBean(nameToLookup, requiredType);
            }
        }

        // 先来标记该bean已经被创建了，防止多线程的情况下，两个线程同时都来创建同一个bean，就不是单实例的了。
        if (!typeCheckOnly) {
            // 标记该bean已经被创建了
            markBeanAsCreated(beanName);
        }

        try {
            // 获取到bean的定义信息。
            final RootBeanDefinition mbd = getMergedLocalBeanDefinition(beanName);
            // 检查获取到的bean的定义信息
            checkMergedBeanDefinition(mbd, beanName, args);

            // Guarantee initialization of beans that the current bean depends on.
            // 获取当前bean依赖的其他bean。如果有按照getBean()把依赖的Bean先创建出来。
            String[] dependsOn = mbd.getDependsOn();
            // 如果当前bean依赖的其他bean不为null
            if (dependsOn != null) {
                // 遍历当前bean依赖的其他bean
                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()把依赖的Bean先创建出来。
                    getBean(dep);
                }
            }

            // Create bean instance.
            // 如果是单实例的就进行创建
            if (mbd.isSingleton()) {
                // 启动单实例Bean的创建流程。beanName是bean的名称，new ObjectFactory<Object>()是bean的工厂。
                sharedInstance = getSingleton(beanName, new ObjectFactory<Object>() {
                    // 使用new ObjectFactory<Object>()工厂的getObject()方法创建bean。
                    @Override
                    public Object getObject() throws BeansException {
                        try {
                            // 调用createBean(beanName, mbd, args);创建bean。
                            // 创建成功bean以后直接返回。
                            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);
            }
            // 否则，如果是多实例的bean对象。
            else if (mbd.isPrototype()) {
                // It's a prototype -> create a new instance.
                Object prototypeInstance = null;
                try {
                    beforePrototypeCreation(beanName);
                    // 创建bean对象，自己可以跟进去研究一下。
                    prototypeInstance = createBean(beanName, mbd, args);
                }
                finally {
                    afterPrototypeCreation(beanName);
                }
                bean = getObjectForBeanInstance(prototypeInstance, name, beanName, mbd);
            }

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

    // Check if required type matches the type of the actual bean instance.
    if (requiredType != null && bean != null && !requiredType.isInstance(bean)) {
        try {
            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;
}

如下所示：

Step Over(F6)下一步，直到走到Object sharedInstance = getSingleton(beanName); 可以点击Step Into(F5)进入getSingleton(beanName);

可以看到private final Map<String, Object> singletonObjects = new ConcurrentHashMap<String, Object>(256);

singletonObjects对象缓存所有的单实例bean，按照bean的名称和bean的实例对象。

Step Over(F6)下一步，直到走到sharedInstance = getSingleton(beanName, new ObjectFactory<Object>()。

此时将断点打到return createBean(beanName, mbd, args);

点击Resume(F8)放行到此处，然后点击Step Into(F5)进入createBean(beanName, mbd, args);方法。

点击Step Into(F5)进入createBean(beanName, mbd, args); 

@Override
protected Object createBean(String beanName, RootBeanDefinition mbd, Object[] args) throws BeanCreationException {
    // 打印日志信息
    if (logger.isDebugEnabled()) {
        logger.debug("Creating instance of bean '" + beanName + "'");
    }
    // 将参数mbd赋值给RootBeanDefinition类型的mbdToUse
    RootBeanDefinition mbdToUse = mbd;

    // Make sure bean class is actually resolved at this point, and
    // clone the bean definition in case of a dynamically resolved Class
    // which cannot be stored in the shared merged bean definition.
    // 解析Bean的类型。我们要创建的bean的类型。
    Class<?> resolvedClass = resolveBeanClass(mbd, beanName);
    // 如果获取到的resolvedClass类型不为空，创建RootBeanDefinition
    if (resolvedClass != null && !mbd.hasBeanClass() && mbd.getBeanClassName() != null) {
        mbdToUse = new RootBeanDefinition(mbd);
        mbdToUse.setBeanClass(resolvedClass);
    }

    // Prepare method overrides.
    try {
        // 
        mbdToUse.prepareMethodOverrides();
    }
    catch (BeanDefinitionValidationException ex) {
        throw new BeanDefinitionStoreException(mbdToUse.getResourceDescription(),
                beanName, "Validation of method overrides failed", ex);
    }

    try {
        // Give BeanPostProcessors a chance to return a proxy instead of the target bean instance.
        // 让BeanPostProcessors先提前拦截代理对象。即提前执行InstantiationAwareBeanPostProcessor这种类型的后置处理器。
        // 切记，此时触发InstantiationAwareBeanPostProcessor这种类型的后置处理器。
        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;
}

如下所示：

Step Over(F6)下一步，直到走到Object bean = resolveBeforeInstantiation(beanName, mbdToUse);

点击Step Into(F5)进入resolveBeforeInstantiation(beanName, mbdToUse);

提前执行InstantiationAwareBeanPostProcessor这种类型的后置处理器。

Step Over(F6)下一步，直到走到applyBeanPostProcessorsBeforeInstantiation(targetType, beanName);

触发applyBeanPostProcessorsBeforeInstantiation(targetType, beanName);方法，如果触发的该方法有返回对象，触发applyBeanPostProcessorsAfterInitialization(bean, beanName);方法。

然后点击Step Into(F5)进入applyBeanPostProcessorsBeforeInstantiation(targetType, beanName); 

Step Over(F6)下一步，直到走到Object bean = resolveBeforeInstantiation(beanName, mbdToUse);即刚才点击Step Into(F5)的起始点。

继续Step Over(F6)下一步，直到走到doCreateBean(beanName, mbdToUse, args);

protected Object doCreateBean(final String beanName, final RootBeanDefinition mbd, final Object[] args)
        throws BeanCreationException {

    // Instantiate the bean.
    // 创建bean的包装类型变量。
    BeanWrapper instanceWrapper = null;
    // 如果mbd是单实例的。
    if (mbd.isSingleton()) {
        // 先从缓存中移除已有的beanName的实例。
        instanceWrapper = this.factoryBeanInstanceCache.remove(beanName);
    }
    // 如果instanceWrapper是null的。
    if (instanceWrapper == null) {
        // 第一步、创建Bean实例。执行完此步，bean实例就已经创建成功的。
        instanceWrapper = createBeanInstance(beanName, mbd, args);
    }
    final Object bean = (instanceWrapper != null ? instanceWrapper.getWrappedInstance() : null);
    Class<?> beanType = (instanceWrapper != null ? instanceWrapper.getWrappedClass() : null);
    mbd.resolvedTargetType = beanType;

    // Allow post-processors to modify the merged bean definition.
    // bean实例创建完毕以后，允许后置处理器修改bean的定义。
    // 第二步、调用此种MergedBeanDefinitionPostProcessor类型的后置处理器的postProcessMergedBeanDefinition方法。
    synchronized (mbd.postProcessingLock) {
        if (!mbd.postProcessed) {
            try {
                // bean实例创建完毕以后调用该方法，如果是MergedBeanDefinitionPostProcessor这种类型的，循环遍历执行bdp.postProcessMergedBeanDefinition(mbd, beanType, beanName);
                applyMergedBeanDefinitionPostProcessors(mbd, beanType, beanName);
            }
            catch (Throwable ex) {
                throw new BeanCreationException(mbd.getResourceDescription(), beanName,
                        "Post-processing of merged bean definition failed", ex);
            }
            mbd.postProcessed = true;
        }
    }

    // Eagerly cache singletons to be able to resolve circular references
    // even when triggered by lifecycle interfaces like BeanFactoryAware.
    boolean earlySingletonExposure = (mbd.isSingleton() && this.allowCircularReferences &&
            isSingletonCurrentlyInCreation(beanName));
    // 获取到要暴露的单实例的bean组件
    if (earlySingletonExposure) {
        if (logger.isDebugEnabled()) {
            logger.debug("Eagerly caching bean '" + beanName +
                    "' to allow for resolving potential circular references");
        }
        // 将这些要暴漏的添加到缓存中 
        addSingletonFactory(beanName, new ObjectFactory<Object>() {
            @Override
            public Object getObject() throws BeansException {
                return getEarlyBeanReference(beanName, mbd, bean);
            }
        });
    }

    // Initialize the bean instance.
    Object exposedObject = bean;
    try {
        // 为属性赋值的操作。
        populateBean(beanName, mbd, instanceWrapper);
        if (exposedObject != null) {
            // 如果exposedObject不为空的话。初始化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);
        }
    }
    
    // 获取到要暴露的单实例的bean组件
    if (earlySingletonExposure) {
        // 获取到单实例的bean组件。此时单实例bean已经创建完毕，也已经初始化完毕。
        // 先从缓存中获取，此时beanName已经有值了。
        Object earlySingletonReference = getSingleton(beanName, false);
        // 此时缓存获取到的earlySingletonReference中如果不为空。
        if (earlySingletonReference != null) {
            if (exposedObject == bean) {
                exposedObject = earlySingletonReference;
            }
            else if (!this.allowRawInjectionDespiteWrapping && hasDependentBean(beanName)) {
                String[] dependentBeans = getDependentBeans(beanName);
                Set<String> actualDependentBeans = new LinkedHashSet<String>(dependentBeans.length);
                for (String dependentBean : dependentBeans) {
                    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的销毁方法。销毁方法是在容器关闭以后执行的。看是否实现了DisposableBean销毁接口的方法。
        registerDisposableBeanIfNecessary(beanName, bean, mbd);
    }
    catch (BeanDefinitionValidationException ex) {
        throw new BeanCreationException(
                mbd.getResourceDescription(), beanName, "Invalid destruction signature", ex);
    }
    
    // 返回exposedObject
    return exposedObject;
}

如下所示：

然后点击Step Into(F5)进入doCreateBean(beanName, mbdToUse, args); 

Step Over(F6)下一步，直到走到createBeanInstance(beanName, mbd, args);

然后点击Step Into(F5)进入createBeanInstance(beanName, mbd, args);

Step Over(F6)下一步，直到走到instantiateUsingFactoryMethod(beanName, mbd, args);

然后点击Step Into(F5)进入instantiateUsingFactoryMethod(beanName, mbd, args); 

此时就是使用构造器进行解析，调用创建bean实例对象。

然后点击Step Into(F5)进入，然后Step Over(F6)下一步，然后点击Step Into(F5)进入，然后Step Over(F6)下一步，直到走到instantiateUsingFactoryMethod(beanName, mbd, explicitArgs);

里面的详细步骤可以研究一下，执行里面的代码最终会调用beanInstance = this.beanFactory.getInstantiationStrategy().instantiate(mbd, beanName, this.beanFactory, factoryBean, factoryMethodToUse, argsToUse);此时就会去创建Bean实例对象。

protected BeanWrapper createBeanInstance(String beanName, RootBeanDefinition mbd, Object[] args) {
    // Make sure bean class is actually resolved at this point.
    // 解析我们要创建的bean实例的类型。
    Class<?> beanClass = resolveBeanClass(mbd, beanName);

    // 如果创建的bean类型不为空，等等，就抛出异常
    if (beanClass != null && !Modifier.isPublic(beanClass.getModifiers()) && !mbd.isNonPublicAccessAllowed()) {
        throw new BeanCreationException(mbd.getResourceDescription(), beanName,
                "Bean class isn't public, and non-public access not allowed: " + beanClass.getName());
    }
    
    // 获取到工厂方法的名称，如果不为空，返回执行的工厂方法。
    if (mbd.getFactoryMethodName() != null)  {
        // 里面的代码很多，自己可以去研究一下的。
        return instantiateUsingFactoryMethod(beanName, mbd, args);
    }

    // Shortcut when re-creating the same bean...
    boolean resolved = false;
    boolean autowireNecessary = false;
    if (args == null) {
        synchronized (mbd.constructorArgumentLock) {
            if (mbd.resolvedConstructorOrFactoryMethod != null) {
                resolved = true;
                autowireNecessary = mbd.constructorArgumentsResolved;
            }
        }
    }
    if (resolved) {
        if (autowireNecessary) {
            return autowireConstructor(beanName, mbd, null, null);
        }
        else {
            return instantiateBean(beanName, mbd);
        }
    }

    // Need to determine the constructor...
    Constructor<?>[] ctors = determineConstructorsFromBeanPostProcessors(beanClass, beanName);
    if (ctors != null ||
            mbd.getResolvedAutowireMode() == RootBeanDefinition.AUTOWIRE_CONSTRUCTOR ||
            mbd.hasConstructorArgumentValues() || !ObjectUtils.isEmpty(args))  {
        return autowireConstructor(beanName, mbd, ctors, args);
    }

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

如下所示：

然后Step Over(F6)下一步，直到走到return new Blue();可以看到执行到了创建bean实例的步骤。

此时，利用工厂方法或者对象的构造器创建出Bean实例。然后Step Over(F6)下一步。直到下一步到instanceWrapper = createBeanInstance(beanName, mbd, args);

Step Over(F6)下一步，直到走到populateBean(beanName, mbd, instanceWrapper); 

初始化bean实例的操作，populateBean(beanName, mbd, instanceWrapper); 方法的调用作用是给bean赋值。

点击Step Into(F5)进入populateBean(beanName, mbd, instanceWrapper);

protected void populateBean(String beanName, RootBeanDefinition mbd, BeanWrapper bw) {
    // 获取到所有要赋值属性的值。
    PropertyValues pvs = mbd.getPropertyValues();

    // 如果包装的bean为空，就抛出异常了
    if (bw == null) {
        if (!pvs.isEmpty()) {
            throw new BeanCreationException(
                    mbd.getResourceDescription(), beanName, "Cannot apply property values to null instance");
        }
        else {
            // Skip property population phase for null instance.
            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.
    // 定义变量，方便下面处理这种类型的InstantiationAwareBeanPostProcessor后置处理器使用。
    boolean continueWithPropertyPopulation = true;
    
    // 赋值之前先遍历了这种类型的InstantiationAwareBeanPostProcessor后置处理器。
    if (!mbd.isSynthetic() && hasInstantiationAwareBeanPostProcessors()) {
        // 遍历所有的后置处理器
        for (BeanPostProcessor bp : getBeanPostProcessors()) {
            // 如果后置处理器是这个类型InstantiationAwareBeanPostProcessor的后置处理器
            if (bp instanceof InstantiationAwareBeanPostProcessor) {
                InstantiationAwareBeanPostProcessor ibp = (InstantiationAwareBeanPostProcessor) bp;
                // 执行这些后置处理器的这个方法postProcessAfterInstantiation()。
                if (!ibp.postProcessAfterInstantiation(bw.getWrappedInstance(), beanName)) {
                    continueWithPropertyPopulation = false;
                    break;
                }
            }
        }
    }
    
    // 如果定义的变量continueWithPropertyPopulation为false。直接返回。
    if (!continueWithPropertyPopulation) {
        return;
    }

    if (mbd.getResolvedAutowireMode() == RootBeanDefinition.AUTOWIRE_BY_NAME ||
            mbd.getResolvedAutowireMode() == RootBeanDefinition.AUTOWIRE_BY_TYPE) {
        MutablePropertyValues newPvs = new MutablePropertyValues(pvs);

        // Add property values based on autowire by name if applicable.
        if (mbd.getResolvedAutowireMode() == RootBeanDefinition.AUTOWIRE_BY_NAME) {
            autowireByName(beanName, mbd, bw, newPvs);
        }

        // Add property values based on autowire by type if applicable.
        if (mbd.getResolvedAutowireMode() == RootBeanDefinition.AUTOWIRE_BY_TYPE) {
            autowireByType(beanName, mbd, bw, newPvs);
        }

        pvs = newPvs;
    }

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

    if (hasInstAwareBpps || needsDepCheck) {
        PropertyDescriptor[] filteredPds = filterPropertyDescriptorsForDependencyCheck(bw, mbd.allowCaching);
        if (hasInstAwareBpps) {
            // 循环遍历，获取到所有的后置处理器
            for (BeanPostProcessor bp : getBeanPostProcessors()) {
                // 如果是InstantiationAwareBeanPostProcessor这种类型的后置处理器。
                if (bp instanceof InstantiationAwareBeanPostProcessor) {
                    InstantiationAwareBeanPostProcessor ibp = (InstantiationAwareBeanPostProcessor) bp;
                    // 执行InstantiationAwareBeanPostProcessor后置处理器的postProcessPropertyValues(pvs, filteredPds, bw.getWrappedInstance(), beanName);这个方法。
                    pvs = ibp.postProcessPropertyValues(pvs, filteredPds, bw.getWrappedInstance(), beanName);
                    if (pvs == null) {
                        return;
                    }
                }
            }
        }
        if (needsDepCheck) {
            checkDependencies(beanName, mbd, filteredPds, pvs);
        }
    }
    
    // 应用Bean属性的值，此时才是为属性利用setter方法进行赋值操作的。利用反射调用setter方法，可以点进去研究一下的。
    applyPropertyValues(beanName, mbd, bw, pvs);
}

如下所示：

Step Over(F6)下一步，直到走到populateBean(beanName, mbd, instanceWrapper);

Step Over(F6)下一步，直到走到initializeBean(beanName, exposedObject, mbd);然后点击Step Into(F5)进入initializeBean(beanName, exposedObject, mbd);

// 这里面其实之前也写过了。
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 {
        // 第一步、
        // 执行实现了xxxAware接口的方法。调用就是判断是否是实现了Aware接口、BeanNameAware接口、BeanClassLoaderAware接口、BeanFactoryAware接口。
        // 执行Aware接口的方法。
        invokeAwareMethods(beanName, bean);
    }

    Object wrappedBean = bean;
    if (mbd == null || !mbd.isSynthetic()) {
        // 第二步、
        // 执行所有的BeanPostProcessor后置处理器，调用BeanPostProcessor.postProcessBeforeInitialization方法。
        // 执行后置处理器初始化之前的方法。
        wrappedBean = applyBeanPostProcessorsBeforeInitialization(wrappedBean, beanName);
    }

    try {
        // 第三步
        // 执行初始化方法。有很多方法执行初始化的方法，如实现了InitializingBean接口的、@Bean注解的initMethod属性等等。
        // 自己可以点进去研究一下执行流程。里面首先判断是否是InitializingBean接口的实现，执行接口规定的初始化。然后再判断是否自定义初始化方法。
        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.postProcessAfterInitialization()方法。
        wrappedBean = applyBeanPostProcessorsAfterInitialization(wrappedBean, beanName);
    }
    // 返回包装的bean组件。
    return wrappedBean;
}

如下所示：

Step Over(F6)下一步，直到走到exposedObject = initializeBean(beanName, exposedObject, mbd);

Step Over(F6)下一步，直到走到Object beanInstance = doCreateBean(beanName, mbdToUse, args);此时bean已经创建成功了。

Step Over(F6)下一步，直到走到return createBean(beanName, mbd, args);

Step Over(F6)下一步，直到走到singletonObject = singletonFactory.getObject();

由于是匿名内部类，getSingleton(beanName, new ObjectFactory<Object>()匿名内部类，调用的是DefaultSingletonBeanRegistry.getSingleton()方法，调用此方法，最后将单实例bean添加到缓存中。注意这一点吧，不然很迷。

Step Over(F6)下一步，直到走到sharedInstance = getSingleton(beanName, new ObjectFactory<Object>()。

Step Over(F6)下一步，直到走到return doGetBean(name, null, null, false);

Step Over(F6)下一步，直到走到getBean(beanName);

IOC容器就是这些MAP，很多的MAP里面保存了单实例Bean，环境信息等等。所有的这些MAP构成了IOC容器，容器里面保存所有组件，从容器中获取组件就是从Map中取出对应的值。
此时，所有的bean就已经创建完毕了，使用循环遍历创建所有的bean实例。Step Over(F6)下一步，直到走到Object singletonInstance = getSingleton(beanName);获取到所有的bean对象。

Step Over(F6)下一步，直到走到beanFactory.preInstantiateSingletons();

12、Step Over(F6)下一步，直到走到finishRefresh();

然后点击Step Into(F5)进入finishRefresh()方法。

protected void finishRefresh() {
    // Initialize lifecycle processor for this context.
    // 初始化和生命周期相关的后置处理器。自己可以点进去研究一下的。
    // 允许我们自己定义LifecycleProcessor的实现类。在BeanFactory容器的生命周期期间来进行一些回调操作onRefresh()、onClose()。
    // 默认从容器中找是否有LifecycleProcessor类型的组件，如果没有使用默认的生命周期组件new DefaultLifecycleProcessor();。
    initLifecycleProcessor();

    // Propagate refresh to lifecycle processor first.
    // 获取到生命周期处理器回调onRefresh()方法。监听BeanFactory生命周期的。
    getLifecycleProcessor().onRefresh();

    // Publish the final event.
    // 给容器发布一个事件，叫容器刷新完成事件。发布容器刷新完成事件。
    publishEvent(new ContextRefreshedEvent(this));

    // Participate in LiveBeansView MBean, if active.
    // 暴露一些MBean
    LiveBeansView.registerApplicationContext(this);
}

 如下所示：

至此，嗯，头蒙眼花。

Spring源码理解点。
第一点、Spring容器在启动的时候，先会保存所有注册进来的Bean的定义信息。切记，Bean的定义，不是创建Bean对象的哦。未来，BeanFactory按照bean的定义创建bean的信息。
    有两种方式定义bean的定义信息。
        第一种，使用xml注册bean的定义信息。
        第二种，使用注解注册bean的定义信息。如@Component、@Service、@Controller、@Repository、@Bean，都是给容器中注册bean的定义信息。
第二点、Spring容器会在合适的时机创建这些Bean。
    合适的时机主要有两个，如下所示：
        第一个，当使用到这个bean的时候，会利用getBean方法创建该bean，创建成功以后保存到容器中。
        第二个，统一创建剩下所有bean的时候。finishBeanFactoryInitialization(beanFactory);如果单实例bean，还没有创建的时候，此时会进行创建。
第三点、后置处理器，每一个bean创建完成以后，都会使用各种后置处理器进行处理，来增强bean的功能。
    比如AutowiredAnnotationBeanPostProcessor，处理自动注入的。
        AnnotationAwareAspectJAutoProxyCreator，来做aop功能的，给bean创建代理对象。
第四点、Spring的事件驱动模型。
    比如，ApplicationListener，做事件监听的。
        ApplicationEventMulticaster事件的派发。

 

作者：别先生

博客园：https://www.cnblogs.com/biehongli/

如果您想及时得到个人撰写文章以及著作的消息推送，可以扫描上方二维码，关注个人公众号哦。