本文转载https://conan.blog.csdn.net/article/details/79572387#comments_13341441

在我们的开发工作中应该都见过或使用过FactoryBean这个类，也许你会看成了BeanFactory这个类。FactoryBean和BeanFactory虽然长的很像，但是他们的作用确实完全不像。这里你可以想象一下，你会在什么样的场景下使用FactoryBean这个接口？FactoryBean是一个工厂Bean，可以生成某一个类型Bean实例，它最大的一个作用是：可以让我们自定义Bean的创建过程。BeanFactory是Spring容器中的一个基本类也是很重要的一个类，在BeanFactory中可以创建和管理Spring容器中的Bean，它对于Bean的创建有一个统一的流程。下面我们先看一下FactoryBean中有什么东西：

public interface FactoryBean<T> {

    //返回的对象实例
    T getObject() throws Exception;
    //Bean的类型
    Class<?> getObjectType();
    //true是单例，false是非单例  在Spring5.0中此方法利用了JDK1.8的新特性变成了default方法，返回true
    boolean isSingleton();
}

从上面的代码中我们发现在FactoryBean中定义了一个Spring Bean的很重要的三个特性：是否单例、Bean类型、Bean实例，这也应该是我们关于Spring中的一个Bean最直观的感受。虽然没有返回BeanName的值，但是我们也知道BeanName的值。下面我们来写一个关于FactoryBean的小例子，看看我们是怎么使用FactoryBean的，然后再从源码的角度看看Spring是怎么解析FactoryBean中的Bean的。

//FactoryBean接口的实现类
@Component
public class FactoryBeanLearn implements FactoryBean {

    @Override
    public Object getObject() throws Exception {
        //这个Bean是我们自己new的，这里我们就可以控制Bean的创建过程了
        return new FactoryBeanServiceImpl();
    }

    @Override
    public Class<?> getObjectType() {
        return FactoryBeanService.class;
    }

    @Override
    public boolean isSingleton() {
        return true;
    }
}
//接口
public interface FactoryBeanService {

    /**
     * 测试FactoryBean
     */
    void testFactoryBean();
}
//实现类
public class FactoryBeanServiceImpl implements FactoryBeanService {
    /**
     * 测试FactoryBean
     */
    @Override
    public void testFactoryBean() {
        System.out.println("我是FactoryBean的一个测试类。。。。");
    }
}
//单测
@Test
public void test() {
        ClassPathXmlApplicationContext cac = new ClassPathXmlApplicationContext("classpath:com/zkn/spring/learn/base/applicationContext.xml");
        FactoryBeanService beanService = cac.getBean(FactoryBeanService.class);
        beanService.testFactoryBean();
    }

我们的输出结果如下：

从上面的代码中我们可以看到我们从Spring容器中获取了FactoryBeanService类型的Bean。那么这个获取Bean的过程Spring是怎么处理的呢？它是怎么从FactoryBean中获取我们自己创建的Bean实例的呢？我们先从getBean这个方法看起，因为在Spring的AbstractApplicationContext中有很多重载的getBean方法，这里我们调用的是根据Type(指Class类型)来获取的Bean信息。我们传入的type是FactoryBeanService类型。

getBean

AbstractApplicationContext#getBean(java.lang.Class)

    @Override
    public <T> T getBean(Class<T> requiredType) throws BeansException {
        //检测BeanFactory的激活状态
        assertBeanFactoryActive();
        //getBeanFactory()获取到的是一个DefaultListableBeanFactory的实例
        //所以我们去DefaultListableBeanFactory中看一下getBean这个方法
        return getBeanFactory().getBean(requiredType);
    }

DefaultListableBeanFactory#getBean(java.lang.Class)

    @Override
    public <T> T getBean(Class<T> requiredType) throws BeansException {
        return getBean(requiredType, (Object[]) null);
    }
    @Override
    public <T> T getBean(Class<T> requiredType, Object... args) throws BeansException {
        //解析Bean
        NamedBeanHolder<T> namedBean = resolveNamedBean(requiredType, args);
        if (namedBean != null) {
            return namedBean.getBeanInstance();
        }
        //如果当前Spring容器中没有获取到相应的Bean信息，则从父容器中获取
        //SpringMVC是一个很典型的父子容器
        BeanFactory parent = getParentBeanFactory();
        if (parent != null) {
            //一个重复的调用过程，只不过BeanFactory的实例变了
            return parent.getBean(requiredType, args);
        }
        //如果都没有获取到，则抛出异常
        throw new NoSuchBeanDefinitionException(requiredType);
    }

在上面的代码中，我们重点关注的是resolveNamedBean这个方法：

在上面的代码中我们说我们传入的type是com.zkn.spring.learn.service.FactoryBeanService类型，但是在我们的Spring容器中却没有FactoryBeanService类型的Bean，那么我们是怎么从getBeanNamesForType获取到beanName的呢？
getBeanNamesForType的分析

    public String[] getBeanNamesForType(Class<?> type, boolean includeNonSingletons, boolean allowEagerInit) {
        if (!isConfigurationFrozen() || type == null || !allowEagerInit) {
            return doGetBeanNamesForType(ResolvableType.forRawClass(type), includeNonSingletons, allowEagerInit);
        }
        //先从缓存中获取
        Map<Class<?>, String[]> cache =
                (includeNonSingletons ? this.allBeanNamesByType : this.singletonBeanNamesByType);
        String[] resolvedBeanNames = cache.get(type);
        if (resolvedBeanNames != null) {
            return resolvedBeanNames;
        }
        //调用doGetBeanNamesForType方法获取beanName
        resolvedBeanNames = doGetBeanNamesForType(ResolvableType.forRawClass(type), includeNonSingletons, true);
        //所传入的类能不能被当前类加载加载
        if (ClassUtils.isCacheSafe(type, getBeanClassLoader())) {
            //放入到缓存中，解析一次以后从缓存中获取
            //这里对应到我们这里 key是FactoryBeanService Value是beanFactoryLearn
            cache.put(type, resolvedBeanNames);
        }
        return resolvedBeanNames;
    }

doGetBeanNamesForType的分析

在上面的代码中，我们可以知道的是我们的FactoryBeanLearn是一个FactoryBean类型的类。所以在上面的代码中会调用isTypeMatch这个方法来判断FactoryBeanLearn是不是和我们传入的类型相匹配。这里是值：FactoryBeanService类。我们去isTypeMatch方法中去看一下它是怎么进行类型匹配判断的：由于isTypeMatch方法很长，这里我们只看和我们这次分析相关的一部分代码

    public boolean isTypeMatch(String name, ResolvableType typeToMatch) throws NoSuchBeanDefinitionException {
        //转换beanName   这里我们可以知道我们的beanName为factoryBeanLearn 因为上面是循环了Spring容器中的所有的Bean
        String beanName = transformedBeanName(name);
        //因为我们这里是用的AbstractApplicationContext的子类来从Spring容器中获取Bean
        //获取beanName为factoryBeanLearn的Bean实例 这里是可以获取到Bean实例的
        //这里有一个问题：使用AbstractApplicationContext的子类从Spring容器中获取Bean和
        //使用BeanFactory的子类从容器中获取Bean有什么区别？这个可以思考一下
        Object beanInstance = getSingleton(beanName, false);
        if (beanInstance != null) {
            //factoryBeanLearn是FactoryBean的一个实现类
            if (beanInstance instanceof FactoryBean) {
                //这里判断beanName是不是以&开头  这里明显不是 这里可以想一下什么情况下会有&开头的Bean
                if (!BeanFactoryUtils.isFactoryDereference(name)) {
                    //这里就是从factoryBeanLearn中获type类型 我们在下面会分析一下这个类
                    Class<?> type = getTypeForFactoryBean((FactoryBean<?>) beanInstance);
                    //从factoryBeanLearn中获取到的type类型和我们传入的类型是不是同一种类型 是的话直接返回
                    return (type != null && typeToMatch.isAssignableFrom(type));
                }
                else {
                    return typeToMatch.isInstance(beanInstance);
                }
            }

getTypeForFactoryBean

    protected Class<?> getTypeForFactoryBean(final FactoryBean<?> factoryBean) {
        try {
            if (System.getSecurityManager() != null) {
                return AccessController.doPrivileged(new PrivilegedAction<Class<?>>() {
                    @Override
                    public Class<?> run() {
                        return factoryBean.getObjectType();
                    }
                }, getAccessControlContext());
            }
            else {
                //看到这里是不是很熟悉了 调用FactoryBean实例的getObjectType()方法
                return factoryBean.getObjectType();
            }
        }
    }

我们在调用factoryBeanLearn的getObjectType方法的时候，获取到的值为：com.zkn.spring.learn.service.FactoryBeanService和我们传入的type是一样的类型。所以这里返回true，根据我们上面说的如果isTypeMatch返回true的话，我们返回的beanName为factoryBeanLearn。
上面的分析总结起来是：我们调用getBean(Class requiredType)方法根据类型来获取容器中的bean的时候，对应我们的例子就是：根据类型com.zkn.spring.learn.service.FactoryBeanService来从Spring容器中获取Bean(首先明确的一点是在Spring容器中没有FactoryBeanService类型的BeanDefinition。但是却有一个Bean和FactoryBeanService这个类型有一些关系)。Spring在根据type去获取Bean的时候，会先获取到beanName。获取beanName的过程是：先循环Spring容器中的所有的beanName，然后根据beanName获取对应的BeanDefinition，如果当前bean是FactoryBean的类型，则会从Spring容器中根据beanName获取对应的Bean实例，接着调用获取到的Bean实例的getObjectType方法获取到Class类型，判断此Class类型和我们传入的Class是否是同一类型。如果是则返回测beanName，对应到我们这里就是：根据factoryBeanLearn获取到FactoryBeanLearn实例，调用FactoryBeanLearn的getObjectType方法获取到返回值FactoryBeanService.class。和我们传入的类型一致，所以这里获取的beanName为factoryBeanLearn。换句话说这里我们把factoryBeanLearn这个beanName映射为了：FactoryBeanService类型。即FactoryBeanService类型对应的beanName为factoryBeanLearn这是很重要的一点。在这里我们也看到了FactoryBean中三个方法中的