Spring Boot Starter 入门教程

Spring Boot Starter 入门教程

Spring Boot Starter是Spring Boot框架的核心特性之一，它通过提供一组预定义的依赖和自动配置，极大地简化了Spring应用的开发过程。本文将详细介绍Spring Boot Starter的概念、原理、使用方法以及如何自定义开发Starter。

1. Spring Boot Starter 简介

1.1 什么是Spring Boot Starter

Spring Boot Starter是一组便捷的依赖描述符，它整合了某个功能模块所需的所有依赖库，并提供了自动配置功能。通过引入相应的Starter，开发者可以快速搭建具有特定功能的Spring应用，无需手动添加和配置大量的依赖项。

1.2 Starter的命名规范

• Spring官方Starter：通常命名为spring-boot-starter-{module}，例如spring-boot-starter-web
• 第三方Starter：通常命名为{module}-spring-boot-starter，例如mybatis-spring-boot-starter

2. Spring Boot Starter 工作原理

2.1 自动配置机制

Spring Boot自动配置是Starter的核心，它的工作原理主要基于以下几个关键技术：

1. 起步依赖：将具备特定功能的坐标打包在一起，并提供默认配置
2. 自动配置：基于类路径下的依赖、环境变量等条件，自动装配相关Bean到Spring容器

2.2 自动配置的核心原理

自动配置的核心在于@EnableAutoConfiguration注解，它通过以下步骤工作：

1. 扫描META-INF/spring.factories文件中注册的自动配置类
2. 根据条件注解（如@ConditionalOnClass、@ConditionalOnProperty等）判断是否需要加载对应的配置类
3. 对于满足条件的配置类，使用@Bean注解将相关Bean注册到Spring容器中

3. 常用的内置 Starter

3.1 Web开发相关

<!-- Web开发 -->
<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-web</artifactId>
</dependency>

<!-- WebFlux响应式Web开发 -->
<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-webflux</artifactId>
</dependency>

3.2 数据访问相关

<!-- JPA数据访问 -->
<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-data-jpa</artifactId>
</dependency>

<!-- JDBC数据访问 -->
<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-jdbc</artifactId>
</dependency>

<!-- MongoDB数据访问 -->
<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-data-mongodb</artifactId>
</dependency>

3.3 安全相关

<!-- Spring Security安全框架 -->
<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-security</artifactId>
</dependency>

3.4 测试相关

<!-- 测试支持 -->
<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-test</artifactId>
    <scope>test</scope>
</dependency>

4. 使用现有 Starter

4.1 在Maven项目中使用Starter

在项目的pom.xml文件中添加所需的Starter依赖：

<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.example</groupId>
    <artifactId>demo</artifactId>
    <version>0.0.1-SNAPSHOT</version>
    <packaging>jar</packaging>

    <parent>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-parent</artifactId>
        <version>2.7.5</version>
        <relativePath/> <!-- lookup parent from repository -->
    </parent>

    <properties>
        <java.version>11</java.version>
    </properties>

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

    <build>
        <plugins>
            <plugin>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-maven-plugin</artifactId>
            </plugin>
        </plugins>
    </build>
</project>

4.2 创建应用主类

package com.example.demo;

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;

@SpringBootApplication
public class DemoApplication {

    public static void main(String[] args) {
        SpringApplication.run(DemoApplication.class, args);
    }
}

4.3 创建Controller

package com.example.demo.controller;

import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RestController;

@RestController
public class HelloController {

    @GetMapping("/hello")
    public String hello() {
        return "Hello, Spring Boot Starter!";
    }
}

5. 自定义 Starter 开发

5.1 自定义Starter的结构

一个完整的自定义Starter通常包含两个模块：

1. autoconfigure模块：包含自动配置类和相关Bean
2. starter模块：仅包含对autoconfigure模块的依赖，用于依赖管理

5.2 开发自定义Starter的步骤

1. 创建Maven项目，定义依赖
2. 创建配置类，定义配置项和默认值
3. 创建自动装配类，实现自动配置逻辑
4. 创建spring.factories文件，指定自动装配类
5. 打包发布

5.3 实战：开发自定义Starter

5.3.1 创建autoconfigure模块

pom.xml配置：

<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.example</groupId>
    <artifactId>custom-spring-boot-autoconfigure</artifactId>
    <version>1.0.0</version>

    <parent>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-parent</artifactId>
        <version>2.7.5</version>
        <relativePath/> <!-- lookup parent from repository -->
    </parent>

    <dependencies>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter</artifactId>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-autoconfigure</artifactId>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-configuration-processor</artifactId>
            <optional>true</optional>
        </dependency>
    </dependencies>
</project>

5.3.2 创建配置属性类

package com.example.custom.autoconfigure.properties;

import org.springframework.boot.context.properties.ConfigurationProperties;

@ConfigurationProperties(prefix = "custom.service")
public class CustomServiceProperties {
    private String prefix = "Hello";
    private String suffix = "!";
    private boolean enable = true;

    // getters and setters
    public String getPrefix() {
        return prefix;
    }

    public void setPrefix(String prefix) {
        this.prefix = prefix;
    }

    public String getSuffix() {
        return suffix;
    }

    public void setSuffix(String suffix) {
        this.suffix = suffix;
    }

    public boolean isEnable() {
        return enable;
    }

    public void setEnable(boolean enable) {
        this.enable = enable;
    }
}

5.3.3 创建核心服务类

package com.example.custom.autoconfigure.service;

import com.example.custom.autoconfigure.properties.CustomServiceProperties;

public class CustomService {
    private CustomServiceProperties properties;

    public CustomService(CustomServiceProperties properties) {
        this.properties = properties;
    }

    public String doSomething(String input) {
        if (!properties.isEnable()) {
            return input;
        }
        return properties.getPrefix() + " " + input + " " + properties.getSuffix();
    }
}

5.3.4 创建自动配置类

package com.example.custom.autoconfigure.config;

import com.example.custom.autoconfigure.properties.CustomServiceProperties;
import com.example.custom.autoconfigure.service.CustomService;
import org.springframework.boot.autoconfigure.condition.ConditionalOnProperty;
import org.springframework.boot.context.properties.EnableConfigurationProperties;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;

@Configuration
@EnableConfigurationProperties(CustomServiceProperties.class)
@ConditionalOnProperty(prefix = "custom.service", name = "enable", havingValue = "true", matchIfMissing = true)
public class CustomAutoConfiguration {

    @Bean
    public CustomService customService(CustomServiceProperties properties) {
        return new CustomService(properties);
    }
}

5.3.5 创建spring.factories文件

在resources目录下创建META-INF文件夹，并在其中创建spring.factories文件：

org.springframework.boot.autoconfigure.EnableAutoConfiguration=com.example.custom.autoconfigure.config.CustomAutoConfiguration

5.3.6 创建starter模块

pom.xml配置：

<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.example</groupId>
    <artifactId>custom-spring-boot-starter</artifactId>
    <version>1.0.0</version>

    <dependencies>
        <dependency>
            <groupId>com.example</groupId>
            <artifactId>custom-spring-boot-autoconfigure</artifactId>
            <version>1.0.0</version>
        </dependency>
    </dependencies>
</project>

6. 使用自定义 Starter

6.1 在项目中引入自定义Starter

<dependency>
    <groupId>com.example</groupId>
    <artifactId>custom-spring-boot-starter</artifactId>
    <version>1.0.0</version>
</dependency>

6.2 在application.properties中配置属性

custom.service.enable=true
custom.service.prefix=Hi
custom.service.suffix=!!!

6.3 在Controller中使用自定义服务

package com.example.demo.controller;

import com.example.custom.autoconfigure.service.CustomService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RestController;

@RestController
public class CustomController {

    @Autowired
    private CustomService customService;

    @GetMapping("/custom")
    public String custom(String name) {
        return customService.doSomething(name);
    }
}

7. 自定义Starter的条件注解

Spring Boot提供了多种条件注解，可以根据不同的条件决定是否加载配置：

• @ConditionalOnBean：当容器中存在指定Bean时
• @ConditionalOnMissingBean：当容器中不存在指定Bean时
• @ConditionalOnClass：当类路径下存在指定类时
• @ConditionalOnMissingClass：当类路径下不存在指定类时
• @ConditionalOnProperty：当指定的属性有指定的值时
• @ConditionalOnResource：当类路径下存在指定资源时
• @ConditionalOnWebApplication：当应用是Web应用时
• @ConditionalOnNotWebApplication：当应用不是Web应用时

8. 最佳实践

8.1 命名规范

• 遵循Spring Boot的命名约定
• 官方Starter：spring-boot-starter-{module}
• 第三方Starter：{module}-spring-boot-starter

8.2 条件配置

• 使用合适的条件注解确保Starter只在需要时被加载
• 提供默认配置，同时允许用户通过配置文件覆盖默认值

8.3 文档完善

• 提供详细的文档，说明如何使用Starter
• 清晰描述所有可配置的属性及其默认值

8.4 测试充分

• 为Starter编写单元测试和集成测试
• 确保在不同的环境和配置下都能正常工作

9. 总结

Spring Boot Starter是Spring Boot框架的重要特性，它通过整合依赖和提供自动配置，极大地简化了Spring应用的开发。本文详细介绍了Spring Boot Starter的概念、原理、使用方法以及如何自定义开发Starter。通过学习本文，开发者可以更好地理解和应用Spring Boot Starter，提高开发效率，构建更加模块化、可复用的Spring应用。

在实际开发中，合理使用现有的Starter可以快速构建应用，而开发自定义Starter则可以将常用功能模块化，提高代码复用率和维护性。希望本文能够帮助开发者更好地掌握Spring Boot Starter的使用和开发技巧。

10. 代码链接

gitee.com/tree_boss/s…