Spring拓展接口之FactoryBean，咱们来看看其源码实现

时间  2019-12-05
标签 spring 拓展 接口 factorybean 咱们 看看 源码 实现 栏目 Spring 繁體版
原文   原文链接

前言

　　开心一刻git

　　　那年去相亲，地点在饭店里，威特先上了两杯水，男方绅士的喝了一口，咧嘴咋舌轻放桌面，手抚额头闭眼一脸陶醉，白水硬是喝出了82年拉菲的感受。如此有生活情调的幽默男人，果断拿下，相处后却发现他比较木讷，问他为何那天喝水那么有趣，他仰头道：鬼知道那杯水怎么那么烫啊！spring

是什么

　　FactoryBean的源码比较简单，你们能够细读下其注释，我作了简单的以下翻译缓存

/**
 * 实现此接口的bean不能用做普通bean。此bean暴露的对象是经过getObject()建立的对象，而不是它自身
 */
public interface FactoryBean<T> {

    /**
     * 返回此工厂管理的对象的实例（多是共享的或独立的，取决于isSingleton()的返回值）
     */
    @Nullable
    T getObject() throws Exception;

    /**
     * 返回此FactoryBean建立的对象类型,
     */
    @Nullable
    Class<?> getObjectType();

    /**
     * 该工厂管理的对象是否为单例?
     * 若是是(return true),getObject()老是返回同一个共享的实例，该对象会被BeanFactory缓存起来
     * 若是是(return false),getObject()返回独立的实例
     * 通常状况下返回true
     */
    default boolean isSingleton() {
        return true;
    }

}

　　说的简单点，FactoryBean是BeanFactory支持的、用来暴露bean实例的接口springboot

有什么用

　　先带你们回忆下，目前咱们配置bean主要有哪几种方式？app

　　一、基于XML的配置方式ide

　　　　在xml文件中配置，例如spring-boot

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
    xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
    xsi:schemaLocation="http://www.springframework.org/schema/beans
    http://www.springframework.org/schema/beans/spring-beans-4.1.xsd">
    
    <bean id="user" class="com.lee.factorybean.User">
        <property name="name" value="zhangsan"/>
    </bean>    
</beans>

　　　　spring的发布的初版就支持，这个你们都知道测试

　　二、基于注解的配置方式ui

　　　　spring2.5开始支持，例如：@Compoment、@Repository、@Controller、@Service等，平时咱们用的挺多的this

　　三、基于Java类的配置方式

　　　　spring3.0开始支持，也是目前spring推荐的方式，@Configuration结合@Bean，springboot中用的很是多

　　通常状况下，Spring经过反射机制利用<bean>的class属性指定实现类实例化Bean，在某些状况下，实例化Bean过程比较复杂，若是按照传统的xml方式，则须要在<bean>中提供大量的配置信息。xml配置方式的灵活性是受限的，这时采用编码的方式可能会获得一个简单的方案。那么编码方式又有哪些了？spring3.0以后，编码的方式有基于注解、基于Java类以及基于FactoryBean，那么在spring2.5以前了，如何用xml方式配置实例化过程比较复杂的Bean？能够采用xml结合FactoryBean来实现，xml中配置FactoryBean，FactoryBean建立咱们须要的、实例化过程比较复杂的Bean，示例核心代码以下，从spring容器获取name为user的bean实例，获取到的是User类型的Bean

　　xml配置

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
    xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
    xsi:schemaLocation="http://www.springframework.org/schema/beans
    http://www.springframework.org/schema/beans/spring-beans-4.1.xsd">
    
    <bean id="user" class="com.lee.factorybean.config.UserFactoryBean" />
</beans>

　　UserFactoryBean

package com.lee.factorybean.config;

import com.lee.factorybean.entity.User;
import org.springframework.beans.factory.FactoryBean;

public class UserFactoryBean implements FactoryBean<User> {

    @Override
    public User getObject() throws Exception {
        // 假设User的实例化过程比较复杂，在此处进行User的实例化
        return new User();
    }

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

    @Override
    public boolean isSingleton() {
        return true;
    }
}

　　spring2.5以前，只能经过xml的配置方式将Bean注册到spring管理，可是xml的配置方式又不够灵活，配置实例化过程比较复杂的Bean比较麻烦，全部结合FactoryBean，既能采用编码的方式构建实例化过程比较复杂的Bean，也能将Bean交由Spring管理；spring2.5以后，特别是spring3.0以后，注册实例化过程比较复杂的Bean到spring容器的方式就比较多了（可采用的编码方式比较多），FactoryBean的方式也一直被spring支持。

　　说的再简单点，经过FactoryBean能够建立实例化过程比较复杂的Bean，至于咱们以何种方式将FactoryBean的实例注册到Spring容器，在不一样的spring版本，能够采用不一样的方式

怎么用

　　咱们经过一个简单的示例来看看FactoryBean究竟是怎么用的

　　应用示例

　　　　示例地址：spring-boot-FactoryBean

　　　　UserFactoryBean

package com.lee.factorybean.config;

import com.lee.factorybean.entity.User;
import org.springframework.beans.factory.FactoryBean;
import org.springframework.stereotype.Component;

@Component("user")          // beanName = user
public class UserFactoryBean implements FactoryBean<User> {

    @Override
    public User getObject() throws Exception {
        // 假设User的实例化过程比较复杂，在此处进行User的实例化
        return new User();
    }

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

    @Override
    public boolean isSingleton() {
        return true;
    }
}
View Code

　　　　User

package com.lee.factorybean.entity;

public class User {
    private Integer id;
    private String name;
    private Integer age;

    public Integer getId() {
        return id;
    }

    public void setId(Integer id) {
        this.id = id;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public Integer getAge() {
        return age;
    }

    public void setAge(Integer age) {
        this.age = age;
    }
}
View Code

　　　　FactoryBeanTest

package com.lee.factorybean.test;

import com.lee.factorybean.FactoryBeanApplication;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.springframework.beans.factory.BeanFactory;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.context.SpringBootTest;
import org.springframework.test.context.junit4.SpringRunner;

@RunWith(SpringRunner.class)
@SpringBootTest
public class FactoryBeanTest {

    @Autowired
    private BeanFactory beanFactory;

    @Test
    public void test() {
        Object user = beanFactory.getBean("user");
        System.out.println(user.getClass().getName());
    }

}
View Code

　　　　咱们运行测试用例，发现输出的结果是：com.lee.factorybean.entity.User，而不是：com.lee.factorybean.config.UserFactoryBean

　　spring中的FactoryBean实现

　　　　Spring自身就提供了不少FactoryBean的实现（spring版本不同，实现数量不同），springboot2.0.3（对应spring5.0.7）中FactoryBean实现有以下

　　　　除了咱们自定义的UserFactoryBean，有60个是springboot中的实现，其中有50多个是spring中的实现；有兴趣的能够细看下，注意springboot版本，若是直接用的spring，则注意spring的版本

　　实际工做中，咱们本身实现FactoryBean的场景很是少，反正我工做中是用的很是少，印象中有，但感受是好久以前的事了；Spring中有不少FactoryBean的实现，也有不少第三方的实现，好比MyBatis的MapperFactoryBean、druid的JdbcStatManagerFactoryBean、shiro的ShiroFilterFactoryBean等等。用不用FactoryBean，全看咱们我的，但咱们必定得知道FactoryBean，当咱们碰到FactoryBean的实现时（读源码很容易碰到），咱们一眼就能明白其意图，当咱们须要构建实例化过程比较复杂的Bean时，FactoryBean也是一种可选的方案

为何

　　具体问题应该是这样的：上述示例中，为何从spring容器获取的name为user的实例，其类型是User，而不是UserFactoryBean；抽象的问题：根据FactoryBean实例的name获取的为何不是FactoryBean实例，而是FactoryBean实例的getObject()返回的对象？ 

　　源码探究

　　　　咱们就以beanFactory.getBean("user");为断点入口

@Test
public void test() {
        // 断点入口
    Object user = beanFactory.getBean("user");
    System.out.println(user.getClass().getName());
}

　　　　一开始从spring容器获取名为user的bean，类型确实是：UserFactoryBean，可是后面又通过getObjectForBeanInstance来真正获取咱们须要的对象

bean = getObjectForBeanInstance(sharedInstance, name, beanName, null);

/**
 * 获取实例对象
 * 多是beanInstance自身，也多是beanInstance建立的对象(若是beanInstance是FactoryBean类型)
 */
protected Object getObjectForBeanInstance(
        Object beanInstance, String name, String beanName, @Nullable RootBeanDefinition mbd) {

    // name以工厂引用(&)开头，能够跟下isFactoryDereference方法
    if (BeanFactoryUtils.isFactoryDereference(name)) {
        if (beanInstance instanceof NullBean) {
            return beanInstance;
        }
        // 若是name以&开头，而beanInstance不是FactoryBean类型，则抛异常（咱们没按spring规则来使用）
        if (!(beanInstance instanceof FactoryBean)) {
            throw new BeanIsNotAFactoryException(transformedBeanName(name), beanInstance.getClass());
        }
    }

    // 若是beanInstance不是FactoryBean类型，则直接返回beanInstance
    // 或者name以&开头，也直接返回beanInstance，说明咱们就想获取FactoryBean实例
    if (!(beanInstance instanceof FactoryBean) || BeanFactoryUtils.isFactoryDereference(name)) {
        return beanInstance;
    }

    Object object = null;
    if (mbd == null) {
        object = getCachedObjectForFactoryBean(beanName);
    }
    if (object == null) {
        // 此时beanInstance是FactoryBean类型，而name又不是以&开头; 这是咱们示例工程的状况，也是最普通、用的最多的状况
        // 将beanInstance强转成FactoryBean类型
        FactoryBean<?> factory = (FactoryBean<?>) beanInstance;
        // 从缓存中获取咱们须要的实例对象
        if (mbd == null && containsBeanDefinition(beanName)) {
            mbd = getMergedLocalBeanDefinition(beanName);
        }
        boolean synthetic = (mbd != null && mbd.isSynthetic());
        // 调用FactoryBean的getObject方法建立咱们须要的实例对象；你们自行跟下getObjectFromFactoryBean
        object = getObjectFromFactoryBean(factory, beanName, !synthetic);
    }
    return object;
}
View Code

　　　　根据name从spring容器获取实例，若是该实例不是FactoryBean类型，则直接返回该实例，这也是咱们平时用的最多的、最普通的状况；若是该实例是FactoryBean类型，而name又是以&开头，也直接返回该实例，说明咱们想要的就是FactoryBean实例；若是name不是以&开头，而该实例又是FactoryBean类型，则会调用该实例的getObject()来建立咱们须要的目标实例

　　如何获取FactoryBean实例

　　　　这个答案在上面已经有了，经过在name前加&便可，以下

@Test
public void test() {
    Object user = beanFactory.getBean("&user");
    System.out.println(user.getClass().getName());
}

　　　　输出结果以下

com.lee.factorybean.config.UserFactoryBean

总结

　　一、FactoryBean是BeanFactory支持的、用来暴露bean实例的接口，能够实现此接口来完成实例化过程比较复杂的bean的建立；

　　二、经过beanName从spring容器获取bean实例时，一开始获取的是beanName直接关联的bean实例，后续spring容器会根据此bean实例返回咱们须要的对象实例；若是bean实例不是FactoryBean类型，则直接返回bean实例，若是bean实例是FactoryBean类型，而beanName又是以&开头，直接返回bean实例，若是bean实例是FactoryBean类型，而beanName不是以&开头，则返回bean实例的getObject()方法获取的对象实例（通常getObject中就是咱们须要的实例对象的建立过程）；

　　三、对于建立过程比较复杂的对象的建立，目前spring其实有不少实现方式了，而FactoryBean只是其中一种，也许咱们不会采用此种方式来实现实例对象的建立，但咱们须要可以看懂此种方式，知道有这种实现方式；不少第三方都沿用了此种方式，咱们去追源码的时候，很容易就能碰到；

　　四、相比普通bean的建立，FactoryBean的方式会在spring容器中多存在一个FactoryBean的实例，若想获取FactoryBean实例对象，只须要在FactoryBean的beanName加&便可；

相关文章
相关标签/搜索
每日一句
    每一个你不满意的现在，都有一个你没有努力的曾经。
本站公众号
   欢迎关注本站公众号,获取更多信息
联系我们 最近搜索 最新文章 沪ICP备13005482号-10 MyBatis教程 SQL 教程 MySQL教程 Java 教程 Thymeleaf 教程 Hibernate教程 Spring教程 Redis教程