AbstractAutowireCapableBeanFactory#createBean()创建Bean实例主流程

1.AbstractAutowireCapableBeanFactory#createBean()主流程

    protected Object createBean(String beanName, RootBeanDefinition mbd, @Nullable Object[] args)
            throws BeanCreationException {

        if (logger.isTraceEnabled()) {
            logger.trace("Creating instance of bean '" + beanName + "'");
        }
        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.
        //判断当前mbd中的class是否已经加载到jvm，如果未加载，则使用类加载器将classStr加载到Jvm中，并且返回Class对象
        Class resolvedClass = resolveBeanClass(mbd, beanName);
        //条件一：拿到mbd实例化对象时的真实Class对象。
        //条件二（!mbd.hasBeanClass()）：条件成立，说明mbd在resolveBeanClass之前，是没有Class对象的。
        //条件三：成立，说明mbd有ClassName
        if (resolvedClass != null && !mbd.hasBeanClass() && mbd.getBeanClassName() != null) {
            mbdToUse = new RootBeanDefinition(mbd);
            mbdToUse.setBeanClass(resolvedClass);
        }

        // Prepare method overrides.
        try {
            // 对XML标签中定义的lookUp属性进行预处理，如果只能根据名字找到一个就标记为非重载的，这样在后续就不需要去推断到底是哪个方法了，
            // 对于@LookUp注解标注的方法是不需要在这里处理的，AutowiredAnnotationBeanPostProcessor会处理这个注解
            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.
            //可以通过后处理器，在这一步返回一个代理实例对象..注意，这里的代理对象不是Spring AOP 逻辑实现的地方。
            //instantiation 实例化不要和init 搞混。
            //后处理器调用点：创建实例之前的一个调用点。
            // 它的另外一个作用就是对AOP提供了支持，在这里会将一些不需要被代理的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实例对象，并且生命周期的动作大部分都在这里
            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);
        }
    }

2.短路操作resolveBeforeInstantiation()

    protected 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 = applyBeanPostProcessorsBeforeInstantiation(targetType, beanName);
                    if (bean != null) {
                        bean = applyBeanPostProcessorsAfterInitialization(bean, beanName);
                    }
                }
            }
            mbd.beforeInstantiationResolved = (bean != null);
        }
        return bean;
    }

这里跟FactoryBean#getObject()会调用BeanPostProcessor#postProcessAfterInitialization()一样，也会调用这个方法，因为这里创建的bean也没有经过完整的生命周期，但是也会调用后置处理器初始化后的方法。

使用示例：

public class MyInstantiationAwareBeanPostProcessor implements InstantiationAwareBeanPostProcessor {

    /**
     * InstantiationAwareBeanPostProcessor中自定义的方法
     * 在方法实例化之前执行  Bean对象还没有
     */
    @Override
    public Object postProcessBeforeInstantiation(Class beanClass, String beanName) throws BeansException {
        System.out.println("--->postProcessBeforeInstantiation");

        // 利用cglib动态代理生成对象返回
        if (beanClass == Student.class) {
            Enhancer e = new Enhancer();
            e.setSuperclass(beanClass);
            e.setCallback(new MethodInterceptor() {
                @Override
                public Object intercept(Object obj, Method method, Object[] objects, MethodProxy methodProxy) throws Throwable {

                    System.out.println("目标方法执行前:" + method);
                    Object object = methodProxy.invokeSuper(obj, objects);
                    System.out.println("目标方法执行后:" + method + "\n");
                    return object;
                }
            });
            Student student = (Student) e.create();
            // 返回代理类
            return student;
        }

        return null;
    }
}

配置：

结果：

目标方法执行前:public void com.wz.spring.instantiation.Student.study()
因为学习让我们相遇...
目标方法执行后:public void com.wz.spring.instantiation.Student.study()

3.AbstractAutowireCapableBeanFactory#doCreateBean主流程

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

        // Instantiate the bean.
        //包装对象，内部最核心的字段就是咱们的真实实例。它提供了一些额外的接口方法，比如 属性访问器
        BeanWrapper instanceWrapper = null;
        if (mbd.isSingleton()) {
            instanceWrapper = this.factoryBeanInstanceCache.remove(beanName);
        }
        if (instanceWrapper == null) {
            //该方法创建出来真实的bean实例，并且将其包装到BeanWrapper实例中。
            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 {
                    //后处理器调用点：合并bd信息，因为接下来就是populate处理依赖了..
                    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));
        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 {
            //处理当前实例的依赖数据...依赖注入在这一步完成的。
            populateBean(beanName, mbd, instanceWrapper);
            //生命周期中的初始化方法的调用。
            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);
            //条件成立：说明当前bean实例 从 2级缓存获取到了...
            //说明产生循环依赖了...3级缓存 当前对象的ObjectFactory.getObject() 被调用过
            if (earlySingletonReference != null) {
                //条件成立有几种情况？
                //1.当前“真实实例”不需要被代理
                //2.当前“实例”已经被代理过了...是在ObjectFactory.getObject() 方法调用时 实现的增强代理。
                if (exposedObject == bean) {
                    exposedObject = earlySingletonReference;
                }
                else if (!this.allowRawInjectionDespiteWrapping && hasDependentBean(beanName)) {
                    //获取依赖当前bean的 其它beanName
                    String[] dependentBeans = getDependentBeans(beanName);
                    Set actualDependentBeans = new LinkedHashSet<>(dependentBeans.length);
                    for (String dependentBean : dependentBeans) {
                        if (!removeSingletonIfCreatedForTypeCheckOnly(dependentBean)) {
                            actualDependentBeans.add(dependentBean);
                        }
                    }
                    //为什么有问题？
                    //因为咱们当前对象的AOP操作是在 当前方法的 initializeBean 这个方法完成的。
                    //在这之前 外部其它bean持有到的当前的 “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 " +
                                "'getBeanNamesForType' with the 'allowEagerInit' flag turned off, for example.");
                    }
                }
            }
        }

        // Register bean as disposable.
        try {
            //判断当前bean实例是否需要注册 析构回调。当容器销毁时，会给当前bean的析构方法进行回调。
            registerDisposableBeanIfNecessary(beanName, bean, mbd);
        }
        catch (BeanDefinitionValidationException ex) {
            throw new BeanCreationException(
                    mbd.getResourceDescription(), beanName, "Invalid destruction signature", ex);
        }

        return exposedObject;
    }

3.1 this.factoryBeanInstanceCache.remove(beanName)关于FactoryBean

// 这里申明了一个FactoryBean,并且通过@DependsOn注解申明了这个FactoryBean的创建要在orderService之后，主要目的是为了在DmzFactoryBean创建前让容器发生一次属性注入
@Component
@DependsOn("orderService")
public class DmzFactoryBean implements FactoryBean {
 @Override
 public DmzService getObject() throws Exception {
  return new DmzService();
 }

 @Override
 public Class getObjectType() {
  return DmzService.class;
 }
}

// 没有通过注解的方式将它放到容器中，而是通过上面的DmzFactoryBean来管理对应的Bean
public class DmzService {
}

// OrderService中需要注入dmzService
@Component
public class OrderService {
 @Autowired
 DmzService dmzService;
}

DmzFactoryBean是依赖于orderService的，所以必定会先创建orderService再创建DmzFactoryBean。
orderService属性注入阶段：

为orderService进行属性注入可以分为这么几步

• 找到需要注入的注入点，也就是orderService中的dmzService字段
• 根据字段的类型以及名称去容器中查询符合要求的Bean
• 当遍历到一个FactroyBean时，为了确定其getObject方法返回的对象的类型需要创建这个FactroyBean（只会到对象级别），然后调用这个创建好的FactroyBean的getObjectType方法明确其类型并与注入点需要的类型比较，看是否是一个候选的Bean，在创建这个FactroyBean时就将其放入了factoryBeanInstanceCache中。
• 在确定了唯一的候选Bean之后，Spring就会对这个Bean进行创建，创建的过程又经过三个步骤

在创建对象时，因为此时factoryBeanInstanceCache已经缓存了这个Bean对应的对象，所以直接通过this.factoryBeanInstanceCache.remove(beanName)这行代码就返回了，避免了二次创建对象。

3.2 扩展点applyMergedBeanDefinitionPostProcessors()

        // Allow post-processors to modify the merged bean definition.
        synchronized (mbd.postProcessingLock) {
            if (!mbd.postProcessed) {
                try {
                    //后处理器调用点：合并bd信息，因为接下来就是populate处理依赖了..
                    applyMergedBeanDefinitionPostProcessors(mbd, beanType, beanName);
                }
                catch (Throwable ex) {
                    throw new BeanCreationException(mbd.getResourceDescription(), beanName,
                            "Post-processing of merged bean definition failed", ex);
                }
                mbd.postProcessed = true;
            }
        }

    protected void applyMergedBeanDefinitionPostProcessors(RootBeanDefinition mbd, Class beanType, String beanName) {
        for (BeanPostProcessor bp : getBeanPostProcessors()) {
            //AutowiredAnnotationBeanPostProcessor.postProcessMergedBeanDefinition
            //做了一件事：提取出来当前beanType类型整个继承体系内的 @Autowired @Value @Inject 信息 并且包装成一个InjectionMetadata的一个
            //对象，存放到 AutowiredAnnotationBeanPostProcessor 它的缓存中了，key是 beanName。
            if (bp instanceof MergedBeanDefinitionPostProcessor) {
                MergedBeanDefinitionPostProcessor bdp = (MergedBeanDefinitionPostProcessor) bp;
                bdp.postProcessMergedBeanDefinition(mbd, beanType, beanName);
            }
        }
    }

重点看看AutowiredAnnotationBeanPostProcessor#postProcessMergedBeanDefinition：

AutowiredAnnotationBeanPostProcessor.postProcessMergedBeanDefinition做了一件事：提取出来当前beanType类型整个继承体系内的 @Autowired @Value @Inject 信息 并且包装成一个InjectionMetadata的一个对象，存放到 AutowiredAnnotationBeanPostProcessor 它的缓存中了，key是 beanName。

    public void postProcessMergedBeanDefinition(RootBeanDefinition beanDefinition, Class beanType, String beanName) {
        InjectionMetadata metadata = findAutowiringMetadata(beanName, beanType, null);
        metadata.checkConfigMembers(beanDefinition);
    }

    private InjectionMetadata findAutowiringMetadata(String beanName, Class clazz, @Nullable PropertyValues pvs) {
        // Fall back to class name as cache key, for backwards compatibility with custom callers.
        String cacheKey = (StringUtils.hasLength(beanName) ? beanName : clazz.getName());
        // Quick check on the concurrent map first, with minimal locking.
        InjectionMetadata metadata = this.injectionMetadataCache.get(cacheKey);
        if (InjectionMetadata.needsRefresh(metadata, clazz)) {
            synchronized (this.injectionMetadataCache) {
                metadata = this.injectionMetadataCache.get(cacheKey);
                if (InjectionMetadata.needsRefresh(metadata, clazz)) {
                    if (metadata != null) {
                        metadata.clear(pvs);
                    }
                    // 获取当前clazz关注的@Autowired @Value @Inject注解信息
                    metadata = buildAutowiringMetadata(clazz);
                    this.injectionMetadataCache.put(cacheKey, metadata);
                }
            }
        }
        return metadata;
    }

3.3 依赖注入populateBean()

详情请参考：https://www.jianshu.com/p/bbf51b8553d9?v=1670512502259

3.4 初始化initializeBean()

    protected Object initializeBean(String beanName, Object bean, @Nullable RootBeanDefinition mbd) {
        if (System.getSecurityManager() != null) {
            AccessController.doPrivileged((PrivilegedAction