AbstractAutowireCapableBeanFactory#createBean()方法

protected Object createBean(String beanName, RootBeanDefinition mbd, @Nullable Object[] args)throws BeanCreationException {if (logger.isTraceEnabled()) {logger.trace("Creating instance of bean '" + beanName + "'");}//到这个方法创建Bean的时候beanDefinition的类型必须是RootBeanDefinition//RootBeanDefinition是顶级的父类BeanDefinition，是不允许再有父亲的BeanDefinition的//在调用这个方法之前，是会进行BeanDefinition的封装和合并的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.//加载beanclass，将bean的class拿出来加载到jvm中Class<?> resolvedClass = resolveBeanClass(mbd, beanName);if (resolvedClass != null && !mbd.hasBeanClass() && mbd.getBeanClassName() != null) {//加载成功过后，然后创建一个对象RootBeanDefinition，这个RootBeanDefinition就是最终创建的单例对象放入到单例池mbdToUse = new RootBeanDefinition(mbd);mbdToUse.setBeanClass(resolvedClass);}// Prepare method overrides.try {//检查是否有方法重载 避免args类型检查开销//lookup-mehtod标签 replace-method 标签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.//上面的的英文是官方解释：给一个创建一个代理对象bean的机会在bean的后置处理器中//简单来说就是这里是提供给程序员实现的方法，比如你想代理一些bean，那么你就可以实现相关的后置处理器//比如aop，或者你想为一些bean添加一些职责，那么只要返回不为空，spring就不会为你创建bean了，会直接用你创建的bean//这个方法可以叫做bean的实例化前，可以简单这样理解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);}try {//这个创建bean是spring容器自带的创建bean，也就是代码走到这里，则证明需要spring来创建bean了//一般在spring项目中，普通的bean一般都会在这里由spring来创建，而特殊的Bean可能在上面由resolveBeforeInstantiation//来直接创建了Object beanInstance = doCreateBean(beanName, mbdToUse, args);if (logger.isTraceEnabled()) {logger.trace("Finished creating instance of bean '" + beanName + "'");}return beanInstance;}catch (BeanCreationException | ImplicitlyAppearedSingletonException ex) {// A previously detected exception with proper bean creation context already,// or illegal singleton state to be communicated up to DefaultSingletonBeanRegistry.throw ex;}catch (Throwable ex) {throw new BeanCreationException(mbdToUse.getResourceDescription(), beanName, "Unexpected exception during bean creation", ex);}}

AbstractAutowireCapableBeanFactory#resolveBeforeInstantiation()方法

/*** Apply before-instantiation post-processors, resolving whether there is a* before-instantiation shortcut for the specified bean.* @param beanName the name of the bean* @param mbd the bean definition for the bean* @return the shortcut-determined bean instance, or {@code null} if none* 这个方法其实就是调用bean的后置处理器，bean的后置处理器有点多，分为* 实例化前、实例化后、调用aware后、初始化前、初始化后* 而下面这个方法就是在bean的实例化之前调用的，而这个方法是返回一个对象* 所以如果说你这个方法调用完毕过后，返回的一个对象不为空，那么就说明你的bean已经存在了，已经有了* 那么就不会在调用你后面的调用aware就是不会再调用spring提供的创建Bean的方法了* 但是如果applyBeanPostProcessorsBeforeInstantiation返回的对象不为空，那么spring还猜想你可能还有* 实例化的一些操作，所以这里还要调用那个实例化后的bean后置处理器applyBeanPostProcessorsAfterInitialization* 按正常的逻辑，spring会通过实例化前、实例化后、调用aware后、初始化前、初始化后来调用后置处理器，但是下的这个方法* 是你人为的干预了spring的实例化和初始化，那么你既然实例化了，那么就自己去调用初始化后的一些后置处理器，* 请注意，这个方法也不会调用后面的aware方法了*/@Nullableprotected Object resolveBeforeInstantiation(String beanName, RootBeanDefinition mbd) {Object bean = null;if (!Boolean.FALSE.equals(mbd.beforeInstantiationResolved)) {// Make sure bean class is actually resolved at this point.if (!mbd.isSynthetic() && hasInstantiationAwareBeanPostProcessors()) {Class<?> targetType = determineTargetType(beanName, mbd);if (targetType != null) {//是调用的bean的实例化的后置处理器bean = applyBeanPostProcessorsBeforeInstantiation(targetType, beanName);if (bean != null) {//如果返回的bean不为空，则证明spring不会去调用它自己的createBean方法了，因为你返回了对象//所以下面还要看你有没有自己的bean初始化后的逻辑，如果有就调用，所以卫生么这个方法有//bean的实例化前的方法和bean初始化后的方法//是调用的bean的初始化后置处理器bean = applyBeanPostProcessorsAfterInitialization(bean, beanName);}}}mbd.beforeInstantiationResolved = (bean != null);}return bean;}

AbstractAutowireCapableBeanFactory#doCreateBean()方法

protected Object doCreateBean(String beanName, RootBeanDefinition mbd, @Nullable Object[] args)throws BeanCreationException {// Instantiate the bean.BeanWrapper instanceWrapper = null;if (mbd.isSingleton()) {//单例bean//从缓存中获取instanceWrapper = this.factoryBeanInstanceCache.remove(beanName);}if (instanceWrapper == null) {//没有 则创建bean//bean的实例化，里面包含了推断构造方法，简单来说就是对bean进行实例化，这个方法后面来讲instanceWrapper = createBeanInstance(beanName, mbd, args);}Object bean = instanceWrapper.getWrappedInstance();Class<?> beanType = instanceWrapper.getWrappedClass();if (beanType != NullBean.class) {mbd.resolvedTargetType = beanType;}// Allow post-processors to modify the merged bean definition.synchronized (mbd.postProcessingLock) {if (!mbd.postProcessed) {try {//spring提供的又一个bean后置处理器，就是在bean实例化完成过后，可以进行调用//这个后置处理器可以传入指定的BeanDefinition，也就是你可以改变BeanDefinition的属性//但是这个时候bean都已经实例化完成了，就算你修改了beanclass也没有用了//但是有些属性我们还是可以设置的，比如可以手动设置初始化的方法mbd.setInitMethodName//@AutoWired注解的切入点就是在这个后置处理器中找到的并且注入到缓存中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.//当前bean 是否需要早期暴露boolean earlySingletonExposure = (mbd.isSingleton() && this.allowCircularReferences &&isSingletonCurrentlyInCreation(beanName));if (earlySingletonExposure) {if (logger.isTraceEnabled()) {logger.trace("Eagerly caching bean '" + beanName +"' to allow for resolving potential circular references");}//和循环依赖有关，后面讲addSingletonFactory(beanName, () -> getEarlyBeanReference(beanName, mbd, bean));}// Initialize the bean instance.Object exposedObject = bean;try {/*** 填充属性，处理@AutoWried，调用bean的实例化后的方法*/populateBean(beanName, mbd, instanceWrapper);/*** 这个方法是调用bean的初始化方法的*/exposedObject = initializeBean(beanName, exposedObject, mbd);}catch (Throwable ex) {if (ex instanceof BeanCreationException && beanName.equals(((BeanCreationException) ex).getBeanName())) {throw (BeanCreationException) ex;}else {throw new BeanCreationException(mbd.getResourceDescription(), beanName, "Initialization of bean failed", ex);}}//下面是依赖注入的代码，这个后面说if (earlySingletonExposure) {Object earlySingletonReference = getSingleton(beanName, false);if (earlySingletonReference != null) {if (exposedObject == bean) {exposedObject = earlySingletonReference;}else if (!this.allowRawInjectionDespiteWrapping && hasDependentBean(beanName)) {String[] dependentBeans = getDependentBeans(beanName);Set<String> actualDependentBeans = new LinkedHashSet<>(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 " +"'getBeanNamesForType' with the 'allowEagerInit' flag turned off, for example.");}}}}// Register bean as disposable.try {registerDisposableBeanIfNecessary(beanName, bean, mbd);}catch (BeanDefinitionValidationException ex) {throw new BeanCreationException(mbd.getResourceDescription(), beanName, "Invalid destruction signature", ex);}return exposedObject;}

AbstractAutowireCapableBeanFactory#createBeanInstance()方法

protected BeanWrapper createBeanInstance(String beanName, RootBeanDefinition mbd, @Nullable Object[] args) {// Make sure bean class is actually resolved at this point.//解析bean 获取ClassClass<?> beanClass = resolveBeanClass(mbd, beanName);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());}//是否有bean的Supplier接口 如果有通过回调来创建beanSupplier<?> instanceSupplier = mbd.getInstanceSupplier();if (instanceSupplier != null) {return obtainFromSupplier(instanceSupplier, beanName);}//如果工厂方法不为空 则通过工厂方法创建if (mbd.getFactoryMethodName() != null) {return instantiateUsingFactoryMethod(beanName, mbd, args);}// Shortcut when re-creating the same bean...// 标记下，防止重复创建同一个beanboolean resolved = false;// 是否需要自动装配boolean autowireNecessary = false;if (args == null) {//参数未空 则通过synchronized (mbd.constructorArgumentLock) {// 因为一个类可能由多个构造函数，所以需要根据配置文件中配置的参数或传入的参数来确定最终调用的构造函数。// 因为判断过程会比较，所以spring会将解析、确定好的构造函数缓存到BeanDefinition中的resolvedConstructorOrFactoryMethod字段中。// 在下次创建相同时直接从RootBeanDefinition中的属性resolvedConstructorOrFactoryMethod缓存的值获取，避免再次解析if (mbd.resolvedConstructorOrFactoryMethod != null) {resolved = true;autowireNecessary = mbd.constructorArgumentsResolved;}}}// 有构造参数的或者工厂方法if (resolved) {// 构造器有参数if (autowireNecessary) {// 构造函数自动注入return autowireConstructor(beanName, mbd, null, null);}else {// 使用默认构造函数构造return instantiateBean(beanName, mbd);}}// Candidate constructors for autowiring?// 从bean后置处理器中为自动装配寻找构造方法, 有且仅有一个有参构造或者有且仅有@Autowired注解构造Constructor<?>[] ctors = determineConstructorsFromBeanPostProcessors(beanClass, beanName);// 以下情况符合其一即可进入// 1、存在可选构造方法// 2、自动装配模型为构造函数自动装配// 3、给BeanDefinition中设置了构造参数值// 4、有参与构造函数参数列表的参数if (ctors != null || mbd.getResolvedAutowireMode() == AUTOWIRE_CONSTRUCTOR ||mbd.hasConstructorArgumentValues() || !ObjectUtils.isEmpty(args)) {return autowireConstructor(beanName, mbd, ctors, args);}// Preferred constructors for default construction?// 找出最合适的默认构造方法ctors = mbd.getPreferredConstructors();if (ctors != null) {// 构造函数自动注入return autowireConstructor(beanName, mbd, ctors, null);}// No special handling: simply use no-arg constructor.// 使用默认无参构造函数创建对象，如果没有无参构造且存在多个有参构造且没有@AutoWired注解构造，会报错return instantiateBean(beanName, mbd);}

DefaultSingletonBeanRegistry#addSingletonFactory()方法

/*** Add the given singleton factory for building the specified singleton* if necessary.* <p>To be called for eager registration of singletons, e.g. to be able to* resolve circular references.* @param beanName the name of the bean* @param singletonFactory the factory for the singleton object*  将ObjectFactory 添加到三级缓存中*/protected void addSingletonFactory(String beanName, ObjectFactory<?> singletonFactory) {Assert.notNull(singletonFactory, "Singleton factory must not be null");synchronized (this.singletonObjects) {if (!this.singletonObjects.containsKey(beanName)) {this.singletonFactories.put(beanName, singletonFactory);this.earlySingletonObjects.remove(beanName);this.registeredSingletons.add(beanName);}}}

AbstractAutowireCapableBeanFactory#getEarlyBeanReference()方法

protected Object getEarlyBeanReference(String beanName, RootBeanDefinition mbd, Object bean) {Object exposedObject = bean;if (!mbd.isSynthetic() && hasInstantiationAwareBeanPostProcessors()) {for (BeanPostProcessor bp : getBeanPostProcessors()) {if (bp instanceof SmartInstantiationAwareBeanPostProcessor) {SmartInstantiationAwareBeanPostProcessor ibp = (SmartInstantiationAwareBeanPostProcessor) bp;exposedObject = ibp.getEarlyBeanReference(exposedObject, beanName);}}}return exposedObject;}