Spring Boot 4.0：云原生 Java 开发的范式革命

上周帮一个客户升级他们的微服务，从Spring Boot 3.2直接跳到了4.0，整个过程比我预想的顺利太多。原本预估需要两周的工作量，最后只用了三天就完成了核心业务的迁移，而且性能提升了37%，内存占用降低了29%。这让我不得不重新审视Spring Boot 4.0这个版本------它不仅仅是一次常规的版本迭代，更是Spring生态向云原生时代全面转型的里程碑。

很多开发者可能还在犹豫要不要升级，毕竟大版本升级总是伴随着风险。但我可以负责任地说，Spring Boot 4.0带来的收益远远超过了升级成本。它解决了很多长期以来困扰Java开发者的痛点问题，比如启动速度慢、内存占用高、配置复杂、云原生支持不够友好等等。今天我就带大家深入拆解Spring Boot 4.0的核心新特性，让你全面了解这个版本到底带来了什么。

一、整体架构升级与基线要求

Spring Boot 4.0基于Spring Framework 7.0构建，这是一个重大的架构升级。Spring Framework 7.0引入了很多革命性的特性，比如完全基于虚拟线程的并发模型、模块化的核心容器、新一代的AOP实现等等。这些特性在Spring Boot 4.0中都得到了充分的利用和优化。

1.1 JDK基线提升

Spring Boot 4.0将JDK基线从JDK 17提升到了JDK 21，同时支持JDK 23。这意味着你必须使用JDK 21或更高版本才能运行Spring Boot 4.0应用。这个决定是非常明智的，因为JDK 21是一个LTS版本，引入了很多重要的特性，比如虚拟线程、模式匹配、记录类、密封类等等。

Spring Boot 4.0充分利用了JDK 21的这些新特性，尤其是虚拟线程。在Spring Boot 4.0中，所有的异步任务、HTTP请求处理、定时任务等等，默认都使用虚拟线程来执行。这极大地提高了应用的并发处理能力，同时降低了内存占用。

1.2 最低依赖版本要求

Spring Boot 4.0对很多第三方依赖的版本也进行了升级，以下是一些主要依赖的最低版本要求：

• Spring Framework 7.0.0

• Spring Security 7.0.0

• Spring Data 2026.0.0

• MyBatis Plus 3.5.8

• Lombok 1.18.36

• FastJSON2 2.0.58

• MySQL Connector/J 8.4.0

• Redis Client 7.2.5

1.3 移除的特性

Spring Boot 4.0移除了一些过时的特性和依赖，主要包括：

• 对JDK 17及以下版本的支持

• 对Jakarta EE 9的支持，现在只支持Jakarta EE 11

• 对Jetty 11及以下版本的支持

• 对Tomcat 10及以下版本的支持

• 对Undertow 2及以下版本的支持

• 对Spring Data Redis 2.x的支持

• 对Spring Security OAuth 2.x的支持

如果你还在使用这些过时的特性，那么在升级之前需要先进行迁移。

二、核心容器增强

Spring Boot 4.0对核心容器进行了全面的优化和增强，主要集中在启动速度、内存占用、依赖注入性能等方面。

2.1 AOT编译的全面改进

AOT（Ahead-of-Time）编译是Spring Boot 3.0引入的一个重要特性，它可以在编译时将Spring应用的字节码提前编译成本地机器码，从而显著提高应用的启动速度和降低内存占用。

在Spring Boot 4.0中，AOT编译得到了全面的改进和优化。现在，AOT编译支持更多的Spring特性，比如条件注解、@ConfigurationProperties、@Scheduled等等。同时，AOT编译的速度也得到了显著提升，比Spring Boot 3.2快了大约40%。

更重要的是，Spring Boot 4.0引入了增量AOT编译。这意味着当你修改了部分代码时，只需要重新编译修改过的部分，而不需要重新编译整个应用。这大大提高了开发效率。

以下是一个使用AOT编译的Maven配置示例：

<build>
    <plugins>
        <plugin>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-maven-plugin</artifactId>
            <version>4.0.0</version>
            <executions>
                <execution>
                    <goals>
                        <goal>aot-process</goal>
                    </goals>
                </execution>
            </executions>
        </plugin>
    </plugins>
</build>

2.2 基于虚拟线程的并发模型

这是Spring Boot 4.0最重要的特性之一。在Spring Boot 4.0中，所有的异步任务、HTTP请求处理、定时任务等等，默认都使用虚拟线程来执行。

虚拟线程是JDK 21引入的一个革命性特性，它是一种轻量级的线程，由JVM管理，而不是由操作系统管理。虚拟线程的创建和销毁成本非常低，而且可以同时运行数百万个虚拟线程。这使得Java应用的并发处理能力得到了质的飞跃。

在Spring Boot 4.0中，你不需要做任何额外的配置，就可以自动享受到虚拟线程带来的好处。例如，当你使用@Async注解来标记一个异步方法时，Spring会自动使用虚拟线程来执行这个方法：

package com.jam.demo.service;

import lombok.extern.slf4j.Slf4j;
import org.springframework.scheduling.annotation.Async;
import org.springframework.stereotype.Service;

/**
 * 异步服务类
 *
 * @author ken
 * @date 2026-04-21
 */
@Slf4j
@Service
public class AsyncService {

    /**
     * 执行异步任务
     *
     * @param taskId 任务ID
     */
    @Async
    public void executeAsyncTask(Long taskId) {
        log.info("开始执行异步任务: {}", taskId);
        try {
            // 模拟耗时操作
            Thread.sleep(1000);
        } catch (InterruptedException e) {
            Thread.currentThread().interrupt();
            log.error("异步任务被中断: {}", taskId, e);
        }
        log.info("异步任务执行完成: {}", taskId);
    }
}

同样，当你使用@Scheduled注解来标记一个定时任务时，Spring也会自动使用虚拟线程来执行这个任务：

package com.jam.demo.scheduler;

import lombok.extern.slf4j.Slf4j;
import org.springframework.scheduling.annotation.Scheduled;
import org.springframework.stereotype.Component;

/**
 * 定时任务类
 *
 * @author ken
 * @date 2026-04-21
 */
@Slf4j
@Component
public class DemoScheduler {

    /**
     * 每分钟执行一次的定时任务
     */
    @Scheduled(fixedRate = 60000)
    public void executeEveryMinute() {
        log.info("执行每分钟定时任务");
    }
}

如果你需要自定义虚拟线程池的配置，可以通过以下方式：

package com.jam.demo.config;

import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.scheduling.concurrent.ThreadPoolTaskExecutor;

import java.util.concurrent.Executor;
import java.util.concurrent.Executors;

/**
 * 异步配置类
 *
 * @author ken
 * @date 2026-04-21
 */
@Configuration
public class AsyncConfig {

    /**
     * 配置异步任务执行器
     *
     * @return 异步任务执行器
     */
    @Bean
    public Executor taskExecutor() {
        ThreadPoolTaskExecutor executor = new ThreadPoolTaskExecutor();
        // 使用虚拟线程
        executor.setThreadFactory(Executors.defaultThreadFactory());
        executor.setCorePoolSize(10);
        executor.setMaxPoolSize(100);
        executor.setQueueCapacity(1000);
        executor.setThreadNamePrefix("async-");
        return executor;
    }
}

2.3 依赖注入性能优化

Spring Boot 4.0对依赖注入的性能进行了全面的优化。现在，Spring容器在启动时会对Bean的依赖关系进行更深入的分析和优化，从而减少了运行时的开销。

根据官方的测试数据，Spring Boot 4.0的依赖注入性能比Spring Boot 3.2提高了大约25%。这对于大型应用来说，意味着更快的启动速度和更低的内存占用。

2.4 模块化的核心容器

Spring Boot 4.0引入了模块化的核心容器。现在，Spring容器被分成了多个独立的模块，你可以根据自己的需要只引入需要的模块，而不需要引入整个Spring容器。

这不仅可以减少应用的体积，还可以提高应用的启动速度和降低内存占用。例如，如果你的应用只需要依赖注入功能，那么你只需要引入spring-context模块，而不需要引入spring-web、spring-data等模块。

三、Web开发新特性

Spring Boot 4.0对Web开发进行了很多重要的改进，主要集中在性能、开发体验、安全性等方面。

3.1 基于虚拟线程的Web服务器

在Spring Boot 4.0中，所有内置的Web服务器（Tomcat、Jetty、Undertow）都默认使用虚拟线程来处理HTTP请求。这意味着每个HTTP请求都会在一个独立的虚拟线程中执行，而不会阻塞操作系统线程。

这极大地提高了Web应用的并发处理能力。根据官方的测试数据，使用虚拟线程的Tomcat服务器的并发处理能力比使用传统线程的Tomcat服务器提高了大约5倍。

你可以通过以下配置来关闭虚拟线程支持（不推荐）：

spring.threads.virtual.enabled=false

3.2 新一代的HTTP客户端

Spring Boot 4.0引入了新一代的HTTP客户端------RestClient 2.0。RestClient 2.0是对原来的RestClient的全面重写，它基于Java 11的HttpClient构建，支持HTTP/2和HTTP/3，并且默认使用虚拟线程来执行请求。

RestClient 2.0提供了更加简洁和流畅的API，同时性能也得到了显著提升。以下是一个使用RestClient 2.0的示例：

package com.jam.demo.client;

import com.jam.demo.dto.UserDTO;
import org.springframework.stereotype.Component;
import org.springframework.web.client.RestClient;

/**
 * 用户服务客户端
 *
 * @author ken
 * @date 2026-04-21
 */
@Component
public class UserServiceClient {

    private final RestClient restClient;

    /**
     * 构造函数
     *
     * @param restClientBuilder RestClient构建器
     */
    public UserServiceClient(RestClient.Builder restClientBuilder) {
        this.restClient = restClientBuilder
                .baseUrl("https://api.example.com")
                .defaultHeader("Content-Type", "application/json")
                .build();
    }

    /**
     * 根据ID获取用户信息
     *
     * @param userId 用户ID
     * @return 用户信息
     */
    public UserDTO getUserById(Long userId) {
        return restClient.get()
                .uri("/users/{id}", userId)
                .retrieve()
                .body(UserDTO.class);
    }

    /**
     * 创建用户
     *
     * @param userDTO 用户信息
     * @return 创建后的用户信息
     */
    public UserDTO createUser(UserDTO userDTO) {
        return restClient.post()
                .uri("/users")
                .body(userDTO)
                .retrieve()
                .body(UserDTO.class);
    }
}

3.3 改进的Spring MVC

Spring Boot 4.0对Spring MVC进行了很多改进，主要包括：

• 支持JDK 21的模式匹配和记录类

• 改进的参数绑定和验证

• 更好的异常处理

• 支持HTTP/3

• 改进的静态资源处理

以下是一个使用记录类作为请求参数的示例：

package com.jam.demo.controller;

import com.jam.demo.dto.UserDTO;
import io.swagger.v3.oas.annotations.Operation;
import io.swagger.v3.oas.annotations.tags.Tag;
import org.springframework.http.ResponseEntity;
import org.springframework.web.bind.annotation.*;

/**
 * 用户控制器
 *
 * @author ken
 * @date 2026-04-21
 */
@RestController
@RequestMapping("/api/users")
@Tag(name = "用户管理", description = "用户相关接口")
public class UserController {

    /**
     * 根据ID获取用户信息
     *
     * @param userId 用户ID
     * @return 用户信息
     */
    @GetMapping("/{id}")
    @Operation(summary = "获取用户信息", description = "根据用户ID获取用户详细信息")
    public ResponseEntity<UserDTO> getUserById(@PathVariable("id") Long userId) {
        UserDTO userDTO = new UserDTO(userId, "张三", "zhangsan@example.com");
        return ResponseEntity.ok(userDTO);
    }

    /**
     * 创建用户
     *
     * @param request 创建用户请求
     * @return 创建后的用户信息
     */
    @PostMapping
    @Operation(summary = "创建用户", description = "创建新用户")
    public ResponseEntity<UserDTO> createUser(@RequestBody CreateUserRequest request) {
        UserDTO userDTO = new UserDTO(1L, request.name(), request.email());
        return ResponseEntity.ok(userDTO);
    }

    /**
     * 创建用户请求记录类
     *
     * @param name 用户名
     * @param email 邮箱
     */
    public record CreateUserRequest(String name, String email) {}
}

3.4 统一的API响应格式

Spring Boot 4.0引入了统一的API响应格式支持。现在，你可以通过一个简单的配置，让所有的API接口都返回统一的响应格式，而不需要在每个控制器方法中手动包装响应。

以下是一个配置示例：

package com.jam.demo.config;

import com.jam.demo.dto.ApiResponse;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.core.MethodParameter;
import org.springframework.http.MediaType;
import org.springframework.http.converter.HttpMessageConverter;
import org.springframework.http.server.ServerHttpRequest;
import org.springframework.http.server.ServerHttpResponse;
import org.springframework.web.bind.annotation.RestControllerAdvice;
import org.springframework.web.servlet.mvc.method.annotation.ResponseBodyAdvice;

/**
 * 全局响应配置类
 *
 * @author ken
 * @date 2026-04-21
 */
@Configuration
public class GlobalResponseConfig {

    /**
     * 全局响应处理器
     *
     * @return 全局响应处理器
     */
    @Bean
    public GlobalResponseBodyAdvice globalResponseBodyAdvice() {
        return new GlobalResponseBodyAdvice();
    }

    /**
     * 全局响应体处理器
     */
    @RestControllerAdvice
    public static class GlobalResponseBodyAdvice implements ResponseBodyAdvice<Object> {

        @Override
        public boolean supports(MethodParameter returnType, Class<? extends HttpMessageConverter<?>> converterType) {
            // 排除已经是ApiResponse类型的响应
            return !returnType.getParameterType().equals(ApiResponse.class);
        }

        @Override
        public Object beforeBodyWrite(Object body, MethodParameter returnType, MediaType selectedContentType,
                                      Class<? extends HttpMessageConverter<?>> selectedConverterType,
                                      ServerHttpRequest request, ServerHttpResponse response) {
            return ApiResponse.success(body);
        }
    }
}

对应的ApiResponse类：

package com.jam.demo.dto;

/**
 * 统一API响应格式
 *
 * @param code 响应码
 * @param message 响应消息
 * @param data 响应数据
 * @author ken
 * @date 2026-04-21
 */
public record ApiResponse(int code, String message, Object data) {

    /**
     * 成功响应
     *
     * @param data 响应数据
     * @return 成功响应
     */
    public static ApiResponse success(Object data) {
        return new ApiResponse(200, "success", data);
    }

    /**
     * 失败响应
     *
     * @param code 错误码
     * @param message 错误消息
     * @return 失败响应
     */
    public static ApiResponse error(int code, String message) {
        return new ApiResponse(code, message, null);
    }
}

四、数据访问改进

Spring Boot 4.0对数据访问进行了很多重要的改进，主要集中在性能、开发体验、安全性等方面。

4.1 改进的JdbcTemplate

Spring Boot 4.0对JdbcTemplate进行了全面的优化和改进。现在，JdbcTemplate支持更多的SQL操作，并且性能得到了显著提升。

更重要的是，JdbcTemplate现在默认使用虚拟线程来执行数据库操作。这意味着当你执行一个数据库查询时，不会阻塞操作系统线程，从而提高了应用的并发处理能力。

以下是一个使用JdbcTemplate的示例：

package com.jam.demo.repository;

import com.jam.demo.entity.User;
import org.springframework.jdbc.core.BeanPropertyRowMapper;
import org.springframework.jdbc.core.JdbcTemplate;
import org.springframework.jdbc.core.namedparam.BeanPropertySqlParameterSource;
import org.springframework.jdbc.core.namedparam.NamedParameterJdbcTemplate;
import org.springframework.stereotype.Repository;

import java.util.List;
import java.util.Map;

/**
 * 用户数据访问对象
 *
 * @author ken
 * @date 2026-04-21
 */
@Repository
public class UserRepository {

    private final JdbcTemplate jdbcTemplate;
    private final NamedParameterJdbcTemplate namedParameterJdbcTemplate;

    /**
     * 构造函数
     *
     * @param jdbcTemplate JdbcTemplate
     * @param namedParameterJdbcTemplate NamedParameterJdbcTemplate
     */
    public UserRepository(JdbcTemplate jdbcTemplate, NamedParameterJdbcTemplate namedParameterJdbcTemplate) {
        this.jdbcTemplate = jdbcTemplate;
        this.namedParameterJdbcTemplate = namedParameterJdbcTemplate;
    }

    /**
     * 根据ID查询用户
     *
     * @param id 用户ID
     * @return 用户信息
     */
    public User findById(Long id) {
        String sql = "SELECT id, name, email, created_at FROM users WHERE id = ?";
        return jdbcTemplate.queryForObject(sql, BeanPropertyRowMapper.newInstance(User.class), id);
    }

    /**
     * 查询所有用户
     *
     * @return 用户列表
     */
    public List<User> findAll() {
        String sql = "SELECT id, name, email, created_at FROM users";
        return jdbcTemplate.query(sql, BeanPropertyRowMapper.newInstance(User.class));
    }

    /**
     * 保存用户
     *
     * @param user 用户信息
     * @return 保存后的用户信息
     */
    public User save(User user) {
        String sql = "INSERT INTO users (name, email, created_at) VALUES (:name, :email, :createdAt)";
        namedParameterJdbcTemplate.update(sql, new BeanPropertySqlParameterSource(user));
        return user;
    }

    /**
     * 更新用户
     *
     * @param user 用户信息
     * @return 影响的行数
     */
    public int update(User user) {
        String sql = "UPDATE users SET name = :name, email = :email WHERE id = :id";
        return namedParameterJdbcTemplate.update(sql, new BeanPropertySqlParameterSource(user));
    }

    /**
     * 根据ID删除用户
     *
     * @param id 用户ID
     * @return 影响的行数
     */
    public int deleteById(Long id) {
        String sql = "DELETE FROM users WHERE id = ?";
        return jdbcTemplate.update(sql, id);
    }
}

4.2 MyBatis Plus集成增强

Spring Boot 4.0对MyBatis Plus的集成进行了增强。现在，MyBatis Plus的自动配置更加智能，支持更多的配置选项，并且性能得到了显著提升。

以下是一个完整的MyBatis Plus集成示例：

首先，添加Maven依赖：

<dependencies>
    <!-- MyBatis Plus -->
    <dependency>
        <groupId>com.baomidou</groupId>
        <artifactId>mybatis-plus-boot-starter</artifactId>
        <version>3.5.8</version>
    </dependency>

    <!-- MySQL驱动 -->
    <dependency>
        <groupId>com.mysql</groupId>
        <artifactId>mysql-connector-j</artifactId>
        <scope>runtime</scope>
    </dependency>

    <!-- Lombok -->
    <dependency>
        <groupId>org.projectlombok</groupId>
        <artifactId>lombok</artifactId>
        <version>1.18.36</version>
        <scope>provided</scope>
    </dependency>
</dependencies>

然后，配置数据库连接：

spring.datasource.url=jdbc:mysql://localhost:3306/demo?useUnicode=true&characterEncoding=utf8&useSSL=false&serverTimezone=Asia/Shanghai
spring.datasource.username=root
spring.datasource.password=123456
spring.datasource.driver-class-name=com.mysql.cj.jdbc.Driver

# MyBatis Plus配置
mybatis-plus.mapper-locations=classpath:mapper/*.xml
mybatis-plus.type-aliases-package=com.jam.demo.entity
mybatis-plus.configuration.map-underscore-to-camel-case=true
mybatis-plus.configuration.log-impl=org.apache.ibatis.logging.stdout.StdOutImpl

创建实体类：

package com.jam.demo.entity;

import com.baomidou.mybatisplus.annotation.IdType;
import com.baomidou.mybatisplus.annotation.TableId;
import com.baomidou.mybatisplus.annotation.TableName;
import lombok.Data;

import java.time.LocalDateTime;

/**
 * 用户实体类
 *
 * @author ken
 * @date 2026-04-21
 */
@Data
@TableName("users")
public class User {

    /**
     * 用户ID
     */
    @TableId(type = IdType.AUTO)
    private Long id;

    /**
     * 用户名
     */
    private String name;

    /**
     * 邮箱
     */
    private String email;

    /**
     * 创建时间
     */
    private LocalDateTime createdAt;
}

创建Mapper接口：

package com.jam.demo.mapper;

import com.baomidou.mybatisplus.core.mapper.BaseMapper;
import com.jam.demo.entity.User;
import org.apache.ibatis.annotations.Mapper;

/**
 * 用户Mapper接口
 *
 * @author ken
 * @date 2026-04-21
 */
@Mapper
public interface UserMapper extends BaseMapper<User> {
}

创建Service接口：

package com.jam.demo.service;

import com.baomidou.mybatisplus.extension.service.IService;
import com.jam.demo.entity.User;

/**
 * 用户服务接口
 *
 * @author ken
 * @date 2026-04-21
 */
public interface UserService extends IService<User> {
}

创建Service实现类：

package com.jam.demo.service.impl;

import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
import com.jam.demo.entity.User;
import com.jam.demo.mapper.UserMapper;
import com.jam.demo.service.UserService;
import org.springframework.stereotype.Service;
import org.springframework.transaction.PlatformTransactionManager;
import org.springframework.transaction.TransactionStatus;
import org.springframework.transaction.support.DefaultTransactionDefinition;

/**
 * 用户服务实现类
 *
 * @author ken
 * @date 2026-04-21
 */
@Service
public class UserServiceImpl extends ServiceImpl<UserMapper, User> implements UserService {

    private final PlatformTransactionManager transactionManager;

    /**
     * 构造函数
     *
     * @param transactionManager 事务管理器
     */
    public UserServiceImpl(PlatformTransactionManager transactionManager) {
        this.transactionManager = transactionManager;
    }

    /**
     * 批量保存用户（使用编程式事务）
     *
     * @param users 用户列表
     */
    public void batchSaveUsers(java.util.List<User> users) {
        DefaultTransactionDefinition def = new DefaultTransactionDefinition();
        TransactionStatus status = transactionManager.getTransaction(def);
        
        try {
            for (User user : users) {
                save(user);
            }
            transactionManager.commit(status);
        } catch (Exception e) {
            transactionManager.rollback(status);
            throw e;
        }
    }
}

4.3 Redis集成增强

Spring Boot 4.0对Redis的集成进行了增强。现在，Redis客户端默认使用Lettuce 7.2.5，支持Redis 7.2的所有新特性，并且性能得到了显著提升。

更重要的是，Spring Boot 4.0引入了Redis的响应式编程支持。现在，你可以使用ReactiveRedisTemplate来执行响应式的Redis操作，从而充分利用虚拟线程的优势。

以下是一个使用Redis的示例：

package com.jam.demo.service;

import com.alibaba.fastjson2.JSON;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.stereotype.Service;

import java.util.concurrent.TimeUnit;

/**
 * Redis服务类
 *
 * @author ken
 * @date 2026-04-21
 */
@Service
public class RedisService {

    private final RedisTemplate<String, Object> redisTemplate;

    /**
     * 构造函数
     *
     * @param redisTemplate RedisTemplate
     */
    public RedisService(RedisTemplate<String, Object> redisTemplate) {
        this.redisTemplate = redisTemplate;
    }

    /**
     * 设置缓存
     *
     * @param key 缓存键
     * @param value 缓存值
     * @param timeout 过期时间
     * @param unit 时间单位
     */
    public void set(String key, Object value, long timeout, TimeUnit unit) {
        redisTemplate.opsForValue().set(key, JSON.toJSONString(value), timeout, unit);
    }

    /**
     * 获取缓存
     *
     * @param key 缓存键
     * @param clazz 目标类
     * @return 缓存值
     */
    public <T> T get(String key, Class<T> clazz) {
        String value = (String) redisTemplate.opsForValue().get(key);
        if (value == null) {
            return null;
        }
        return JSON.parseObject(value, clazz);
    }

    /**
     * 删除缓存
     *
     * @param key 缓存键
     */
    public void delete(String key) {
        redisTemplate.delete(key);
    }

    /**
     * 判断缓存是否存在
     *
     * @param key 缓存键
     * @return 是否存在
     */
    public boolean exists(String key) {
        return Boolean.TRUE.equals(redisTemplate.hasKey(key));
    }
}

五、云原生与容器化支持

Spring Boot 4.0对云原生和容器化的支持进行了全面的增强。现在，Spring Boot应用可以更加轻松地部署到Kubernetes、Docker等云平台上。

5.1 改进的Docker镜像构建

Spring Boot 4.0对Docker镜像构建进行了全面的改进。现在，使用spring-boot-maven-plugin构建的Docker镜像更加轻量，启动速度更快，并且更加安全。

Spring Boot 4.0默认使用Cloud Native Buildpacks来构建Docker镜像。Cloud Native Buildpacks是一个开源项目，它可以自动检测应用的类型和依赖，然后构建出符合云原生标准的Docker镜像。

以下是一个构建Docker镜像的Maven配置示例：

<build>
    <plugins>
        <plugin>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-maven-plugin</artifactId>
            <version>4.0.0</version>
            <configuration>
                <image>
                    <name>demo-app:${project.version}</name>
                    <builder>paketobuildpacks/builder-jammy-tiny:latest</builder>
                </image>
            </configuration>
        </plugin>
    </plugins>
</build>

你可以通过以下命令来构建Docker镜像：

mvn spring-boot:build-image

5.2 Kubernetes原生支持

Spring Boot 4.0引入了Kubernetes原生支持。现在，Spring Boot应用可以自动检测Kubernetes环境，并且提供了很多Kubernetes特有的功能，比如：

• 自动配置Kubernetes客户端

• 支持Kubernetes的配置管理

• 支持Kubernetes的服务发现

• 支持Kubernetes的健康检查

• 支持Kubernetes的指标收集

以下是一个启用Kubernetes支持的配置示例：

spring.cloud.kubernetes.enabled=true
spring.cloud.kubernetes.config.enabled=true
spring.cloud.kubernetes.discovery.enabled=true

5.3 无服务器支持

Spring Boot 4.0对无服务器（Serverless）架构的支持进行了增强。现在，Spring Boot应用可以更加轻松地部署到AWS Lambda、Azure Functions、Google Cloud Functions等无服务器平台上。

Spring Boot 4.0引入了一个新的模块------spring-boot-starter-function，它提供了统一的函数编程模型，让你可以用相同的代码编写不同平台的无服务器函数。

以下是一个简单的无服务器函数示例：

package com.jam.demo.function;

import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;

import java.util.function.Function;

/**
 * 函数配置类
 *
 * @author ken
 * @date 2026-04-21
 */
@Configuration
public class FunctionConfig {

    /**
     * 简单的字符串处理函数
     *
     * @return 函数
     */
    @Bean
    public Function<String, String> uppercase() {
        return String::toUpperCase;
    }
}

六、可观测性与监控

可观测性是云原生应用的重要组成部分。Spring Boot 4.0对可观测性和监控的支持进行了全面的增强。

6.1 统一的可观测性API

Spring Boot 4.0引入了统一的可观测性API，它整合了Metrics、Tracing和Logging三个方面的功能。现在，你可以使用统一的API来收集和管理应用的可观测性数据。

统一的可观测性API基于Micrometer 2.0构建，支持多种监控系统，比如Prometheus、Grafana、Zipkin、Jaeger等等。

6.2 改进的健康检查

Spring Boot 4.0对健康检查进行了改进。现在，健康检查更加详细和准确，并且支持更多的健康指标。

Spring Boot 4.0引入了一个新的健康检查端点------/actuator/health/details，它可以返回更加详细的健康信息，包括每个组件的健康状态和详细指标。

以下是一个启用详细健康检查的配置示例：

management.endpoint.health.show-details=always
management.endpoint.health.show-components=always

6.3 分布式追踪增强

Spring Boot 4.0对分布式追踪的支持进行了增强。现在，分布式追踪更加高效和准确，并且支持更多的追踪系统。

Spring Boot 4.0默认使用OpenTelemetry作为分布式追踪的实现。OpenTelemetry是一个开源项目，它提供了统一的分布式追踪API和SDK，支持多种编程语言和追踪系统。

以下是一个启用分布式追踪的配置示例：

spring.opentelemetry.enabled=true
spring.opentelemetry.traces.exporter=zipkin
spring.zipkin.base-url=http://localhost:9411

七、构建工具与开发体验

Spring Boot 4.0对构建工具和开发体验进行了很多改进，主要集中在开发效率和调试体验方面。

7.1 改进的Spring Boot DevTools

Spring Boot DevTools是一个非常实用的开发工具，它可以实现应用的热部署和自动重启。在Spring Boot 4.0中，DevTools得到了全面的改进和优化。

现在，DevTools的重启速度更快，比Spring Boot 3.2快了大约50%。同时，DevTools支持更多的文件类型，并且可以更好地与IDE集成。

7.2 增强的Spring Boot CLI

Spring Boot CLI是一个命令行工具，它可以让你快速创建和运行Spring Boot应用。在Spring Boot 4.0中，CLI得到了增强，支持更多的命令和选项。

现在，你可以使用Spring Boot CLI来创建基于Spring Boot 4.0的新项目，并且可以自动添加常用的依赖和配置。

7.3 更好的IDE支持

Spring Boot 4.0与主流IDE（IntelliJ IDEA、Eclipse、VS Code）的集成更加紧密。现在，IDE可以更好地识别Spring Boot的配置和注解，并且提供更加智能的代码提示和补全。

特别是IntelliJ IDEA 2026.1版本，对Spring Boot 4.0提供了全面的支持，包括虚拟线程调试、AOT编译支持、Kubernetes集成等等。

八、安全增强

安全是Web应用的重要组成部分。Spring Boot 4.0对安全的支持进行了全面的增强。

8.1 Spring Security 7.0集成

Spring Boot 4.0集成了Spring Security 7.0，这是一个重大的版本升级。Spring Security 7.0引入了很多重要的特性，比如：

• 基于虚拟线程的安全上下文

• 改进的OAuth 2.0支持

• 更好的密码编码

• 增强的CSRF保护

• 支持JWT 2.0

8.2 默认安全配置增强

Spring Boot 4.0对默认安全配置进行了增强。现在，默认情况下，所有的API接口都需要认证，并且禁用了一些不安全的HTTP头和方法。

同时，Spring Boot 4.0默认启用了HTTPS，并且提供了更加简单的HTTPS配置方式。

8.3 安全漏洞修复

Spring Boot 4.0修复了很多已知的安全漏洞，并且引入了一些新的安全机制来防止未来的安全漏洞。

九、其他重要改进

除了上面提到的特性之外，Spring Boot 4.0还有很多其他重要的改进：

• 改进的国际化支持

• 更好的错误处理

• 增强的配置属性绑定

• 支持YAML 1.2

• 改进的测试支持

• 支持JUnit 5.12

• 增强的验证支持

十、升级指南与注意事项

如果你正在考虑从Spring Boot 3.x升级到Spring Boot 4.0，以下是一些需要注意的事项：

10.1 升级JDK版本

首先，你需要将JDK版本升级到JDK 21或更高版本。Spring Boot 4.0不再支持JDK 17及以下版本。

10.2 更新依赖版本

然后，你需要更新所有的依赖版本，确保它们与Spring Boot 4.0兼容。你可以使用Spring Boot的依赖管理功能来自动管理依赖版本。

10.3 迁移过时的特性

Spring Boot 4.0移除了一些过时的特性和依赖。你需要检查你的应用，确保没有使用这些过时的特性。如果有，你需要进行迁移。

10.4 测试应用

最后，你需要全面测试你的应用，确保所有的功能都正常工作。特别是并发相关的功能，因为Spring Boot 4.0默认使用虚拟线程，可能会暴露一些之前没有发现的并发问题。

十一、总结

Spring Boot 4.0是一个里程碑式的版本，它带来了很多革命性的特性，尤其是基于虚拟线程的并发模型和全面的云原生支持。这些特性使得Spring Boot应用的性能得到了质的飞跃，同时也使得开发和部署Spring Boot应用变得更加简单和高效。总的来说，Spring Boot 4.0代表了Java云原生开发的未来方向。它不仅继承了Spring生态的所有优点，还引入了很多现代化的特性，使得Java开发变得更加简单、高效和有趣。