0
0

SpringBoot如何自定义自己的条件注解与自动配置

本专栏将从基础开始，循序渐进，以实战为线索，逐步深入SpringBoot相关知识相关知识，打造完整的云原生学习步骤，提升工程化编码能力和思维能力，写出高质量代码。希望大家都能够从中有所收获，也请大家多多支持。
专栏地址:SpringBoot专栏 **
本文涉及的代码都已放在gitee上：gitee地址
** 如果文章知识点有错误的地方，请指正！大家一起学习，一起进步。

Spring Boot的核心功能就是为整合第三方框架提供自动配置，而本文则带着大家实现了自己的自动配置和Starter，一旦真正掌握了本文的内容，就会对Spring Boot产生“一览众山小”的感觉。

文章目录

自定义条件注解

在SpringBoot中，所有自定义条件注解其实都是基于@Conditional而来的，使用@Conditional定义新条件注解关键就是要有一个Condition实现类，该Condition实现类就负责条件注解的处理逻辑，该实现类所实现的matches()方法决定了条件注解的要求是否得到满足。

下面是自定义条件注解的Condition实现类的代码。

  • src/main/java/com/example/_003configtest/condition/MyCondition.java
packagecom.example._003configtest.condition;importcom.example._003configtest.annotation.ConditionalCustom;importorg.springframework.context.annotation.Condition;importorg.springframework.context.annotation.ConditionContext;importorg.springframework.core.env.Environment;importorg.springframework.core.type.AnnotatedTypeMetadata;importjava.util.Map;publicclassMyConditionimplementsCondition{@Overridepublicbooleanmatches(ConditionContext context,AnnotatedTypeMetadata metadata){//获取@ConditionalCustom注解的全部属性,其中ConditionalCustom是自定义的注解Map<String,Object> annotationAttributes = metadata.getAnnotationAttributes(ConditionalCustom.class.getName());//获取注解的value属性值String[] vals =(String[]) annotationAttributes.get("value");//env是application.properties或application.yml中配置的属性Environment env = context.getEnvironment();//遍历每个value的每个属性值for(String val : vals){//如果某个属性值对应的配置属性不存在，则返回falseif(env.getProperty(val.toString())==null){returnfalse;}}returntrue;}}

从上面的逻辑可以看到，自定义条件注解的处理逻辑比较简单：就是要求value属性所指定的所有配置属性必须存在，至于这些配置属性的值是什么无所谓，这些配置属性是否有值也无所谓。

有了上面的Condition实现类之后，接下来即可基于@Conditional来定义自定义条件注解。下面是自定义条件注解的代码。

  • src/main/java/com/example/_003configtest/annotation/ConditionalCustom.java
packagecom.example._003configtest.annotation;importcom.example._003configtest.condition.MyCondition;importorg.springframework.context.annotation.Conditional;importjava.lang.annotation.*;@Target({ElementType.TYPE,ElementType.METHOD})@Retention(RetentionPolicy.RUNTIME)@Documented//只要通过@Conditional指定Condition实现类即可，该Condition实现类就会负责该条件注解的判断逻辑@Conditional(MyCondition.class)public@interfaceConditionalCustom{String[]value()default{};}

下面的配置类示范了如何使用该自定义的条件注解：

  • src/main/java/com/example/_003configtest/config/MyConfigTest.java
// proxyBeanMethods = true  :单例模式,保证每个@Bean方法被调用多少次返回的组件都是同一个// proxyBeanMethods = false :原型模式，每个@Bean方法被调用多少次返回的组件都是新创建的@Configuration(proxyBeanMethods =true)publicclassMyConfigTest{@Bean//只有当applicaion.properties或application.yml中org.test1,org.test2两个配置属性都存在时才生效@ConditionalCustom({"org.test1","org.test2"})publicMyBeanmyBean(){returnnewMyBean();}}

在application.properties文件中添加如下配置：

org.test1 =1
org.test2 =2

运行测试发现成功获得了容器中对应的类：

image-20220608230844951

自定义自动配置

开发自己的自动配置很简单，其实也就两步：

  1. 使用@Configuration和条件注解定义自动配置类。
  2. 在META-INF/spring.factories文件中注册自动配置类。

为了清楚地演示Spring Boot自动配置的效果，避免引入第三方框架导致的额外复杂度，本例先自行开发一个funny框架，该框架的功能是用文件或数据库保存程序的输出信息。

新建一个Maven项目funny(注意不是用SpringInitializr创建项目)，为该项目添加mysql-connector-java和slf4j-api两个依赖。由于该项目是我们自己开发的框架，因此无须为该项目添加任何Spring Boot依赖。下面是该项目的pom.xml文件代码。

<?xml version="1.0" encoding="UTF-8"?><project xmlns="http://maven.apache.org/POM/4.0.0"
         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd"><modelVersion>4.0.0</modelVersion><groupId>org.example</groupId><artifactId>funny</artifactId><version>1.0-SNAPSHOT</version><!-- 定义所使用的Java版本和源代码使用的字符集--><properties><maven.compiler.source>8</maven.compiler.source><maven.compiler.target>8</maven.compiler.target><project.build.sourceEncoding>UTF-8</project.build.sourceEncoding></properties><dependencies><!--MySQL数据库驱动依赖 --><dependency><groupId>mysql</groupId><artifactId>mysql-connector-java</artifactId><version>8.0.27</version></dependency><!-- https://mvnrepository.com/artifact/org.slf4j/slf4j-api --><dependency><groupId>org.slf4j</groupId><artifactId>slf4j-api</artifactId><version>1.7.36</version></dependency></dependencies></project>

接下来为这个框架项目开发如下类。

  • src/main/java/io/WriterTemplate.java
packageio;importorg.slf4j.Logger;importorg.slf4j.LoggerFactory;importjava.io.File;importjava.io.FileNotFoundException;importjava.io.IOException;importjava.io.RandomAccessFile;importjava.nio.charset.Charset;importjava.sql.Connection;importjava.sql.ResultSet;importjava.sql.SQLException;importjava.util.Objects;importjavax.sql.DataSource;publicclassWriterTemplate{Logger log =LoggerFactory.getLogger(this.getClass());privatefinalDataSource dataSource;privateConnection conn;privateFile dest;privatefinalCharset charset;privateRandomAccessFile raf;publicWriterTemplate(DataSource dataSource)throwsSQLException{this.dataSource = dataSource;this.dest =null;this.charset =null;if(Objects.nonNull(this.dataSource)){
            log.debug("========获取数据库连接========");this.conn = dataSource.getConnection();}}publicWriterTemplate(File dest,Charset charset)throwsFileNotFoundException{this.dest = dest;this.charset = charset;this.dataSource =null;this.raf =newRandomAccessFile(this.dest,"rw");}publicvoidwrite(String message)throwsIOException,SQLException{if(Objects.nonNull(this.conn)){//查询当前数据库的fnny_message表是否存在ResultSet rs = conn.getMetaData().getTables(conn.getCatalog(),null,"funny_message",null);//如果funy_message表不存在，需要创建表if(!rs.next()){
                log.debug("~~~~~~~~~创建funny_message表~~~~~~~~~");
                conn.createStatement().execute("create table funny_message "+"(id int primary key auto_increment,message_text text)");}
            log.debug("~~~~~~~~~输出到数据表~~~~~~~~~");//往数据库中插入数据
            conn.createStatement().executeUpdate("insert into "+"funny_message values(null,'"+ message +"')");
            rs.close();}else{
            log.debug("~~~~~~~~~输出到文件~~~~~~~~~");
            raf.seek(this.dest.length());
            raf.write((message +"\n").getBytes(this.charset));}}//关闭资源publicvoidclose()throwsSQLException,IOException{if(this.conn !=null){this.conn.close();}if(this.raf !=null){this.raf.close();}}}

该工具类根据是否传入 DataSource 来决定输出目标：如果为该工具类传入了DataSource，它就会向该数据源所连接的数据库中的funny_message表输出内容（如果该表不存在，该工具类将会自动建表）；如果没有为该工具类传入DataSource，它就会向指定文件输出内容。

接下来使用install打包到maven仓库：

image-20220609112738611

有了该框架之后，接下来为该框架开发自动配置。如果为整合现有的第三方框架开发自动配置，则可直接从这一步开始（因为框架已经存在了，直接为框架开发自动配置即可）。

同样新建一个Maven项目funny-spring-boot-starter(为了方便可以用SpringInitializr创建项目)，这个项目是自定义Starter项目，因此必须要有Spring Boot支持，将前面Spring Boot项目中的pom.xml文件复制过来，保留其中的spring-boot-starter依赖，并添加刚刚开发的funny框架的依赖。此外，由于该项目不是Spring Boot应用，因此不需要主类，也不需要运行，故删除其中的spring-boot-maven-plugin插件。修改后的pom.xml文件内容如下。

<?xml version="1.0" encoding="UTF-8"?><projectxmlns="http://maven.apache.org/POM/4.0.0"xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 https://maven.apache.org/xsd/maven-4.0.0.xsd"><modelVersion>4.0.0</modelVersion><groupId>com.example</groupId><artifactId>funny-spring-boot-starter</artifactId><version>0.0.1-SNAPSHOT</version><name>funny-spring-boot-starter</name><description>funny-spring-boot-starter</description><properties><java.version>1.8</java.version><project.build.sourceEncoding>UTF-8</project.build.sourceEncoding><project.reporting.outputEncoding>UTF-8</project.reporting.outputEncoding><spring-boot.version>2.3.7.RELEASE</spring-boot.version></properties><dependencies><!-- Spring Boot Starter依赖--><dependency><groupId>org.springframework.boot</groupId><artifactId>spring-boot-starter</artifactId></dependency><!-- 依赖自定义的funny框架，如果正在为其他第三方框架开发自动配置，则此处应该填写被整合的第三方框架的坐标。--><dependency><groupId>org.example</groupId><artifactId>funny</artifactId><version>1.0-SNAPSHOT</version></dependency></dependencies><dependencyManagement><dependencies><dependency><groupId>org.springframework.boot</groupId><artifactId>spring-boot-dependencies</artifactId><version>${spring-boot.version}</version><type>pom</type><scope>import</scope></dependency></dependencies></dependencyManagement></project>

接下来定义如下自动配置类。

  • src/main/java/com/example/funnyspringbootstarter/autoconfig/FunnyAutoConfiguration.java
packagecom.example.funnyspringbootstarter.autoconfig;importio.WriterTemplate;importorg.springframework.boot.autoconfigure.AutoConfigureAfter;importorg.springframework.boot.autoconfigure.AutoConfigureOrder;importorg.springframework.boot.autoconfigure.condition.ConditionalOnClass;importorg.springframework.boot.autoconfigure.condition.ConditionalOnMissingBean;importorg.springframework.boot.autoconfigure.condition.ConditionalOnSingleCandidate;importorg.springframework.boot.autoconfigure.jdbc.DataSourceAutoConfiguration;importorg.springframework.boot.context.properties.EnableConfigurationProperties;importorg.springframework.context.annotation.Bean;importorg.springframework.context.annotation.Configuration;importjavax.sql.DataSource;importjavax.xml.crypto.Data;importjava.io.File;importjava.io.FileNotFoundException;importjava.nio.charset.Charset;importjava.sql.SQLException;@Configuration//当WriteTemplate类存在时配置生效@ConditionalOnClass(WriterTemplate.class)//FunnyProperties是自定义的类，后面会定义，这里表示启动FunnyProperties@EnableConfigurationProperties(FunnyProperties.class)//让该自动配置类位于DataSourceAutoConfiguration自动配置类之后处理@AutoConfigureAfter(DataSourceAutoConfiguration.class)publicclassFunnyAutoConfiguration{privatefinalFunnyProperties properties;//FunnyProperties类负责加载配置属性publicFunnyAutoConfiguration(FunnyProperties properties){this.properties = properties;}@Bean(destroyMethod ="close")//当单例的DataSource Bean存在时配置生效@ConditionalOnSingleCandidate(DataSource.class)//只有当容器中没有WriterTemplate Bean时，该配置才会生效@ConditionalOnMissingBean//通过@AutoConfigureOrder注解指定该配置方法比下一个配置WriterTemplate的方法的优先级更高@AutoConfigureOrder(99)publicWriterTemplatewriterTemplate(DataSource dataSource)throwsSQLException{returnnewWriterTemplate(dataSource);}@Bean(destroyMethod ="close")//只有当前面的WriteTemplate配置没有生效时，该方法的配置才会生效@ConditionalOnMissingBean@AutoConfigureOrder(199)publicWriterTemplatewriterTemplate2()throwsFileNotFoundException{File f =newFile(this.properties.getDest());Charset charset =Charset.forName(this.properties.getCharset());returnnewWriterTemplate(f,charset);}}

在FunnyAutoConfiguration 自动配置类中定义了两个@Bean方法，这两个@Bean 方法都用于自动配置 WriterTemplate。为了指定它们的优先级，程序使用了@AutoConfigureOrder 注解修饰它们，该注解指定的数值越小，优先级越高。

FunnyAutoConfiguration 自动配置类中的@Bean 方法同样使用了@ConditionalOnMissingBean`@ConditionalOnSingleCandidate等条件注解修饰，从而保证只有当容器中不存在WriterTemplate时，该自动配置类才会配置WriterTemplate Bean，且优先配置基于DataSource的WriterTemplate。

上面的自动配置类还用到了FunnyProperties属性处理类，该类的代码如下：

packagecom.example.funnyspringbootstarter.autoconfig;importorg.springframework.boot.context.properties.ConfigurationProperties;@ConfigurationProperties(prefix =FunnyProperties.FUNNY_PREFIX)publicclassFunnyProperties{publicstaticfinalString FUNNY_PREFIX ="org.test";privateString dest;privateString charset;publicStringgetDest(){return dest;}publicvoidsetDest(String dest){this.dest = dest;}publicStringgetCharset(){return charset;}publicvoidsetCharset(String charset){this.charset = charset;}}

上面的属性处理类负责处理以“org.test”开头的属性，这个“org.test”是必要的，它相当于这一组配置属性的“命名空间”，通过这个命名空间可以将这些配置属性与其他框架的配置属性区分开。

有了上面的自动配置类之后，接下来使用如下META-INF/spring.factories文件来注册自动配置类。

  • src/main/resources/META-INF/spring.factories
org.springframework.boot.autoconfigure.EnableAutoConfiguration = \
  com.example.funnyspringbootstarter.autoconfig.FunnyAutoConfiguration

经过上面步骤，自动配置开发完成,接下来使用install打包到maven仓库：

image-20220609125306059

有了自定义的Starter之后，接下来使用该Starter与使用Spring Boot官方Starter并没有任何区别。首先新建一个Maven项目myfunnytest，在pom文件中引入该starter：

<?xml version="1.0" encoding="UTF-8"?><projectxmlns="http://maven.apache.org/POM/4.0.0"xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 https://maven.apache.org/xsd/maven-4.0.0.xsd"><modelVersion>4.0.0</modelVersion><groupId>com.example</groupId><artifactId>myfunnytest</artifactId><version>0.0.1-SNAPSHOT</version><name>myfunnytest</name><description>myfunnytest</description><properties><java.version>1.8</java.version><project.build.sourceEncoding>UTF-8</project.build.sourceEncoding><project.reporting.outputEncoding>UTF-8</project.reporting.outputEncoding><spring-boot.version>2.3.7.RELEASE</spring-boot.version></properties><dependencies><dependency><groupId>com.example</groupId><artifactId>funny-spring-boot-starter</artifactId><version>0.0.1-SNAPSHOT</version></dependency><!--        <dependency>--><!--            <groupId>org.springframework.boot</groupId>--><!--            <artifactId>spring-boot-starter</artifactId>--><!--        </dependency>--><dependency><groupId>org.springframework.boot</groupId><artifactId>spring-boot-starter-test</artifactId><scope>test</scope><exclusions><exclusion><groupId>org.junit.vintage</groupId><artifactId>junit-vintage-engine</artifactId></exclusion></exclusions></dependency></dependencies><dependencyManagement><dependencies><dependency><groupId>org.springframework.boot</groupId><artifactId>spring-boot-dependencies</artifactId><version>${spring-boot.version}</version><type>pom</type><scope>import</scope></dependency></dependencies></dependencyManagement><build><plugins><plugin><groupId>org.apache.maven.plugins</groupId><artifactId>maven-compiler-plugin</artifactId><version>3.8.1</version><configuration><source>1.8</source><target>1.8</target><encoding>UTF-8</encoding></configuration></plugin><plugin><groupId>org.springframework.boot</groupId><artifactId>spring-boot-maven-plugin</artifactId><version>2.3.7.RELEASE</version><configuration><mainClass>com.example.myfunnytest.MyfunnytestApplication</mainClass></configuration><executions><execution><id>repackage</id><goals><goal>repackage</goal></goals></execution></executions></plugin></plugins></build></project>

由于 funny-spring-boot-starter 本身需要依赖 spring-boot-starter，因此不再需要显式配置依赖spring-boot-starter。

在添加了上面的funny-spring-boot-starter依赖之后，该Starter包含的自动配置生效，它会尝试在容器中自动配置WriterTemplate，并且还会读取application.properties因此还需要在application.properties文件中进行配置。

  • src/main/resources/application.properties
# 应用名称
spring.application.name=myfunnytest
org.test.dest = F:/abc-12345.txt
org.test.charset=UTF-8
spring.datasource.url=jdbc:mysql://localhost:3306/springboot?useUnicode=true&characterEncoding=UTF-8&useJDBCCompliantTimezoneShift=true&useLegacyDateTimeCode=false&serverTimezone=GMT%2B8
spring.datasource.username=root
spring.datasource.password=root

该示例的主类很简单，它直接获取容器中的WriterTemplate Bean，并调用该Bean的write（）方法执行输出。下面是该主类的代码:

packagecom.example.myfunnytest;importio.WriterTemplate;importorg.springframework.boot.SpringApplication;importorg.springframework.boot.autoconfigure.SpringBootApplication;importorg.springframework.context.ConfigurableApplicationContext;@SpringBootApplicationpublicclassMyfunnytestApplication{publicstaticvoidmain(String[] args)throwsException{ConfigurableApplicationContext run =SpringApplication.run(MyfunnytestApplication.class, args);WriterTemplate writerTemplate = run.getBean(WriterTemplate.class);System.out.println(writerTemplate);
        writerTemplate.write("自动配置");}}

运行该程序，由于当前Spring容器中没有DataSource Bean，因此FunnyAutoConfiguration将会自动配置输出到文件的WriterTemplate。因此，运行该程序，可以看到程序向“f:/abc-12345.txt”文件（由前面的org.test.dest属性配置）输出内容:

在这里插入图片描述

运行结果如下：

image-20220609130748581

如果在项目的pom.xml文件中通过如下配置来添加依赖。

<!--        Spring Boot JDBC Starter依赖--><dependency><groupId>org.springframework.boot</groupId><artifactId>spring-boot-starter-jdbc</artifactId></dependency>

此时为项目添加了spring-boot-starter-jdbc依赖，该依赖将会在容器中自动配置一个DataSource Bean，这个自动配置的DataSource Bean将导致FunnyAutoConfiguration会自动配置输出到数据库的WriterTemplate。因此，运行该程序，可以看到程序向数据库名为springboot数据库的funny_message表输出内容:

image-20220609132600694

Spring Boot的核心功能就是为整合第三方框架提供自动配置，而本文则带着大家实现了自己的自动配置和Starter，一旦真正掌握了本文的内容，就会对Spring Boot产生“一览众山小”的感觉。

标签： spring boot java spring
本文转载自: https://blog.csdn.net/Learning_xzj/article/details/125215568
版权归原作者 潮浪之巅 所有， 如有侵权，请联系我们删除。
登录后发布评论

“SpringBoot如何自定义自己的条件注解与自动配置”的评论:

还没有评论
关于作者
...
overfit同步小助手
文章同步
相关阅读

249_基于springboot的安全生产培训管理系统（共享资源、学习课件、用户管理、公告管理等功能）

Ubuntu 24.04-自动安装-Nvidia驱动

动态网页爬取 —— ajax 与 selenium

Error:不支持发行版本 5 解决方法--Idea一次性解决所有idea项目（包括新项目）的maven配置问题

Atom：开源世界的代码编辑利器

Hadoop学习 第二章 HDFS

最全Kafka知识宝典之消费端深度剖析

文章导航