• spring boot 根据注解动态注入bean到spring容器中


     简要

    有的时候需要动态注入bean到spring容器中,@service,@component 满足不了,还可以在class上的根据注解来进行扩展,例如我想根据注解里的多个id来进行注入spring容器中,不用创建每个id来写@component,然后根据id中获取实例,还可以动态注入一些需要的属性,等等。

      解决方案还是有的,而且还不止一种,这都得亏于spring的设计扩展性太强,根据不同时刻满足不同需求,我这边分别用2中方式BeanDefinitionRegistryPostProcessor和ImportBeanDefinitionRegistrar进行切入口

     1.BeanDefinitionRegistryPostProcessor

      结合@Import使用
      spring官方就是用这种方式,实现@Component、@Service等注解的动态注入机制。定义一个ImportBeanDefinitionRegistrar的实现类,然后在有@Configuration注解的配置类上使用@Import导入。

      类似mybatis @Mapper和@MapperScan结合使用,可以指定注解参数,并进行处理业务,比如需要扫描指定的package进行注入,以及实现开启注解功能等,扩展性强

    2.BeanDefinitionRegistryPostProcessor

      这个接口扩展自BeanFactoryPostProcessor,专门用于动态注册Bean。

     其实在spring的生命周期中,bean在实例化之前都是无差别的被当做资源加载进来的,并被封装成一个个Beandefinition。在spring启动时,所有bean实例化的注解和xml文件都会被加载进来,并注册成Beandefinition。准备后续的bean实例化。那么在注册成   Beandefinition这步,spring其实提供给了我们不少后门进行操作。常见的后置处理器BeanDefinitionRegistryPostProcessor就是一个比较常见的自定义操作bean的接口。BeanDefinitionRegistryPostProcessor是BeanFactoryPostProcessor的子接口,     BeanFactoryPostProcessor的作用是在bean的定义信息已经加载但还没有初始化的时候执行方法postProcessBeanFactory()方法,而BeanDefinitionRegistryPostProcessor是在BeanFactoryPostProcessor的前面执。

    实现

    1. 编写自定义注解
    @Target({ElementType.TYPE})
    @Retention(RetentionPolicy.RUNTIME)
    @Documented
    public @interface CoreAnnotation {
        String[] value() default {};
    }

    注解的value是输入数组,比如输入多个id。

    1. 注解应用
    public interface FinService {
        String say(String arg);
    }
    @CoreAnnotation({"write"})
    public class WriteService implements FinService {
        @Override
        public String say(String arg) {
            return "write";
        }
    }

    以上就随意写了个WriteService对象,用coreAnnotation进行注解并写了write值传入。接下来就应该要进行注入bean到spring容器中了

    • BeanDefinitionRegistryPostProcessor

    先用实现这个最简单,只需要实现BeanDefinitionRegistryPostProcessor接口就行,会在启动后执行一次

    先写了一个公共的注册方法,都可以用

        /**
         * 注册 BeanDefinition
         */
        private void registerCandidateComponents(BeanDefinitionRegistry registry, Set<BeanDefinition> candidateComponents) throws ClassNotFoundException {
            for (BeanDefinition candidateComponent : candidateComponents) {
                if (candidateComponent instanceof AnnotatedBeanDefinition) {
                    AnnotatedBeanDefinition annotatedBeanDefinition = (AnnotatedBeanDefinition) candidateComponent;
                    AnnotationMetadata annotationMetadata = annotatedBeanDefinition.getMetadata();
                    Map<String, Object> customImportAnnotationAttributesMap = annotationMetadata.getAnnotationAttributes(CoreAnnotation.class.getName());
                    AnnotationAttributes customImportAnnotationAttributes = Optional.ofNullable(AnnotationAttributes.fromMap(customImportAnnotationAttributesMap)).orElseGet(AnnotationAttributes::new);
              //获取注解里的值 String[] values
    = customImportAnnotationAttributes.getStringArray("value"); String className = annotationMetadata.getClassName(); Class<?> clazzName = Class.forName(className); // AbstractBeanDefinition beanDefinition = BeanDefinitionBuilder.genericBeanDefinition(CustomImportFactoryBean.class) // .addPropertyValue("type", clazzName) // .addPropertyValue("beanName", beanName) // .setAutowireMode(AbstractBeanDefinition.AUTOWIRE_BY_TYPE) // .setRole(BeanDefinition.ROLE_INFRASTRUCTURE) // .getBeanDefinition(); // registry.registerBeanDefinition(beanName, beanDefinition); Arrays.asList(values).forEach(m ->{ RootBeanDefinition mbean = null; try { mbean = new RootBeanDefinition(clazzName); } catch (Exception e) { e.printStackTrace(); } registry.registerBeanDefinition(m, mbean); }); } } }
    @Component
    public class DefinitionRegistryPostProcessor implements BeanDefinitionRegistryPostProcessor, ResourceLoaderAware, EnvironmentAware {
        private Environment environment;
        private ResourceLoader resourceLoader;
    
        @Override
        public void postProcessBeanDefinitionRegistry(BeanDefinitionRegistry beanDefinitionRegistry) throws BeansException {
            //用扫描器根据指定注解进行扫描获取BeanDefinition
            ClassPathBeanDefinitionScanner scanner = new ClassPathBeanDefinitionScanner(beanDefinitionRegistry, false, environment, resourceLoader);
            scanner.addIncludeFilter(new AnnotationTypeFilter(CoreAnnotation.class));
            Set<BeanDefinition> candidateComponents = scanner.findCandidateComponents("com");
            registerCandidateComponents(beanDefinitionRegistry,candidateComponents);
        }
    
        @Override
        public void postProcessBeanFactory(ConfigurableListableBeanFactory configurableListableBeanFactory) throws BeansException {
    
        }
    
        @Override
        public void setEnvironment(Environment environment) {
            this.environment = environment;
        }
    
        @Override
        public void setResourceLoader(ResourceLoader resourceLoader) {
            this.resourceLoader = resourceLoader;
    
        }
    }

    ResourceLoaderAware, EnvironmentAware 这个内置接口,只要实现接口Spring会自动帮你注入,是不是很方便,根据内容来进行对ClassPathBeanDefinitionScanner的扫描获取指定注解,其中findCandidateComponents方法就是指定扫描包开始位置,

    这里写死了com包下,具体的时候需要根据动态的去获取,也可以根据指定用户进行扫描,比如@MapperScan功能

    如果不用ClassPathBeanDefinitionScanner,用反射表Reflections来进行查找注解的哪些对象也可以实现,如下

            Reflections reflections = new Reflections("com");
            Set<Class<? extends FinService>> subTypes = reflections.getSubTypesOf(FinService.class);
            Set<Class<?>> annotated = reflections.getTypesAnnotatedWith(CoreAnnotation.class);
            annotated.forEach(x -> {
                x.getSimpleName();
                CoreAnnotation coreAnnotation = x.getAnnotation(CoreAnnotation.class);
                String[] values = coreAnnotation.value();
                if (null != values) {
                    List<String> strings = Arrays.asList(values);
                    strings.forEach(m -> {
                        RootBeanDefinition mbean = null;
                        try {
                            mbean = new RootBeanDefinition(x.newInstance().getClass());
                        } catch (InstantiationException e) {
                            e.printStackTrace();
                        } catch (IllegalAccessException e) {
                            e.printStackTrace();
                        }
                        beanDefinitionRegistry.registerBeanDefinition(m, mbean);
                    });
                }
            });
    • ImportBeanDefinitionRegistrar

    这个要结合@Import来使用

    @Target({ElementType.TYPE})
    @Retention(RetentionPolicy.RUNTIME)
    @Documented
    @Import(MyImportBeanDefinitionRegistrar.class)
    public @interface EnableCustomImport {
        String[] packages() default {};
    }
    public class MyImportBeanDefinitionRegistrar implements ImportBeanDefinitionRegistrar, ResourceLoaderAware, EnvironmentAware {
        private Environment environment;
        private ResourceLoader resourceLoader;
    
        @SneakyThrows
        @Override
        public void registerBeanDefinitions(AnnotationMetadata importingClassMetadata, BeanDefinitionRegistry registry) {
            boolean enableCustomImport = importingClassMetadata.hasAnnotation(EnableCustomImport.class.getName());
            //@Import不是在这个EnableCustomImport注解上的不执行
            if (!enableCustomImport) {
                return;
            }
            Map<String, Object> annotationAttributesMap = importingClassMetadata.getAnnotationAttributes(EnableCustomImport.class.getName());
            AnnotationAttributes annotationAttributes = Optional.ofNullable(AnnotationAttributes.fromMap(annotationAttributesMap)).orElseGet(AnnotationAttributes::new);
            // 获取需要扫描的包
            String[] packages = retrievePackagesName(importingClassMetadata, annotationAttributes);
            // useDefaultFilters = false,即第二个参数 表示不扫描 @Component、@ManagedBean、@Named 注解标注的类
            ClassPathBeanDefinitionScanner scanner = new ClassPathBeanDefinitionScanner(registry, false, environment, resourceLoader);
            scanner.addIncludeFilter(new AnnotationTypeFilter(CoreAnnotation.class));
            // 扫描包
            for (String needScanPackage : packages) {
                Set<BeanDefinition> candidateComponents = scanner.findCandidateComponents(needScanPackage);
                try {
                    registerCandidateComponents(registry, candidateComponents);
                } catch (ClassNotFoundException e) {
                    e.printStackTrace();
                }
            }
        }
    
        /**
         * 获取需要扫描的包
         */
        private String[] retrievePackagesName(AnnotationMetadata annotationMetadata, AnnotationAttributes annotationAttributes) {
            String[] packages = annotationAttributes.getStringArray("packages");
            if (packages.length > 0) {
                return packages;
            }
            //如果不存在,则默认第一个包开始
            String className = annotationMetadata.getClassName();
            return new String[]{className.split("\.")[0]};
        }
        
        @Override
        public void setEnvironment(Environment environment) {
            this.environment = environment;
        }
    
        @Override
        public void setResourceLoader(ResourceLoader resourceLoader) {
            this.resourceLoader = resourceLoader;
        }
    }

    在启动项中加入@EnableCustomImport注解配置

    @SpringBootApplication
    @EnableCustomImport
    public class Application {
        public static void main(String[] args) {
            SpringApplication.run(Application.class, args);
        }
    }

     

  • 相关阅读:
    redis的安装,使用
    命令行操作数据库
    7天免登陆
    javascript基础 (2)
    SPSS中,进行配对样本T检验
    SPSS中,进行两独立样本T检验
    SPSS中,进行描述性统计,绘制箱线图,直方图,检验数据正态性分布等
    SpringMVC详细步骤
    JAVA线程缓存池
    常用命令(转http://blog.csdn.net/ljianhui/article/details/11100625/)
  • 原文地址:https://www.cnblogs.com/zjtao/p/14938888.html
Copyright © 2020-2023  润新知