Object beanInstance = doCreateBean(beanName, mbdToUse, args);
    protected Object doCreateBean(String beanName, RootBeanDefinition mbd, @Nullable Object[] args)
            throws BeanCreationException {
        // Instantiate the bean.
        BeanWrapper instanceWrapper = null;
        if (mbd.isSingleton()) {
            // bean实例Wrapper 对象
            instanceWrapper = this.factoryBeanInstanceCache.remove(beanName);
        }
        if (instanceWrapper == null) {
            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 {
                    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);
            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;
    }

尝试从FactoryBean的缓存中获取
获取不到，则实例化bean
MergedBeanDefinitionPostProcessor的应用，Autowired注解正是通过此方法实现诸如类型的预解析
依赖处理：若允许循环依赖，需要将bean提前放入三级缓存中
属性填充
初始化bean
循环依赖检查
注册DisposableBean

完成创建并返回

从FactoryBean获取

FactoryBeanMap中存放的是 factoryBeanName —> FactoryBean#getObject()的对象;

创建实例bean

protected BeanWrapper createBeanInstance(String beanName, RootBeanDefinition mbd, @Nullable Object[] args) {
     // Make sure bean class is actually resolved at this point.
     Class<?> 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());
     }
     Supplier<?> 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...
     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);
         }
     }
     // Candidate constructors for autowiring?
     Constructor<?>[] ctors = determineConstructorsFromBeanPostProcessors(beanClass, beanName);
     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.
     return instantiateBean(beanName, mbd);
 }

若RootBeanDefinition中存在factoryMethodName则使用instantiateUsingFactoryMethod

解析使用哪个构造函数，并用它进行实例化

`autowireConstructor(beanName, mbd, null, null)`

 public BeanWrapper autowireConstructor(String beanName, RootBeanDefinition mbd,
         @Nullable Constructor<?>[] chosenCtors, @Nullable Object[] explicitArgs) {
     BeanWrapperImpl bw = new BeanWrapperImpl();
     this.beanFactory.initBeanWrapper(bw);
     Constructor<?> constructorToUse = null;
     ArgumentsHolder argsHolderToUse = null;
     Object[] argsToUse = null;
     if (explicitArgs != null) {
         argsToUse = explicitArgs;
     }
     else {
         Object[] argsToResolve = null;
         synchronized (mbd.constructorArgumentLock) {
             constructorToUse = (Constructor<?>) mbd.resolvedConstructorOrFactoryMethod;
             if (constructorToUse != null && mbd.constructorArgumentsResolved) {
                 // Found a cached constructor...
                 argsToUse = mbd.resolvedConstructorArguments;
                 if (argsToUse == null) {
                     argsToResolve = mbd.preparedConstructorArguments;
                 }
             }
         }
         if (argsToResolve != null) {
             argsToUse = resolvePreparedArguments(beanName, mbd, bw, constructorToUse, argsToResolve);
         }
     }
     if (constructorToUse == null || argsToUse == null) {
         // Take specified constructors, if any.
         Constructor<?>[] candidates = chosenCtors;
         if (candidates == null) {
             Class<?> beanClass = mbd.getBeanClass();
             try {
                 candidates = (mbd.isNonPublicAccessAllowed() ?
                         beanClass.getDeclaredConstructors() : beanClass.getConstructors());
             }
             catch (Throwable ex) {
                 throw new BeanCreationException(mbd.getResourceDescription(), beanName,
                         "Resolution of declared constructors on bean Class [" + beanClass.getName() +
                         "] from ClassLoader [" + beanClass.getClassLoader() + "] failed", ex);
             }
         }
         if (candidates.length == 1 && explicitArgs == null && !mbd.hasConstructorArgumentValues()) {
             Constructor<?> uniqueCandidate = candidates[0];
             if (uniqueCandidate.getParameterCount() == 0) {
                 synchronized (mbd.constructorArgumentLock) {
                     mbd.resolvedConstructorOrFactoryMethod = uniqueCandidate;
                     mbd.constructorArgumentsResolved = true;
                     mbd.resolvedConstructorArguments = EMPTY_ARGS;
                 }
                 bw.setBeanInstance(instantiate(beanName, mbd, uniqueCandidate, EMPTY_ARGS));
                 return bw;
             }
         }
         // Need to resolve the constructor.
         boolean autowiring = (chosenCtors != null ||
                 mbd.getResolvedAutowireMode() == AutowireCapableBeanFactory.AUTOWIRE_CONSTRUCTOR);
         ConstructorArgumentValues resolvedValues = null;
         int minNrOfArgs;
         if (explicitArgs != null) {
             minNrOfArgs = explicitArgs.length;
         }
         else {
             ConstructorArgumentValues cargs = mbd.getConstructorArgumentValues();
             resolvedValues = new ConstructorArgumentValues();
             minNrOfArgs = resolveConstructorArguments(beanName, mbd, bw, cargs, resolvedValues);
         }
         AutowireUtils.sortConstructors(candidates);
         int minTypeDiffWeight = Integer.MAX_VALUE;
         Set<Constructor<?>> ambiguousConstructors = null;
         Deque<UnsatisfiedDependencyException> causes = null;
         for (Constructor<?> candidate : candidates) {
             int parameterCount = candidate.getParameterCount();
             if (constructorToUse != null && argsToUse != null && argsToUse.length > parameterCount) {
                 // Already found greedy constructor that can be satisfied ->
                 // do not look any further, there are only less greedy constructors left.
                 break;
             }
             if (parameterCount < minNrOfArgs) {
                 continue;
             }
             ArgumentsHolder argsHolder;
             Class<?>[] paramTypes = candidate.getParameterTypes();
             if (resolvedValues != null) {
                 try {
                     String[] paramNames = ConstructorPropertiesChecker.evaluate(candidate, parameterCount);
                     if (paramNames == null) {
                         ParameterNameDiscoverer pnd = this.beanFactory.getParameterNameDiscoverer();
                         if (pnd != null) {
                             paramNames = pnd.getParameterNames(candidate);
                         }
                     }
                     argsHolder = createArgumentArray(beanName, mbd, resolvedValues, bw, paramTypes, paramNames,
                             getUserDeclaredConstructor(candidate), autowiring, candidates.length == 1);
                 }
                 catch (UnsatisfiedDependencyException ex) {
                     if (logger.isTraceEnabled()) {
                         logger.trace("Ignoring constructor [" + candidate + "] of bean '" + beanName + "': " + ex);
                     }
                     // Swallow and try next constructor.
                     if (causes == null) {
                         causes = new ArrayDeque<>(1);
                     }
                     causes.add(ex);
                     continue;
                 }
             }
             else {
                 // Explicit arguments given -> arguments length must match exactly.
                 if (parameterCount != explicitArgs.length) {
                     continue;
                 }
                 argsHolder = new ArgumentsHolder(explicitArgs);
             }
             int typeDiffWeight = (mbd.isLenientConstructorResolution() ?
                     argsHolder.getTypeDifferenceWeight(paramTypes) : argsHolder.getAssignabilityWeight(paramTypes));
             // Choose this constructor if it represents the closest match.
             if (typeDiffWeight < minTypeDiffWeight) {
                 constructorToUse = candidate;
                 argsHolderToUse = argsHolder;
                 argsToUse = argsHolder.arguments;
                 minTypeDiffWeight = typeDiffWeight;
                 ambiguousConstructors = null;
             }
             else if (constructorToUse != null && typeDiffWeight == minTypeDiffWeight) {
                 if (ambiguousConstructors == null) {
                     ambiguousConstructors = new LinkedHashSet<>();
                     ambiguousConstructors.add(constructorToUse);
                 }
                 ambiguousConstructors.add(candidate);
             }
         }
         if (constructorToUse == null) {
             if (causes != null) {
                 UnsatisfiedDependencyException ex = causes.removeLast();
                 for (Exception cause : causes) {
                     this.beanFactory.onSuppressedException(cause);
                 }
                 throw ex;
             }
             throw new BeanCreationException(mbd.getResourceDescription(), beanName,
                     "Could not resolve matching constructor " +
                     "(hint: specify index/type/name arguments for simple parameters to avoid type ambiguities)");
         }
         else if (ambiguousConstructors != null && !mbd.isLenientConstructorResolution()) {
             throw new BeanCreationException(mbd.getResourceDescription(), beanName,
                     "Ambiguous constructor matches found in bean '" + beanName + "' " +
                     "(hint: specify index/type/name arguments for simple parameters to avoid type ambiguities): " +
                     ambiguousConstructors);
         }
         if (explicitArgs == null && argsHolderToUse != null) {
             argsHolderToUse.storeCache(mbd, constructorToUse);
         }
     }
     Assert.state(argsToUse != null, "Unresolved constructor arguments");
     bw.setBeanInstance(instantiate(beanName, mbd, constructorToUse, argsToUse));
     return bw;
 }

构造函数参数的确定

若入参中传入了explicitArgs,则直接确定参数，进而确定使用哪个构造函数。
从缓存中获取
分析xml配置文件中的信息

构造函数确定

根据参数的个数进行匹配
若指定参数名，可以通过ParameterNameDiscoverer工具类获取

转换对应的参数类型
构造函数不确定性验证

根据实例化策略实例化bean

instantiateBean(beanName, mbd);

无参的，也就是没有必要注入其他依赖的情况

 protected BeanWrapper instantiateBean(String beanName, RootBeanDefinition mbd) {
     try {
         Object beanInstance;
         if (System.getSecurityManager() != null) {
             beanInstance = AccessController.doPrivileged(
                     (PrivilegedAction<Object>) () -> getInstantiationStrategy().instantiate(mbd, beanName, this),
                     getAccessControlContext());
         }
         else {
             beanInstance = getInstantiationStrategy().instantiate(mbd, beanName, this);
         }
         BeanWrapper bw = new BeanWrapperImpl(beanInstance);
         initBeanWrapper(bw);
         return bw;
     }
     catch (Throwable ex) {
         throw new BeanCreationException(
                 mbd.getResourceDescription(), beanName, "Instantiation of bean failed", ex);
     }
 }

根据实例化策略进行实例化

实例化策略

上面实例化bean都涉及了一个实例化策略的问题

若没有look-up或者replace-method方法，则直接反射

否则，通过Cblib创建

记录创建bean的ObjectFactory

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

getEarlyBeanReference

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

调用了SmartInstantiationAwareBeanPostProcessor的处理器方法

属性注入

protected void populateBean(String beanName, RootBeanDefinition mbd, @Nullable BeanWrapper bw) {
     if (bw == null) {
         if (mbd.hasPropertyValues()) {
             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.
     if (!mbd.isSynthetic() && hasInstantiationAwareBeanPostProcessors()) {
         for (InstantiationAwareBeanPostProcessor bp : getBeanPostProcessorCache().instantiationAware) {
             if (!bp.postProcessAfterInstantiation(bw.getWrappedInstance(), beanName)) {
                 return;
             }
         }
     }
     PropertyValues pvs = (mbd.hasPropertyValues() ? mbd.getPropertyValues() : null);
     int resolvedAutowireMode = mbd.getResolvedAutowireMode();
     if (resolvedAutowireMode == AUTOWIRE_BY_NAME || resolvedAutowireMode == AUTOWIRE_BY_TYPE) {
         MutablePropertyValues newPvs = new MutablePropertyValues(pvs);
         // Add property values based on autowire by name if applicable.
         if (resolvedAutowireMode == AUTOWIRE_BY_NAME) {
             autowireByName(beanName, mbd, bw, newPvs);
         }
         // Add property values based on autowire by type if applicable.
         if (resolvedAutowireMode == AUTOWIRE_BY_TYPE) {
             autowireByType(beanName, mbd, bw, newPvs);
         }
         pvs = newPvs;
     }
     boolean hasInstAwareBpps = hasInstantiationAwareBeanPostProcessors();
     boolean needsDepCheck = (mbd.getDependencyCheck() != AbstractBeanDefinition.DEPENDENCY_CHECK_NONE);
     PropertyDescriptor[] filteredPds = null;
     if (hasInstAwareBpps) {
         if (pvs == null) {
             pvs = mbd.getPropertyValues();
         }
         for (InstantiationAwareBeanPostProcessor bp : getBeanPostProcessorCache().instantiationAware) {
             PropertyValues pvsToUse = bp.postProcessProperties(pvs, bw.getWrappedInstance(), beanName);
             if (pvsToUse == null) {
                 if (filteredPds == null) {
                     filteredPds = filterPropertyDescriptorsForDependencyCheck(bw, mbd.allowCaching);
                 }
                 pvsToUse = bp.postProcessPropertyValues(pvs, filteredPds, bw.getWrappedInstance(), beanName);
                 if (pvsToUse == null) {
                     return;
                 }
             }
             pvs = pvsToUse;
         }
     }
     if (needsDepCheck) {
         if (filteredPds == null) {
             filteredPds = filterPropertyDescriptorsForDependencyCheck(bw, mbd.allowCaching);
         }
         checkDependencies(beanName, mbd, filteredPds, pvs);
     }
     if (pvs != null) {
         applyPropertyValues(beanName, mbd, bw, pvs);
     }
 }

执行InstantiationAwareBeanPostProcessor,此函数可以控制是否继续进行属性填充
获取propertyValues,并根据装配类型，补充PropertyValues
应用InstantiationAwareBeanPostProcessor处理器的postProcessPropertyValues方法，对属性获取完毕填充前对属性的再次处理，典型应用是RequiredAnnotationBeanPostProcessor类中对属性的验证
将所有PropertyValues中的属性填充至BeanWrapper中
autowireByName

autowireByType

初始化bean

protected Object initializeBean(String beanName, Object bean, @Nullable RootBeanDefinition mbd) {
        if (System.getSecurityManager() != null) {
            AccessController.doPrivileged((PrivilegedAction<Object>) () -> {
                invokeAwareMethods(beanName, bean);
                return null;
            }, getAccessControlContext());
        }
        else {
            invokeAwareMethods(beanName, bean);
        }
        Object wrappedBean = bean;
        if (mbd == null || !mbd.isSynthetic()) {
            wrappedBean = applyBeanPostProcessorsBeforeInitialization(wrappedBean, beanName);
        }
        try {
            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()) {
            wrappedBean = applyBeanPostProcessorsAfterInitialization(wrappedBean, beanName);
        }
        return wrappedBean;
    }

调用Aware方法

Aware方法只对以下方法进行注入

private void invokeAwareMethods(String beanName, Object bean) {
        if (bean instanceof Aware) {
            if (bean instanceof BeanNameAware) {
                ((BeanNameAware) bean).setBeanName(beanName);
            }
            if (bean instanceof BeanClassLoaderAware) {
                ClassLoader bcl = getBeanClassLoader();
                if (bcl != null) {
                    ((BeanClassLoaderAware) bean).setBeanClassLoader(bcl);
                }
            }
            if (bean instanceof BeanFactoryAware) {
                ((BeanFactoryAware) bean).setBeanFactory(AbstractAutowireCapableBeanFactory.this);
            }
        }
    }

BeanNameAware
BeanClassLoaderAware

BeanFactoryAware

处理器的应用

     Object wrappedBean = bean;
     if (mbd == null || !mbd.isSynthetic()) {
         //before
         wrappedBean = applyBeanPostProcessorsBeforeInitialization(wrappedBean, beanName);
     }
     try {
         //。。。。。
         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()) {
         //after
         wrappedBean = applyBeanPostProcessorsAfterInitialization(wrappedBean, beanName);
     }

调用初始化方法前后分别使用BeanPostProcessor的postProcessBeforeInitialization或postProcessAfterInitialization

自定义init方法

 protected void invokeInitMethods(String beanName, Object bean, @Nullable RootBeanDefinition mbd)
         throws Throwable {
     boolean isInitializingBean = (bean instanceof InitializingBean);
     if (isInitializingBean && (mbd == null || !mbd.isExternallyManagedInitMethod("afterPropertiesSet"))) {
         if (logger.isTraceEnabled()) {
             logger.trace("Invoking afterPropertiesSet() on bean with name '" + beanName + "'");
         }
         if (System.getSecurityManager() != null) {
             try {
                 AccessController.doPrivileged((PrivilegedExceptionAction<Object>) () -> {
                     ((InitializingBean) bean).afterPropertiesSet();
                     return null;
                 }, getAccessControlContext());
             }
             catch (PrivilegedActionException pae) {
                 throw pae.getException();
             }
         }
         else {
             ((InitializingBean) bean).afterPropertiesSet();
         }
     }
     if (mbd != null && bean.getClass() != NullBean.class) {
         String initMethodName = mbd.getInitMethodName();
         if (StringUtils.hasLength(initMethodName) &&
                 !(isInitializingBean && "afterPropertiesSet".equals(initMethodName)) &&
                 !mbd.isExternallyManagedInitMethod(initMethodName)) {
             invokeCustomInitMethod(beanName, bean, mbd);
         }
     }
 }

InitializingBean的afterPropertiesSet()
invokeCustomInitMethod调用自定义初始化方法

注册DisposableBean

    protected void registerDisposableBeanIfNecessary(String beanName, Object bean, RootBeanDefinition mbd) {
        AccessControlContext acc = (System.getSecurityManager() != null ? getAccessControlContext() : null);
        if (!mbd.isPrototype() && requiresDestruction(bean, mbd)) {
            if (mbd.isSingleton()) {
                // Register a DisposableBean implementation that performs all destruction
                // work for the given bean: DestructionAwareBeanPostProcessors,
                // DisposableBean interface, custom destroy method.
                registerDisposableBean(beanName, new DisposableBeanAdapter(
                        bean, beanName, mbd, getBeanPostProcessorCache().destructionAware, acc));
            }
            else {
                // A bean with a custom scope...
                Scope scope = this.scopes.get(mbd.getScope());
                if (scope == null) {
                    throw new IllegalStateException("No Scope registered for scope name '" + mbd.getScope() + "'");
                }
                scope.registerDestructionCallback(beanName, new DisposableBeanAdapter(
                        bean, beanName, mbd, getBeanPostProcessorCache().destructionAware, acc));
            }
        }
    }

public DisposableBeanAdapter(Object bean, String beanName, RootBeanDefinition beanDefinition,
            List<DestructionAwareBeanPostProcessor> postProcessors, @Nullable AccessControlContext acc) {
        Assert.notNull(bean, "Disposable bean must not be null");
        this.bean = bean;
        this.beanName = beanName;
        this.invokeDisposableBean =
                (this.bean instanceof DisposableBean && !beanDefinition.isExternallyManagedDestroyMethod("destroy"));
        this.nonPublicAccessAllowed = beanDefinition.isNonPublicAccessAllowed();
        this.acc = acc;
        String destroyMethodName = inferDestroyMethodIfNecessary(bean, beanDefinition);
        if (destroyMethodName != null && !(this.invokeDisposableBean && "destroy".equals(destroyMethodName)) &&
                !beanDefinition.isExternallyManagedDestroyMethod(destroyMethodName)) {
            this.destroyMethodName = destroyMethodName;
            Method destroyMethod = determineDestroyMethod(destroyMethodName);
            if (destroyMethod == null) {
                if (beanDefinition.isEnforceDestroyMethod()) {
                    throw new BeanDefinitionValidationException("Could not find a destroy method named '" +
                            destroyMethodName + "' on bean with name '" + beanName + "'");
                }
            }
            else {
                if (destroyMethod.getParameterCount() > 0) {
                    Class<?>[] paramTypes = destroyMethod.getParameterTypes();
                    if (paramTypes.length > 1) {
                        throw new BeanDefinitionValidationException("Method '" + destroyMethodName + "' of bean '" +
                                beanName + "' has more than one parameter - not supported as destroy method");
                    }
                    else if (paramTypes.length == 1 && boolean.class != paramTypes[0]) {
                        throw new BeanDefinitionValidationException("Method '" + destroyMethodName + "' of bean '" +
                                beanName + "' has a non-boolean parameter - not supported as destroy method");
                    }
                }
                destroyMethod = ClassUtils.getInterfaceMethodIfPossible(destroyMethod);
            }
            this.destroyMethod = destroyMethod;
        }
        this.beanPostProcessors = filterPostProcessors(postProcessors, bean);
    }

DestructionAwareBeanPostProcessor
DisposableBean/destroy-method

如上的两个内容都会被注册

雨润工作笔记

常规bean创建-doCreateBean