Java 扫描包下自定义注解的类 spring 扫描自定义注解

转载

编程之翼 2023-12-24 13:10:54

文章标签 Java 扫描包下自定义注解的类 spring boot 自动配置自定义注解自定义starter 文章分类 Java 后端开发

文章目录

1. 情况说明
2. 步骤
3. 代码实现

3.1 pom文件
3.2 自动配置类
3.3 自定义注解
3.4 CustomEnhanceRegister类
3.4 具体业务类
3.5 spring.factories

4. 测试

1. 情况说明

上篇文章写了一个简单版的SpringBoot自定义starter。其核心原理就是SpringBoot在启动的过程中，会拿到类路径下所有jar包中的META-INF/spring.factories文件，拿到里面的org.springframework.boot.autoconfigure.EnableAutoConfiguration配置项，来判断配置的类是否满足自动装配的条件。

如果自动配置类生效了，就可以做很多事情了。很多第三方jar包的集成就是基于这个点，比如Mybatis和Spring的集成。

下面就模拟一个场景，自己自定义一个注解@Scorpios，让SpringBoot在启动过程中，把指定注解的类扫描进Spring容器中，模拟第三方应用的扩展。

其实现思路和代码，参考了Spring源码

2. 步骤

引入对应的依赖
编写自定义注解：@Scorpios注解
编写自动配置类：@Configuration注解、@Import注解
编写具体扫描实现类：CustomEnhanceRegister
在resources/META-INF/spring.factories中配置自定义的自动装配类

本文知识点涉及@Import注解及ImportBeanDefinitionRegistrar接口的使用，在阅读前，可参考以下文章，熟悉其中知识点：
向Spring容器中注册组件的几种方式：

Spring源码系列（八）——Mybatis是如何整合进Spring源码分析

3. 代码实现

目录结构

Java 扫描包下自定义注解的类 spring 扫描自定义注解_Java 扫描包下自定义注解的类

3.1 pom文件

最后要把自定义的starter工程打成jar，让其他工程引用

<dependencies>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter</artifactId>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
        </dependency>
        <dependency>
            <groupId>org.projectlombok</groupId>
            <artifactId>lombok</artifactId>
        </dependency>
    </dependencies>

3.2 自动配置类

对于这个自动配置类，要配置在META-INF/spring.factories文件里。一旦让这个自动配置类生效，就可以做很多事情啦。下一篇加强版就在这地方做文章的。

@Slf4j
@Configuration
@Import(CustomEnhanceRegister.class)
@ConditionalOnClass(CustomEnhanceService.class) // 当类路径下有指定类 改配置才有效
public class CustomEnhanceAutoConfiguration {

}

3.3 自定义注解

@Documented
@Target(ElementType.TYPE)
@Retention(RetentionPolicy.RUNTIME)
public @interface Scorpios {

    boolean registerBean() default false;

}

3.4 CustomEnhanceRegister类

此类完成自定义注解的扫描和注册。

这里实现实现EnvironmentAware接口，可以拿到系统的环境变量信息。
我们在配置文件application.properties中配置的配置项，最后都会放到这个Environment中。可参考下面这篇文章：
环境变量（Env）和系统属性（Property）使用

@Slf4j
public class CustomEnhanceRegister implements ImportBeanDefinitionRegistrar, EnvironmentAware {

    static final String DEFAULT_RESOURCE_PATTERN = "**/*.class";

    // 实现EnvironmentAware接口，可以拿到系统的环境变量信息
    private Environment environment;

    @Override
    public void setEnvironment(Environment environment) {
        this.environment = environment;
    }

    @Override
    public void registerBeanDefinitions(AnnotationMetadata importingClassMetadata, BeanDefinitionRegistry registry) {

        // 扫描指定包，可以手动传入
        String basePackages = "com.scorpios.customenhance";

        List<Class<?>> candidates = scanPackages(basePackages);
        if (candidates.isEmpty()) {
            log.info("扫描指定包下，未发现符合条件的类", basePackages.toString());
            return;
        }
        // 注册扫描到的类
        registerBeanDefinitions(candidates, registry);
    }


    private List<Class<?>> scanPackages(String basePackages) {
        List<Class<?>> candidates = new ArrayList<Class<?>>();
        try {
            candidates.addAll(findCandidateClasses(basePackages));
        } catch (IOException e) {
            log.error("扫描指定包时出现异常", basePackages);
        }
        return candidates;
    }

    // 将指定包下面的符合条件的类返回
    private List<Class<?>> findCandidateClasses(String basePackage) throws IOException {
        List<Class<?>> candidates = new ArrayList<Class<?>>();
        // classpath*:com/scorpios/**/*.class
        String packageSearchPath = ResourcePatternResolver.CLASSPATH_ALL_URL_PREFIX +
                convertPath(basePackage) + '/' + this.DEFAULT_RESOURCE_PATTERN;
        ResourceLoader resourceLoader = new DefaultResourceLoader();
        MetadataReaderFactory readerFactory = new SimpleMetadataReaderFactory(resourceLoader);
        Resource[] resources = ResourcePatternUtils.getResourcePatternResolver(resourceLoader).getResources(packageSearchPath);
        for (Resource resource : resources) {
            MetadataReader reader = readerFactory.getMetadataReader(resource);
            // 过滤哪些类符合条件，此处判断自定义注解 @Scorpios
            if (match(reader.getClassMetadata())) {
                Class<?> candidateClass = transform(reader.getClassMetadata().getClassName());
                if (candidateClass != null) {
                    candidates.add(candidateClass);
                    log.debug("扫描到符合要求的类：" + candidateClass.getName());
                }
            }
        }
        return candidates;
    }


    private void registerBeanDefinitions(List<Class<?>> internalClasses, BeanDefinitionRegistry registry) {
        for (Class<?> clazz : internalClasses) {
            String beanName = ClassUtils.getShortNameAsProperty(clazz);
            RootBeanDefinition rbd = new RootBeanDefinition(clazz);
            registry.registerBeanDefinition(beanName, rbd);
            if (registerSpringBean(clazz)) {
                registry.registerBeanDefinition(beanName, new RootBeanDefinition(clazz));
            }
        }
    }


    private String convertPath(String path) {
        return StringUtils.replace(path, ".", "/");
    }

    // 根据类名返回Class
    private Class<?> transform(String className) {
        Class<?> clazz = null;
        try {
            clazz = ClassUtils.forName(className, this.getClass().getClassLoader());
        } catch (ClassNotFoundException e) {
            log.info("未找到指定类", className);
        }
        return clazz;
    }


    protected boolean match(ClassMetadata metadata) {
        Class<?> clazz = transformToClass(metadata.getClassName());
        if (clazz == null || !clazz.isAnnotationPresent(Scorpios.class)) {
            return false;
        }
        Scorpios scorpios = clazz.getAnnotation(Scorpios.class);
        if (scorpios.registerBean() && isAnnotatedBySpring(clazz)) {
            throw new IllegalStateException("类{" + clazz.getName() + "}已经标识了Spring组件注解");
        }
        // 过滤抽象类,接口,注解,枚举,内部类及匿名类
        return !metadata.isAbstract() && !clazz.isInterface() && !clazz.isAnnotation() && !clazz.isEnum()
                && !clazz.isMemberClass() && !clazz.getName().contains("$");
    }

    private Class<?> transformToClass(String className) {
        Class<?> clazz = null;
        try {
            clazz = ClassUtils.forName(className, this.getClass().getClassLoader());
        } catch (ClassNotFoundException e) {
            log.info("未找到指定类", className);
        }
        return clazz;
    }


    private boolean isAnnotatedBySpring(Class<?> clazz) {
        return clazz.isAnnotationPresent(Component.class) || clazz.isAnnotationPresent(Configuration.class)
                || clazz.isAnnotationPresent(Service.class) || clazz.isAnnotationPresent(Repository.class)
                || clazz.isAnnotationPresent(Controller.class);
    }

    private boolean registerSpringBean(Class<?> beanClass) {
        return beanClass.getAnnotation(Scorpios.class).registerBean();
    }
}

3.4 具体业务类

使用自定义注解

@Slf4j
@Scorpios
public class CustomEnhanceServiceImpl implements CustomEnhanceService {

    @Override
    public void enhance() {
        log.info("CustomEnhanceServiceImpl...enhance.....");
    }
}

3.5 spring.factories

org.springframework.boot.autoconfigure.EnableAutoConfiguration=com.scorpios.customenhance.autoconfigure.CustomEnhanceAutoConfiguration

4. 测试

新建一个工程，引入上面的jar包，在Controller中，自动注入CustomEnhanceService。

@RestController
public class IndexController {

    @Autowired
    CustomEnhanceService customEnhanceService;

    @RequestMapping("/index")
    public String index(){
        customEnhanceService.enhance();
        return "index 8001...";
    }
}

启动日志：

Java 扫描包下自定义注解的类 spring 扫描自定义注解_自定义注解_02