Springboot扩展点之FactoryBean

傷城~ 2024-03-26 08:40 35阅读 0赞

Springboot扩展点系列：

[Springboot扩展点之ApplicationContextInitializer][Springboot_ApplicationContextInitializer]

[Springboot扩展点之BeanFactoryPostProcessor][Springboot_BeanFactoryPostProcessor]

[Springboot扩展点之BeanDefinitionRegistryPostProcessor][Springboot_BeanDefinitionRegistryPostProcessor]

[Springboot扩展点之BeanPostProcessor][Springboot_BeanPostProcessor]

[Springboot扩展点之InstantiationAwareBeanPostProcessor][Springboot_InstantiationAwareBeanPostProcessor]

[Springboot扩展点之SmartInstantiationAwareBeanPostProcessor][Springboot_SmartInstantiationAwareBeanPostProcessor]

[Springboot扩展点之ApplicationContextAwareProcessor][Springboot_ApplicationContextAwareProcessor]

[Springboot扩展点之@PostConstruct][Springboot_PostConstruct]

[Springboot扩展点之InitializingBean][Springboot_InitializingBean]

[Springboot扩展点之SmartInitializingSingleton][Springboot_SmartInitializingSingleton]

[Springboot扩展点之CommandLineRunner和ApplicationRunner][Springboot_CommandLineRunner_ApplicationRunner]

[Springboot扩展点之FactoryBean][Springboot_FactoryBean]

[Springboot扩展点之DisposableBean][Springboot_DisposableBean]

[Springboot扩展点系列之终结篇：Bean的生命周期][Springboot_Bean]

--------------------

## **前言** ##

FactoryBean是一个有意思，且非常重要的扩展点，之所以说是有意思，是因为它老是被拿来与另一个名字比较类似的BeanFactory来比较，特别是在面试当中，动不动就问你：你了解Beanfactory和FactoryBean的区别吗？其实两个是完全不同的接口，如果非要说出有什么明显区别，大概就是名字吧。为什么又说非常重要呢？那是因为在创建一些比较复杂的bean的时候，常规的方式不能使用，就可以考虑使用FactoryBean，特别其他框架技术与Spring集成的时候，如mybatis与Spring的集成，大家都知道，mybatis是通过SqlSessionFactory创建出Sqlsession来执行sql的，那么Service层在调用Dao层的接口来执行数据库操作时肯定得持有SqlSessionFactory，那么问题来了：Spring容器怎么才能持有SqlSessionFactory呢？答案就是SqlSessionFactoryBean，它实现了FactoryBean接口。

既然FactoryBean如此神奇，那么就先盘一盘它的主要功能特性，然后再通过一个示例来验证一下，最后再深入盘一盘其工作原理 。

## **功能特性** ##

1、FactoryBean接口有三个方法：1、getObject()，用于获取bean，主要应用在创建一些复杂的bean的场景；2、getObjectType()，用于获取返回bean的类型；3、isSingleton()，用于判断返回bean是否属于单例，默认trure，通俗说就是工厂bean；

2、BeanFactory是Spring bean容器的根接口，ApplicationContext是Spring bean容器的高级接口，继承于BeanFactory，通俗理解就是生成bean的工厂；

所以FactoryBean与BeanFactory本质上是完全不同的两个接口。既然完全不同，又说什么区别呢？至少我是这么认为的。

## **实现方式** ##

那么FactoryBean怎么用呢？这里先举一个场景：假如需要要创建一个特别复杂的类Computer

1、定义Computer类；

@Slf4j
    public class Computer {
        private String type;
    
        public String getType() {
            return type;
        }
    
        public void setType(String type) {
            this.type = type;
        }
    
        public Computer() {
            log.info("----Computer类无参数构造方法触发执行");
        }
    
        public Computer(String type) {
            this.type = type;
            log.info("----Computer类有参数构造方法触发执行");
        }
    }

2、定义ComputerFactoryBean，实现FactoryBean接口，实现了getObject()，创建了一个“复杂”的Bean；在getObjectType()返回了Bean的类型；在isSingleton()指定Bean的作用域为单例；

@Component
    @Slf4j
    public class ComputerFactoryBean implements FactoryBean {
        private String name = "ComputerFactoryBean本尊";
    
        public ComputerFactoryBean() {
            log.info("----ComputerFactoryBean无参数构造方法触发执行");
        }
    
        @Override
        public Object getObject() throws Exception {
            log.info("----com.fanfu.bean.ComputerFactoryBean.getObject()触发执行-start");
            Computer computer = new Computer("商用笔记本电脑");
            log.info("----com.fanfu.bean.ComputerFactoryBean.getObject()触发执行-end");
            return computer;
        }
    
        @Override
        public Class<?> getObjectType() {
            return Computer.class;
        }
    
        @Override
        public boolean isSingleton() {
            return true;
        }
    }

3、编写单元测试，从Spring容器中取出beanName为"computeFactoryBean"的bean，通常情况下，如果ComputerFactoryBean未实现FactoryBean接口，getBean("computeFactoryBean")的结果是computeFactoryBean对象；而实现了FactoryBean接口，getBean("computeFactoryBean")的结果的是getObject()方法中返回的结果，即computer，这就是FactoryBean如此神奇的地方。

@Test
    public void test6() {
        log.info("----单元测试执行开始");
        log.info("----Spring容器实例化开始");
        AnnotationConfigApplicationContext context = new AnnotationConfigApplicationContext("com.fanfu");
        log.info("----Spring容器实例化完成");
        ComputerFactoryBean computerFactoryBean = ((ComputerFactoryBean) context.getBean("&computerFactoryBean"));
        Computer computer = (Computer) context.getBean("computerFactoryBean");
        Assert.isTrue(computerFactoryBean.getClass().getName().equals("com.fanfu.bean.ComputerFactoryBean"));
        Assert.isTrue(computer.getClass().getName().equals("com.fanfu.entity.Computer"));
        log.info("----单元测试执行完毕");
    }

单元测试结果：

![d6bf43b494404c55a02c33454d4fad24.png][]

## **工作原理**  ##

从单元测试验证结果来看，ComputerFactoryBean本尊在Spring容器实例化的过程中，就以非懒加载的单例bean实例化完成注册到了Spring容器里。顺着context.getBean("computerFactoryBean")往下跟踪，会发现接着调用了AbstractApplicationContext\#getBean(java.lang.String)-->AbstractBeanFactory\#getBean(java.lang.String)-->AbstractAutowireCapableBeanFactory\#getObjectForBeanInstance()-->AbstractBeanFactory\#getObjectForBeanInstance()，到这是一个关键点：

1、AbstractBeanFactory\#getObjectForBeanInstance()中判断是否bean是否是一个工厂引用，即beanName是否是“&”开头，如果beanName是以“&”开头，则直接返回本尊；如果不是，则继续向下执行；

2、检查bean是否实现了FactoryBean接口，如果获取的bean没有实现FactoryBean接口，则直接返回；如果获取的bean实现了FactoryBean接口，则继续向下执行；

3、对获取的bean强制转换为FactoryBean，然后去执行FactoryBean接口实现类的getObject()；

protected Object getObjectForBeanInstance(
          Object beanInstance, String name, String beanName, @Nullable RootBeanDefinition mbd) {
        //检查bean是否是一个工厂引用，即beanName是否是“&”开头
       if (BeanFactoryUtils.isFactoryDereference(name)) {
          if (beanInstance instanceof NullBean) {
             return beanInstance;
          }
          if (!(beanInstance instanceof FactoryBean)) {
             throw new BeanIsNotAFactoryException(beanName, beanInstance.getClass());
          }
          if (mbd != null) {
             mbd.isFactoryBean = true;
          }
          //如果beanName是以“&”开头，则直接返回本尊
          return beanInstance;
       }
        //如果获取的bean没有实现FactoryBean接口，则直接返回；
       if (!(beanInstance instanceof FactoryBean)) {
          return beanInstance;
       }
       Object object = null;
       if (mbd != null) {
          mbd.isFactoryBean = true;
       }
       else {
          object = getCachedObjectForFactoryBean(beanName);
       }
       if (object == null) {
          // 如果获取的bean实现FactoryBean接口，则对bean进行强制转换
          FactoryBean<?> factory = (FactoryBean<?>) beanInstance;
          if (mbd == null && containsBeanDefinition(beanName)) {
             mbd = getMergedLocalBeanDefinition(beanName);
          }
          boolean synthetic = (mbd != null && mbd.isSynthetic());
          //去执行FactoryBean接口实现类的getObject()
          object = getObjectFromFactoryBean(factory, beanName, !synthetic);
       }
       return object;
    }

## **总结** ##

总体来讲，从FactoryBean的实现方式到工作原理，都很简单，同时也是有大用处的扩展点，特别要必要牢牢掌握。当然，如果有面试官再问你，FactoryBean与BeanFactory有什么区别的时候？不要再犹豫，直接告诉他：”FactoryBean与BeanFactory本身并没有什么区别，但是我可以分别给你介绍介绍这两个接口有什么用处。FactoryBean是一个工厂Bean，在需要创建比较复杂的bean的时候可以用到，BeanFactory是Spring bean容器的根接口，也就是说实现BeanFactory，可以得到一个最基础的Spring容器，Spring中的所有高级容器都继承了这个根接口。“

如果你能这样回答这个问题，相信会给面试官留下一下好印象的。

[Springboot_ApplicationContextInitializer]: https://blog.csdn.net/fox9916/article/details/128522598
[Springboot_BeanFactoryPostProcessor]: https://blog.csdn.net/fox9916/article/details/128823328
[Springboot_BeanDefinitionRegistryPostProcessor]: https://blog.csdn.net/fox9916/article/details/128538625
[Springboot_BeanPostProcessor]: https://blog.csdn.net/fox9916/article/details/128917992
[Springboot_InstantiationAwareBeanPostProcessor]: https://blog.csdn.net/fox9916/article/details/128941464
[Springboot_SmartInstantiationAwareBeanPostProcessor]: https://blog.csdn.net/fox9916/article/details/128976944
[Springboot_ApplicationContextAwareProcessor]: https://blog.csdn.net/fox9916/article/details/128990305
[Springboot_PostConstruct]: https://blog.csdn.net/fox9916/article/details/128998846
[Springboot_InitializingBean]: https://blog.csdn.net/fox9916/article/details/129016083
[Springboot_SmartInitializingSingleton]: https://blog.csdn.net/fox9916/article/details/129042652
[Springboot_CommandLineRunner_ApplicationRunner]: https://blog.csdn.net/fox9916/article/details/129086542?spm=1001.2014.3001.5502
[Springboot_FactoryBean]: https://blog.csdn.net/fox9916/article/details/129070764?spm=1001.2014.3001.5502
[Springboot_DisposableBean]: https://blog.csdn.net/fox9916/article/details/129026156?spm=1001.2014.3001.5501
[Springboot_Bean]: https://blog.csdn.net/fox9916/article/details/129101918
[d6bf43b494404c55a02c33454d4fad24.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/26/cee75c360a5d47d893812900f68b7abc.png