spring源码系列-Bean的创建流程

上一篇文章 spring源码系列-容器之XmlBeanFactory 中，我们以XmlBeanFactory为例，分析了spring 配置文件的解析，及容器的初始化流程。历经九九八十一难，终于拿到了BeanDefinition，并将之保存到beanDefinitionMap中,这些解析的数据毫无疑问是创建bean的基础，那么bean的创建究竟经历了什么非人的过程？这篇文章，我们将会一探究竟。本文可以分为以下几个板块

1. 前言
2. bean的创建
   2.1 转换对应的beanName
   2.2 从缓存中加载bean
   2.3 bean的实例化
   2.4 原型模式的依赖检查
   2.5 从parentBeanFactory加载配置
   2.6 转换rootBeanDefinition
   2.7 寻找依赖
   2.8 针对不同的scope进行bean的创建
   2.8.1 处理MethodOverrides
   2.8.2 实例化的前置处理
   2.8.3 根据不同的策略实例化bean
   2.8.4 暴露创建工厂
   2.8.5 属性填充
   2.8.6 初始化
   2.8.7 注册销毁相关方法
   2.9 类型转换
3. 总结

1. 前言

在开始分析之前，我们先思考几个小问题。

1. 程序设计的原则之一单一职责。那么如果程序职责划分不明确，多个bean之间存在循环依赖的情况，如ServiceA依赖ServiceB，ServiceB 又依赖ServieA。因为spring 创建bean的时候，会去初始化依赖，那么这种循环依赖，该如何处理呢？
2. 我们都知道spring的bean是单例的。那么spring的bean 是如何实现单列的呢？是懒汉模式，饿汉模式，还是双重锁单列，还是枚举单列？
3. 我们都知道spring关于bean的生命周期中提供了很多可扩展的点，如BeanPostProcessor，InitializingBean,init-method，destory-method等，这些关键扩展点是如何实现的，执行顺序是什么？
4. spring bean创建的时候会存在依赖注入的情况，注解/配置文件。那么依赖注入是如何实现的呢？
   那么我们就带着这些问题，共同阅读一下spring的源码，看看spring背着我们，到底偷偷做了什么。

2. bean的创建

在开始bean创建流程分析之前，我们先回顾一下bean创建的基础用法。

        //步骤1：初始化BeanFactory
        BeanFactory beanFactory=new XmlBeanFactory(new ClassPathResource("spring-config.xml"));
        //步骤2：获取Bean
        Person person=(Person) beanFactory.getBean("um");

其中步骤1是我们上篇文章分析的重点，而步骤2究竟是怎么实现的呢？

Bean的创建.jpg

从流程图中可以看出来，主要分为以下步骤：
1. 转换beanName
2. 尝试从缓存或者提前暴露的BeanFactory中获取实例
3. bean的实例化（存在FactoryBean的情况）
4. 原型类型循环引用的检查
5. 尝试从父类工厂中实例化bean
6. 转换RootBeanDefinition，并合并父类属性
7. 查找并实例化依赖-depend on
8. 根据不同的scope做bean的创建
9. 类型转换

protected  T doGetBean(
            final String name, final Class requiredType, final Object[] args, boolean typeCheckOnly)
            throws BeansException {
        //1. 转换beanName
        final String beanName = transformedBeanName(name);
        Object bean;

        // 2. 尝试从缓存或者提前暴露的BeanFactory中获取实例
        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 + "'");
                }
            }
            //3. bean的实例化（存在FactoryBean的情况）
            bean = getObjectForBeanInstance(sharedInstance, name, beanName, null);
        }

        else {
            //4. 原型类型循环引用的检查
            if (isPrototypeCurrentlyInCreation(beanName)) {
                throw new BeanCurrentlyInCreationException(beanName);
            }

            // 5. 尝试从父类工厂中实例化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);
                }
            }

            if (!typeCheckOnly) {
                markBeanAsCreated(beanName);
            }

            try {
                //6. 转换RootBeanDefinition，并合并父类属性
                final RootBeanDefinition mbd = getMergedLocalBeanDefinition(beanName);
                checkMergedBeanDefinition(mbd, beanName, args);

                // 7. 查找并实例化依赖-depend on
                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 + "'");
                        }
                        registerDependentBean(dep, beanName);
                        try {
                            getBean(dep);
                        }
                        catch (NoSuchBeanDefinitionException ex) {
                            throw new BeanCreationException(mbd.getResourceDescription(), beanName,
                                    "'" + beanName + "' depends on missing bean '" + dep + "'", ex);
                        }
                    }
                }

                // 8. 根据不同的scope做bean的创建
                if (mbd.isSingleton()) {
                    sharedInstance = getSingleton(beanName, new ObjectFactory