教你写Spring组件

前言

原文地址：https://www.cnblogs.com/qnlcy/p/15905682.html

一、宗旨

在如日中天的 Spring 架构体系下，不管是什么样的组件，不管它采用的接入方式如何眼花缭乱，它们永远只有一个目的：

接入Spring容器

二、Spring 容器

Spring 容器内可以认为只有一种东西，那就是 bean，但是围绕 bean 的生命周期，Spring 添加了许多东西

2.1 `bean` 的生命周期

2.1.1 实例化 bean 实例

实例化 bean 实例是 spring 针对 bean 作的拓展最多的周期

它包括：

bean 的扫描
bean 的解析
bean 实例化

常见扫描相关内容：

@Component、@Service 、@Controller 、@Configuration、applicationContext.xml

spring/springboot 在启动的时候，会扫描到这些注解或配置文件修饰的类信息

根据拿到的类信息，经过第二步解析后，转换成 BeanDefintion 存入到 spring 容器当中，BeanDefintion 描述 bean 的 class、scop、beanName 等信息

在 bean 的解析过程中，我们常用到的 Properties 读取、 @Configuration 配置类的处理会在这一步完成

bean 的实例化实际有自动完成和调用 getBean() 时候完成，还有容器初始化完毕之后实例化 bean ，他们都是根据 bean 的定义 BeanDefintion 来反射目标 bean 类，并放到 bean 容器当中

这就是大名鼎鼎的 bean 容器，就是一个 Map

private final Map<String, Object> singletonObjects = new ConcurrentHashMap<>(256);

2.1.2 设置实例属性

这一阶段是 @Value 、@Autowired 、@Resource 注解起作用的阶段

2.1.3 bean 前置处理

BeanPostProcessor 前置处理方法

2.1.4 bean init 处理

@PostConstruct 注解起作用的阶段

2.1.5 bean 后置处理

BeanPostProcessor 后置处理方法

2.1.6 正常使用

2.1.7 bean 销毁

@PreDestroy 注解起作用的阶段

bean 的销毁过程中，主要的作用就是释放一些需要手动释放的资源和一些收尾工作，如文件归并、连接池释放等

在了解了 Spring bean 的生命周期后，我们接下来介绍自建 Spring 组件的接入方式

三、使用简单配置类接入方式

使用配置类接入 Spring ，一般需要搭配 PostConstruct 来使用，并且要确保 Spring 能扫描到配置

如，在组件 quartz-configable 1.0 版本当中，就是使用的这种方式

quartz-configable 需要扫描用户自定义的 job 来注册到 quartz-configable 自动创建的调度器 Scheduler 当中，并启动调度器 Scheduler

在注册 Job 的过程当中，又添加了自定义的 TriggerListener 监听器，来监听配置的变动，以动态调整 Job 执行时机

@Configuration
public class QuartzInitConfig {
    @Autowired
    private Scheduler scheduler;
    @Autowired
    private CustomTriggerListener customTriggerListener;
    @PostConstruct
    public void init() {
        //先把所有jobDetail放到map里
        initJobMap();
        //添加自定义Trigger监听器，进行任务开关的监听和故障定位的配置
        addTriggerListener(scheduler, customTriggerListener);
        //添加任务到任务调度器中
        addJobToScheduler(scheduler);
        //启动任务调度器
        try {
            scheduler.start();
        } catch (SchedulerException e) {
            log.error("任务调度器启动失败", e);
            throw new RuntimeException("任务调度器启动失败");
        }
        log.info("任务调度器已启动");
    }
    private void initJobMap() {
        //省略部分代码
    }
    private void addJobToScheduler(Scheduler scheduler) {
        //省略部分代码
    }
    private void addTriggerListener(Scheduler scheduler, CustomTriggerListener customTriggerListener) {
        //省略部分代码
    }
}

QuartzInitConfig 类的作用是把扫描到的任务类放入调度器当中，并添加自定义监听（用于动态修改 cron 表达式）

此类加载有两个过程：

注入组件初始化需要的资源
根据注入的资源初始化组件

步骤 1 所需要的功能与 Spring 的注入功能完美契合，而恰好 @Configuration 修饰的类也被当作了一个 Spring bean，所以才能顺利注入组件需要的资源

步骤 2 的初始化任务，极为契合 Spring bean 创建完毕后的初始化动作 @PostConstruct 当中，它同样是资源注入完毕后的初始化动作。

四、带有条件的简单配置类

有时候，我们希望通过开关或者特定的配置来启用应用内具备的功能，这时候，我们可以使用 @ConditionalOnProperty 来解决问题

risk 组件扫描出符合规则的切点，在切点执行之前，去执行发送风控数据到风控平台的动作

@Configuration
@ConditionalOnProperty({"risk.expression", "risk.appid", "risk.appsecret", "risk.url"})
public class RiskAspectConfig {
    //项目内配置
    @Value("${risk.expression}")
    private String riskExpression;
    @Bean
    public DefaultPointcutAdvisor defaultPointcutAdvisor() {
        SpringBeans springBeans = springBeans();
        RiskSenderDelegate riskSenderDelegate = new RiskSenderDelegate(springBeans);
        GrjrMethodInterceptor grjrMethodInterceptor = new GrjrMethodInterceptor(riskSenderDelegate);
        JdkRegexpMethodPointcut jdkRegexpMethodPointcut = new JdkRegexpMethodPointcut();
        jdkRegexpMethodPointcut.setPattern(riskExpression);
        log.info("切面准备完毕，切点为{}", riskExpression);
        return new DefaultPointcutAdvisor(jdkRegexpMethodPointcut, grjrMethodInterceptor);
    }
    //省略部分代码
}

虽然类 RiskAspectConfig 是一个 Spring 配置类，方法 defaultPointcutAdvisor() 创建了一个切点顾问，用来在切点方法处实现风控的功能，但是，并不是应用启动之后，切点就会生效，这是因为有 @ConditionalOnProperty 的存在

@ConditionalOnProperty 的作用：

根据提供的条件判断对应的属性是否存在，存在，则加载此配置类，不存在，则忽略。

当应用中存在如下配置时：

grjr:
  risk:
   expression: xxxx
   appid: xxx
   appsecret: xxx
   url: xxx

RiskAspectConfig 配置类才会被加载，才会生成切点顾问 DefaultPointcutAdvisor，因此切点就会生效

当需要的配置逐渐增多的时候，一条条添加进 @ConditionalOnProperty 显得比较冗长复杂，这时候该如何处理呢？

五、使用对应的 Properties 配置类来封装配置

在项目 fastdfs-spring-boot-starter 当中，像上述需要的配置有很多，那么它是怎么处理的呢？

它把需要的配置放到了一个 Java 类里

@ConfigurationProperties(prefix = "fastdfs.boot")
public class FastDfsProperties {
    private String trackerServerHosts;
    private int trackerHttpPort = 80;
    private int connectTimeout = 5000;
    private int networkTimeout = 30000;
    private boolean antiStealToken = false;
    private String charset = "ISO8859-1";
    private String secretKey;
    //省略字段 get set 方法
}

其中， @ConfigurationProperties 指定了配置的 prefix ，上述配置相当于

fastdfs:
  boot:
    trackerServerHosts: xxx
    trackerHttpPort: 80
    connectTimeout: 5000
    networkTimeout: 30000
    antiStealToken: false
    charset: ISO8859-1
    secretKey: xxx

这种类到现在为止还不可以和 Spring 结合起来，尚需要把它声明为 Spring bean 才生效

声明为 Spring bean 有两种形式

在类本身上添加 @Component 注解，标识这是一个 Spring bean
在 @Configuration 类上使用 @EnableConfigurationProperties 来启用配置

通常的，在开发组件的时候，我们使用第二种方式，把 Properties 的启用，交给 @Configuration 配置类来管理，大家可以想想为什么

@Configuration(proxyBeanMethods = false)
@ConditionalOnMissingBean(FastDfsClient.class) // 当 Spring 容器中不存在 FastDfsClient 时才加载这个类
@EnableConfigurationProperties(FastDfsProperties.class) //启用上面的 FastDfsProperties
public class FastDfsAutoConfiguration {
    /**
    * 创建 FastDfsClient 放到 Spring 容器当中
    */
    @Bean
    @ConditionalOnProperty("fastdfs.boot.trackerServerHosts")
    FastDfsClient fastDFSClient(FastDfsProperties fastDfsProperties) {
        globalInit(fastDfsProperties);
        return new FastDfsClient();
    }
    /**
    * 根据 properties 来配置 fastdfs
    */
    private void globalInit(FastDfsProperties fastDFSProperties) {
        // 省略部分代码
    }
    //省略部分代码
}

@EnableConfigurationProperties(FastDfsProperties.class) 启用了括号内的 Properties 类，并把它们注入到 Spring 容器当中，使其可以被其他 Spring bean 导入

六、使用 META-INF/spring.factories 文件来代替扫描

有时候，我们开发的组件的类路径和应用的类路径不同，比如，应用类路径常常为 com.xxx.xxx，而组件的类路径常常为 com.xxx.yyy，这时候，经常需要为 Spring 指定扫描路径，才能把我们的组件加载进去，如果在自己项目当中加载上述 quartz-configable 组件，组件类路径为 com.xxx.yyy：

@ComponentScan({"com.xxx.xxx", "com.xxx.yyy"})
@SpringBootApplication
public class GrjrFundBatch {
    public static void main(String[] args) {
        SpringApplication.run(GrjrFundBatch.class);
    }
}

如果新增了类似这样的 quartz-configable 组件，就需要改动 @ComponentScan 代码，这对启动类是有侵入性的，也是繁琐的，也极有可能写错，当组件路径有改动的时候也需要跟着改动

怎样避免这种硬编码形式的注入呢？

Springboot 在加载类的时候，会扫描 classpath 下的 META-INF/spring.factories 文件，当发现了 spring.factories 文件后，根据文件中的配置来加载类

其中一项配置为 org.springframework.boot.autoconfigure.EnableAutoConfiguration=xxx.xxx.xxx.xxxx ，它声明了 Springboot 要加载的自动配置类，Springboot根据配置自动去加载配置类

借用这个规则，现在来升级我们的 quartz-configable 组件

我们在组件项目 resources 目录下添加 META-INF/spring.factories 文件，文件内容如下

org.springframework.boot.autoconfigure.EnableAutoConfiguration=com.grjr.quartz.config.GjSchedulerAutoConfiguration

然后在应用启动类当中删除已经无用的 @Component 注解即可

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

此时，quartz-configable 依然能生效

使用 META-INF/spring.factories 虽然带来了简洁和便利，但是它总是去自动加载配置类，所以我们在设计组件的时候，一定要搭配 @ConditionOnxxxx 注解，有条件的去加载我们的组件

七、使用自定义 @EnableXxxx 注解的形式开启组件功能

就像上面说的一样，使用 META-INF/spring.factories 总会去加载配置类，自定义扫描路径有可能会写错类路径，那么，还有没有其他方式呢？

有，使用自定义注解来注入自己的组件，就像 dubbo 的 starter 组件一样，我们自己造一个 @EnableXxx 注解

7.1 自定义注解的核心

自定义注解的核心是 Spring 的 @Import 注解，它基于 @Import 注解来注入组件自身需要的资源和初始化组件自身

7.2 @Import 注解解析

@Import 注解是 Spring 用来注入 Spring bean 的一种方式，可以用来修饰别的注解，也可以直接在 Springboot 配置类上使用。

它只有一个value属性需要设置，来看一下源码

public @interface Import {
    Class<?>[] value();
}

这里的 value属性只接受三种类型的Class：

被 @Configuration 修饰的配置类
接口 org.springframework.context.annotation.ImportBeanDefinitionRegistrar 的实现类
接口 org.springframework.context.annotation.ImportSelector 的实现类

下面针对三种类型的 Class 分别做简单介绍，中间穿插自定义注解与外部配置的结合使用方式。

7.2.1 被`@Configuration` 修饰的配置类

像 Springboot 中的配置类一样正常使用，需要注意的是，如果该类的包路径已在 Springboot 启动类上配置的扫描路径下，则不需要再重新使用 @Import 导入了，因为 @Import 的目的是注入 bean，但是 Springboot 启动类自动扫描已经可以注入你想通过 @Import 导入的 bean 了。

7.2.2 接口 `org.springframework.context.annotation.ImportBeanDefinitionRegistrar` 的实现类

当 @Import 修饰自定义注解时候，通常会导入这个接口的实现类。

来看一下接口定义

public interface ImportBeanDefinitionRegistrar {
    default void registerBeanDefinitions(AnnotationMetadata importingClassMetadata, BeanDefinitionRegistry registry,
            BeanNameGenerator importBeanNameGenerator) {
        registerBeanDefinitions(importingClassMetadata, registry);
    }
    /**
    * importingClassMetadata 被@Import修饰的自定义注解的元信息，可以获得属性集合
    * registry Spring bean注册中心
    **/
    default void registerBeanDefinitions(AnnotationMetadata importingClassMetadata, BeanDefinitionRegistry registry) {
    }

通过这种方式，我们可以根据自定义注解配置的属性值来注入 Spring Bean 信息。

来看如下案例，我们通过一个注解，启动 RocketMq 的消息发送器：

@SpringBootApplication
@EnableMqProducer(group="xxx")
public class App {
    public static void main(String[] args) {
        SpringApplication.run(App.class);
    }
}

这是一个服务项目的启动类，这个服务开启了 RocketMq 的一个发送器，并且分到 xxx 组里。

来看一下 @EnableMqProducer 注解

@Retention(RetentionPolicy.RUNTIME)
@Target({ElementType.TYPE})
@Documented
@Import({XXXRegistrar.class,XXXConfig.class})
public @interface EnableMqProducer {
    String group() default "DEFAULT_PRODUCER_GROUP";
    String instanceName() default "defaultProducer";
    boolean retryAnotherBrokerWhenNotStoreOK() default true;
}

这里使用 @Import 导入了两个配置类，第一个是接口 org.springframework.context.annotation.ImportBeanDefinitionRegistrar 的实现类，第二个是被 @Configuration 修饰的配置类

我们看第一个类 XXXRegistrar，这个类的功能是注入一个自定义的 DefaultMQProducer 到Spring 容器中，使业务方可以直接通过 @Autowired 注入 DefaultMQProducer 使用

public class XXXRegistrar implements ImportBeanDefinitionRegistrar {
    @Override
    public void registerBeanDefinitions(AnnotationMetadata importingClassMetadata, BeanDefinitionRegistry registry) {
        //获取注解里配置的属性
        AnnotationAttributes attributes = AnnotationAttributes.fromMap(importingClassMetadata.getAnnotationAttributes(EnableMqProducer.class.getName()));
        //根据配置的属性注入自定义 bean 到 spring 容器当中
        registerBeanDefinitions(attributes, registry);
    }
    private void registerBeanDefinitions(AnnotationAttributes attributes, BeanDefinitionRegistry registry) {
        //获取配置
        String group = attributes.getString("group");
        //省略部分代码...
        //添加要注入的类的字段值
        Map<String, Object> values = new HashMap<>();
        //这里有的同学可能不清楚为什么key是这个
        //这里的key就是DefaultMQProducer的字段名
        values.put("producerGroup", group);
        //省略部分代码
        //注册到Spring中
        BeanRegistrationUtil.registerBeanDefinitionIfNotExists(registry, DefaultMQProducer.class.getName(), DefaultMQProducer.class, values);
    }

到这里，我们已经注入了一个 DefaultMQProducer 的实例到 Spring 容器中，但是这个实例，还不完整，比如：

还没有启动
nameServer地址还没有配置
外部配置的属性还没有覆盖实例已有的值（nameServer地址建议外部配置）。

但是好消息是，我们已经可以通过注入来使用这个未完成的实例了。

上面遗留的问题，就是第二个类接下来要做的事。

来看第二个配置类

@Configuration
@Role(BeanDefinition.ROLE_INFRASTRUCTURE)
@EnableConfigurationProperties(XxxProperties.class)  //Spring提供的配置自动映射功能，配置后可直接注入
public class XXXConfig {
    @Resource //直接注入
    private XxxProperties XxxProperties;
    @Autowired //注入上一步生成的实例
    private DefaultMQProducer producer;
    @PostConstruct
    public void init() {
        //省略部分代码
        //获取外部配置的值
        String nameServer = XxxProperties.getNameServer();
        //修改实例
        producer.setNamesrvAddr(nameServer);
        //启动实例
        try {
            this.producer.start();
        } catch (MQClientException e) {
            throw new RocketMqException("mq消息发送实例启动失败", e);
        }
    }
    @PreDestroy
    public void destroy() {
        producer.shutdown();
    }

到这里，通过自定义注解和外部配置的结合，一个完整的消息发送器就可以使用了，但方式有取巧之嫌，因为在消息发送器启动之前，不知道还有没有别的类使用了这个实例，这是不安全的。

7.2.3 接口`org.springframework.context.annotation.ImportSelector`的实现类

首先看一下接口

public interface ImportSelector {
    /**
     * importingClassMetadata 注解元信息，可获取自定义注解的属性集合
     * 根据自定义注解的属性，或者没有属性，返回要注入Spring的Class全限定类名集合
     如：XXX.class.getName()，Spring会自动注入XXX的一个实例
     */
    String[] selectImports(AnnotationMetadata importingClassMetadata);
    @Nullable
    default Predicate<String> getExclusionFilter() {
        return null;
    }
}

这个接口的实现类如果没有进行 Spring Aware 接口拓展，功能比较单一，因为我们无法参与 Spring Bean 的构建过程，只是告诉 Spring 要注入的 Bean 的名字。不再详述。

八、总结

综上所述，我们一共聊了三种形式的组件创建方式

相同路径下， @Configuration 修饰的配置类
使用 META-INF/spring.factories 文件接入
结合 @Import 注解注入

其中穿插了 @ConditionOnXxxx 选择性启动、Properties 封装的技术，快去试一下吧