Spring IOC源码阅读笔记（二） Bean的加载

1. 容器基本用法
   测试类

public class MyTestBean {
    private String testStr = "testStr";

    public String getTestStr() {
        return testStr;
    }

    public void setTestStr(String testStr) {
        this.testStr = testStr;
    }
}

XML文件

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xsi:schemaLocation="http://www.springframework.org/schema/beans
        http://www.springframework.org/schema/beans/spring-beans.xsd">
    <bean id="myTestBean" class="com.xxy.core.ioc.MyTestBean"/>
</beans>

测试代码

 @Test
 public void test() {
      BeanFactory bf = new XmlBeanFactory(new ClassPathResource("beanFactoryTest.xml"));
      MyTestBean bean = (MyTestBean) bf.getBean("myTestBean");
      Assert.assertEquals("testStr", bean.getTestStr());
  }

测试类第一行代码调用了默认标签的解析及BeanDifition加载的逻辑。
测试类的第二行代码则开始了加载bean的逻辑。

2. 源码学习

MyTestBean bean = (MyTestBean) bf.getBean("myTestBean");

直接进入getBean方法，定义在BeanFactory接口中，有很多重载，看AbstractBeanFactory中的实现：

 public Object getBean(String name) throws BeansException {
     return this.doGetBean(name, (Class)null, (Object[])null, false);
 }

调用了doGetBean方法，doGetBean的代码量很大，逻辑也相对复杂：

protected <T> T doGetBean(String name, @Nullable Class<T> requiredType, @Nullable Object[] args, boolean typeCheckOnly) throws BeansException {
//首先根据传入的name获取beanName
    String beanName = this.transformedBeanName(name);
    //获取缓存或者实例工厂中是否有对应的实例
    Object sharedInstance = this.getSingleton(beanName);
    Object bean;
    //存在单例且传入的args为null
    if (sharedInstance != null && args == null) {
        if (this.logger.isTraceEnabled()) {
        //分情况打印日志
            if (this.isSingletonCurrentlyInCreation(beanName)) {
                this.logger.trace("Returning eagerly cached instance of singleton bean '" + beanName + "' that is not fully initialized yet - a consequence of a circular reference");
            } else {
                this.logger.trace("Returning cached instance of singleton bean '" + beanName + "'");
            }
        }
//返回对应实例
        bean = this.getObjectForBeanInstance(sharedInstance, name, beanName, (RootBeanDefinition)null);
    } else {
    //单例模式下才会尝试解决循环依赖，原型模式如果当前bean正在创建，则抛出异常
        if (this.isPrototypeCurrentlyInCreation(beanName)) {
            throw new BeanCurrentlyInCreationException(beanName);
        }
//获取parentBeanFactory
        BeanFactory parentBeanFactory = this.getParentBeanFactory();
       // 如果beanDefinitionMap不存在beanName则从parentBeanFactory中寻找
        if (parentBeanFactory != null && !this.containsBeanDefinition(beanName)) {
            String nameToLookup = this.originalBeanName(name);
            if (parentBeanFactory instanceof AbstractBeanFactory) {
            //如果parentBeanFactory是AbstractBeanFactory的实现类对象，调用parentBeanFactory中的doGetBean方法
                return ((AbstractBeanFactory)parentBeanFactory).doGetBean(nameToLookup, requiredType, args, typeCheckOnly);
            }

            if (args != null) {
                return parentBeanFactory.getBean(nameToLookup, args);
            }

            if (requiredType != null) {
                return parentBeanFactory.getBean(nameToLookup, requiredType);
            }

            return parentBeanFactory.getBean(nameToLookup);
        }
//如果不是做类型检查，则要创建bean，这里进行记录
        if (!typeCheckOnly) {
            this.markBeanAsCreated(beanName);
        }

        try {
        //将加载的GenericBeanDefinition转化为RootBeanDefinition，如果指定的beanName是子Bean则会合并父类属性
            RootBeanDefinition mbd = this.getMergedLocalBeanDefinition(beanName);
            //检测
            this.checkMergedBeanDefinition(mbd, beanName, args);
            //获取依赖，如果存在需要递归实例化
            String[] dependsOn = mbd.getDependsOn();
            String[] var11;
            if (dependsOn != null) {
                var11 = dependsOn;
                int var12 = dependsOn.length;

                for(int var13 = 0; var13 < var12; ++var13) {
                    String dep = var11[var13];
                    if (this.isDependent(beanName, dep)) {
                        throw new BeanCreationException(mbd.getResourceDescription(), beanName, "Circular depends-on relationship between '" + beanName + "' and '" + dep + "'");
                    }

                    this.registerDependentBean(dep, beanName);

                    try {
                        this.getBean(dep);
                    } catch (NoSuchBeanDefinitionException var24) {
                        throw new BeanCreationException(mbd.getResourceDescription(), beanName, "'" + beanName + "' depends on missing bean '" + dep + "'", var24);
                    }
                }
            }
//实例化依赖bean之后开始实例化mbd本身
//单例模式的创建
            if (mbd.isSingleton()) {
                sharedInstance = this.getSingleton(beanName, () -> {
                    try {
                    //返回创建的bean
                        return this.createBean(beanName, mbd, args);
                    } catch (BeansException var5) {
                        this.destroySingleton(beanName);
                        throw var5;
                    }
                });
                //缓存中的bean是bean的原始状态，获取最终想要的bean
                bean = this.getObjectForBeanInstance(sharedInstance, name, beanName, mbd);
                //原型创建
            } else if (mbd.isPrototype()) {
                var11 = null;

                Object prototypeInstance;
                try {
                //前置处理
                    this.beforePrototypeCreation(beanName);
                    //创建bean
                    prototypeInstance = this.createBean(beanName, mbd, args);
                } finally {
                //后置处理
                    this.afterPrototypeCreation(beanName);
                }
                bean = this.getObjectForBeanInstance(prototypeInstance, name, beanName, mbd);
            } else {
            //获取指定范围的bean
                String scopeName = mbd.getScope();
                Scope 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, () -> {
                        this.beforePrototypeCreation(beanName);

                        Object var4;
                        try {
                            var4 = this.createBean(beanName, mbd, args);
                        } finally {
                            this.afterPrototypeCreation(beanName);
                        }

                        return var4;
                    });
                    bean = this.getObjectForBeanInstance(scopedInstance, name, beanName, mbd);
                } catch (IllegalStateException var23) {
                    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", var23);
                }
            }
        } catch (BeansException var26) {
            this.cleanupAfterBeanCreationFailure(beanName);
            throw var26;
        }
    }
//检查需要的类型是否符合bean的类型
    if (requiredType != null && !requiredType.isInstance(bean)) {
        try {
            T convertedBean = this.getTypeConverter().convertIfNecessary(bean, requiredType);
            if (convertedBean == null) {
                throw new BeanNotOfRequiredTypeException(name, requiredType, bean.getClass());
            } else {
                return convertedBean;
            }
        } catch (TypeMismatchException var25) {
            if (this.logger.isTraceEnabled()) {
                this.logger.trace("Failed to convert bean '" + name + "' to required type '" + ClassUtils.getQualifiedName(requiredType) + "'", var25);
            }

            throw new BeanNotOfRequiredTypeException(name, requiredType, bean.getClass());
        }
    } else {
        return bean;
    }
}

首先，通过transformedBeanName方法获取对应的beanName，因为传入的name可能是别名，可能是beanName等。这个方法的详细逻辑就略过了。
获取对应的beanName之后，进入getSingleton方法，这个方法的实现在DefaultSingletonBeanRegistry类中：

//单例模式实例缓存
private final Map<String, Object> singletonObjects = new ConcurrentHashMap(256);
//提前曝光的单例缓存，即bean没有创建完毕就可以使用getBean方法获取了
private final Map<String, Object> earlySingletonObjects = new HashMap(16);、
//创建bean工厂的缓存
private final Map<String, ObjectFactory<?>> singletonFactories = new HashMap(16);

private final Set<String> singletonsCurrentlyInCreation = Collections.newSetFromMap(new ConcurrentHashMap(16));
public Object getSingleton(String beanName) {
   return this.getSingleton(beanName, true);
}
protected Object getSingleton(String beanName, boolean allowEarlyReference) {
    Object singletonObject = this.singletonObjects.get(beanName);
    if (singletonObject == null && this.isSingletonCurrentlyInCreation(beanName)) {
        Map var4 = this.singletonObjects;
        synchronized(this.singletonObjects) {
        //如果此bean正在加载这不处理
            singletonObject = this.earlySingletonObjects.get(beanName);
            //如果仍未获取到单例，则尝试获取工厂方法
            if (singletonObject == null && allowEarlyReference) {
                ObjectFactory<?> singletonFactory = (ObjectFactory)this.singletonFactories.get(beanName);
                if (singletonFactory != null) {
                //获取单例
                    singletonObject = singletonFactory.getObject();
                    //earlySingletonObjects和singletonFactories互斥
                    this.earlySingletonObjects.put(beanName, singletonObject);
                    this.singletonFactories.remove(beanName);
                }
            }
        }
    }

    return singletonObject;
}

这段代码存在循环依赖的检测以及多处bean的缓存，首先从singletonObjects中获取，获取不到且当前单例正在创建中则从earlySingletonObjects中获取，如果还是获取不到且allowEarlyReference，则尝试获取ObjectFactory，调用其getObject方法。最后无论是否获取到都返回。回到doGetBean方法，如果获取到单例且传入的args为null，则直接调用getObjectForBeanInstance方法：

protected Object getObjectForBeanInstance(Object beanInstance, String name, String beanName, @Nullable RootBeanDefinition mbd) {
//如果指定的name是以&为前缀
    if (BeanFactoryUtils.isFactoryDereference(name)) {
        if (beanInstance instanceof NullBean) {
            return beanInstance;
        }
        
        if (!(beanInstance instanceof FactoryBean)) {
            throw new BeanIsNotAFactoryException(beanName, beanInstance.getClass());
        }
    }
//执行到这里则表示用户传入的beanName前没有加&，如果用户想要获取factoryBean而不是getObject方法返回的实例则应该加&
//如果指定的name不是以&为前缀且beanInstance是FactoryBean的实例
    if (beanInstance instanceof FactoryBean && !BeanFactoryUtils.isFactoryDereference(name)) {
        Object object = null;
        //如果RootBeanDefinition为null，尝试从缓存中获取bean
        if (mbd == null) {
            object = this.getCachedObjectForFactoryBean(beanName);
        }

        if (object == null) {
        //方法执行到这里则表示beanInstance一定是FactoryBean的实例
            FactoryBean<?> factory = (FactoryBean)beanInstance;
            //如果存在BeanDefinition则获取尝试
            if (mbd == null && this.containsBeanDefinition(beanName)) {
                mbd = this.getMergedLocalBeanDefinition(beanName);
            }
//判断是用户自定义的还是应用程序定义的
            boolean synthetic = mbd != null && mbd.isSynthetic();
            //获取实例
            object = this.getObjectFromFactoryBean(factory, beanName, !synthetic);
        }
//返回
        return object;
        //如果指定的name不是以&为前缀且beanInstance不是FactoryBean的实例，则直接返回
    } else {
        return beanInstance;
    }
}

这段代码主要是对name不是以&为前缀且beanInstance是FactoryBean的实例进行处理，而这个逻辑主要由FactoryBeanRegistrySupport类的getObjectFromFactoryBean方法处理：

private final Map<String, Object> factoryBeanObjectCache = new ConcurrentHashMap(16);
protected Object getObjectFromFactoryBean(FactoryBean<?> factory, String beanName, boolean shouldPostProcess) {
//如果是FactoryBean是单例且当前存在实例
    if (factory.isSingleton() && this.containsSingleton(beanName)) {
    //加锁
        synchronized(this.getSingletonMutex()) {
        //获取实例
            Object object = this.factoryBeanObjectCache.get(beanName);
            //获取的实例为null
            if (object == null) {
            //调用doGetObjectFromFactoryBean获取实例
                object = this.doGetObjectFromFactoryBean(factory, beanName);
                //再次从缓存中获取实例
                Object alreadyThere = this.factoryBeanObjectCache.get(beanName);
                if (alreadyThere != null) {
                    object = alreadyThere;
                } else {
                //后处理
                    if (shouldPostProcess) {
                        if (this.isSingletonCurrentlyInCreation(beanName)) {
                            return object;
                        }
//单例创建前处理，主要是对DefaultSingletonBeanRegistry两缓存的维护
                        this.beforeSingletonCreation(beanName);

                        try {
                        //调用后处理器
                            object = this.postProcessObjectFromFactoryBean(object, beanName);
                        } catch (Throwable var14) {
                            throw new BeanCreationException(beanName, "Post-processing of FactoryBean's singleton object failed", var14);
                        } finally {
                        //单例创建后处理，主要是对DefaultSingletonBeanRegistry两缓存的维护
                            this.afterSingletonCreation(beanName);
                        }
                    }

                    if (this.containsSingleton(beanName)) {
                        this.factoryBeanObjectCache.put(beanName, object);
                    }
                }
            }
            return object;
        }
        //FactoryBean不为单例或者当前缓存中不存在对应的bean
    } else {
        Object object = this.doGetObjectFromFactoryBean(factory, beanName);
        if (shouldPostProcess) {
            try {
                object = this.postProcessObjectFromFactoryBean(object, beanName);
            } catch (Throwable var17) {
                throw new BeanCreationException(beanName, "Post-processing of FactoryBean's object failed", var17);
            }
        }

        return object;
    }
}

上面的代码主要是一些逻辑的处理，但是没有真正的获取bean，保证了单例的全局唯一性，以及非单例模式的创建。接下来进入doGetObjectFromFactoryBean方法：

private Object doGetObjectFromFactoryBean(FactoryBean<?> factory, String beanName) throws BeanCreationException {
   Object object;
   try {
   //是否需要权限验证
       if (System.getSecurityManager() != null) {
           AccessControlContext acc = this.getAccessControlContext();

           try {
               object = AccessController.doPrivileged(factory::getObject, acc);
           } catch (PrivilegedActionException var6) {
               throw var6.getException();
           }
       } else {
           object = factory.getObject();
       }
   } catch (FactoryBeanNotInitializedException var7) {
       throw new BeanCurrentlyInCreationException(beanName, var7.toString());
   } catch (Throwable var8) {
       throw new BeanCreationException(beanName, "FactoryBean threw exception on object creation", var8);
   }

   if (object == null) {
       if (this.isSingletonCurrentlyInCreation(beanName)) {
           throw new BeanCurrentlyInCreationException(beanName, "FactoryBean which is currently in creation returned null from getObject");
       }
//创建NullBean实例
       object = new NullBean();
   }

   return object;
}

//这个代码的逻辑比较简单，首先是判断需不需要权限，不论是否需要权限都会调factoryBean的getObject()方法，最后是对返回值为null的情况做处理，最后返回object。接下来回到getObjectFromFactoryBean方法，可以看到除了逻辑处理之外，对于单例和非单例的创建都调用了postProcessObjectFromFactoryBean方法：

protected Object postProcessObjectFromFactoryBean(Object object, String beanName) throws BeansException {
    return object;
}

这里的实现是直接返回object，但是在其子类AbstractAutowireCapableBeanFactory有对postProcessObjectFromFactoryBean的重写：

protected Object postProcessObjectFromFactoryBean(Object object, String beanName) {
    return this.applyBeanPostProcessorsAfterInitialization(object, beanName);
}

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

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

   return result;
}

从代码来看就是对结果的处理，后处理器目前并没有接触或者使用，以后了解了再补充。接下来根据return一步一步返回上一层，回到getObjectFromFactoryBean方法，不论是哪种情况，都会在调用了postProcessObjectFromFactoryBean后进行返回。回到getObjectForBeanInstance方法，其实是根据传入的beanName和实例是否是FactoryBean类型的实例对实例进行处理。再回到doGetBean方法，接下来就是对sharedInstance为null或者args不为null两种情况的处理。跳过parentBeanFactory中获取bean的过程，直接看后面的程序，如果不仅仅是做类型检查的话，需要调用markBeanAsCreated方法对缓存进行维护：

protected void markBeanAsCreated(String beanName) {
    if (!this.alreadyCreated.contains(beanName)) {
        Map var2 = this.mergedBeanDefinitions;
        synchronized(this.mergedBeanDefinitions) {
            if (!this.alreadyCreated.contains(beanName)) {
                this.clearMergedBeanDefinition(beanName);
                this.alreadyCreated.add(beanName);
            }
        }
    }
}

首先isDependent以及registerDependentBean方法主要是对循环依赖的维护以及检测。for循环中主要是获取依赖的bean，主要还是调用getBean方法。将所有的依赖bean都创建完成之后才会开始当前bean的创建。首先是单例模式的创建：

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

首先是调用了getSingleton方法传入beanName并且使用lambda表达式传入了一段代码，最后将返回值赋值给sharedInstance。在低版本中也可能是实例化一个接口并实现接口中的方法。
首先看getSingleton方法，在DefaultSingletonBeanRegistry类中实现,有两种重载，看当前调用的这个：

private final Map<String, Object> singletonObjects = new ConcurrentHashMap(256);
public Object getSingleton(String beanName, ObjectFactory<?> singletonFactory) {
//断言beanName不能为null
    Assert.notNull(beanName, "Bean name must not be null");
    Map var3 = this.singletonObjects;
    synchronized(this.singletonObjects) {
    //现在缓存中获取
        Object singletonObject = this.singletonObjects.get(beanName);
        if (singletonObject == null) {
            if (this.singletonsCurrentlyInDestruction) {
                throw new BeanCreationNotAllowedException(beanName, "Singleton bean creation not allowed while singletons of this factory are in destruction (Do not request a bean from a BeanFactory in a destroy method implementation!)");
            }

            if (this.logger.isDebugEnabled()) {
                this.logger.debug("Creating shared instance of singleton bean '" + beanName + "'");
            }

            this.beforeSingletonCreation(beanName);
            boolean newSingleton = false;
            boolean recordSuppressedExceptions = this.suppressedExceptions == null;
            if (recordSuppressedExceptions) {
                this.suppressedExceptions = new LinkedHashSet();
            }

            try {
                singletonObject = singletonFactory.getObject();
                newSingleton = true;
            } catch (IllegalStateException var16) {
                singletonObject = this.singletonObjects.get(beanName);
                if (singletonObject == null) {
                    throw var16;
                }
            } catch (BeanCreationException var17) {
                BeanCreationException ex = var17;
                if (recordSuppressedExceptions) {
                    Iterator var8 = this.suppressedExceptions.iterator();

                    while(var8.hasNext()) {
                        Exception suppressedException = (Exception)var8.next();
                        ex.addRelatedCause(suppressedException);
                    }
                }

                throw ex;
            } finally {
                if (recordSuppressedExceptions) {
                    this.suppressedExceptions = null;
                }

                this.afterSingletonCreation(beanName);
            }

            if (newSingleton) {
                this.addSingleton(beanName, singletonObject);
            }
        }

        return singletonObject;
    }
}

beforeSingletonCreation和afterSingletonCreation两个方法是对缓存的维护，还有对发生异常以及创建完后之后的缓存等逻辑，而真正的bean创建则在singletonFactory实例的getObject()方法，这里可以看到其实指正的代码调用其实是通过lambda表达式传入的代码。
进createBean方法，在AbstractBeanFactory类中是一个抽象方法，在其子类AbstractAutowireCapableBeanFactory中实现：

protected Object createBean(String beanName, RootBeanDefinition mbd, @Nullable Object[] args) throws BeanCreationException {
    if (this.logger.isTraceEnabled()) {
        this.logger.trace("Creating instance of bean '" + beanName + "'");
    }

    RootBeanDefinition mbdToUse = mbd;
    //解析并获取Class对象
    Class<?> resolvedClass = this.resolveBeanClass(mbd, beanName, new Class[0]);
    if (resolvedClass != null && !mbd.hasBeanClass() && mbd.getBeanClassName() != null) {
        mbdToUse = new RootBeanDefinition(mbd);
        mbdToUse.setBeanClass(resolvedClass);
    }

    try {
    //验证及准备覆盖的方法
        mbdToUse.prepareMethodOverrides();
    } catch (BeanDefinitionValidationException var9) {
        throw new BeanDefinitionStoreException(mbdToUse.getResourceDescription(), beanName, "Validation of method overrides failed", var9);
    }

    Object beanInstance;
    try {
    //给BeanPostProcessors返回代理类替换实例的机会
        beanInstance = this.resolveBeforeInstantiation(beanName, mbdToUse);
        //短路操作，如果创建了代理类则直接返回，这里和AOP功能有联系，这里不做分析
        if (beanInstance != null) {
            return beanInstance;
        }
    } catch (Throwable var10) {
        throw new BeanCreationException(mbdToUse.getResourceDescription(), beanName, "BeanPostProcessor before instantiation of bean failed", var10);
    }

    try {
    //创建bean
        beanInstance = this.doCreateBean(beanName, mbdToUse, args);
        if (this.logger.isTraceEnabled()) {
            this.logger.trace("Finished creating instance of bean '" + beanName + "'");
        }

        return beanInstance;
    } catch (ImplicitlyAppearedSingletonException | BeanCreationException var7) {
        throw var7;
    } catch (Throwable var8) {
        throw new BeanCreationException(mbdToUse.getResourceDescription(), beanName, "Unexpected exception during bean creation", var8);
    }
}

直接看prepareMethodOverrides方法，在AbstractBeanDefinition类中实现：

public void prepareMethodOverrides() throws BeanDefinitionValidationException {
    if (this.hasMethodOverrides()) {
        Set<MethodOverride> overrides = this.getMethodOverrides().getOverrides();
        synchronized(overrides) {
            Iterator var3 = overrides.iterator();

            while(var3.hasNext()) {
                MethodOverride mo = (MethodOverride)var3.next();
                this.prepareMethodOverride(mo);
            }
        }
    }

}

protected void prepareMethodOverride(MethodOverride mo) throws BeanDefinitionValidationException {
   int count = ClassUtils.getMethodCountForName(this.getBeanClass(), mo.getMethodName());
    if (count == 0) {
        throw new BeanDefinitionValidationException("Invalid method override: no method with name '" + mo.getMethodName() + "' on class [" + this.getBeanClassName() + "]");
    } else {
        if (count == 1) {
        //标记方法暂时未被覆盖
            mo.setOverloaded(false);
        }

    }
}

在定义bean的时候有两个属性，lookup-method和replace-method,这里做了部分匹配工作以及方法的存在性验证，对于重载方法还需要参数类型验证，这里并没有完成。
接下来进入真正的创建bean的代码doCreateBean方法：

//存储BeanWrapper
private final ConcurrentMap<String, BeanWrapper> factoryBeanInstanceCache;
protected Object doCreateBean(String beanName, RootBeanDefinition mbd, @Nullable Object[] args) throws BeanCreationException {
    BeanWrapper instanceWrapper = null;
    //单例模式 尝试从缓存中获取
    if (mbd.isSingleton()) {
        instanceWrapper = (BeanWrapper)this.factoryBeanInstanceCache.remove(beanName);
    }
//instanceWrapper为null则进行创建
    if (instanceWrapper == null) {
        instanceWrapper = this.createBeanInstance(beanName, mbd, args);
    }
//获取实例及类型
    Object bean = instanceWrapper.getWrappedInstance();
    Class<?> beanType = instanceWrapper.getWrappedClass();
    if (beanType != NullBean.class) {
        mbd.resolvedTargetType = beanType;
    }

//匹配后处理器
    Object var7 = mbd.postProcessingLock;
    synchronized(mbd.postProcessingLock) {
        if (!mbd.postProcessed) {
            try {
                this.applyMergedBeanDefinitionPostProcessors(mbd, beanType, beanName);
            } catch (Throwable var17) {
                throw new BeanCreationException(mbd.getResourceDescription(), beanName, "Post-processing of merged bean definition failed", var17);
            }
//允许后处理
            mbd.postProcessed = true;
        }
    }
//提前曝光 = 单例 & 允许循环依赖 & 当前单例正在创建中
    boolean earlySingletonExposure = mbd.isSingleton() && this.allowCircularReferences && this.isSingletonCurrentlyInCreation(beanName);
    if (earlySingletonExposure) {
        if (this.logger.isTraceEnabled()) {
            this.logger.trace("Eagerly caching bean '" + beanName + "' to allow for resolving potential circular references");
        }
//在bean初始化完成前将ObjectFactory加入工厂，目的是为了解决循环依赖，通过上面的创建过程结合这里的代码，也就解释清楚了为什么不允许构造函数循环依赖
        this.addSingletonFactory(beanName, () -> {
        //AOP就是在这里动态的织入advice的
            return this.getEarlyBeanReference(beanName, mbd, bean);
        });
    }

    Object exposedObject = bean;

    try {
    //属性填充，可能依赖其他bean
        this.populateBean(beanName, mbd, instanceWrapper);
        //调用初始化方法 比如init-method 这里生成的才是最终想要的bean
        exposedObject = this.initializeBean(beanName, exposedObject, mbd);
    } catch (Throwable var18) {
        if (var18 instanceof BeanCreationException && beanName.equals(((BeanCreationException)var18).getBeanName())) {
            throw (BeanCreationException)var18;
        }

        throw new BeanCreationException(mbd.getResourceDescription(), beanName, "Initialization of bean failed", var18);
    }

    if (earlySingletonExposure) {
    //earlySingletonReference  检测到依赖则不为null  对缓存的维护 
        Object earlySingletonReference = this.getSingleton(beanName, false);
        if (earlySingletonReference != null) {
        //当exposedObject等于原始的bean，说明不是proxy，则把缓存中的bean赋值给exposedObject 
            if (exposedObject == bean) {
                exposedObject = earlySingletonReference;
                //检测其依赖的bean是否初始化完毕
            } else if (!this.allowRawInjectionDespiteWrapping && this.hasDependentBean(beanName)) {
                String[] dependentBeans = this.getDependentBeans(beanName);
                Set<String> actualDependentBeans = new LinkedHashSet(dependentBeans.length);
                String[] var12 = dependentBeans;
                int var13 = dependentBeans.length;

                for(int var14 = 0; var14 < var13; ++var14) {
                    String dependentBean = var12[var14];
                    if (!this.removeSingletonIfCreatedForTypeCheckOnly(dependentBean)) {
                        actualDependentBeans.add(dependentBean);
                    }
                }
//没有则抛出异常，依赖bean应该都创建好了
                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.");
                }
            }
        }
    }

    try {
    //注册需要销毁的bean
        this.registerDisposableBeanIfNecessary(beanName, bean, mbd);
        return exposedObject;
    } catch (BeanDefinitionValidationException var16) {
        throw new BeanCreationException(mbd.getResourceDescription(), beanName, "Invalid destruction signature", var16);
    }
}

先进入createBeanInstance方法：

protected BeanWrapper createBeanInstance(String beanName, RootBeanDefinition mbd, @Nullable Object[] args) {
//解析Class
    Class<?> beanClass = this.resolveBeanClass(mbd, beanName, new Class[0]);
    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());
    } else {
    //Supplier java提供的用来创造对象的接口
        Supplier<?> instanceSupplier = mbd.getInstanceSupplier();
        if (instanceSupplier != null) {
            return this.obtainFromSupplier(instanceSupplier, beanName);
            //工厂方法不为空则使用工厂方法
        } else if (mbd.getFactoryMethodName() != null) {
            return this.instantiateUsingFactoryMethod(beanName, mbd, args);
        } else {
        //根据构造方法创建
            boolean resolved = false;
            boolean autowireNecessary = false;
            //无参
            if (args == null) {
                Object var8 = mbd.constructorArgumentLock;
                synchronized(mbd.constructorArgumentLock) {
                    if (mbd.resolvedConstructorOrFactoryMethod != null) {
                        resolved = true;
                        autowireNecessary = mbd.constructorArgumentsResolved;
                    }
                }
            }
//带参 
//已解析
            if (resolved) {
            //是否使用构造函数注入？构造函数注入：默认函数注入
                return autowireNecessary ? this.autowireConstructor(beanName, mbd, (Constructor[])null, (Object[])null) : this.instantiateBean(beanName, mbd);
                //未解析
            } else {
            //根据需要的参数解析构造函数
                Constructor<?>[] ctors = this.determineConstructorsFromBeanPostProcessors(beanClass, beanName);
                if (ctors == null && mbd.getResolvedAutowireMode() != 3 && !mbd.hasConstructorArgumentValues() && ObjectUtils.isEmpty(args)) {
                    ctors = mbd.getPreferredConstructors();
                    return ctors != null ? this.autowireConstructor(beanName, mbd, ctors, (Object[])null) : this.instantiateBean(beanName, mbd);
                } else {
                    return this.autowireConstructor(beanName, mbd, ctors, args);
                }
            }
        }
    }
}

autowireConstructor方法代码量非常大，但是总体来说做了两件事，确定构造函数，调用实例化策略的instantiateBean方法创建实例并加入到BeanWrapper中。而instantiateBean同样也是调用了实例化策略的instantiateBean方法：

protected BeanWrapper instantiateBean(String beanName, RootBeanDefinition mbd) {
try {
    Object beanInstance;
    if (System.getSecurityManager() != null) {
        beanInstance = AccessController.doPrivileged(() -> {
            return thisx.getInstantiationStrategy().instantiate(mbd, beanName, this);
        }, this.getAccessControlContext());
    } else {
        beanInstance = this.getInstantiationStrategy().instantiate(mbd, beanName, this);
    }

    BeanWrapper bw = new BeanWrapperImpl(beanInstance);
    this.initBeanWrapper(bw);
    return bw;
} catch (Throwable var6) {
    throw new BeanCreationException(mbd.getResourceDescription(), beanName, "Instantiation of bean failed", var6);
}
}

首先看实例化策略，也就是getInstantiationStrategy方法，在AbstractAutowireCapableBeanFactory类中：

private InstantiationStrategy instantiationStrategy;
//无参构造中的语句
this.instantiationStrategy = new CglibSubclassingInstantiationStrategy();
public void setInstantiationStrategy(InstantiationStrategy instantiationStrategy) {
this.instantiationStrategy = instantiationStrategy;
}

protected InstantiationStrategy getInstantiationStrategy() {
return this.instantiationStrategy;
}

显而意见，如果用户不去设置，则默认的就是CglibSubclassingInstantiationStrategy类的实例，而CglibSubclassingInstantiationStrategy则是SimpleInstantiationStrategy类的子类，instantiate也是在SimpleInstantiationStrategy类中实现的：

public Object instantiate(RootBeanDefinition bd, @Nullable String beanName, BeanFactory owner) {
//如果用户配置了lookup-method或者replace-mathed 则创建代理
// 没有则进行反射
    if (!bd.hasMethodOverrides()) {
        Object var5 = bd.constructorArgumentLock;
        Constructor constructorToUse;
        //解析并获取构造函数
        synchronized(bd.constructorArgumentLock) {
            constructorToUse = (Constructor)bd.resolvedConstructorOrFactoryMethod;
            if (constructorToUse == null) {
                Class<?> clazz = bd.getBeanClass();
                if (clazz.isInterface()) {
                    throw new BeanInstantiationException(clazz, "Specified class is an interface");
                }

                try {
                    if (System.getSecurityManager() != null) {
                        clazz.getClass();
                        constructorToUse = (Constructor)AccessController.doPrivileged(() -> {
                            return clazz.getDeclaredConstructor();
                        });
                    } else {
                        constructorToUse = clazz.getDeclaredConstructor();
                    }

                    bd.resolvedConstructorOrFactoryMethod = constructorToUse;
                } catch (Throwable var9) {
                    throw new BeanInstantiationException(clazz, "No default constructor found", var9);
                }
            }
        }
//调用BeanUtils的instantiateClass方法
        return BeanUtils.instantiateClass(constructorToUse, new Object[0]);
    } else {
    //其实是个抛异常的方法，但是子类CglibSubclassingInstantiationStrategy实现了重写
        return this.instantiateWithMethodInjection(bd, beanName, owner);
    }
}

反射的具体过程这里就不看了，直接进入CglibSubclassingInstantiationStrategy类重写的instantiateWithMethodInjection方法：

protected Object instantiateWithMethodInjection(RootBeanDefinition bd, @Nullable String beanName, BeanFactory owner) {
    return this.instantiateWithMethodInjection(bd, beanName, owner, (Constructor)null);
}
protected Object instantiateWithMethodInjection(RootBeanDefinition bd, @Nullable String beanName, BeanFactory owner, @Nullable Constructor<?> ctor, Object... args) {
   return (new CglibSubclassingInstantiationStrategy.CglibSubclassCreator(bd, owner)).instantiate(ctor, args);
}

public Object instantiate(@Nullable Constructor<?> ctor, Object... args) {
//创建代理类
    Class<?> subclass = this.createEnhancedSubclass(this.beanDefinition);
    //实例化
    Object instance;
    if (ctor == null) {
        instance = BeanUtils.instantiateClass(subclass);
    } else {
        try {
            Constructor<?> enhancedSubclassConstructor = subclass.getConstructor(ctor.getParameterTypes());
            instance = enhancedSubclassConstructor.newInstance(args);
        } catch (Exception var6) {
            throw new BeanInstantiationException(this.beanDefinition.getBeanClass(), "Failed to invoke constructor for CGLIB enhanced subclass [" + subclass.getName() + "]", var6);
        }
    }
//设置拦截器增强
    Factory factory = (Factory)instance;
    factory.setCallbacks(new Callback[]{NoOp.INSTANCE, new CglibSubclassingInstantiationStrategy.LookupOverrideMethodInterceptor(this.beanDefinition, this.owner), new CglibSubclassingInstantiationStrategy.ReplaceOverrideMethodInterceptor(this.beanDefinition, this.owner)});
    //返回代理实例
    return instance;
}

终于完成了实例的创建，可以返回doCreateBean函数了。当bean创建完毕之后，需要进行属性填充以及调用初始化方法，当然也可能没有，初始化方法中也存在一些其他逻辑，最后则是收尾工作，检测依赖以及注册需要销毁的bean，就不再进入代码详细分析了。doCreateBean方法结束后其实一直返回会发现关于bean的创建基本上已经结束了，其他的逻辑比较简单。至此关于bean的创建告一段落。

如果有不正确的地方欢迎指正。