SpringBoot3新特性教程 - 2023最新Spring Boot特性完整指南

1. Spring Boot 3简介

Spring Boot 3.0于2022年11月24日正式发布，这是Spring Boot框架的一个重要里程碑版本。Spring Boot 3基于Spring Framework 6构建，带来了许多重大变化和新特性。

主要变化：

✅ 最低Java版本：要求Java 17或更高版本（不再支持Java 8/11）
✅ Jakarta EE：从javax.*迁移到jakarta.*命名空间
✅ 原生镜像支持：支持GraalVM Native Image
✅ AOT编译：支持提前编译优化
✅ 观察性增强：改进的监控和追踪功能
✅ 性能提升：启动速度更快，内存占用更少
现代化：利用Java 17+的新特性
性能：原生镜像和AOT编译带来性能提升
云原生：更好的云原生应用支持
长期支持：Spring Boot 2.x将在2023年停止支持
新特性：访问最新的Spring Boot特性

组件	Spring Boot 2.x	Spring Boot 3.x
Java版本	8, 11, 17	17+
Spring Framework	5.x	6.x
Jakarta EE	不支持	9+
GraalVM Native	实验性	正式支持

2. 环境准备与升级指南

Java版本要求

# 检查Java版本
java -version
# 应该显示：openjdk version "17" 或更高

# 如果未安装Java 17，请先安装
# macOS
brew install openjdk@17

# Ubuntu/Debian
sudo apt install openjdk-17-jdk

# Windows
# 从Oracle或Adoptium官网下载安装

Maven/Gradle版本

# Maven 3.5+ 或 Gradle 7.5+
mvn -version
gradle -version

方式1：使用Spring Initializr（推荐）

访问：https://start.spring.io/
选择：
- Project: Maven或Gradle
- Language: Java
- Spring Boot: 3.2.x（最新稳定版）
- Java: 17或21
- 添加依赖：Spring Web、Spring Data JPA等
点击"Generate"下载项目

方式2：使用命令行

# 使用curl
curl https://start.spring.io/starter.zip \
  -d type=maven-project \
  -d language=java \
  -d bootVersion=3.2.0 \
  -d baseDir=myapp \
  -d groupId=com.example \
  -d artifactId=myapp \
  -d name=myapp \
  -d description="Spring Boot 3 Demo" \
  -d packageName=com.example.myapp \
  -d packaging=jar \
  -d javaVersion=17 \
  -d dependencies=web,data-jpa \
  -o myapp.zip

# 解压
unzip myapp.zip
cd myapp

方式3：使用IDE

IntelliJ IDEA:

File → New → Project
选择Spring Initializr
选择Spring Boot 3.x版本
配置项目信息
选择依赖
完成创建

创建后的项目结构：

myapp/
├── src/
│   ├── main/
│   │   ├── java/
│   │   │   └── com/
│   │   │       └── example/
│   │   │           └── myapp/
│   │   │               └── MyappApplication.java
│   │   └── resources/
│   │       ├── application.properties
│   │       └── static/
│   └── test/
│       └── java/
│           └── com/
│               └── example/
│                   └── myapp/
│                       └── MyappApplicationTests.java
├── pom.xml (Maven) 或 build.gradle (Gradle)
└── README.md

升级步骤

更新依赖版本

Maven (pom.xml):

<parent>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-parent</artifactId>
    <version>3.2.0</version>
    <relativePath/>
</parent>

<properties>
    <java.version>17</java.version>
</properties>

Gradle (build.gradle):

plugins {
    id 'org.springframework.boot' version '3.2.0'
    id 'io.spring.dependency-management' version '1.1.4'
}

java {
    sourceCompatibility = '17'
}

更新包名：javax → jakarta

# 使用IDE的全局替换功能
# 将所有 javax.* 替换为 jakarta.*

# 常见替换：
javax.servlet → jakarta.servlet
javax.persistence → jakarta.persistence
javax.validation → jakarta.validation
javax.annotation → jakarta.annotation

更新配置文件

# application.properties
# 检查并更新已废弃的配置项

3. Java 17支持与特性

记录类型（Records）

// 定义记录类型
public record UserResponse(Long id, String username, String email) {}

// 在Controller中使用
@RestController
@RequestMapping("/api/users")
public class UserController {
    
    @GetMapping("/{id}")
    public UserResponse getUser(@PathVariable Long id) {
        User user = userService.findById(id);
        return new UserResponse(user.getId(), user.getUsername(), user.getEmail());
    }
}

模式匹配（Pattern Matching）

// switch表达式
public String processValue(Object value) {
    return switch (value) {
        case String s -> "String: " + s;
        case Integer i -> "Integer: " + i;
        case null -> "Null value";
        default -> "Unknown: " + value;
    };
}

文本块（Text Blocks）

// 多行字符串
String json = """
    {
        "name": "Spring Boot 3",
        "version": "3.2.0"
    }
    """;

// 定义密封接口
public sealed interface Result permits Success, Failure {
    String getMessage();
}

public final class Success implements Result {
    private final String message;
    public Success(String message) { this.message = message; }
    @Override
    public String getMessage() { return message; }
}

public final class Failure implements Result {
    private final String message;
    public Failure(String message) { this.message = message; }
    @Override
    public String getMessage() { return message; }
}

// 使用
public Result process() {
    return switch (result) {
        case Success s -> s;
        case Failure f -> f;
    };
}

4. Jakarta EE 10迁移

主要包名变化

Spring Boot 2.x	Spring Boot 3.x
javax.servlet.*	jakarta.servlet.*
javax.persistence.*	jakarta.persistence.*
javax.validation.*	jakarta.validation.*
javax.annotation.*	jakarta.annotation.*
javax.transaction.*	jakarta.transaction.*

Servlet API

// Spring Boot 2.x
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;

// Spring Boot 3.x
import jakarta.servlet.http.HttpServletRequest;
import jakarta.servlet.http.HttpServletResponse;

JPA实体

// Spring Boot 2.x
import javax.persistence.*;
import javax.validation.constraints.NotNull;

@Entity
@Table(name = "users")
public class User {
    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    private Long id;
    
    @NotNull
    private String username;
}

// Spring Boot 3.x
import jakarta.persistence.*;
import jakarta.validation.constraints.NotNull;

@Entity
@Table(name = "users")
public class User {
    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    private Long id;
    
    @NotNull
    private String username;
}

验证注解

// Spring Boot 2.x
import javax.validation.constraints.Email;
import javax.validation.constraints.Size;

public class UserDto {
    @Email
    @Size(min = 5, max = 50)
    private String email;
}

// Spring Boot 3.x
import jakarta.validation.constraints.Email;
import jakarta.validation.constraints.Size;

public class UserDto {
    @Email
    @Size(min = 5, max = 50)
    private String email;
}

使用IDE的查找替换

在IntelliJ IDEA中：
- Edit → Find → Replace in Files
- 查找：javax.servlet
- 替换为：jakarta.servlet
- 范围：整个项目
批量替换脚本（Linux/Mac）：

find . -type f -name "*.java" -exec sed -i 's/javax\.servlet/jakarta.servlet/g' {} +
find . -type f -name "*.java" -exec sed -i 's/javax\.persistence/jakarta.persistence/g' {} +
find . -type f -name "*.java" -exec sed -i 's/javax\.validation/jakarta.validation/g' {} +

5. GraalVM原生镜像支持

GraalVM Native Image可以将Java应用编译为原生可执行文件，具有以下优势：

快速启动：毫秒级启动时间
低内存占用：减少内存消耗
小体积：生成的可执行文件更小
云原生：适合容器化和Serverless场景

安装GraalVM

# macOS
brew install --cask graalvm-jdk

# Linux
# 从 https://www.graalvm.org/downloads/ 下载

# 设置环境变量
export GRAALVM_HOME=/path/to/graalvm
export PATH=$GRAALVM_HOME/bin:$PATH

# 安装native-image
gu install native-image

验证安装

native-image --version

Maven配置

<build>
    <plugins>
        <plugin>
            <groupId>org.graalvm.buildtools</groupId>
            <artifactId>native-maven-plugin</artifactId>
        </plugin>
    </plugins>
</build>

Gradle配置

plugins {
    id 'org.graalvm.buildtools.native' version '0.9.28'
}

Maven命令

# 构建原生镜像
./mvnw -Pnative native:compile

# 运行原生镜像
./target/myapp

Gradle命令

# 构建原生镜像
./gradlew nativeCompile

# 运行原生镜像
./build/native/nativeCompile/myapp

创建native-image.properties

# src/main/resources/META-INF/native-image/native-image.properties
Args = --initialize-at-build-time

配置反射

@Configuration
public class NativeImageConfiguration {
    
    @Bean
    public RuntimeHints runtimeHints() {
        RuntimeHints hints = new RuntimeHints();
        hints.reflection().registerType(User.class, MemberCategory.values());
        return hints;
    }
}

指标	JVM模式	原生镜像
启动时间	2-5秒	50-200毫秒
内存占用	200-500MB	50-150MB
文件大小	JAR文件	可执行文件

6. AOT编译支持

AOT（Ahead-Of-Time）编译是在应用运行前进行编译优化，可以：

减少启动时间
优化运行时性能
提前发现潜在问题

Maven配置

<plugin>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-maven-plugin</artifactId>
    <executions>
        <execution>
            <id>process-aot</id>
            <goals>
                <goal>process-aot</goal>
            </goals>
        </execution>
    </executions>
</plugin>

构建AOT优化应用

# Maven
./mvnw clean package -Pnative

# Gradle
./gradlew clean nativeCompile

启动速度：提升50-80%的启动速度
内存优化：减少内存占用
性能提升：运行时性能提升10-20%

7. 观察性功能增强

Spring Boot 3改进了与Micrometer的集成，提供更好的指标收集和监控。

添加依赖

<dependency>
    <groupId>io.micrometer</groupId>
    <artifactId>micrometer-registry-prometheus</artifactId>
</dependency>

配置指标

# application.properties
management.endpoints.web.exposure.include=metrics,prometheus
management.metrics.export.prometheus.enabled=true

使用Micrometer Tracing

<dependency>
    <groupId>io.micrometer</groupId>
    <artifactId>micrometer-tracing-bridge-brave</artifactId>
</dependency>

配置追踪

@Configuration
public class TracingConfiguration {
    
    @Bean
    public Tracing tracing() {
        return Tracing.newBuilder()
            .localServiceName("my-service")
            .build();
    }
}

@Component
public class CustomHealthIndicator implements HealthIndicator {
    
    @Override
    public Health health() {
        // 自定义健康检查逻辑
        if (isHealthy()) {
            return Health.up()
                .withDetail("status", "OK")
                .build();
        }
        return Health.down()
            .withDetail("error", "Service unavailable")
            .build();
    }
}

8. 自动配置改进

Spring Boot 3改进了自动配置的条件判断，更加智能和灵活。

自定义自动配置

@Configuration
@ConditionalOnProperty(name = "app.feature.enabled", havingValue = "true")
public class FeatureAutoConfiguration {
    
    @Bean
    @ConditionalOnMissingBean
    public FeatureService featureService() {
        return new DefaultFeatureService();
    }
}

@ConfigurationProperties(prefix = "app")
public class AppProperties {
    private String name;
    private String version;
    private Database database = new Database();
    
    // getters and setters
    
    public static class Database {
        private String url;
        private String username;
        private String password;
        
        // getters and setters
    }
}

启用配置属性

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

9. 新的配置属性绑定

@ConfigurationProperties(prefix = "app")
public class AppProperties {
    private final String name;
    private final String version;
    
    // 构造函数绑定
    public AppProperties(String name, String version) {
        this.name = name;
        this.version = version;
    }
    
    // getters only
    public String getName() { return name; }
    public String getVersion() { return version; }
}

@ConfigurationProperties(prefix = "app")
public record AppProperties(String name, String version) {}

@ConfigurationProperties(prefix = "app")
@Validated
public class AppProperties {
    @NotBlank
    private String name;
    
    @Min(1)
    @Max(100)
    private int version;
    
    // getters and setters
}

10. 改进的错误处理

Spring Boot 3支持RFC 7807 Problem Details标准。

自定义错误响应

@RestControllerAdvice
public class GlobalExceptionHandler {
    
    @ExceptionHandler(UserNotFoundException.class)
    public ProblemDetail handleUserNotFound(UserNotFoundException ex) {
        ProblemDetail problemDetail = ProblemDetail.forStatus(HttpStatus.NOT_FOUND);
        problemDetail.setTitle("User Not Found");
        problemDetail.setDetail(ex.getMessage());
        problemDetail.setProperty("userId", ex.getUserId());
        return problemDetail;
    }
}

{
    "type": "about:blank",
    "title": "User Not Found",
    "status": 404,
    "detail": "User with ID 123 not found",
    "instance": "/api/users/123",
    "userId": 123
}

11. 测试支持增强

@SpringBootTest
class UserServiceTest {
    
    @MockBean
    private UserRepository userRepository;
    
    @Autowired
    private UserService userService;
    
    @Test
    void testFindUser() {
        User user = new User("test", "test@example.com");
        when(userRepository.findById(1L)).thenReturn(Optional.of(user));
        
        User result = userService.findById(1L);
        assertThat(result).isNotNull();
        assertThat(result.getUsername()).isEqualTo("test");
    }
}

@SpringBootTest
@Testcontainers
class IntegrationTest {
    
    @Container
    static MySQLContainer<?> mysql = new MySQLContainer<>("mysql:8.0")
            .withDatabaseName("testdb")
            .withUsername("test")
            .withPassword("test");
    
    @DynamicPropertySource
    static void configureProperties(DynamicPropertyRegistry registry) {
        registry.add("spring.datasource.url", mysql::getJdbcUrl);
        registry.add("spring.datasource.username", mysql::getUsername);
        registry.add("spring.datasource.password", mysql::getPassword);
    }
}

12. 性能优化

延迟初始化

# application.properties
spring.main.lazy-initialization=true

排除不必要的自动配置

@SpringBootApplication(exclude = {
    DataSourceAutoConfiguration.class,
    JpaRepositoriesAutoConfiguration.class
})
public class Application {
    public static void main(String[] args) {
        SpringApplication.run(Application.class, args);
    }
}

使用WebFlux（响应式）

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

@RestController
public class UserController {
    
    @GetMapping("/users")
    public Flux<User> getUsers() {
        return userService.findAll();
    }
}

13. 实际项目迁移案例

更新Java版本到17+
更新Spring Boot版本到3.x
替换javax为jakarta
更新第三方依赖
测试和修复问题

迁移前（Spring Boot 2.x）

// pom.xml
<parent>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-parent</artifactId>
    <version>2.7.14</version>
</parent>

// User.java
import javax.persistence.*;
import javax.validation.constraints.NotNull;

@Entity
public class User {
    @Id
    @GeneratedValue
    private Long id;
    
    @NotNull
    private String username;
}

// UserController.java
import javax.servlet.http.HttpServletRequest;

@RestController
public class UserController {
    @GetMapping("/users")
    public List<User> getUsers(HttpServletRequest request) {
        return userService.findAll();
    }
}

迁移后（Spring Boot 3.x）

// pom.xml
<parent>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-parent</artifactId>
    <version>3.2.0</version>
</parent>

<properties>
    <java.version>17</java.version>
</properties>

// User.java
import jakarta.persistence.*;
import jakarta.validation.constraints.NotNull;

@Entity
public class User {
    @Id
    @GeneratedValue
    private Long id;
    
    @NotNull
    private String username;
}

// UserController.java
import jakarta.servlet.http.HttpServletRequest;

@RestController
public class UserController {
    @GetMapping("/users")
    public List<User> getUsers(HttpServletRequest request) {
        return userService.findAll();
    }
}