Spring Boot 详解：核心原理与开发指南

@ConfigurationProperties：用于将配置文件中的属性映射到 Java 类中。这样，配置可以作为一个 Java Bean 进行管理，便于在应用中使用。

@ConfigurationProperties(prefix = "myapp")
public class MyAppProperties {
    private String name;
    private int maxAttempts;
    // getters and setters
}
// myapp.name=MyApplication
// myapp.maxAttempts=5

@Value：从配置文件中注入值到字段，允许应用程序灵活地读取外部配置。

@Component
public class MyComponent {
    @Value("${my.property}")
    private String myProperty;
}

@Bean：在配置类中定义 Bean 方法，Spring 管理这些 Bean 的生命周期。

@Bean
public MyBean myBean() {
    return new MyBean();
}

@Configuration：标记 Spring 配置类，用于配置 Spring 容器、配置 Bean。

@Configuration
public class AppConfig {
    @Bean
    public MyBean myBean() {
        return new MyBean();
    }
}

@Repository：标记 Spring 数据访问组件，用于数据持久化。

@Repository
public class MyRepository {
    // 数据访问逻辑
}

@Service：标记 Spring 业务组件，用于业务逻辑处理。

@Service
public class MyService {
    // 业务逻辑
}

@Component：标记 Spring 组件，使其能够被自动扫描和管理，@Component 为标记通用的 Spring 组件。

@Service
public class MyService {
    private final MyRepository myRepository;
    @Autowired
    public MyService(MyRepository myRepository) {
        this.myRepository = myRepository;
    }
}

@Autowired：自动注入 Spring 管理的 Bean。可以用于构造函数、字段或 setter 方法。

@Service
public class MyService {
    private final MyRepository myRepository;
    @Autowired
    public MyService(MyRepository myRepository) {
        this.myRepository = myRepository;
    }
}

@ResponseBody：将方法的返回值直接写入 HTTP 响应体中。常用于控制器方法，以使得返回的数据，通常是 JSON 或 XML，能够被自动序列化并发送给客户端。

@Controller
@ResponseBody
@RequestMapping("/api")
public class MyRestController {
    @GetMapping("/info")
    public MyResponseData getInfo() {
        return new MyResponseData("Alice", 30);
    }
}
class MyResponseData {
    private String name;
    private int age;
    public MyResponseData(String name, int age) {
        this.name = name;
        this.age = age;
    }
}

@RequestBody：将 HTTP 请求体的内容绑定到方法参数上。通常用于 POST 请求，当请求的内容是 JSON、XML 或其他类型的数据时，可以通过 @RequestBody 注解将其自动转换为 Java 对象。

@RestController
public class MyRestController {
    @PostMapping("/submit")
    public String submitData(@RequestBody MyRequestData data) {
        // 处理数据
        return "Data received: " + data.toString();
    }
}
class MyRequestData {
    private String name;
    private int age;
}

@RequestMapping：映射 HTTP 请求到控制器的方法。支持不同的请求方法（GET、POST 等），其衍生注解为 @GetMapping、@PostMapping、@PutMapping、@DeleteMapping。

@RestController
public class MyController {
    @RequestMapping(value = "/hello", method = RequestMethod.GET)
    public String getHello() {
        return "Hello, GET!";
    }
}

@Controller：用于定义一个 SpringMVC 控制器类，它的主要目的是处理 Web 请求并返回视图，如 JSP、Thymeleaf 模板等。

@Controller
public class MyController {
    @GetMapping("/home")
    public String home() {
        return "home"; // 返回视图名（例如 home.html）
    }
}

@RestController：是一个组合注解，结合了 @Controller 和 @ResponseBody。用于定义控制器类，并将返回的对象自动转换为 JSON 或 XML 格式，简化了 RESTful API 的开发。

@RestController
@RequestMapping("/api")
public class MyController {
    @GetMapping("/hello")
    public String sayHello() {
        return "Hello, World!";
    }
}

@SpringBootApplication：标注在启动类上，它综合了 @Configuration、@EnableAutoConfiguration 和 @ComponentScan 注解，用于自动配置和组件扫描。

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

Spring Boot 自动配置

Spring Boot 的自动配置通过条件化配置和扫描机制来简化应用设置。应用启动时，Spring Boot 根据 spring.factories 文件中的配置自动加载所有标记为自动配置的类。每个自动配置类使用条件注解，如 @ConditionalOnClass、@ConditionalOnMissingBean 等，来判断是否应该应用特定的配置。这些注解帮助决定是否创建和配置 Bean。如果符合条件，Spring Boot 会自动生成所需的 Bean 实例并将其添加到应用上下文中。

其自动配置原理，是通过 @SpringBootApplication 注解，在启动时加载的。@SpringBootApplication 这个注解通常标注在启动类上：

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

@SpringBootApplication 是一个复合注解，即由其他注解构成。核心注解是 @SpringBootConfiguration 和 @EnableAutoConfiguration。

@Target(ElementType.TYPE)
@Retention(RetentionPolicy.RUNTIME)
@Documented
@Inherited
@SpringBootConfiguration
@EnableAutoConfiguration
@ComponentScan(excludeFilters = {
    @Filter(type = FilterType.CUSTOM, classes = TypeExcludeFilter.class),
    @Filter(type = FilterType.CUSTOM, classes = AutoConfigurationExcludeFilter.class)
})
public @interface SpringBootApplication {}

@SpringBootConfiguration

@SpringBootConfiguration 核心注解是 @Configuration 的作用是将类标记为配置类，可以定义 @Bean 方法来创建和配置 Spring 容器中的 Bean。

@Target({ElementType.TYPE})
@Retention(RetentionPolicy.RUNTIME)
@Documented
@Configuration
public @interface SpringBootConfiguration {}

@Configuration 底层实现就是一个 Component。

/**
 * Indicates that an annotated class is a "component".
 * Such classes are considered as candidates for auto-detection
 * when using annotation-based configuration and classpath scanning.
 * */
@Target(ElementType.TYPE)
@Retention(RetentionPolicy.RUNTIME)
@Documented
@Indexed
public @interface Component{}

@EnableAutoConfiguration

@EnableAutoConfiguration 作用是启用 Spring Boot 的自动配置机制。它的核心是 @AutoConfigurationPackage 和 @Import({AutoConfigurationImportSelector.class})

@Target({ElementType.TYPE})
@Retention(RetentionPolicy.RUNTIME)
@Documented
@Inherited
@AutoConfigurationPackage
@Import({AutoConfigurationImportSelector.class})
public @interface EnableAutoConfiguration {}

@AutoConfigurationPackage 的核心是引入了一个 @Import(AutoConfigurationPackages.Registrar.class) 配置类，该类实现了 ImportBeanDefinitionRegistrar 接口。这个注解本身的含义就是将主配置类（@SpringBootApplication 标注的类）所在的包下面所有的组件都扫描到 Spring 容器中。

/**
 * {@link ImportBeanDefinitionRegistrar} to store the base package from the importing
 * configuration.
 */
static class Registrar implements ImportBeanDefinitionRegistrar, DeterminableImports {
    @Override
    public void registerBeanDefinitions(AnnotationMetadata metadata, BeanDefinitionRegistry registry) {
        register(registry, new PackageImports(metadata).getPackageNames().toArray(new String[0]));
    }
    @Override
    public Set<Object> determineImports(AnnotationMetadata metadata) {
        return Collections.singleton(new PackageImports(metadata));
    }
}

AutoConfigurationImportSelector 类的作用是通过扫描 spring.factories 文件，加载所有自动配置类。

/**
 * Return the auto-configuration class names that should be considered. By default
 * this method will load candidates using {@link SpringFactoriesLoader} with
 * {@link #getSpringFactoriesLoaderFactoryClass()}.
 * @param metadata the source metadata
 * @param attributes the {@link #getAttributes(AnnotationMetadata) annotation
 * attributes}
 * @return a list of candidate configurations
 */
protected List<String> getCandidateConfigurations(AnnotationMetadata metadata, AnnotationAttributes attributes) {
    List<String> configurations = SpringFactoriesLoader.loadFactoryNames(getSpringFactoriesLoaderFactoryClass(), getBeanClassLoader());
    Assert.notEmpty(configurations, "No auto configuration classes found in META-INF/spring.factories. If you "
            + "are using a custom packaging, make sure that file is correct.");
    return configurations;
}

但是 spring.factories 包含了很多类，并不是全部都加载的，在某些类里面，是有一个条件 @ConditionalOnXXX 注解，只有当这个注解上的条件满足才会加载。如 SpringApplicationAdminJmxAutoConfiguration。

@Configuration(proxyBeanMethods = false)
@AutoConfigureAfter(JmxAutoConfiguration.class)
@ConditionalOnProperty(prefix = "spring.application.admin", value = "enabled", havingValue = "true", matchIfMissing = false)
public class SpringApplicationAdminJmxAutoConfiguration {}

当一个类使用 @SpringBootApplication 注解时，Spring Boot 会自动进行一系列配置，让应用快速启动并运行。这个注解包含了 @SpringBootConfiguration，相当于告诉 Spring 这是一个配置类，就像使用了 @Configuration 一样。@Configuration 的作用是将类标记为配置类，这个配置类可以定义 @Bean 方法来创建和配置 Spring 容器中的 Bean。同时，@EnableAutoConfiguration 启用了 Spring Boot 的自动配置功能，Spring Boot 会根据项目中的依赖，自动配置很多常用的 Spring 组件，这样就不需要手动配置它们。这个自动配置的过程是通过扫描 spring.factories 文件中的自动配置类来实现的。另外，@ComponentScan 让 Spring 自动扫描当前包及其子包下的所有组件，比如标注了 @Component、@Service、@Repository 和 @Controller 的类，并把它们注册到 Spring 容器中。因此，把应用的主类放在根包中，Spring Boot 就会自动扫描并加载所有需要的组件和配置，让你可以专注于编写业务代码，而不用担心复杂的配置细节。Spring Boot 通过这一系列自动化的配置和扫描机制，简化了开发和配置的工作量，让应用能够快速启动并运行。

Spring Boot 配置管理

Spring Boot 支持 application.properties 和 application.yml 两种格式的配置文件，通常放置在 src/main/resources 目录下。

server:
  port: 8080
spring:
  # 数据源配置
  datasource:
    url: jdbc:mysql://localhost:3306/mydb
    username: root
    password: secret
  # 自定义属性
  myapp:
    name: MyApplication
    maxAttempts: 5

如果想要读取配置，可以使用 @Value 注解或者 @ConfigurationProperties 注解。使用 @ConfigurationProperties 注解将配置文件中的属性绑定到 Java 类中，能够将复杂配置集中管理。

@ConfigurationProperties(prefix = "myapp")
public class MyAppProperties {
    private String name;
    private int maxAttempts;
    // getters and setters
}

使用 @Value 注解可以将配置文件中的单个属性注入到 Bean 的字段中。

@Component
public class MyComponent {
    @Value("${myapp.name}")
    private String appName;
}

但需要注意的是，并不是在配置文件中配置了，就一定会加载，Spring Boot 配置的加载优先级由高到低依为：

系统属性：系统属性通过 System.setProperty 方法设置，优先级最低。这些属性可以在应用启动时或者在 JVM 启动时通过 -D 参数设置，虽然优先级低于其他配置源，但它们仍然会被加载。

System.setProperty("server.port", "9090");

application.properties 或 application.yml 文件：这些文件通常位于 src/main/resources 目录下，提供了默认的配置。这些配置会被加载到应用程序上下文中，但它们的优先级低于命令行参数。

server.port=8080

环境变量：环境变量的配置优先级低于命令行参数，但高于 application.properties 和 application.yml 文件。环境变量通常用于在操作系统级别定义配置，例如在生产环境中。

export SERVER_PORT=9090

命令行参数：命令行参数的配置优先级最高。当你启动 Spring Boot 应用时，可以通过命令行传递配置参数，这些参数会覆盖其他来源的配置。

java -jar myapp.jar -Dserver.port=9090

除此之外可以使用 application-{profile}.properties 或 application-{profile}.yml 文件为不同的环境提供特定的配置。且通过设置 spring.profiles.active 属性来激活特定的环境配置。

server.port=8081 # application.properties
spring.profiles.active=dev

有时需要根据特定条件加载不同的配置文件。这种需求通常出现在环境配置、特性开关或者动态调整配置的场景中，就可以通过环境控制的方式来实现。

application-prod.properties

server.port=80
myapp.feature=disabled

application-dev.properties

server.port=8081
myapp.feature=enabled

在 application.properties 中激活特定的 profile：

spring.profiles.active=dev

这样 Spring Boot 会根据激活的 profile 加载对应的配置文件。

其实使用 @Profile 注解也能实现环境控制，@Profile 注解允许在特定的 profile 激活时创建 Bean 或配置类。结合 @Configuration 使用，可以在不同的环境中加载不同的 Bean 配置。

@Configuration
@Profile("dev")
public class DevConfiguration {
    @Bean
    public MyBean myBean() {
        return new MyBean("Development Bean");
    }
}

或者使用 @Conditional，@Conditional 注解允许根据条件决定是否加载配置。可以结合自定义条件来实现复杂的条件加载逻辑。

public class OnCustomCondition implements Condition {
    @Override
    public boolean matches(ConditionContext context, AnnotatedTypeMetadata metadata) {
        // 逻辑判断
        return "true".equals(System.getProperty("custom.condition"));
    }
}
@Configuration
@Conditional(OnCustomCondition.class)
public class CustomConditionConfiguration {
    @Bean
    public CustomBean customBean() {
        return new CustomBean();
    }
}

Spring Boot 嵌入式服务器

Spring Boot 提供了内置的 Web 服务器，如 Tomcat、Jetty 和 Undertow，嵌入式的服务器功能使得构建和运行 JavaWeb 应用变得更加简单。

有了嵌入式的服务器就不需要将应用程序打包为 WAR 包并部署到外部服务器，直接打包为 JAR 文件即可运行。而且运行和调试 Web 应用时不需要管理服务器的独立生命周期，而且内置服务器通常比外部服务器占用的资源少，启动速度更快。

Spring Boot 默认内置 Tomcat 作为嵌入式服务器。如果没有特别修改，应用将使用 Tomcat。

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

如果要使用 Jetty 代替 Tomcat，需要在 pom.xml 中排除 Tomcat 并添加 Jetty 依赖。

<dependencies>
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-web</artifactId>
        <exclusions>
            <exclusion>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-starter-tomcat</artifactId>
            </exclusion>
        </exclusions>
    </dependency>
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-jetty</artifactId>
    </dependency>
</dependencies>

内置的服务器实际上，Spring Boot 是通过自动配置机制来简化 Web 服务器的配置。应用启动时，Spring Boot 会自动检测类路径中的依赖，并根据它们自动配置 Web 服务器。自动配置类位于 org.springframework.boot.autoconfigure.web.servlet 包中，例如 TomcatServletWebServerFactory、JettyServletWebServerFactory 和 UndertowServletWebServerFactory。

@Configuration
@ConditionalOnClass(Servlet.class)
@ConditionalOnMissingBean(ServletWebServerFactory.class)
@EnableConfigurationProperties(WebServerProperties.class)
public class TomcatServletWebServerFactoryConfiguration {
    @Bean
    public TomcatServletWebServerFactory tomcatServletWebServerFactory(WebServerProperties properties) {
        TomcatServletWebServerFactory factory = new TomcatServletWebServerFactory();
        // 配置 Tomcat 服务器
        return factory;
    }
}

Spring Boot 使用 ServletWebServerFactory 接口及其实现，例如 TomcatServletWebServerFactory 来创建内嵌的 Web 服务器。ServletWebServerFactory 提供了创建和配置 Web 服务器的能力。当应用启动时，Spring Boot 会创建一个 ServletWebServerFactory 实现的实例，并使用该实例启动 Web 服务器。

@Bean
public ServletWebServerFactory servletContainer() {
    TomcatServletWebServerFactory factory = new TomcatServletWebServerFactory();
    factory.setPort(8080);
    return factory;
}

可以通过实现 TomcatServletWebServerFactory、JettyServletWebServerFactory 或 UndertowServletWebServerFactory 接口来自定义嵌入式服务器的配置。

@Configuration
public class CustomTomcatFactory extends TomcatServletWebServerFactory {
    @Bean
    @Override
    public ServletWebServerFactory servletContainer() {
        return new TomcatServletWebServerFactory() {
            @Override
            protected Tomcat getTomcatEmbeddedServletContainer() {
                Tomcat tomcat = super.getTomcatEmbeddedServletContainer();
                // 自定义 Tomcat 配置
                tomcat.getConnector().setAttribute("maxThreads", 200);
                // 可以在这里添加更多自定义逻辑
                return tomcat;
            }
        };
    }
}

Spring Boot 测试

测试是保证应用正确性和稳定性的关键部分，Spring Boot 提供了多种测试工具和注解，以便于进行集成测试、单元测试和功能测试。

创建一个单元测试步骤：

1. 导入测试依赖。org.springframework.boot spring-boot-starter-test test org.junit.jupiter junit-jupiter-api test org.junit.jupiter junit-jupiter-engine test

2. 编写测试类。通常，测试类放在与主代码相同的包结构中的 src/test/java 目录下。

@SpringBootTest
// @RunWith(xxxx.class)
public class MyServiceTests {
    @Autowired
    private MyService myService;

    @Test
    public void testPerformAction() {
        String result = myService.performAction();
        assertEquals("ExpectedResult", result);
    }
}

一个最简单的单元测试就创建完毕了。在实际测试中，有时候需要测试场景中加载配置，@TestConfiguration 注解用于创建专门的测试配置类。这些配置类仅在测试上下文中有效，用于提供测试所需的额外 Bean。

@TestConfiguration
public class TestConfig {
    @Bean
    public TestService testService() {
        return new TestService();
    }
}

然后在测试类中引入该配置：

@SpringBootTest
@Import(TestConfig.class)
public class ServiceTests {
    @Autowired
    private TestService testService;

    @Test
    public void testService() {
        // 测试逻辑
    }
}

除了这些，还能使用 @ExtendWith 和自定义扩展，自定义扩展来添加额外的功能，如测试环境准备、清理操作等。

public class CustomExtension implements TestInstancePostProcessor, TestExecutionExceptionHandler {
    @Override
    public void postProcessTestInstance(Object testInstance, ExtensionContext context) {
        // Custom initialization
    }

    @Override
    public void handleTestExecutionException(ExtensionContext context, Throwable throwable) throws Throwable {
        // Custom exception handling
    }
}

在测试类中引入该扩展：

@ExtendWith(CustomExtension.class)
public class CustomExtensionTests {
    @Test
    public void testWithCustomExtension() {
        // Test logic
    }
}