SpringBoot自定义starter增强版（二）——扫描自定义注解

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容器中注册组件的几种方式：

https://blog.csdn.net/zxd1435513775/article/details/100625879

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

https://blog.csdn.net/zxd1435513775/article/details/121180974

3. 代码实现

目录结构

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）使用

https://blog.csdn.net/zxd1435513775/article/details/103039651

@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...";
    }
}

启动日志：

访问接口地址：http://localhost:8001/index

自定义注解修饰的CustomEnhanceService已经被调用。

这样是不是就可以集成第三方应用了。。。。。搞定！

具体代码地址如下：

代码地址：https://github.com/Hofanking/springboot-custom-starter-example