Spring Boot之自定义starter

痛定思痛。 2021-11-09 00:58 335阅读 0赞

### 自定义starter ###

*  前言
 *  自定义starter实现步骤
 *   *  创建maven工程
     *  引入必要的依赖
     *  Xxxproperties
     *  核心服务类
     *  自动配置类
     *  创建配置文件
     *  打包
     *  创建一个Spring Boot 工程并引入依赖
     *  修改application.properties配置文件
     *  测试

# 前言 #

在Spring Boot中，使用的最多的就是starter。starter可以理解为一个可拔插式的插件，例如，你想使用jdbc插件，那么可以使用spring-boot-starter-jdbc；如果想使用mongodb，可以使用spring-boot-starter-data-mongodb。 Spring Boot中已经给我们提供了大量使用的starter，本文主要分析如何实现自定义的starter。

# 自定义starter实现步骤 #

## 创建maven工程 ##

由于我们要创建的是需要被依赖的starter，所以是不可以创建Spring Initializr工程的，需要创建一个Maven工程，不需要选择模板。注意ArtifactId的命名规则，Spring官方starter通常命名为spring-boot-starter-\{name\}如 spring-boot-starter-web， Spring官方建议非官方Starter命名应遵循\{name\}-spring-boot-starter的格式, 如mybatis-spring-boot-starter。这里创建的项目的artifactId为hello-spring-boot-starter

## 引入必要的依赖 ##

<?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>com.yjn</groupId>
        <artifactId>hello-spring-boot-starter</artifactId>
        <version>1.0-SNAPSHOT</version>
    
        <dependencies>
            <dependency>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-autoconfigure</artifactId>
                <version>2.1.6.RELEASE</version>
            </dependency>
            <dependency>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-configuration-processor</artifactId>
                <version>2.1.4.RELEASE</version>
                <optional>true</optional>
            </dependency>
        </dependencies>
    
    </project>

## Xxxproperties ##

在使用Spring官方的starter时通常可以在application.properties中来配置参数覆盖掉默认的值，例如在使用redis时一般就会有对应的RedisProperties

@ConfigurationProperties(prefix = "spring.redis")
    public class RedisProperties { 
        private int database = 0;
        private String url;
        private String host = "localhost";
        private String password;
        private int port = 6379;
    }

我们来模仿它定义一个Properties类

package com.yjn.starter;
    
    import org.springframework.boot.context.properties.ConfigurationProperties;
    
    @ConfigurationProperties(prefix = "spring.hello")
    public class HelloProperties { 
        // 姓名
        private String name;
        // 年龄
        private int age;
        // 性别
        private String sex = "M";
    
        // Getter & Setter
         public String getName() { 
            return name;
        }
    
        public void setName(String name) { 
            this.name = name;
        }
    
        public int getAge() { 
            return age;
        }
    
        public void setAge(int age) { 
            this.age = age;
        }
    
        public String getSex() { 
            return sex;
        }
    
        public void setSex(String sex) { 
            this.sex = sex;
        }
    }

## 核心服务类 ##

每个starter都有自己的功能，例如在spring-boot-starter-jdbc中最重要的类时JdbcTemplate，每个starter中的核心业务类明白都不同，也没什么规律（像spring-boot-starter-data-xxx的命名是比较有规律的），这里使用HelloService来定义hello-spring-boot-starter的功能，这里通过一个sayHello来模拟一个功能。

public class HelloService { 
    
        private HelloProperties properties;
    
        public HelloService() { 
        }
    
        public HelloService(HelloProperties properties) { 
            this.properties = properties;
        }
    
        public void sayHello(){ 
            System.out.println("大家好，我叫: " + properties.getName() + ", 今年" + properties.getAge() + "岁"
                    + ", 性别: " + properties.getSex());
        }
    }

## 自动配置类 ##

一般每个starter都至少会有一个自动配置类，一般命名规则使用XxxAutoConfiguration, 例如RedisAutoConfiguration

@Configuration
    @ConditionalOnClass({  JedisConnection.class, RedisOperations.class, Jedis.class })
    @EnableConfigurationProperties(RedisProperties.class)
    public class RedisAutoConfiguration { 
    
    	@Configuration
    	@ConditionalOnClass(GenericObjectPool.class)
    	protected static class RedisConnectionConfiguration { 
    		private final RedisProperties properties;
    		
    		@Bean
    		@ConditionalOnMissingBean(RedisConnectionFactory.class)
    		public JedisConnectionFactory redisConnectionFactory()
    				throws UnknownHostException { 
    			return applyProperties(createJedisConnectionFactory());
    		}
    	}		
    	
    	@Configuration
    	protected static class RedisConfiguration { 
    		@Bean
    		@ConditionalOnMissingBean(name = "redisTemplate")
    		public RedisTemplate<Object, Object> redisTemplate(RedisConnectionFactory redisConnectionFactory)
    						throws UnknownHostException { 
    			RedisTemplate<Object, Object> template = new RedisTemplate<Object, Object>();
    			template.setConnectionFactory(redisConnectionFactory);
    			return template;
    		}
    
    }

这里我们定义自己的自动配置HelloServiceAutoConfiguration，并将核心功能类PersonService放入到Spring Context容器中

@Configuration
    @EnableConfigurationProperties(HelloProperties.class)
    @ConditionalOnClass(HelloService.class)
    @ConditionalOnProperty(prefix = "spring.hello", value = "enabled", matchIfMissing = true)
    public class HelloServiceAutoConfiguration { 
    
        @Autowired
        private HelloProperties properties;
    
        @Bean
        @ConditionalOnMissingBean(HelloService.class)  // 当容器中没有指定Bean的情况下，自动配置HelloService类
        public HelloService helloService(){ 
            HelloService helloService = new HelloService(properties);
            return helloService;
        }
    }

@ConditionalOnClass：当类路径classpath下有指定的类的情况下进行自动配置

@ConditionalOnMissingBean:当容器(Spring Context)中没有指定Bean的情况下进行自动配置

@ConditionalOnProperty(prefix = “example.service”, value = “enabled”, matchIfMissing = true)，当配置文件中example.service.enabled=true时进行自动配置，如果没有设置此值就默认使用matchIfMissing对应的值

@ConditionalOnMissingBean，当Spring Context中不存在该Bean时。

@ConditionalOnBean:当容器(Spring Context)中有指定的Bean的条件下

@ConditionalOnMissingClass:当类路径下没有指定的类的条件下

@ConditionalOnExpression:基于SpEL表达式作为判断条件

@ConditionalOnJava:基于JVM版本作为判断条件

@ConditionalOnJndi:在JNDI存在的条件下查找指定的位置

@ConditionalOnNotWebApplication:当前项目不是Web项目的条件下

@ConditionalOnWebApplication:当前项目是Web项目的条件下

@ConditionalOnResource:类路径下是否有指定的资源

@ConditionalOnSingleCandidate:当指定的Bean在容器中只有一个，或者在有多个Bean的情况下，用来指定首选的Bean

## 创建配置文件 ##

spring.factories

org.springframework.boot.autoconfigure.EnableAutoConfiguration=com.yjn.starter.HelloServiceAutoConfiguration

## 打包 ##

mvn install

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3lqbjE5OTU_size_16_color_FFFFFF_t_70]  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3lqbjE5OTU_size_16_color_FFFFFF_t_70 1]

## 创建一个Spring Boot 工程并引入依赖 ##

<dependency>
                <groupId>com.yjn</groupId>
                <artifactId>hello-spring-boot-starter</artifactId>
                <version>1.0-SNAPSHOT</version>
            </dependency>

## 修改application.properties配置文件 ##

spring.hello.name=JustinNeil
    spring.hello.age=18
    spring.hello.sex=M

## 测试 ##

测试前不要忘记install项目  
![在这里插入图片描述][20190807083426156.png]  
到这里为止一个自定义的starter就实现成功了，在实际开发中需要我们自定义starter的情况其实很少，但是你也许会发现很多有趣的事情，如果能把一些常用的模块这样提取出来，供后来者使用，未尝不是一种对自己的提升。

[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3lqbjE5OTU_size_16_color_FFFFFF_t_70]: /images/20211108/3d12c8753ce0472491f3a80f4343c32c.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3lqbjE5OTU_size_16_color_FFFFFF_t_70 1]: /images/20211108/f2cc7e8c3b4e446591bedf8a9f411307.png
[20190807083426156.png]: /images/20211108/ea4af78355664c8180942301ac207fd5.png