Spring实战系列（四）-动态注入接口Bean

小鱼儿 2022-05-22 23:57 532阅读 1赞

“对于Spring框架，现实公司使用的非常广泛，但是由于业务的复杂程度不同，了解到很多小伙伴们利用Spring开发仅仅是利用了Spring的IOC，即使是AOP也很少用，但是目前的Spring是一个大家族，形成了一个很大的生态，覆盖了我们平时开发的方方面面，抛开特殊的苛刻要求之外，Spring的生态其实已经很全面了，所以在此开个系列来研究下Spring提供给我们的一些平时不太却又很实用的内容。”

上一篇我们分析了BeanPostProcessor的基本使用，接下来我们分析下如何使用该类实现动态的接口注入，示例说明：在BeetlSQL框架中，在使用自动扫描注入时，我们通常只需要配置上要扫描的包路径，然后在该路径下声明对应的Dao接口类，这些接口类都默认继承BaseMapper接口类，然后我们在使用这些Dao类的时候，直接根据类型注入（@Autowired）即可使用，这个其实和Mybatis的那一套相似，也和Spring自身的Spring-data框架也类似。这个经常用于框架的开发，那么我就该部分的实现做相应的解释，这三个框架具体实现可能有差距，感兴趣的小伙伴自行去查看源码，我会以一个很简单的例子来讲解大概的实现逻辑。

问题描述：

继承Spring框架，实现声明某个自定义接口（UserMapper）,改接口继承通用接口BaseMapper，（通用接口BaseMapper有默认的实现类），实现通过类型注入UserMapper类，然后通过Spring框架的上下文类（ApplicationContext实现类）的getBean（）方法拿到UserMapper类来调用内部提供的方法。

1、声明BaseMapper接口类

  1. public interface BaseMapper {
  3.     /**
  4.      * @param value
  5.      */
  6.     public void add(String value);
  8.     /**
  9.      * @param key
  10.      */
  11.     public void remove(String key);
  12. }

2、默认BaseMapper实现类：CustomBaseMapper

  1. public class CustomBaseMapper implements BaseMapper {
  2.     private final Logger logger = Logger.getLogger(this.getClass().getName());
  3.     private List<String> dataList = new CopyOnWriteArrayList<>();
  5.     /**
  6.      * @param value
  7.      */
  8.     @Override
  9.     public void add(String value) {
  10.         logger.info("添加数据:" + value);
  11.         dataList.add(value);
  12.     }
  14.     /**
  15.      * @param key
  16.      */
  17.     @Override
  18.     public void remove(String key) {
  19.         if (dataList.isEmpty())
  20.             throw new IllegalArgumentException("Can't remove because the list is Empty!");
  22.     }
  23. }

接下来是继承Spring的核心代码

3、首先我们要先定义一个扫描某路径下的类，该类继承ClassPathBeanDefinitionScanner，自定义扫描类：DefaultClassPathScanner

  1. public class DefaultClassPathScanner extends ClassPathBeanDefinitionScanner {
  3.     private final String DEFAULT_MAPPER_SUFFIX = "Mapper";
  5.     public DefaultClassPathScanner(BeanDefinitionRegistry registry) {
  6.         super(registry, false);
  7.     }
  9.     private String mapperManagerFactoryBean;
  11.     /**
  12.      * 扫描包下的类-完成自定义的Bean定义类
  13.      *
  14.      * @param basePackages
  15.      * @return
  16.      */
  17.     @Override
  18.     protected Set<BeanDefinitionHolder> doScan(String... basePackages) {
  19.         Set<BeanDefinitionHolder> beanDefinitions = super.doScan(basePackages);
  20.         // 如果指定的基础包路径中不存在任何类对象，则提示
  21.         if (beanDefinitions.isEmpty()) {
  22.             logger.warn("系统没有在 '" + Arrays.toString(basePackages) + "' 包中找到任何Mapper，请检查配置");
  23.         } else {
  24.             processBeanDefinitions(beanDefinitions);
  25.         }
  26.         return beanDefinitions;
  27.     }
  29.     /**
  30.      * 注册过滤器-保证正确的类被扫描注入
  31.      */
  32.     protected void registerFilters() {
  33.         addIncludeFilter(new TypeFilter() {
  34.             @Override
  35.             public boolean match(MetadataReader metadataReader, MetadataReaderFactory metadataReaderFactory)
  36.                     throws IOException {
  37.                 String className = metadataReader.getClassMetadata().getClassName();
  38.                 //TODO 这里设置包含条件-此处是个扩展点，可以根据自定义的类后缀过滤出需要的类
  39.                 return className.endsWith(DEFAULT_MAPPER_SUFFIX);
  40.             }
  41.         });
  42.         addExcludeFilter(new TypeFilter() {
  43.             @Override
  44.             public boolean match(MetadataReader metadataReader, MetadataReaderFactory metadataReaderFactory)
  45.                     throws IOException {
  46.                 String className = metadataReader.getClassMetadata().getClassName();
  47.                 return className.endsWith("package-info");
  48.             }
  49.         });
  50.     }
  52.     /**
  53.      * 重写父类的判断是否能够实例化的组件-该方法是在确认是否真的是isCandidateComponent
  54.      * 原方法解释：
  55.      * 确定给定的bean定义是否有资格成为候选人。
  56.      * 默认实现检查类是否不是接口，也不依赖于封闭类。
  57.      * 以在子类中重写。
  58.      *
  59.      * @param beanDefinition
  60.      * @return
  61.      */
  62.     protected boolean isCandidateComponent(AnnotatedBeanDefinition beanDefinition) {
  63.         // 原方法这里是判断是否为顶级类和是否是依赖类（即接口会被排除掉-由于我们需要将接口加进来，所以需要覆盖该方法）
  64.         return beanDefinition.getMetadata().isInterface() && beanDefinition.getMetadata().isIndependent();
  65.     }
  67.     /**
  68.      * 扩展方法-对扫描到的含有BeetlSqlFactoryBean的Bean描述信息进行遍历
  69.      *
  70.      * @param beanDefinitions
  71.      */
  72.     void processBeanDefinitions(Set<BeanDefinitionHolder> beanDefinitions) {
  73.         GenericBeanDefinition definition;
  74.         for (BeanDefinitionHolder holder : beanDefinitions) {
  75.             definition = (GenericBeanDefinition) holder.getBeanDefinition();
  76.             String mapperClassName = definition.getBeanClassName();
  77.             // 必须在这里加入泛型限定，要不然在spring下会有循环引用的问题
  78.             definition.getConstructorArgumentValues().addGenericArgumentValue(mapperClassName);
  79.             //依赖注入
  80.             definition.getPropertyValues().add("mapperInterface", mapperClassName);
  81.             // 根据工厂的名称创建出默认的BaseMapper实现
  82.             definition.getPropertyValues().add("mapperManagerFactoryBean", new RuntimeBeanReference(this.mapperManagerFactoryBean));
  83.             definition.setBeanClass(BaseMapperFactoryBean.class);
  84.             // 设置Mapper按照接口组装
  85.             definition.setAutowireMode(AbstractBeanDefinition.AUTOWIRE_BY_TYPE);
  86.             logger.info("已开启自动按照类型注入 '" + holder.getBeanName() + "'.");
  87.         }
  88.     }
  90.     public void setMapperManagerFactoryBean(String mapperManagerFactoryBean) {
  91.         this.mapperManagerFactoryBean = mapperManagerFactoryBean;
  92.     }
  93. }

4、核心的接口实现类：BaseMapperFactoryBean

  1. public class BaseMapperFactoryBean<T> implements FactoryBean<T>, InitializingBean, ApplicationListener<ApplicationEvent>, ApplicationContextAware {
  2.     /**
  3.      * 要注入的接口类定义
  4.      */
  5.     private Class<T> mapperInterface;
  7.     /**
  8.      * Spring上下文
  9.      */
  10.     private ApplicationContext applicationContext;
  12.     //也因该走工厂方法注入得来
  14.     private BaseMapper mapperManagerFactoryBean;
  16.     public BaseMapperFactoryBean(Class<T> mapperInterface) {
  17.         this.mapperInterface = mapperInterface;
  18.     }
  20.     @Override
  21.     public T getObject() throws Exception {
  22.         //采用动态代理生成接口实现类，核心实现
  23.         return (T) Proxy.newProxyInstance(applicationContext.getClassLoader(), new Class[]{mapperInterface}, new MapperJavaProxy(mapperManagerFactoryBean, mapperInterface));
  24.     }
  26.     @Override
  27.     public Class<?> getObjectType() {
  28.         return this.mapperInterface;
  29.     }
  31.     @Override
  32.     public boolean isSingleton() {
  33.         return true;
  34.     }
  36.     @Override
  37.     public void afterPropertiesSet() throws Exception {
  38.         //TODO 判断属性的注入是否正确-如mapperInterface判空
  39.         if (null == mapperInterface)
  40.             throw new IllegalArgumentException("Mapper Interface Can't Be Null!!");
  41.     }
  43.     /**
  44.      * Handle an application event.
  45.      *
  46.      * @param event the event to respond to
  47.      */
  48.     @Override
  49.     public void onApplicationEvent(ApplicationEvent event) {
  50.         //TODO 可依据事件进行扩展
  51.     }
  54.     @Override
  55.     public void setApplicationContext(ApplicationContext applicationContext) throws BeansException {
  56.         this.applicationContext = applicationContext;
  57.     }
  59.     public void setMapperInterface(Class<T> mapperInterface) {
  60.         this.mapperInterface = mapperInterface;
  61.     }
  64.     public void setMapperManagerFactoryBean(BaseMapper mapperManagerFactoryBean) {
  65.         this.mapperManagerFactoryBean = mapperManagerFactoryBean;
  66.     }
  67. }

5、定义默认的BaseMapper的FactoryBean-MapperManagerFactoryBean

  1. public class MapperManagerFactoryBean implements FactoryBean<BaseMapper>, InitializingBean, ApplicationListener<ApplicationEvent> {
  3.     @Override
  4.     public BaseMapper getObject() throws Exception {
  5.         return new CustomBaseMapper();
  6.     }
  8.     @Override
  9.     public Class<?> getObjectType() {
  10.         return BaseMapper.class;
  11.     }
  13.     @Override
  14.     public boolean isSingleton() {
  15.         return true;
  16.     }
  18.     @Override
  19.     public void afterPropertiesSet() throws Exception {
  20.         //TODO 判断属性的注入是否正确
  21.     }
  23.     /**
  24.      * Handle an application event.
  25.      *
  26.      * @param event the event to respond to
  27.      */
  28.     @Override
  29.     public void onApplicationEvent(ApplicationEvent event) {
  30.         System.out.println(event.toString());
  31.     }
  32. }

6、核心的java动态代理类：MapperJavaProxy

  1. public class MapperJavaProxy implements InvocationHandler {
  3.     private BaseMapper baseMapper;
  5.     private Class<?> interfaceClass;
  7.     public MapperJavaProxy(BaseMapper baseMapper, Class<?> interfaceClass) {
  8.         this.baseMapper = baseMapper;
  9.         this.interfaceClass = interfaceClass;
  10.     }
  12.     @Override
  13.     public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
  14.         if (!interfaceClass.isInterface()) {
  15.             throw new IllegalArgumentException("mapperInterface is not interface.");
  16.         }
  18.         if (baseMapper == null) {
  19.             baseMapper = new CustomBaseMapper();
  20.         }
  21.         return method.invoke(baseMapper, args);
  22.     }
  23. }

7、调用时的核心配置类：DefaultClassRegistryBeanFactory

  1. public class DefaultClassRegistryBeanFactory implements ApplicationContextAware, BeanDefinitionRegistryPostProcessor, BeanNameAware {
  3.     private String scanPackage;
  5.     private String beanName;
  7.     private String mapperManagerFactoryBean;
  9.     private ApplicationContext applicationContext;
  11.     public String getScanPackage() {
  12.         return scanPackage;
  13.     }
  15.     public void setScanPackage(String scanPackage) {
  16.         this.scanPackage = scanPackage;
  17.     }
  19.     public String getMapperManagerFactoryBean() {
  20.         return mapperManagerFactoryBean;
  21.     }
  23.     public void setMapperManagerFactoryBean(String mapperManagerFactoryBean) {
  24.         this.mapperManagerFactoryBean = mapperManagerFactoryBean;
  25.     }
  27.     @Override
  28.     public void postProcessBeanDefinitionRegistry(BeanDefinitionRegistry beanDefinitionRegistry) throws BeansException {
  29.         if (StringUtils.isEmpty(this.scanPackage)) {
  30.             throw new IllegalArgumentException("scanPackage can't be null");
  31.         }
  32.         String basePackage2 = this.applicationContext.getEnvironment().resolvePlaceholders(this.scanPackage);
  33.         String[] packages = StringUtils.tokenizeToStringArray(basePackage2, ConfigurableApplicationContext.CONFIG_LOCATION_DELIMITERS);
  34.         DefaultClassPathScanner defaultClassPathScanner = new DefaultClassPathScanner(beanDefinitionRegistry);
  35.         defaultClassPathScanner.setMapperManagerFactoryBean(mapperManagerFactoryBean);
  36.         defaultClassPathScanner.registerFilters();
  38.         defaultClassPathScanner.doScan(packages);
  39.     }
  41.     @Override
  42.     public void postProcessBeanFactory(ConfigurableListableBeanFactory configurableListableBeanFactory) throws BeansException {
  44.     }
  46.     @Override
  47.     public void setApplicationContext(ApplicationContext applicationContext) throws BeansException {
  48.         this.applicationContext = applicationContext;
  49.     }
  51.     @Override
  52.     public void setBeanName(String name) {
  53.         this.beanName = name;
  54.     }
  55. }

8、调用测试

8.1、假设你在包目录：colin.spring.basic.advanced.inject.dao下声明自定义的类UserMapper

  1. public interface UserMapper extends BaseMapper {
  2. }

8.2、声明配置类：ClassRegistryBeanScannerConfig

  1. @Configuration
  2. public class ClassRegistryBeanScannerConfig {
  4.     @Bean(name = "mapperManagerFactoryBean")
  5.     public MapperManagerFactoryBean configMapperManagerFactoryBean() {
  6.         MapperManagerFactoryBean mapperManagerFactoryBean = new MapperManagerFactoryBean();
  7.         return mapperManagerFactoryBean;
  8.     }
  10.     @Bean
  11.     public DefaultClassRegistryBeanFactory configDefaultClassRegistryBeanFactory() {
  12.         DefaultClassRegistryBeanFactory defaultClassRegistryBeanFactory = new DefaultClassRegistryBeanFactory();
  13.         defaultClassRegistryBeanFactory.setScanPackage("colin.spring.basic.advanced.inject.dao");
  14.         defaultClassRegistryBeanFactory.setMapperManagerFactoryBean("mapperManagerFactoryBean");
  15.         return defaultClassRegistryBeanFactory;
  16.     }
  17. }

8.3、测试调用

  1. public static void main(String[] args) {
  2.         AnnotationConfigApplicationContext acApplicationCOntext = new AnnotationConfigApplicationContext("colin.spring.basic.advanced.inject");
  3.         UserMapper userMapper = acApplicationCOntext.getBean(UserMapper.class);
  4.         userMapper.add("lalaldsf");
  5.         acApplicationCOntext.stop();
  6.     }

总结：

此处对于BeanPostProcessor接口的调用应该属于高级应用了，该思路常用来解决扩展或集成Spring框架，其核心的思路可以分为以下几步：

1、自定义实现类路径扫描类，决定哪些类应该被注入进Spring容器。

2、采用Java动态代理来动态实现对于声明接口类的注入。

3、实现BeanDefinitionRegistryPostProcessor，在Spring初始化初期将需要扫描导入Spring容器的类进行注入。

（PS:需要对Spring的BeanDefinition类有一定的了解，下一张我们来分析该类的）

发表评论

表情：
评论列表 （有 0 条评论，532人围观）

还没有评论，来说两句吧...

相关阅读

    相关 Spring5系列(四) | 依赖注入

    上篇文章我们讲解了如何通过spring的工厂创建对象。对象有了，但是其实往往我们也不能够直接进行使用，有时候需要对对象进行赋值的操作。而spring中有一个比较重要的概念叫做依

    清疚清疚/ 0 赞/ 276 阅读