参考博文: https://blog.csdn.net/f641385712/article/details/88651128

从宏观上看，AutowireCapableBeanFactory提供了如下能力：

1 为已经实例化的对象装配属性，这些属性对象都是Spring管理的；

2 实例化一个Bean，并自动装配，这些被装配的属性对象都是Spring管理的，但是实例化的Bean可以不被Spring管理（这点特别重要）。所以这个接口提供功能就是自动装配bean相关的

(自动装配的原对象可以不在Spring的IOC容器里，但是需要被依赖注入的成员，就必须是Spring容器管辖的Bean)
 此接口主要是针对框架之外，没有向Spring托管Bean的应用。通过暴露此功能，Spring框架之外的程序，也能具有自动装配的能力（此接口赋予它的）。

可以使用这个接口集成其它框架。捆绑并填充（注入）并不由Spring管理生命周期并已存在的实例.像集成WebWork的Actions 和Tapestry Page就很实用
 一般应用开发者不会使用这个接口,所以像ApplicationContext这样的外观实现类不会实现这个接口,

但是提供了getAutowireCapableBeanFactory()方法允许你拿这个工具去做你需要的事。

接口定义:

public interface AutowireCapableBeanFactory01 extends BeanFactory {
/**
* 表明工厂没有自动装配的Bean
*/
int AUTOWIRE_NO = 0;

/\*\*  
 \* 表明根据名称自动装配  
 \*/  
int AUTOWIRE\_BY\_NAME = 1;

/\*\*  
 \* 表明根据类型自动装配  
 \*/  
int AUTOWIRE\_BY\_TYPE = 2;

/\*\*  
 \* 表明根据构造方法快速装配  
 \*/  
int AUTOWIRE\_CONSTRUCTOR = 3;

@Deprecated  
// 表明通过Bean的class的内部来自动装配 Spring3.0被弃用。  
int AUTOWIRE\_AUTODETECT = 4;

String ORIGINAL\_INSTANCE\_SUFFIX = ".ORIGINAL";

/\*\*  
 \* 创建一个指定class的实例  
 \*/  
<T> T createBean(Class<T> beanClass) throws BeansException;

/\*\*  
 \* 通过调用给定Bean的after-instantiation及post-processing接口，对bean进行配置  
 \*/  
void autowireBean(Object existingBean) throws BeansException;

/\*\*  
 \* 自动装配属性,填充属性值,使用诸如setBeanName,setBeanFactory这样的工厂回调填充属性,最好还要调用post processor  
 \*/  
Object configureBean(Object existingBean, String beanName) throws BeansException;

/\*\*  
 \* 创建一个指定class的实例，通过参数可以指定其自动装配模式（by-name or by-type）.  
 \*/  
Object createBean(Class<?> beanClass, int autowireMode, boolean dependencyCheck) throws BeansException;

/\*\*  
 \* 通过指定的自动装配策略来初始化一个Bean  
 \*/  
Object autowire(Class<?> beanClass, int autowireMode, boolean dependencyCheck) throws BeansException;

/\*\*  
 \* 通过指定的自动装配方式来对给定的Bean进行自动装配  
 \*/  
void autowireBeanProperties(Object existingBean, int autowireMode, boolean dependencyCheck)  
        throws BeansException;

/\*\*  
 \* 将参数中指定了那么的Bean，注入给定实例当中  
 \*/  
void applyBeanPropertyValues(Object existingBean, String beanName) throws BeansException;

/\*\*  
 \* 初始化参数中指定的Bean，调用任何其注册的回调函数如setBeanName、setBeanFactory等。  
 \*/  
Object initializeBean(Object existingBean, String beanName) throws BeansException;

/\*\*  
 \* 调用参数中指定Bean的postProcessBeforeInitialization方法  
 \*/  
Object applyBeanPostProcessorsBeforeInitialization(Object existingBean, String beanName)  
        throws BeansException;

/\*\*  
 \* 调用参数中指定Bean的postProcessAfterInitialization方法  
 \*/  
Object applyBeanPostProcessorsAfterInitialization(Object existingBean, String beanName)  
        throws BeansException;

/\*\*  
 \* 销毁参数中指定的Bean，同时调用此Bean上的DisposableBean和DestructionAwareBeanPostProcessors方法  
 \*/  
void destroyBean(Object existingBean);

/\*\*  
 \* 查找唯一符合指定类的实例，如果有，则返回实例的名字和实例本身  
 \* 底层依赖于：BeanFactory中的getBean(Class)方法  
 \*/  
<T> NamedBeanHolder<T> resolveNamedBean(Class<T> requiredType) throws BeansException;

/\*\*  
 \* 解析出在Factory中与指定Bean有指定依赖关系的Bean（@Autowired依赖注入的核心方法）  
 \*/  
Object resolveBeanByName(String name, DependencyDescriptor descriptor) throws BeansException;

@Nullable  
Object resolveDependency(DependencyDescriptor descriptor, @Nullable String requestingBeanName) throws BeansException;

@Nullable  
Object resolveDependency(DependencyDescriptor descriptor, @Nullable String requestingBeanName,  
                         @Nullable Set<String> autowiredBeanNames, @Nullable TypeConverter typeConverter) throws BeansException;  

}

准备一个外部类,即不被spring容器管理:

public class Person {

//不使用@Autowired  
private User user;

public User getUser() {  
    return user;  
}

public void setUser(User user) {  
    this.user = user;  
}  

}

spring管理的User bean进行实例化,这里以spring-bean.xml为例:

利用AutowireCapableBeanFactory创建Bean:

public class BeanTest{
@Test
public void beanTest(){
ClassPathXmlApplicationContext applicationContext = new ClassPathXmlApplicationContext("spring-bean.xml");
//ApplicationContext没有实现接口,但是可以通过方法直接获取使用
AutowireCapableBeanFactory autowireCapableBeanFactory = applicationContext.getAutowireCapableBeanFactory();
// autowireCapableBeanFactory创建Bean实例,执行多次就创建多个
Person person = (Person) autowireCapableBeanFactory.createBean(Person.class, AutowireCapableBeanFactory.AUTOWIRE_BY_TYPE, false);
//没有@Autowired注解也直接给注入了
System.out.println("获取自动注入的属性:"+person.getUser());
//异常: No qualifying bean of type 'com.hou.spring.Person' available
Person bean = applicationContext.getBean(Person.class);//没有交给spring容器管理
System.out.println(bean);
}
}

执行结果:

不使用接口测试:

主要从createBean方法进行分析:

_这个接口调用的方法是在_AbstractAutowireCapableBeanFactory抽象类中实现的:

@Override  
public Object createBean(Class<?> beanClass, int autowireMode, boolean dependencyCheck) throws BeansException {  
    // Use non-singleton bean definition, to avoid registering bean as dependent bean.  
    RootBeanDefinition bd = new RootBeanDefinition(beanClass, autowireMode, dependencyCheck);  
    //这里设置为原型,而不是单例,所以调用多次会生成多个对象  
    bd.setScope(BeanDefinition.SCOPE\_PROTOTYPE);  
    return createBean(beanClass.getName(), bd, null);  
}

然后就是return里面调用的createBean方法,这个是_AbstractAutowireCapableBeanFactory类的父类AbstractBeanFactory定义的抽象方法:
_

AbstractAutowireCapableBeanFactory类中实现了这个抽象方法,这个方法很单纯：创建一个实例，然后初始化他（给属性们赋值），然后return出去即可:

@Override  
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.  
    Class<?> resolvedClass = resolveBeanClass(mbd, beanName);  
    if (resolvedClass != null && !mbd.hasBeanClass() && mbd.getBeanClassName() != null) {  
        mbdToUse = new RootBeanDefinition(mbd);  
        mbdToUse.setBeanClass(resolvedClass);  
    }

    try {  
        mbdToUse.prepareMethodOverrides();  
    }  
    catch (BeanDefinitionValidationException ex) {  
        throw new BeanDefinitionStoreException(mbdToUse.getResourceDescription(),  
                beanName, "Validation of method overrides failed", ex);  
    }

    try {  
        //若BeanPostProcessors 产生了一个代理对象，就不需要我去创建了，就不继续往下走了（AOP都走这里）  
        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 {  
        //本类的一个protected方法，专门用于处理创建Bean的过程（包括属性赋值之类的）  
        Object beanInstance = doCreateBean(beanName, mbdToUse, args);  
        if (logger.isTraceEnabled()) {  
            logger.trace("Finished creating instance of bean '" + beanName + "'");  
        }  
        return beanInstance;  
    }  
    catch (BeanCreationException | ImplicitlyAppearedSingletonException ex) {  
        throw ex;  
    }  
    catch (Throwable ex) {  
        throw new BeanCreationException(  
                mbdToUse.getResourceDescription(), beanName, "Unexpected exception during bean creation", ex);  
    }  
}

再看本类的doCreateBean方法,主要有三个核心步骤三个步骤：createBeanInstance、populateBean、initializeBean:

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

    // Instantiate the bean.  
    BeanWrapper instanceWrapper = null;  
    if (mbd.isSingleton()) {  
        instanceWrapper = this.factoryBeanInstanceCache.remove(beanName);  
    }  
    if (instanceWrapper == null) {  
        //创建Bean实例,返回一个BeanWrapper,它也是本类的一个protected方法  
        instanceWrapper = createBeanInstance(beanName, mbd, args);  
    }  
    final Object bean = instanceWrapper.getWrappedInstance();  
    Class<?> beanType = instanceWrapper.getWrappedClass();  
    if (beanType != NullBean.class) {  
        mbd.resolvedTargetType = beanType;  
    }

    // 处理循环引用，现在若我们Bean不在容器里，肯定是不存在循环引用的（但是我依赖的Bean可能还没创建是真的，也是这里来处理的）  
    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));  
    }

    Object exposedObject = bean;  
    try {  
        //// 给Bean实例的各个属性进行赋值  
        populateBean(beanName, mbd, instanceWrapper);  
        //初始化Bean 执行一些初始化方法init @PostContruct方法等等  
        exposedObject = initializeBean(beanName, exposedObject, mbd);  
    }

其他具体细节以后其他博文专门记录笔记