微服务 on 吾爱主机

Spring Cloud 微服务架构全解：注册发现、网关、熔断与实战

Thu, 25 Jun 2026 18:00:00 +0000

前言

Spring Cloud 是基于 Spring Boot 的微服务架构解决方案，提供了一系列工具和框架来解决分布式系统中的常见问题：服务注册与发现、配置中心、负载均衡、熔断降级、网关路由、链路追踪等。本文基于 Spring Cloud 2022.x + Spring Boot 3.x 体系讲解。

1. 微服务架构概览

 ┌──────────────┐
 │ 客户端 │
 └──────┬───────┘
 │
 ┌──────▼───────┐
 │ Gateway │ (路由、限流、鉴权)
 │ 网关服务 │
 └──────┬───────┘
 │
 ┌──────────────┼──────────────┐
 │ │ │
 ┌──────▼──────┐ ┌────▼──────┐ ┌─────▼─────┐
 │ 用户服务 │ │ 订单服务 │ │ 商品服务 │
 │ user-svc │ │ order-svc │ │ product-svc│
 └──────┬──────┘ └────┬──────┘ └─────┬─────┘
 │ │ │
 ┌──────▼──────────────▼──────────────▼─────┐
 │ Nacos (注册中心 + 配置中心) │
 └──────────────────────────────────────────┘
 │ │ │
 ┌──────▼──────┐ ┌────▼──────┐ ┌─────▼─────┐
 │ MySQL │ │ Redis │ │ RocketMQ │
 └─────────────┘ └───────────┘ └────────────┘

2. Spring Cloud 版本选择

Spring Cloud	Spring Boot	主要组件
2024.0.x	3.4.x / 3.5.x	Nacos 2.x, Sentinel, Gateway
2023.0.x (Leyton)	3.2.x / 3.3.x	Nacos 2.x, Sentinel, Gateway
2022.0.x (Kilburn)	3.0.x / 3.1.x	Nacos 2.x, Sentinel, Gateway

Spring Boot 4.x 适配的 Spring Cloud 版本请参考官方文档。

2.1 依赖管理（pom.xml）

<dependencyManagement>
 <dependencies>
 <!-- Spring Cloud 版本管理 -->
 <dependency>
 <groupId>org.springframework.cloud</groupId>
 <artifactId>spring-cloud-dependencies</artifactId>
 <version>2023.0.0</version>
 <type>pom</type>
 <scope>import</scope>
 </dependency>

 <!-- Spring Cloud Alibaba 版本管理 -->
 <dependency>
 <groupId>com.alibaba.cloud</groupId>
 <artifactId>spring-cloud-alibaba-dependencies</artifactId>
 <version>2023.0.0.0</version>
 <type>pom</type>
 <scope>import</scope>
 </dependency>
 </dependencies>
</dependencyManagement>

3. Nacos — 注册中心与配置中心

3.1 安装 Nacos

# Docker 快速启动
docker run -d \
 --name nacos \
 -p 8848:8848 \
 -p 9848:9848 \
 -e MODE=standalone \
 -e NACOS_AUTH_ENABLE=true \
 nacos/nacos-server:v2.3.0

# 访问控制台: http://localhost:8848/nacos
# 默认账号: nacos / nacos

3.2 服务注册

<!-- 引入依赖 -->
<dependency>
 <groupId>com.alibaba.cloud</groupId>
 <artifactId>spring-cloud-starter-alibaba-nacos-discovery</artifactId>
</dependency>

# application.yml
spring:
 application:
 name: user-service
 cloud:
 nacos:
 discovery:
 server-addr: localhost:8848
 namespace: dev
 group: DEFAULT_GROUP
 username: nacos
 password: nacos

// 启动类
@SpringBootApplication
@EnableDiscoveryClient
public class UserServiceApplication {
 public static void main(String[] args) {
 SpringApplication.run(UserServiceApplication.class, args);
 }
}

3.3 配置中心

<dependency>
 <groupId>com.alibaba.cloud</groupId>
 <artifactId>spring-cloud-starter-alibaba-nacos-config</artifactId>
</dependency>
<dependency>
 <groupId>org.springframework.cloud</groupId>
 <artifactId>spring-cloud-starter-bootstrap</artifactId>
</dependency>

# bootstrap.yml
spring:
 application:
 name: user-service
 cloud:
 nacos:
 config:
 server-addr: localhost:8848
 file-extension: yml
 namespace: dev
 group: DEFAULT_GROUP
 # 共享配置
 shared-configs:
 - data-id: common.yml
 group: DEFAULT_GROUP
 refresh: true

// 动态刷新配置
@RestController
@RefreshScope
public class ConfigController {

 @Value("${app.custom-config}")
 private String customConfig;

 @GetMapping("/config")
 public String getConfig() {
 return customConfig;
 }
}

4. OpenFeign — 声明式 HTTP 调用

4.1 基本用法

<dependency>
 <groupId>org.springframework.cloud</groupId>
 <artifactId>spring-cloud-starter-openfeign</artifactId>
</dependency>
<dependency>
 <groupId>org.springframework.cloud</groupId>
 <artifactId>spring-cloud-starter-loadbalancer</artifactId>
</dependency>

// 启动类
@SpringBootApplication
@EnableFeignClients
public class OrderServiceApplication { }

// 定义 Feign 客户端
@FeignClient(name = "user-service", fallbackFactory = UserClientFallbackFactory.class)
public interface UserClient {

 @GetMapping("/api/users/{id}")
 ApiResponse<UserDTO> getUserById(@PathVariable("id") Long id);

 @PostMapping("/api/users/batch")
 ApiResponse<List<UserDTO>> getUsersByIds(@RequestBody List<Long> ids);
}

// 降级工厂
@Component
public class UserClientFallbackFactory implements FallbackFactory<UserClient> {
 @Override
 public UserClient create(Throwable cause) {
 return new UserClient() {
 @Override
 public ApiResponse<UserDTO> getUserById(Long id) {
 return ApiResponse.error(503, "用户服务不可用: " + cause.getMessage());
 }
 @Override
 public ApiResponse<List<UserDTO>> getUsersByIds(List<Long> ids) {
 return ApiResponse.error(503, "用户服务不可用");
 }
 };
 }
}

// 使用
@Service
@RequiredArgsConstructor
public class OrderService {

 private final UserClient userClient;

 public OrderDTO getOrderDetail(Long orderId) {
 Order order = orderRepository.findById(orderId).orElseThrow();
 // 调用用户服务
 ApiResponse<UserDTO> userResp = userClient.getUserById(order.getUserId());
 // 组装返回
 OrderDTO dto = new OrderDTO();
 dto.setOrder(order);
 dto.setUser(userResp.getData());
 return dto;
 }
}

4.2 Feign 配置

feign:
 client:
 config:
 default:
 connect-timeout: 5000
 read-timeout: 10000
 logger-level: FULL
 compression:
 request:
 enabled: true
 mime-types: application/json
 min-request-size: 2048
 response:
 enabled: true
 circuitbreaker:
 enabled: true

5. Gateway — API 网关

5.1 网关服务搭建

<dependency>
 <groupId>org.springframework.cloud</groupId>
 <artifactId>spring-cloud-starter-gateway</artifactId>
</dependency>
<dependency>
 <groupId>com.alibaba.cloud</groupId>
 <artifactId>spring-cloud-starter-alibaba-nacos-discovery</artifactId>
</dependency>

spring:
 application:
 name: gateway
 cloud:
 nacos:
 discovery:
 server-addr: localhost:8848
 gateway:
 # 路由配置
 routes:
 - id: user-service
 uri: lb://user-service  # 负载均衡
 predicates:
 - Path=/api/users/**
 filters:
 - StripPrefix=1  # 去掉前缀

 - id: order-service
 uri: lb://order-service
 predicates:
 - Path=/api/orders/**
 filters:
 - StripPrefix=1

 - id: product-service
 uri: lb://product-service
 predicates:
 - Path=/api/products/**
 filters:
 - StripPrefix=1

 # 全局 CORS
 globalcors:
 cors-configurations:
 '[/**]':
 allowedOrigins: "*"
 allowedMethods: "*"
 allowedHeaders: "*"

5.2 自定义过滤器

@Component
public class AuthFilter implements GlobalFilter, Ordered {

 @Override
 public Mono<Void> filter(ServerWebExchange exchange, GatewayFilterChain chain) {
 String token = exchange.getRequest().getHeaders().getFirst("Authorization");

 // 白名单
 String path = exchange.getRequest().getURI().getPath();
 if (path.contains("/auth/") || path.contains("/public/")) {
 return chain.filter(exchange);
 }

 // 验证 Token
 if (token == null || !validateToken(token)) {
 ServerHttpResponse response = exchange.getResponse();
 response.setStatusCode(HttpStatus.UNAUTHORIZED);
 response.getHeaders().setContentType(MediaType.APPLICATION_JSON);
 String body = "{\"code\":401,\"message\":\"未授权\"}";
 DataBuffer buffer = response.bufferFactory().wrap(body.getBytes());
 return response.writeWith(Mono.just(buffer));
 }

 // 将用户信息传递给下游服务
 ServerHttpRequest request = exchange.getRequest().mutate()
 .header("X-User-Id", getUserId(token))
 .build();

 return chain.filter(exchange.mutate().request(request).build());
 }

 @Override
 public int getOrder() {
 return -1; // 最高优先级
 }
}

6. Sentinel — 熔断降级与限流

6.1 引入依赖

<dependency>
 <groupId>com.alibaba.cloud</groupId>
 <artifactId>spring-cloud-starter-alibaba-sentinel</artifactId>
</dependency>

6.2 限流规则

@Service
public class ProductService {

 @SentinelResource(
 value = "getProduct",
 blockHandler = "getProductBlock",
 fallback = "getProductFallback"
 )
 public ProductDTO getProduct(Long id) {
 return productRepository.findById(id)
 .map(this::convertToDTO)
 .orElseThrow(() -> new BusinessException(404, "商品不存在"));
 }

 // 限流降级
 public ProductDTO getProductBlock(Long id, BlockException ex) {
 throw new BusinessException(429, "请求过于频繁，请稍后再试");
 }

 // 业务降级
 public ProductDTO getProductFallback(Long id, Throwable ex) {
 return ProductDTO.builder()
 .id(id)
 .name("商品信息暂不可用")
 .build();
 }
}

6.3 熔断规则（代码配置）

@Configuration
public class SentinelConfig {

 @PostConstruct
 public void initRules() {
 // 限流规则
 FlowRule flowRule = new FlowRule();
 flowRule.setResource("getProduct");
 flowRule.setGrade(RuleConstant.FLOW_GRADE_QPS);
 flowRule.setCount(100); // QPS 限制为 100
 flowRule.setControlBehavior(RuleConstant.CONTROL_BEHAVIOR_WARM_UP);
 flowRule.setWarmUpPeriodSec(10); // 预热 10 秒
 FlowRuleManager.loadRules(Collections.singletonList(flowRule));

 // 熔断规则
 DegradeRule degradeRule = new DegradeRule();
 degradeRule.setResource("getProduct");
 degradeRule.setGrade(CircuitBreakerStrategy.ERROR_RATIO.getType());
 degradeRule.setCount(0.5); // 错误率 50%
 degradeRule.setTimeWindow(30); // 熔断持续 30 秒
 degradeRule.setMinRequestAmount(10); // 最少 10 次请求
 degradeRule.setStatIntervalMs(10000); // 统计窗口 10 秒
 DegradeManager.loadRules(Collections.singletonList(degradeRule));
 }
}

6.4 网关限流

spring:
 cloud:
 gateway:
 routes:
 - id: user-service
 uri: lb://user-service
 predicates:
 - Path=/api/users/**
 filters:
 - name: RequestRateLimiter
 args:
 redis-rate-limiter.replenishRate: 10 # 每秒 10 个请求
 redis-rate-limiter.burstCapacity: 20 # 突发容量 20
 key-resolver: "#{@userKeyResolver}"

@Component
public class UserKeyResolver implements KeyResolver {
 @Override
 public Mono<String> resolve(ServerWebExchange exchange) {
 // 按用户 ID 限流
 String userId = exchange.getRequest().getHeaders().getFirst("X-User-Id");
 return Mono.just(userId != null ? userId : exchange.getRequest().getRemoteAddress().getHostString());
 }
}

7. Seata — 分布式事务

7.1 引入依赖

<dependency>
 <groupId>com.alibaba.cloud</groupId>
 <artifactId>spring-cloud-starter-alibaba-seata</artifactId>
</dependency>

7.2 使用 @GlobalTransactional

@Service
@RequiredArgsConstructor
public class OrderService {

 private final OrderMapper orderMapper;
 private final AccountClient accountClient;
 private final StorageClient storageClient;

 @GlobalTransactional(name = "create-order", rollbackFor = Exception.class)
 public void createOrder(OrderRequest request) {
 // 1. 创建订单
 Order order = new Order();
 order.setUserId(request.getUserId());
 order.setProductId(request.getProductId());
 order.setCount(request.getCount());
 order.setStatus(0);
 orderMapper.insert(order);

 // 2. 扣减库存（远程调用）
 storageClient.deduct(request.getProductId(), request.getCount());

 // 3. 扣减余额（远程调用）
 accountClient.debit(request.getUserId(), request.getTotalAmount());

 // 4. 更新订单状态
 order.setStatus(1);
 orderMapper.updateById(order);

 // 如果任何一步失败，所有操作都会回滚
 }
}

8. Sleuth + Zipkin — 链路追踪

<!-- 依赖 -->
<dependency>
 <groupId>io.micrometer</groupId>
 <artifactId>micrometer-tracing-bridge-brave</artifactId>
</dependency>
<dependency>
 <groupId>io.zipkin.reporter2</groupId>
 <artifactId>zipkin-reporter-brave</artifactId>
</dependency>

management:
 tracing:
 sampling:
 probability: 1.0 # 采样率（1.0 = 100%）
 zipkin:
 tracing:
 endpoint: http://localhost:9411/api/v2/spans

9. 完整项目结构

my-cloud/
├── pom.xml # 父 POM
├── gateway/ # 网关服务
│ ├── pom.xml
│ └── src/
├── user-service/ # 用户服务
│ ├── pom.xml
│ └── src/
├── order-service/ # 订单服务
│ ├── pom.xml
│ └── src/
├── product-service/ # 商品服务
│ ├── pom.xml
│ └── src/
└── common/ # 公共模块
 ├── pom.xml
 └── src/
 └── main/java/com/example/common/
 ├── model/ # 公共 DTO
 ├── exception/ # 异常定义
 ├── util/ # 工具类
 └── config/ # 公共配置

10. 核心组件对比

功能	Spring Cloud Netflix (旧)	Spring Cloud Alibaba (推荐)
注册中心	Eureka	Nacos
配置中心	Spring Cloud Config	Nacos
负载均衡	Ribbon	Spring Cloud LoadBalancer
远程调用	Feign	OpenFeign
网关	Zuul	Spring Cloud Gateway
熔断降级	Hystrix	Sentinel
分布式事务	—	Seata
消息队列	—	RocketMQ

11. 常见面试题

Q: Nacos 和 Eureka 的区别？ A: Nacos 同时支持 CP（配置中心）和 AP（注册中心）模式，支持配置中心，支持主动推送；Eureka 只支持 AP 模式，仅做注册中心。

Q: Sentinel 和 Hystrix 的区别？ A: Sentinel 支持实时监控 Dashboard、多种限流策略（QPS/线程数/热点参数）、网关限流；Hystrix 已停止维护，功能相对简单。

Q: Gateway 和 Zuul 的区别？ A: Gateway 基于 Spring WebFlux（响应式），性能更好；Zuul 1.x 基于 Servlet（阻塞式），性能较差。Zuul 2.x 未与 Spring Cloud 深度集成。

Q: 如何保证分布式事务一致性？ A: 常用方案：Seata（AT/TCC/SAGA 模式）、本地消息表 + MQ、最大努力通知等。

总结

Spring Cloud 核心组件：

Nacos — 注册中心 + 配置中心，服务发现与动态配置
OpenFeign — 声明式 HTTP 调用，简化微服务间通信
Gateway — API 网关，路由、限流、鉴权
Sentinel — 熔断降级 + 限流，保护服务稳定性
Seata — 分布式事务，保证数据一致性
Sleuth + Zipkin — 链路追踪，排查分布式调用问题
LoadBalancer — 客户端负载均衡

Spring Boot 4 从入门到实战：自动配置、Web 开发与生产部署

Thu, 25 Jun 2026 17:30:00 +0000

前言

Spring Boot 是 Spring 生态中最受欢迎的框架，它通过"约定优于配置"的理念，让开发者能快速创建独立运行的、生产级的 Spring 应用。目前最新版本为 Spring Boot 4.1.0（2026 年 6 月发布），要求 Java 17+，基于 Spring Framework 7，全面拥抱 Jakarta EE。

1. 核心特性

特性	说明
自动配置	根据引入的依赖自动配置 Bean
起步依赖	Starter 依赖简化 Maven/Gradle 配置
内嵌服务器	内嵌 Tomcat/Jetty/Undertow，无需外部部署
Actuator	生产级监控和管理端点
外部化配置	支持 YAML/Properties/环境变量/命令行参数
无代码生成	不生成代码，不修改字节码

2. 快速开始

2.1 创建项目

# 使用 Spring Initializr（推荐）
# https://start.spring.io

# 或使用命令行
curl https://start.spring.io/starter.tgz \
 -d type=maven-project \
 -d language=java \
 -d bootVersion=4.1.0 \
 -d baseDir=myapp \
 -d groupId=com.example \
 -d artifactId=myapp \
 -d name=myapp \
 -d packageName=com.example.myapp \
 -d javaVersion=17 \
 -d dependencies=web,data-jpa,mysql,lombok,actuator \
| tar -xzvf -

2.2 pom.xml 核心依赖

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

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

 <!-- 数据库 -->
 <dependency>
 <groupId>org.springframework.boot</groupId>
 <artifactId>spring-boot-starter-data-jpa</artifactId>
 </dependency>
 <dependency>
 <groupId>com.mysql</groupId>
 <artifactId>mysql-connector-j</artifactId>
 </dependency>

 <!-- Redis -->
 <dependency>
 <groupId>org.springframework.boot</groupId>
 <artifactId>spring-boot-starter-data-redis</artifactId>
 </dependency>

 <!-- 参数校验 -->
 <dependency>
 <groupId>org.springframework.boot</groupId>
 <artifactId>spring-boot-starter-validation</artifactId>
 </dependency>

 <!-- Lombok -->
 <dependency>
 <groupId>org.projectlombok</groupId>
 <artifactId>lombok</artifactId>
 <optional>true</optional>
 </dependency>

 <!-- 监控 -->
 <dependency>
 <groupId>org.springframework.boot</groupId>
 <artifactId>spring-boot-starter-actuator</artifactId>
 </dependency>

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

2.3 启动类

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

3. 自动配置原理

3.1 启动流程

@SpringBootApplication
 ├── @SpringBootConfiguration → 标记为配置类
 ├── @EnableAutoConfiguration → 开启自动配置
 │ └── @Import(AutoConfigurationImportSelector)
 │ └── 读取 META-INF/spring/org.springframework.boot.autoconfigure.AutoConfiguration.imports
 └── @ComponentScan → 扫描当前包及子包

3.2 自动配置条件注解

@ConditionalOnClass // 类路径下存在指定类
@ConditionalOnMissingClass // 类路径下不存在指定类
@ConditionalOnBean // 容器中存在指定 Bean
@ConditionalOnMissingBean // 容器中不存在指定 Bean
@ConditionalOnProperty // 配置属性满足条件
@ConditionalOnResource // 类路径下存在指定资源
@ConditionalOnWebApplication // 是 Web 应用

3.3 查看自动配置报告

# 启动时添加 --debug 参数
java -jar myapp.jar --debug

# 或在配置中添加
debug=true

日志中会显示：

Positive matches — 匹配成功的自动配置
Negative matches — 未匹配的自动配置
Unconditional classes — 无条件配置的类

4. 配置文件

4.1 application.yml

server:
 port: 8080
 servlet:
 context-path: /api

spring:
 # 数据源
 datasource:
 url: jdbc:mysql://localhost:3306/mydb?useSSL=false&serverTimezone=Asia/Shanghai
 username: root
 password: ${DB_PASSWORD:default}
 hikari:
 maximum-pool-size: 20
 minimum-idle: 5

 # JPA
 jpa:
 hibernate:
 ddl-auto: update
 show-sql: true
 properties:
 hibernate:
 format_sql: true

 # Redis
 data:
 redis:
 host: localhost
 port: 6379
 password: ${REDIS_PASSWORD:}
 database: 0

 # Jackson
 jackson:
 date-format: yyyy-MM-dd HH:mm:ss
 time-zone: Asia/Shanghai
 default-property-inclusion: non_null

# 自定义配置
app:
 name: My Application
 version: 1.0.0

# 日志
logging:
 level:
 root: INFO
 com.example.myapp: DEBUG
 org.hibernate.SQL: DEBUG
 file:
 name: logs/app.log
 max-size: 100MB
 max-history: 30

# Actuator
management:
 endpoints:
 web:
 exposure:
 include: health,info,metrics,prometheus
 endpoint:
 health:
 show-details: always

4.2 多环境配置

# application-dev.yml → 开发环境
# application-test.yml → 测试环境
# application-prod.yml → 生产环境

# 激活方式
java -jar myapp.jar --spring.profiles.active=prod

# 或环境变量
export SPRING_PROFILES_ACTIVE=prod

4.3 读取配置

// 方式一：@Value
@Value("${app.name}")
private String appName;

// 方式二：@ConfigurationProperties
@Data
@ConfigurationProperties(prefix = "app")
public class AppProperties {
 private String name;
 private String version;
 private List<String> servers;
}

// 在启动类上启用
@SpringBootApplication
@EnableConfigurationProperties(AppProperties.class)
public class MyApplication { }

5. Web 开发

5.1 RESTful Controller

@RestController
@RequestMapping("/api/users")
@RequiredArgsConstructor
public class UserController {

 private final UserService userService;

 @GetMapping
 public ApiResponse<List<UserDTO>> list(@RequestParam(defaultValue = "1") int page,
 @RequestParam(defaultValue = "10") int size) {
 return ApiResponse.success(userService.list(page, size));
 }

 @GetMapping("/{id}")
 public ApiResponse<UserDTO> getById(@PathVariable Long id) {
 return ApiResponse.success(userService.getById(id));
 }

 @PostMapping
 public ApiResponse<UserDTO> create(@Valid @RequestBody UserCreateRequest request) {
 return ApiResponse.success(userService.create(request));
 }

 @PutMapping("/{id}")
 public ApiResponse<UserDTO> update(@PathVariable Long id,
 @Valid @RequestBody UserUpdateRequest request) {
 return ApiResponse.success(userService.update(id, request));
 }

 @DeleteMapping("/{id}")
 public ApiResponse<Void> delete(@PathVariable Long id) {
 userService.delete(id);
 return ApiResponse.success(null);
 }
}

5.2 统一响应封装

@Data
@AllArgsConstructor
@NoArgsConstructor
public class ApiResponse<T> {
 private int code;
 private String message;
 private T data;

 public static <T> ApiResponse<T> success(T data) {
 return new ApiResponse<>(200, "OK", data);
 }

 public static <T> ApiResponse<T> error(int code, String message) {
 return new ApiResponse<>(code, message, null);
 }
}

5.3 全局异常处理

@RestControllerAdvice
@Slf4j
public class GlobalExceptionHandler {

 // 参数校验异常
 @ExceptionHandler(MethodArgumentNotValidException.class)
 public ApiResponse<Void> handleValidation(MethodArgumentNotValidException e) {
 String message = e.getBindingResult().getFieldErrors().stream()
 .map(fe -> fe.getField() + ": " + fe.getDefaultMessage())
 .collect(Collectors.joining(", "));
 return ApiResponse.error(400, message);
 }

 // 业务异常
 @ExceptionHandler(BusinessException.class)
 public ApiResponse<Void> handleBusiness(BusinessException e) {
 return ApiResponse.error(e.getCode(), e.getMessage());
 }

 // 未捕获异常
 @ExceptionHandler(Exception.class)
 public ApiResponse<Void> handleException(Exception e) {
 log.error("Unexpected error", e);
 return ApiResponse.error(500, "服务器内部错误");
 }
}

5.4 请求参数校验

@Data
public class UserCreateRequest {

 @NotBlank(message = "用户名不能为空")
 @Size(min = 2, max = 20, message = "用户名长度 2-20")
 private String username;

 @NotBlank(message = "邮箱不能为空")
 @Email(message = "邮箱格式不正确")
 private String email;

 @NotNull(message = "年龄不能为空")
 @Min(value = 1, message = "年龄最小 1")
 @Max(value = 150, message = "年龄最大 150")
 private Integer age;
}

5.5 拦截器

@Component
public class AuthInterceptor implements HandlerInterceptor {

 @Override
 public boolean preHandle(HttpServletRequest request,
 HttpServletResponse response,
 Object handler) throws Exception {
 String token = request.getHeader("Authorization");
 if (token == null || !validateToken(token)) {
 response.setStatus(401);
 response.getWriter().write("{\"code\":401,\"message\":\"未授权\"}");
 return false;
 }
 return true;
 }
}

@Configuration
public class WebConfig implements WebMvcConfigurer {

 @Autowired
 private AuthInterceptor authInterceptor;

 @Override
 public void addInterceptors(InterceptorRegistry registry) {
 registry.addInterceptor(authInterceptor)
 .addPathPatterns("/api/**")
 .excludePathPatterns("/api/auth/**");
 }
}

5.6 跨域配置

@Configuration
public class CorsConfig implements WebMvcConfigurer {

 @Override
 public void addCorsMappings(CorsRegistry registry) {
 registry.addMapping("/api/**")
 .allowedOrigins("http://localhost:3000")
 .allowedMethods("GET", "POST", "PUT", "DELETE", "OPTIONS")
 .allowedHeaders("*")
 .allowCredentials(true)
 .maxAge(3600);
 }
}

6. 数据访问

6.1 JPA 实体

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

 @Column(nullable = false, unique = true, length = 50)
 private String username;

 @Column(nullable = false)
 private String email;

 @Column(nullable = false)
 private Integer age;

 @CreationTimestamp
 private LocalDateTime createdAt;

 @UpdateTimestamp
 private LocalDateTime updatedAt;
}

6.2 JPA Repository

public interface UserRepository extends JpaRepository<User, Long> {

 Optional<User> findByUsername(String username);

 List<User> findByAgeBetween(Integer minAge, Integer maxAge);

 @Query("SELECT u FROM User u WHERE u.email LIKE %:keyword% OR u.username LIKE %:keyword%")
 Page<User> search(@Param("keyword") String keyword, Pageable pageable);

 @Modifying
 @Query("UPDATE User u SET u.email = :email WHERE u.id = :id")
 int updateEmail(@Param("id") Long id, @Param("email") String email);
}

6.3 Redis 缓存

@Service
@RequiredArgsConstructor
public class UserService {

 private final UserRepository userRepository;
 private final RedisTemplate<String, Object> redisTemplate;

 // 使用 RedisTemplate
 public UserDTO getById(Long id) {
 String key = "user:" + id;
 UserDTO cached = (UserDTO) redisTemplate.opsForValue().get(key);
 if (cached != null) return cached;

 User user = userRepository.findById(id)
 .orElseThrow(() -> new BusinessException(404, "用户不存在"));
 UserDTO dto = convertToDTO(user);
 redisTemplate.opsForValue().set(key, dto, 30, TimeUnit.MINUTES);
 return dto;
 }

 // 使用 Spring Cache 注解
 @Cacheable(value = "users", key = "#id")
 public UserDTO getByIdCached(Long id) { ... }

 @CachePut(value = "users", key = "#id")
 public UserDTO update(Long id, UserUpdateRequest request) { ... }

 @CacheEvict(value = "users", key = "#id")
 public void delete(Long id) { ... }
}

7. AOP 切面

@Aspect
@Component
@Slf4j
public class LogAspect {

 @Around("@annotation(logOperation)")
 public Object around(ProceedingJoinPoint point, LogOperation logOperation) throws Throwable {
 long start = System.currentTimeMillis();
 String methodName = point.getSignature().toShortString();

 log.info("开始执行: {} - {}", logOperation.value(), methodName);

 try {
 Object result = point.proceed();
 long cost = System.currentTimeMillis() - start;
 log.info("执行完成: {} - {} ({}ms)", logOperation.value(), methodName, cost);
 return result;
 } catch (Exception e) {
 log.error("执行异常: {} - {}", logOperation.value(), methodName, e);
 throw e;
 }
 }
}

// 自定义注解
@Target(ElementType.METHOD)
@Retention(RetentionPolicy.RUNTIME)
public @interface LogOperation {
 String value() default "";
}

8. 定时任务

@SpringBootApplication
@EnableScheduling
public class MyApplication { }

@Component
@Slf4j
public class ScheduledTasks {

 @Scheduled(cron = "0 0 2 * * ?") // 每天凌晨 2 点
 public void dailyBackup() {
 log.info("执行每日备份...");
 }

 @Scheduled(fixedRate = 60000) // 每 60 秒
 public void syncData() {
 log.info("同步数据...");
 }

 @Scheduled(fixedDelay = 30000) // 上次完成后 30 秒
 public void cleanup() {
 log.info("清理任务...");
 }
}

9. 异步处理

@SpringBootApplication
@EnableAsync
public class MyApplication { }

@Configuration
public class AsyncConfig {

 @Bean("taskExecutor")
 public Executor taskExecutor() {
 ThreadPoolTaskExecutor executor = new ThreadPoolTaskExecutor();
 executor.setCorePoolSize(5);
 executor.setMaxPoolSize(20);
 executor.setQueueCapacity(100);
 executor.setThreadNamePrefix("async-");
 executor.setRejectedExecutionHandler(new ThreadPoolExecutor.CallerRunsPolicy());
 return executor;
 }
}

@Service
public class NotificationService {

 @Async("taskExecutor")
 public CompletableFuture<String> sendEmail(String to, String content) {
 // 耗时操作
 return CompletableFuture.completedFuture("sent");
 }
}

10. 生产部署

10.1 打包

# Maven 打包
mvn clean package -DskipTests

# Gradle 打包
gradle bootJar

# 运行
java -jar target/myapp-1.0.0.jar

# 指定 profile
java -jar myapp.jar --spring.profiles.active=prod

# JVM 参数
java -Xms512m -Xmx1024m -XX:+UseG1GC -jar myapp.jar

10.2 Docker 部署

FROM eclipse-temurin:17-jre-alpine
WORKDIR /app
COPY target/*.jar app.jar
EXPOSE 8080
ENTRYPOINT ["java", "-jar", "app.jar"]

10.3 Actuator 监控端点

端点	说明
`/actuator/health`	健康检查
`/actuator/info`	应用信息
`/actuator/metrics`	指标数据
`/actuator/prometheus`	Prometheus 格式指标
`/actuator/env`	环境变量
`/actuator/configprops`	配置属性
`/actuator/beans`	所有 Bean
`/actuator/mappings`	URL 映射
`/actuator/loggers`	日志级别管理
`/actuator/threaddump`	线程 dump
`/actuator/heapdump`	堆 dump

11. 常用 Starter 一览

Starter	用途
spring-boot-starter-web	Web/RESTful
spring-boot-starter-data-jpa	JPA 数据访问
spring-boot-starter-data-redis	Redis
spring-boot-starter-data-mongodb	MongoDB
spring-boot-starter-security	安全认证
spring-boot-starter-validation	参数校验
spring-boot-starter-mail	邮件发送
spring-boot-starter-quartz	定时任务
spring-boot-starter-websocket	WebSocket
spring-boot-starter-actuator	监控管理
spring-boot-starter-test	单元测试
mybatis-plus-spring-boot3-starter	MyBatis-Plus

12. Spring Boot 版本选择

版本	状态	Java 要求	Spring Framework
4.1.x (推荐)	最新，OSS 支持到 2027.7	Java 17-26	7.0.x
4.0.x	稳定	Java 17-26	7.0.x
3.5.x	OSS 支持到 2026.6	Java 17-24	6.2.x
3.2.x	已停止 OSS 支持	Java 17-21	6.1.x
2.7.x	已停止支持	Java 8/11/17	5.3.x

💡 建议：新项目直接使用 Spring Boot 4.1.x + Java 21/25。

总结

Spring Boot 核心知识点：

自动配置 — 根据依赖自动配置，减少样板代码
起步依赖 — Starter 一站式引入所需依赖
Web 开发 — RESTful API、参数校验、异常处理、拦截器
数据访问 — JPA、Redis、MyBatis
AOP — 日志、权限、缓存等横切关注点
生产特性 — Actuator 监控、多环境配置、优雅停机
部署方式 — JAR 直接运行、Docker 容器化