SpringBoot中自定义starter

SpringBoot三种创建方式

一、在线创建

首先打开 https://start.spring.io 这个网站，如下：

• 项目构建工具是 Maven 还是 Gradle ？有人用 Gradle 做 Java 后端项目，但是整体感觉 Gradle 在 Java 后端中使用的还是比较少，Gradle 在 Android 中使用较多，Java 后端，目前来看还是 Maven 为主，因此这里选择第一项。
• 开发语言，这个当然是选择 Java 了
• Spring Boot 版本，可以看到，目前最新的稳定版是 2.1.7 ，这里我们就是用最新稳定版。
• 既然是 Maven 工程，当然要有项目坐标，项目描述等信息了，另外这里还让输入了包名，因为创建成功后会自动创建启动类
• Packing 表示项目要打包成 jar 包还是 war 包，Spring Boot 的一大优势就是内嵌了 Servlet 容器，打成 jar 包后可以直接运行，所以这里建议打包成 jar 包，当然，开发者根据实际情况也可以选择 war 包。
• 然后选选择构建的 JDK 版本。
• 最后是选择所需要的依赖，输入关键字如 web ，会有相关的提示，这里我就先加入 web 依赖。

二、开发工具创建

然后点击 Next ，填入 Maven 项目的基本信息，如下：

再接下来选择需要添加的依赖，如下图：

勾选完成后，点击 Next 完成项目的创建。

Eclipse 派系的 STS 给大家参考， STS 创建 Spring Boot 项目，实际上也是从上一小节的那个网站上来的，步骤如下：

然后在打开的页面中填入项目的相关信息，如下图：

最后一路点击 Next ，完成项目的创建

三、Maven创建

首先创建一个普通的 Maven 项目，以 IntelliJ IDEA 为例，创建步骤如下：

注意这里不用选择项目骨架（如果大伙是做练习的话，也可以去尝试选择一下，这里大概有十来个 Spring Boot 相关的项目骨架），直接点击 Next ，下一步中填入一个 Maven 项目的基本信息，如下图：

然后点击 Next 完成项目的创建。

创建完成后，在 pom.xml 文件中，添加如下依赖：

<parent>
	<groupId>org.springframework.boot</groupId>    
	<artifactId>spring-boot-starter-parent</artifactId>
	<version>2.1.7.RELEASE</version>
</parent>

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

【spring-boot-starter-parent】的理解：

• 定义了 Java 编译版本为 1.8
• 使用 UTF-8 格式编码
• 继承自 spring-boot-dependencies，这个里边定义了依赖的版本，也正是因为继承了这个依赖，所以我们在写依赖时才不需要写版本号。
• 执行打包操作的配置
• 自动化的资源过滤
• 自动化的插件配置
• 针对 application.properties 和 application.yml 的资源过滤，包括通过 profile 定义的不同环境的配置文件，例如 application-dev.properties 和 application-dev.yml

添加成功后，再在 java 目录下创建包，包中创建一个名为 App 的启动类，如下：

@EnableAutoConfiguration //注解表示开启自动化配置
@RestController
public class App{
	
	public static void main(String[] args){
		SpringApplication.run(App.class,args);
	} 
	@GetMapping("/hello")
	public String hello(){
		return "hello";
	}
}

项目结构如下：

===========================================================

SpringBoot自动装配原理：

1. @EnableAutoConfiguration注解开启自动装配功能，该注解通常放在应用的主类上。
2. spring.factories文件位于META-INF目录下的配置文件中定义各个自动装配类的全限定名

当SpringBoot启动时，会加载classpath下所有的spring.factories文件，并根据定义的自动配置类全限定名，将其实例化并添加到Spring应用上下文中。
自动配置类通常会通过@Configuration注解标注（@ComponentScan/@Import等）实现各种逻辑

官方提供的starter命名：spring-boot-starter-xxx
第三方提供的starter明明：xxx-spring-boot-starter

SpringBoot常见的starter

====================================================

自定义一个redisson的starter

一、创建按一个SpringBoot项目，命名：redisson-spring-boot-starter

<dependencies>
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter</artifactId>
        <version>2.3.1.RELEASE</version>
        <!-- 不让jar进行传递 避免jar包冲突-->
        <optional>true</optional>
    </dependency>
    <dependency>
        <groupId>org.redisson</groupId>
        <artifactId>redisson</artifactId>
        <version>3.13.1</version>
    </dependency>
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-configuration-processor</artifactId>
        <optional>true</optional>
    </dependency>
</dependencies>

二、创建配置解析类RedissonProperties

@ConfigurationProperties(prefix = "tian.redisson")
public class RedissonProperties{
	
	private String host = "localhost";
	private int port = 6379;
	private int timeout;

	//get   set 省略
}

三、自动装配类

@EnableConfigurationProperties(RedissonProperties.class)
@Configuration
public class RedissonAutoConfiguration{
	
	private static final String PREFIX = "redis://";

	@Bean
	public RedissonClient redissonClient(RedissonProperties redissonProperties){
		
		Config config = new Config();

		//redis单机模式
		config.useSingleServer().setAddress(PREFIX+redissonProperties.getHost()+":"+redissonProperties.getPort())
			.setConnectTimeout(redissonProperties.getTimeout());

		return Redisson.create(config);
	}
}

四、resources目录下创建META-INF，在此目录下创建spring.factories文件

org.springframework.boot.autoconfigure.EnableAutoConfiguration=\
  com.tian.RedissonAutoConfiguration

五、使用自定义starter

再创建一个SpringBoot项目，引入自定义starter

<dependency>
    <groupId>com.tian</groupId>
    <artifactId>charge-sms-spring-boot-starter</artifactId>
    <version>1.0-SNAPSHOT</version>
</dependency>

ResissonProperties类中对host和port赋予了默认值，所以在application.properties配置文件中若不配任何参数，使用的就是默认值。
也可以配置

tian.redisson.host=localhost
tian.redisson.port=6379
tian.redisson.timeout=1000

六、实际应用

@Slf4j
@RestController
@RequestMapping("/test")
public class TestController{
	
	@Resource
	private RedissonClient redissonClient;

	@GetMapping("/redisson")
	public String redisson(){
		
	}
}

配置提示功能

在META-INF下面创建一个文件 additional-spring-configuration-metadata.json
文件内容如下：

{
  "properties": [
    {
      "name": "tian.redisson.host",
      "type": "java.lang.String",
      "description": "redis服务地址ip",
      "defaultValue": "localhost"
    },
    {
      "name": "tian.redisson.port",
      "type": "java.lang.Integer",
      "description": "redis服务端口号",
      "defaultValue": 6379
    },
    {
      "name": "tian.redisson.timeout",
      "type": "java.lang.Integer",
      "description": "redis连接超时时间",
      "defaultValue": 1000
    }
  ]
}

重新打包，在使用的项目里执行Reload All Maven，再去properties中就会有对应的提示了。

==========================================================

自定义starter项目二

一、创建maven项目

<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-autoconfigure</artifactId>
    <version>2.1.8.RELEASE</version>
</dependency>

application.properties

javaboy.name=zhangsan
javaboy.msg=java

创建一个 HelloProperties 类，用来接受 application.properties 中注入的值，如下：

@ConfigurationProperties(prefix = "javaboy")
publicclass HelloProperties {

    private staticfinal String DEFAULT_NAME = "jordan";
    private staticfinal String DEFAULT_MSG = "篮球之神";
    
    private String name = DEFAULT_NAME;
    private String msg = DEFAULT_MSG;
    
    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }
    public String getMsg() {
        return msg;
    }
    public void setMsg(String msg) {
        this.msg = msg;
    }
}

定义一个 HelloService ，然后定义一个简单的 say 方法， HelloService 的定义如下：

public class HelloService {

    private String msg;
    private String name;
    
    public String sayHello() {
        return name + " say " + msg + " !";
    }
    
    public String getMsg() {
        return msg;
    }
    public void setMsg(String msg) {
        this.msg = msg;
    }
    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }
}

二、自定义配置类

• @EnableConfigurationProperties 注解是使我们之前配置的 @ConfigurationProperties 生效，让配置的属性成功的进入 Bean 中
• @ConditionalOnClass 表示当项目当前 classpath 下存在 HelloService 时，后面的配置才生效
• 自动配置类中首先注入 HelloProperties ，这个实例中含有我们在 application.properties 中配置的相关数据
• 提供一个 HelloService 的实例，将 HelloProperties 中的值注入进去

@Configuration
@EnableConfigurationProperties(HelloProperties.class)
@ConditionalOnClass(HelloService.class)
public class HelloServiceAutoConfiguration{
	
	@Autowired
	HelloProperties helloProperties;

	@Bean
	HelloService helloService(){
		HelloService helloService = new HelloService();
        helloService.setName(helloProperties.getName());
        helloService.setMsg(helloProperties.getMsg());
        return helloService;
	}
}

三、创建spring.factories文件

该文件的作用是指定自动化配置类的路径

org.springframework.boot.autoconfigure.EnableAutoConfiguration=org.javaboy.mystarter.HelloServiceAutoConfiguration

SpringBoot启动类中的注解@SpringBootApplication（源码可以得出是一个组合注解）
其中的一个组合项就是 @EnableAutoConfiguration启用 Spring 应用程序上下文的自动配置，会自动导入一个名为 AutoConfigurationImportSelector 的类,而这个类会去读取一个名为 spring.factories 的文件, spring.factories 中则定义需要加载的自动化配置类

@SpringBootConfiguration
@EnableAutoConfiguration
@ComponentScan(excludeFilters = {
		@Filter(type = FilterType.CUSTOM, classes = TypeExcludeFilter.class),
		@Filter(type = FilterType.CUSTOM,
				classes = AutoConfigurationExcludeFilter.class) })
public@interface SpringBootApplication {
}

四、本地安装

自动化配置类打包，然后上传到 Maven 私服上，供其他同事下载使用

在 IntelliJ IDEA 中，点击右边的 Maven Project ，然后选择 Lifecycle 中的 install ，双击即可。安装到本地仓库

五、使用Starter

新建一个普通的 Spring Boot 工程，这个 Spring Boot 创建成功之后，加入我们自定义 Starter 的依赖，如下：

<dependency>
    <groupId>org.javaboy</groupId>
    <artifactId>mystarter</artifactId>
    <version>1.0-SNAPSHOT</version>
</dependency>

引入了上面自定义的 Starter ，也即项目中现在有一个默认的 HelloService 实例可以使用，而且关于这个实例的数据，我们还可以在 application.properties 中进行配置，如下：

javaboy.name=牧码小子
javaboy.msg=java

测试

@RunWith(SpringRunner.class)
@SpringBootTest
publicclass UsemystarterApplicationTests {

    @Autowired
    HelloService helloService;
    @Test
    public void contextLoads() {
        System.out.println(helloService.sayHello());
    }
}

文章来源地址https://www.toymoban.com/news/detail-683869.html

到了这里，关于SpringBoot中自定义starter的文章就介绍完了。如果您还想了解更多内容，请在右上角搜索TOY模板网以前的文章或继续浏览下面的相关文章，希望大家以后多多支持TOY模板网！