Spring FactoryBean作用及应用场景源码分析(Spring整合Mybatis的核心)

太过爱你忘了你带给我的痛 2022-09-03 15:16 117阅读 0赞

### 文章目录 ###

*   *  背景
     *  BeanFactoryPostProcessor
     *  BeanDefinitionRegistryPostProcessor
     *  ImportBeanDefinitionRegistrar
     *  总结
     *  参考

## 背景 ##

假设我们有这种需求，像Mybaits需要将这些接口注入到Spring容器中

public interface OneTestDao { 
        @Select("SELECT name FROM user WHERE id = 1")
        String query();
    }
    
    public interface TwoTestDao { 
        @Select("SELECT name FROM user WHERE id = 2")
        String query();
    }

首先我们想将我们的自己的Bean(比如代理对象)注入到Spring容器中，有什么方式呢？

一般都是通过Spring扫描Resouce资源然后解析为BeanDefinition，才能从getBean时解析BeanDefinition实例化对象放入此单例缓存中.但是我们这里的是接口，没法直接注入到Spring容器中。

不过Spring提供了一些扩展接口来供我们在Bean加载、初始化、加载完提供了一些接口，供我们扩展。

比如

## BeanFactoryPostProcessor ##

来看看源码

@FunctionalInterface
    public interface BeanFactoryPostProcessor { 
    
    	/** * Modify the application context's internal bean factory after its standard * initialization. All bean definitions will have been loaded, but no beans * will have been instantiated yet. This allows for overriding or adding * properties even to eager-initializing beans. * @param beanFactory the bean factory used by the application context * @throws org.springframework.beans.BeansException in case of errors */
    	void postProcessBeanFactory(ConfigurableListableBeanFactory beanFactory) throws BeansException;
    
    }

> 可以看到这是一个函数式接口，实现这个接口，可以在spring的bean创建之前，修改bean的定义属性。也就是说，Spring允许BeanFactoryPostProcessor在容器实例化任何其它bean之前读取配置元数据，然后作一些修改操作，例如我可以将bean的scope从singleton改为prototype,也可以添加一些bean，具体能操作bean的方法全部在beanFactory中。我们可以看看beanFactory有哪些方法

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQyNjUxOTA0_size_16_color_FFFFFF_t_70]

其中提供的**registerSingleton**方法就可以让我注册`bean`，使用方式也很简单

@Component
    public class TestPostProcessor implements BeanFactoryPostProcessor { 
        @Override
        public void postProcessBeanFactory(ConfigurableListableBeanFactory beanFactory) throws BeansException { 
            beanFactory.registerSingleton("test", new String("test"));
        }
    }

这样我们就像spring容器中注册了一个String类型的bean，beanName为 test

这里在这个接口执行前其实spring BeanDefinition已经扫描完成了，我们使用这种方式还不不太好，相当于强制暴力的去修改BeanDefinition属性，可能修改不当会有一些bug。有没有什么方法在扫描的时候添加BeanDefinition呢？也是有的

主要提供了这两个接口：

## BeanDefinitionRegistryPostProcessor ##

public interface BeanDefinitionRegistryPostProcessor extends BeanFactoryPostProcessor { 
    
    	/** * Modify the application context's internal bean definition registry after its * standard initialization. All regular bean definitions will have been loaded, * but no beans will have been instantiated yet. This allows for adding further * bean definitions before the next post-processing phase kicks in. * @param registry the bean definition registry used by the application context * @throws org.springframework.beans.BeansException in case of errors */
    	void postProcessBeanDefinitionRegistry(BeanDefinitionRegistry registry) throws BeansException;
    
    }

可以看到`BeanDefinitionRegistryPostProcessor`也是继承了`BeanFactoryPostProcessor`，但是我们在使用`BeanDefinitionRegistryPostProcessor`只需要实现他的`postProcessBeanDefinitionRegistry`方法即可， `postProcessBeanFactory`方法放一个空实现即可，这样让一个类只做一件事，满足单一原则

使用方式也很简单

public class CustomBeanDefinitionRegistry implements BeanDefinitionRegistryPostProcessor { 
    
    	@Override
    	public void postProcessBeanFactory(ConfigurableListableBeanFactory beanFactory) throws BeansException { 
    
    	}
    
    	@Override
    	public void postProcessBeanDefinitionRegistry(BeanDefinitionRegistry registry) throws BeansException { 
    		RootBeanDefinition testBean = new RootBeanDefinition(Test.class);
    		//新增Bean定义
    		registry.registerBeanDefinition("test", testBean);
    	}
    
    }

这样就完成了`test`Bean的注册

## ImportBeanDefinitionRegistrar ##

public interface ImportBeanDefinitionRegistrar { 
    
    	/** * Register bean definitions as necessary based on the given annotation metadata of * the importing {@code @Configuration} class. * <p>Note that {@link BeanDefinitionRegistryPostProcessor} types may <em>not</em> be * registered here, due to lifecycle constraints related to {@code @Configuration} * class processing. * @param importingClassMetadata annotation metadata of the importing class * @param registry current bean definition registry */
    	public void registerBeanDefinitions(
    			AnnotationMetadata importingClassMetadata, BeanDefinitionRegistry registry);
    
    }

`ImportBeanDefinitionRegistrar`可以看到除了像`BeanDefinitionRegistryPostProcessor`提供了`BeanDefinitionRegistry`参数，还提供了一个`AnnotationMetadata`参数，该参数可以获取指定注解的属性。一般来说`BeanDefinitionRegistryPostProcessor`用来解析**外部资源配置**，`ImportBeanDefinitionRegistrar`解析**注解配置**

如果对mybatis源码了解多的就可以发现mybatis整合spring其中的两个配置类

`MapperScannerConfigurer`就是实现了`BeanDefinitionRegistryPostProcessor`,

`MapperScannerRegistrar`就是实现了`ImportBeanDefinitionRegistrar`

说了这么多，我们还没有聊今天的主角`FactoryBean`

来看看源码

public interface FactoryBean<T> { 
      //获取bean
    	@Nullable
    	T getObject() throws Exception;
      
    	@Nullable
      //获取classType
    	Class<?> getObjectType();
      //是否单例
    	default boolean isSingleton() { 
    		return true;
    	}
    
    }

三个方法也是比较简单，实现`FactoryBean`的Bean本事 就是一个`Bean`， 不同的是 Spring 对其做了特殊处理，在试图获取时`FactoryBean`时，获取的是`getObject()` 返回的对象。

既然获取`FactoryBean`对象的时候，获取的是`getObject()` 方法的bean对象，那么我们是不是可以基于`FactoryBean`设置出一个获取所有mapper代理对象的bean呢？

public class MyFactoryBean<T> implements FactoryBean<T> { 
    
        private final Class<T> clazz;
    
        public MyFactoryBean(Class<T> clazz) { 
            this.clazz = clazz;
        }
        @Override
        public T getObject() throws Exception { 
            return (T) Proxy.newProxyInstance(this.getClass().getClassLoader(), new Class[]{ clazz}, new MyFactoryBeanHandler());
        }
        @Override
        public Class<?> getObjectType() { 
            return clazz;
        }
    }

*  MyFactoryBeanHandler

public class MyFactoryBeanHandler implements InvocationHandler
    { 
        @Override
        public Object invoke(Object proxy, Method method, Object[] args) throws Throwable { 
            // 仅仅打印注解上的sql 假装执行代理对象执行sql
            Select annotation = method.getAnnotation(Select.class);
            if (annotation == null) return null;
            Class<?> returnType = method.getReturnType();
            System.out.println("-------> " + Arrays.toString(annotation.value()));
            return null;
        }
    }

这样我们在`getObject()`的时候就可以返回我们的代理对象了，但是有个问题我们的class类型是通过构造方法传入的。如果我们使用

beanDefinition.setBeanClass(MyFactoryBean.class);

注入对象`MyFactoryBean`我们能使用`getObject()`获取到代理对象吗？明显是不能的，因为我们没有传入clazz属性

那我们的class属性哪里来呢？从`BeanDefinition`中获取

beanDefinition.getBeanClassName()

这样就可以获取到我之前的接口`OneTestDao`类名

然后通过设置构造方法的参数

beanDefinition.getConstructorArgumentValues().addGenericArgumentValue()

最后代码就变成了如下

beanDefinition.getConstructorArgumentValues().addGenericArgumentValue(beanDefinition.getBeanClassName());

到这里就能实例化我们自己的`FactoryBean`，从而在获取我们的Dao接口时获取的都是代理对象，这就是Spring整合Mybatis的核心实现。也是`FactoryBean`的一个应用场景，如果你知道了这些，再去看spring整合Mybatis源码就会发现整个过程特别清晰，也就理解了`FactoryBean`的作用

## 总结 ##

所以说`FactoryBean`本质就是用来给我们实例化、或者动态的注入一些比较复杂的Bean，比如像一些接口的代理对象。这里简单说一下和`BeanFactory`的区别，最主要的一个区别是`FactoryBean`是动态注入Bean和`BeanFactory`主要是负责`Bean`实例化、定位、配置应用程序中的对象及建立这些对象间的依赖.三言两语无法说清，后续有机会重点分析`BeanFactory`再来细说吧

## 参考 ##

[博客][Link 1]

[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQyNjUxOTA0_size_16_color_FFFFFF_t_70]: /images/20220829/d254c243c82c4526a76c2e02a5aa8daa.png
[Link 1]: https://www.skypyb.com/2019/08/jishu/979/