首页 > > 程序设计 > Java技术 >

Spring Framework 组件注册 之 FactoryBean

2019-08-16 09:43:45来源：博客园 阅读 ()

新老客户大回馈,云服务器低至5折

Spring Framework 组件注册 之 FactoryBean

Spring Framework 组件注册 之 FactoryBean

前言

前两篇文章介绍了如何使用@Component，@Import注解来向spring容器中注册组件（javaBean），本文将介绍通过FactoryBean接口继续向spring容器中注册组件。可能第一印象是spring中BeanFactory接口，但是这里确实说的是FactoryBean。

推荐阅读

  • Spring Framework 组件注册 之 @Import
  • Spring Framework 组件注册 之 @Component

FactoryBean 与 BeanFactory

根据接口名称，我们也可以简单看出两者的区别

  • FactoryBean：它是spring中的一个Bean，只不过它是一个特殊的Bean（工厂Bean），我们可以通过它来自定义生产需要的普通JavaBean
  • BeanFactory：它是spring的Bean工厂，是spring最为重要的接口之一，spring通过此接口获取，管理容器中的各个Bean

接下来将进入本文正题，如何通过FactoryBean接口向spring容器中注册组件

FactoryBean简单使用

正如前面说的，FactoryBean也是spring中的一个Bean，但是它又是一个特殊的Bean，它的存在是为了生产其他的JavaBean。首先我们看看FactoryBean自身的接口定义

public interface FactoryBean<T> {
    /**
     * 从Spring容器中获取Bean时会调用此方法，返回一个T对象
     */
    @Nullable
    T getObject() throws Exception;

    /**
     * 此工厂Bean返回对象的类型
     */
    @Nullable
    Class<?> getObjectType();

    /**
     * 工厂Bean创建的对象是否为单例,
         * 如果返回false，说明getObject方法的实例对象不是单例的，
     * Spring每次从容器中获取T对象时，都调用getObject方法创建一个对象
     */
    default boolean isSingleton() {
        //spring 5 接口默认返回true（单例）
        return true;
    }
}

FactoryBean接口定义简单明了，就是用来获取一个Bean的基本信息，下面我们自己实现该接口，来生产一个javaBean

/**
 * 产生 Bike 对象的工厂Bean
 */
@Component
public class BikeFactoryBean implements FactoryBean<Bike> {

    public Bike getObject() throws Exception {
        System.out.println("......开始创建Bike对象......");
        return new Bike();
    }

    public Class<?> getObjectType() {
        return Bike.class;
    }

    public boolean isSingleton() {
        return true;
    }
}

自定义的一个JavaBean类

/**
 * 待注册的自定义组件
 */
@Data
public class Bike {
    private String id = "by FactoryBean";
}

添加spring容器启动的引导类

/**
 * spring 容器启动引导类，测试 FactoryBean 功能
 */
@ComponentScan("com.spring.study.ioc.factorybean")
public class TestFactoryBeanBootstrap {

    public static void main(String[] args) {
        AnnotationConfigApplicationContext applicationContext =
                new AnnotationConfigApplicationContext(TestFactoryBeanBootstrap.class);
        //获取工厂Bean本身的Id
        String[] beanNames = applicationContext.getBeanNamesForType(BikeFactoryBean.class);
        System.out.println("BikeFactoryBean names：" + Arrays.asList(beanNames));
        //获取工厂Bean产生的Bean的Id
        beanNames = applicationContext.getBeanNamesForType(Bike.class);
        System.out.println("Bike bean names：" + Arrays.asList(beanNames));
        Object bean = applicationContext.getBean("bikeFactoryBean");
        System.out.println(bean);
        bean = applicationContext.getBean(Bike.class);
        System.out.println(bean);
        // 获取工厂Bean 本身的实例对象
        bean = applicationContext.getBean(BeanFactory.FACTORY_BEAN_PREFIX + "bikeFactoryBean");
        System.out.println(bean);
        applicationContext.close();
    }
}

启动spring容器，控制台打印结果：

BikeFactoryBean names：[&bikeFactoryBean]
Bike bean names：[bikeFactoryBean]
......开始创建Bike对象......
Bike(id=by FactoryBean)
Bike(id=by FactoryBean)
com.spring.study.ioc.factorybean.BikeFactoryBean@4eb7f003

由结果可以看出

  • 虽然代码中只在BikeFactoryBean类上加了@Component注解，但是从spring容器仍然可以获取到Bike类的信息
  • 工厂Bean的Id与实际产生的Bean的Id仅差了一个&符，也就是说，工厂Bean定义的Id实际为getObject()方法返回Bean的Id，而工厂Bean本身的Id被添加了一个前缀&符
  • 工厂Bean的isSingleton()方法返回了true，所以通过spring容器多次获取实际的Bean时，getObject()方法也是执行一次
  • 根据工厂Bean的Id可以看出，要想从spring容器中获取工厂Bean本身，则需要在注册的Id前面添加一个&符，而此前缀在BeanFactory接口中已经定义了FACTORY_BEAN_PREFIX

如果将BikeFactoryBean的isSingleton()方法返回了false

 public boolean isSingleton() {
        return false;
 }

重新启动spring容器，可以看如下结果：

BikeFactoryBean names：[&bikeFactoryBean]
Bike bean names：[bikeFactoryBean]
......开始创建Bike对象......
Bike(id=by FactoryBean)
......开始创建Bike对象......
Bike(id=by FactoryBean)
com.spring.study.ioc.factorybean.BikeFactoryBean@4eb7f003

由结果可以看出，唯一的变化在于从spring容器中多次获取实际Bean时，工厂Bean的getObject()方法被多次进行了调用。这与spring容器中被标识为原型的普通Bean相同，每次从spring中获取Bean时都会被实例化。

FactoryBean 执行过程

要想了解FactoryBean的执行过程，就需要结合Spring容器启动的过程来进行分析。而spring容器的启动过程经过了纷繁复杂的步骤。为了尽可能少的入坑和挖坑，下面仅结合FactoryBean相关的源码进行说明。

在开始入坑之旅之前，结合前面的例子做几点说明，方便后续讲解

前面定义的 BikeFactoryBean 类上面直接添加了@Component注解，这样spring会默认以类名首字母小写(bikeFactoryBean)作为beanName；如果使用@Bean进行注册时，spring默认会以方法名作为beanName，下面继续以“BikeFactoryBean”为例。

  1. spring容器启动过程中，在执行完所有的BeanFactoryPostProcessor，BeanPostProcessor以及注册Listener后会执行org.springframework.context.support.AbstractApplicationContext#finishBeanFactoryInitialization()方法，此方法会对剩下所有的非Abstract、非LazyInit的单实例Bean进行实例化，以下为部分代码片段。
@Override
public void preInstantiateSingletons() throws BeansException {
        ...省略代码...
    // 1. 拷贝一份副本：spring容器中的所有的Bean名称
    List<String> beanNames = new ArrayList<>(this.beanDefinitionNames);
        // 2. 遍历每一个beanName，尝试通过getBean()方法进行实例化
        // 在getBean()方法内部会先尝试从容器singletonObjects中获取Bean，如果没有才会进行实例化操作
        for (String beanName : beanNames) {
            // 3. 通过beanName获取Bean定义信息 BeanDefinition
            RootBeanDefinition bd = getMergedLocalBeanDefinition(beanName);
        // 4. 根据BeanDefinition判断该Bean是否不是抽象的，单例的，非懒加载的
            if (!bd.isAbstract() && bd.isSingleton() && !bd.isLazyInit()) {
        // 5. 满足上面的条件后，在根据beanName判断此Bean是否是一个工厂Bean（实现了FactoryBean接口）
                if (isFactoryBean(beanName)) {
            // 6. 如果是一个工厂Bean，则在此处进行工厂Bean本身的实例化
                    Object bean = getBean(FACTORY_BEAN_PREFIX + beanName);
            ...省略代码...
                }
                else {
            // 如果不是工厂bean，也是调用getBean()方法进行实例化
                    getBean(beanName);
                }
            }
        }
        ...省略代码...
    }

preInstantiateSingletons()是在finishBeanFactoryInitialization()方法内部调用的

根据上面的代码流程，在第6步时，会对BikeFactoryBean类本身进行实例化，并且可以看出传递的beanName为初始注册的name前添加了&符前缀即&bikeFactoryBean，用于在genBean()方法内部标识它是一个工厂Bean。但是在跟踪源码后发现，在getBean()方法内部，会先将传入的beanName(&bikeFactoryBean)开头的&符去除，并且最终实例化Bean后，在容器中保存的beanName还是不带&符前缀的名称即bikeFactoryBean

  1. 根据第一步的结果，spring容器在启动后，工厂Bean会像普通Bean一样在spring容器中会保留一条自身的单实例Bean（spring容器中保存的数据为：<bikeFactoryBean, BikeFactoryBean>），既然spring容器中只保存了BikeFactoryBean本身，那么后续获取Bike类的beanName和Bean实例时，又是怎么获取到的呢？带着疑问，我们继续看后面的代码。首先，上面的例子中调用了applicationContext.getBeanNamesForType(Bike.class)方法来获取Bike类的beanName。所以继续跟踪此方法看看到底发生了什么。
    // getBeanNamesForType()方法内部最终调用了此方法，可断点跟踪至此
    private String[] doGetBeanNamesForType(ResolvableType type, boolean includeNonSingletons, boolean allowEagerInit) {
        // 用来保存符合条件的结果（beanName集合）
        List<String> result = new ArrayList<>();
        // 与上面的代码相似，遍历spring容器中注册的所有的beanNames
        for (String beanName : this.beanDefinitionNames) {
            if (!isAlias(beanName)) {
                try {
                    // 根据beanName获取Bean的定义信息 BeanDefinition
                    RootBeanDefinition mbd = getMergedLocalBeanDefinition(beanName);
                    // 根据BeanDefinition 进行检查
                    if (!mbd.isAbstract() && (allowEagerInit ||
                            (mbd.hasBeanClass() || !mbd.isLazyInit() || isAllowEagerClassLoading()) &&
                                    !requiresEagerInitForType(mbd.getFactoryBeanName()))) {
                        // 根据beanName和Bean的定义信息判断是否是工厂Bean
                        boolean isFactoryBean = isFactoryBean(beanName, mbd);
                        BeanDefinitionHolder dbd = mbd.getDecoratedDefinition();
                        boolean matchFound =
                                (allowEagerInit || !isFactoryBean ||
                                        (dbd != null && !mbd.isLazyInit()) || containsSingleton(beanName)) &&
                                        (includeNonSingletons ||
                                                (dbd != null ? mbd.isSingleton() : isSingleton(beanName))) &&
                                        // 根据Bean的定义信息判断完后，在此方法中判断此beanName对应的Bean实例是否与传入的类型相匹配
                                        isTypeMatch(beanName, type);
                        // 如果根据beanName获得的是一个工厂Bean，并且与传入的类型不匹配，则满足条件，将beanName添加 & 符前缀
                        if (!matchFound && isFactoryBean) {
                            // 对于工厂Bean，接下来尝试匹配工厂Bean实例本身
                            beanName = FACTORY_BEAN_PREFIX + beanName;
                            matchFound = (includeNonSingletons || mbd.isSingleton()) && isTypeMatch(beanName, type);
                        }
                        // 如果获取的Bean实例与传入的类型匹配，将beanName添加到结果集合中
                        if (matchFound) {
                            result.add(beanName);
                        }
                    }
                }
                catch (CannotLoadBeanClassException ex) {
                    // ...省略代码...
                }
                catch (BeanDefinitionStoreException ex) {
                    // ...省略代码...
                }
            }
        }
        // ...省略代码...

        return StringUtils.toStringArray(result);
    }

isTypeMatch()方法中的部分代码

public boolean isTypeMatch(String name, ResolvableType typeToMatch) throws NoSuchBeanDefinitionException {
        // 对beanName进行处理，将开头的 & 符过滤
        String beanName = transformedBeanName(name);
        // 从spring容器中获取单实例Bean，由于spring容器启动时已经将单实例Bean进行了实例化，
        // 所以此时可以直接在容器中得到Bean实例
        Object beanInstance = getSingleton(beanName, false);
        if (beanInstance != null && beanInstance.getClass() != NullBean.class) {
            // 获取到Bean实例后，判断是否为工厂Bean
            if (beanInstance instanceof FactoryBean) {
                // 如果是工厂Bean，并且获取的beanName不是以&符开头
                if (!BeanFactoryUtils.isFactoryDereference(name)) {
                    // 将实例强转为 FactoryBean 并调用 FactoryBean接口的getObjectType()方法，
                    // 获取工厂Bean所生产的实例类型
                    Class<?> type = getTypeForFactoryBean((FactoryBean<?>) beanInstance);
                    // 判断工厂Bean生产的实例类型与传入的类型是否匹配
                    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((PrivilegedAction<Class<?>>)
                        factoryBean::getObjectType, getAccessControlContext());
            }
            else {
                // 直接调用 FactoryBean 接口的 getObjectType()方法，获取生产的类型
                return factoryBean.getObjectType();
            }
        }
        catch (Throwable ex) {
            // Thrown from the FactoryBean's getObjectType implementation.
            logger.info("FactoryBean threw exception from getObjectType, despite the contract saying " +
                    "that it should return null if the type of its object cannot be determined yet", ex);
            return null;
        }
    }

以上便是getBeanNamesForType()方法经过的部分重要代码

由此可以看出，当我们想要获取BikeFactoryBean本身的beanName时，doGetBeanNamesForType方法内部将bikeFactoryBean前添加了&符前缀，于是便获取到了&bikeFactoryBean；
当我们想要获取Bike类型的beanName时，spring会通过容器遍历已经注册的所有的beanNames，然后根据beanName及对应的Bean定义信息BeanDefinition进行判断过滤，并且对于所有的工厂Bean，会获取spring容器中已经实例化的Bean对象，调用 FactoryBean 接口的 getObjectType()方法，得到工厂Bean所生产的实例类型，然后与Bike.class相比较，如果匹配，则将此beanName保存到结果集中，最后返回。所以，当我们想要获取Bike类型的beanName时，从spring容器中便可以找到bikeFactoryBean。

  1. 从spring容器中获取到beanName后，我们继续获取Bike实例
    从前文中引导类的代码可以看出，获取Bike实例有两种方式，跟踪源码可以发现，根据Bike类型获取实例时，spring实际是通过第二步获取到beanName后再最终调用doGetBean方法获取实例对象。下面看看部分源码
protected <T> T doGetBean(final String name, @Nullable final Class<T> requiredType,
                              @Nullable final Object[] args, boolean typeCheckOnly) throws BeansException {
        // 对传入的beanName进行过滤，去除&符前缀
        final String beanName = transformedBeanName(name);
        Object bean;

        // 从spring容器中获取实例，由于spring容器启动时已经将单实例Bean进行实例化，所以此时可以直接获得
        Object sharedInstance = getSingleton(beanName);
        if (sharedInstance != null && args == null) {
            if (logger.isTraceEnabled()) {
                if (isSingletonCurrentlyInCreation(beanName)) {
                    logger.trace("Returning eagerly cached instance of singleton bean '" + beanName +
                            "' that is not fully initialized yet - a consequence of a circular reference");
                }
                else {
                    logger.trace("Returning cached instance of singleton bean '" + beanName + "'");
                }
            }
            // 获取指定的Bean实例，如果是工厂bean，则为Bean实例本身或其创建的对象。
            bean = getObjectForBeanInstance(sharedInstance, name, beanName, null);
        }
        // ...省略代码...
        return (T) bean;
    }

从上面的代码可以看出，获取Bike实例的具体代码还在getObjectForBeanInstanc()方法内部，我们继续查看

protected Object getObjectForBeanInstance(
            Object beanInstance, String name, String beanName, @Nullable RootBeanDefinition mbd) {

        // 判断beanName是否是以&符开头的
        if (BeanFactoryUtils.isFactoryDereference(name)) {
            if (beanInstance instanceof NullBean) {
                return beanInstance;
            }
            if (!(beanInstance instanceof FactoryBean)) {
                throw new BeanIsNotAFactoryException(transformedBeanName(name), beanInstance.getClass());
            }
        }

        // 根据beanName从spring容器中获取的Bean实例如果不是工厂Bean，或者beanName是以&符开头，就直接返回这个Bean实例
        // 当我们获取Bike类型的实例时，beanName为“bikeFactoryBean”，
        // beanInstance为“BikeFactoryBean”类型，是一个工厂Bean，所以条件不满足，继续向下走
        if (!(beanInstance instanceof FactoryBean) || BeanFactoryUtils.isFactoryDereference(name)) {
            return beanInstance;
        }

        Object object = null;
        if (mbd == null) {
            // 根据beanName从缓存中获取Bean实例，第一次来获取Bike实例时为空，
        // factoryBeanObjectCache.get(beanName);
            // 后续再获取时，便可以在此获得到，然后返回
            object = getCachedObjectForFactoryBean(beanName);
        }
        if (object == null) {
            // 将获取的工厂Bean强转为 FactoryBean 类型，以便下面调用其getObject()方法获取对象
            FactoryBean<?> factory = (FactoryBean<?>) beanInstance;
            // 获取bean定义信息
            if (mbd == null && containsBeanDefinition(beanName)) {
                mbd = getMergedLocalBeanDefinition(beanName);
            }
            boolean synthetic = (mbd != null && mbd.isSynthetic());
            //在此方法内部调用 FactoryBean 接口的 getObject()方法获取对象
            object = getObjectFromFactoryBean(factory, beanName, !synthetic);
        }
        return object;
    }

距离真相还差两步了，坚持就是胜利，我们继续看getObjectFromFactoryBean()的源码

protected Object getObjectFromFactoryBean(FactoryBean<?> factory, String beanName, boolean shouldPostProcess) {
        // 此处调用 FactoryBean 的isSingleton()方法，判断是否是一个单列
        // 如果是单例的，走if内部，获取到对象后，会保存到factoryBeanObjectCache缓存中，以便后续使用
        if (factory.isSingleton() && containsSingleton(beanName)) {
            synchronized (getSingletonMutex()) {
                // 检查缓存中是否已经存在
                Object object = this.factoryBeanObjectCache.get(beanName);
                if (object == null) {
                    // 调用最后一个方法，执行FactoryBean 的 getObject()方法获取对象
                    object = doGetObjectFromFactoryBean(factory, beanName);
                    // 再次检查缓存
                    Object alreadyThere = this.factoryBeanObjectCache.get(beanName);
                    if (alreadyThere != null) {
                        object = alreadyThere;
                    }
                    else {
                        // ... 省略代码 ...
                        if (containsSingleton(beanName)) {
                            // 将获取的对象放入factoryBeanObjectCache缓存中，以便后续使用
                            this.factoryBeanObjectCache.put(beanName, object);
                        }
                    }
                }
                return object;
            }
        }
        // 如果不是单例的，每次获取的对象直接返回，不会放入缓存中,所以每次都会调用getObject()方法
        else {
            Object object = doGetObjectFromFactoryBean(factory, beanName);
            if (shouldPostProcess) {
                try {
                    object = postProcessObjectFromFactoryBean(object, beanName);
                }
                catch (Throwable ex) {
                    throw new BeanCreationException(beanName, "Post-processing of FactoryBean's object failed", ex);
                }
            }
            return object;
        }
    }

根据上面的流程，终于来到了最后一步

private Object doGetObjectFromFactoryBean(final FactoryBean<?> factory, final String beanName)
            throws BeanCreationException {
        Object object;
        try {
            if (System.getSecurityManager() != null) {
                AccessControlContext acc = getAccessControlContext();
                try {
                    object = AccessController.doPrivileged((PrivilegedExceptionAction<Object>) factory::getObject, acc);
                } catch (PrivilegedActionException pae) {
                    throw pae.getException();
                }
            }
            else {
                // 直接调用 FactoryBean 接口的 getObject()方法获取实例对象
                object = factory.getObject();
            }
        }
        catch (FactoryBeanNotInitializedException ex) {
            throw new BeanCurrentlyInCreationException(beanName, ex.toString());
        }
        // ... 省略代码 ...
        return object;
    }

经过如此多的代码，spring终于帮我们获取到Bike对象实例

通过BikeFactoryBean来获取Bike类的实例时，spring先获取Bike类型对应的beanName（bikeFactoryBean），然后根据beanName获取到工厂Bean实例本身（BikeFactoryBean），最终spring会调用BikeFactoryBean 的 getObject()方法来获取Bike对象实例。并且根据 BikeFactoryBean 实例的 isSingleton() 方法来判断Bike类型的实例是否时单例的，依此来决定要不要将获取的Bike对象放入到缓存中，以便后续使用。

总结

本文主要讲解了如何通过 FactoryBean接口向spring容器中注入组件，通过简单的案例进行模拟，并根据案例对源码的执行过程进行跟踪，分析了FactoryBean接口的执行过程。
另外，在每一次跟踪spring源码时，都会有新的收获。在spring庞大的体系下，只有定位好自己的目标，明确自己的需求，才不会被spring无限的代码所淹没。

学习永远都不是一件简单的事情，可以有迷茫，可以懒惰，但是前进的脚步永远都不能停止。

不积跬步，无以至千里；不积小流，无以成江海；


原文链接:https://www.cnblogs.com/tangfd/p/11130637.html
如有疑问请与原作者联系

标签：

版权申明：本站文章部分自网络，如有侵权，请联系：west999com@outlook.com
特别注意：本站所有转载文章言论不代表本站观点，本站所提供的摄影照片，插画，设计作品，如需使用，请与原作者联系，版权归原作者所有

上一篇：netty解决粘包半包问题

下一篇：Java 修饰符

相关文章

IDC资讯： 主机资讯 注册资讯 托管资讯 vps资讯 网站建设

网站运营： 建站经验 策划盈利 搜索优化 网站推广 免费资源

网站联盟： 联盟新闻 联盟介绍 联盟点评 网赚技巧

行业资讯： 搜索引擎 网络游戏 电子商务 广告传媒

网络编程： Asp.Net编程 Asp编程 Php编程 Xml编程 Access Mssql Mysql 其它

服务器技术： Web服务器 Ftp服务器 Mail服务器 Dns服务器 安全防护

软件技巧： 其它软件 Word Excel Powerpoint Ghost Vista QQ空间 QQ FlashGet 迅雷

网页制作： FrontPages Dreamweaver Javascript css photoshop fireworks Flash

程序设计： Java技术 C/C++ VB delphi

网络知识： 网络协议 网络安全 网络管理 组网方案 Cisco技术

操作系统： Win2000 WinXP Win2003 Mac OS Linux FreeBSD

热门词条
最新资讯
热门关注
热门标签