微服务架构与 Spring 生态完全指南

jiayong232025-12-10 13:08

一、核心概念与定位

1.1 四者定位对比

复制代码 
┌───────────────────────────��──────────────────────────┐
│                   微服务架构                           │
│                  (架构设计理念)                         │
│  ├─ 服务拆分                                          │
│  ├─ 独立部署                                          │
│  ├─ 去中心化                                          │
│  └─ 技术栈多样                                        │
└──────────────────────────────────────────────────────┘
                        ▲
                        │ 实现微服务架构的技术栈之一
                        │
┌──────────────────────────────────────────────────────┐
│               Spring Cloud Alibaba                    │
│            (微服务解决方案 - 阿里巴巴版)                 │
│  ├─ Nacos（服务发现/配置中心）                         │
│  ├─ Sentinel（限流熔断）                              │
│  ├─ Seata（分布式事务）                               │
│  └─ RocketMQ（消息队列）                              │
└──────────────────────────────────────────────────────┘
                        ▲
                        │ 基于
                        │
┌──────────────────────────────────────────────────────┐
│                 Spring Cloud                          │
│            (微服务解决方案 - 通用版)                     │
│  ├─ Eureka（服务发现）                                │
│  ├─ Ribbon（负载均衡）                                │
│  ├─ Hystrix（熔断器）                                 │
│  ├─ Gateway（API网关）                                │
│  └─ Config（配置中心）                                │
└──────────────────────────────────────────────────────┘
                        ▲
                        │ 基于
                        │
┌──────────────────────────────────────────────────────┐
│                   Spring Boot                         │
│              (快速开发脚手架)                          │
│  ├─ 自动配置（Auto-Configuration）                    │
│  ├─ Starter 依赖（简化依赖管理）                       │
│  ├─ 内嵌服务器（Tomcat/Jetty）                        │
│  ├─ 生产就绪特性（Actuator）                          │
│  └─ 开箱即用（约定优于配置）                           │
└──────────────────────────────────────────────────────┘
                        ▲
                        │ 基于
                        │
┌──────────────────────────────────────────────────────┐
│                   Spring Framework                    │
│                  (企业级开发框架)                       │
│  ├─ IoC 容器（控制反转）                              │
│  ├─ AOP（面向切面编程）                               │
│  ├─ 数据访问（JDBC/ORM）                              │
│  ├─ 事务管理                                          │
│  └─ Web MVC                                           │
└──────────────────────────────────────────────────────┘

1.2 一句话总结

技术 定位 一句话总结
微服务架构 架构风格 将单体应用拆分为多个小服务的架构设计理念
Spring Framework 基础框架 Java 企业级应用开发的基础框架（IoC + AOP）
Spring Boot 开发脚手架 简化 Spring 应用开发，让你专注于业务逻辑
Spring Cloud 微服务工具集 基于 Spring Boot 的微服务开发工具集
Spring Cloud Alibaba 微服务增强 Spring Cloud 的阿里巴巴增强版（Nacos + Sentinel + Seata）

1.3 层级关系

复制代码 
应用场景层：
└─ 微服务架构
      │
      ├─ 需要：服务发现、负载均衡、熔断降级、配置中心...
      │
技术实现层：
      ├─ Spring Cloud Alibaba（提供具体组件）
      │   └─ 基于 Spring Cloud
      │
      ├─ Spring Cloud（定义微服务标准接口）
      │   └─ 基于 Spring Boot
      │
      ├─ Spring Boot（简化配置，快速开发）
      │   └─ 基于 Spring Framework
      │
      └─ Spring Framework（提供基础能力：IoC、AOP、事务）

二、四者的区别与联系

2.1 核心区别对比表

维度 Spring Framework Spring Boot Spring Cloud Spring Cloud Alibaba
定位 企业级开发框架 快速开发脚手架 微服务工具集 微服务增强工具集
层级 基础层 应用层 微服务层 微服务增强层
核心功能 IoC、AOP、事务、MVC 自动配置、Starter 服务治理、分布式配置 Nacos、Sentinel、Seata
配置方式 XML/注解 注解 + application.yml 注解 + 配置中心 注解 + Nacos
部署方式 War → Tomcat Jar → 内嵌Tomcat 多个独立服务 多个独立服务
适用场景 单体应用/企业应用 快速开发/单体应用 微服务架构 微服务架构（阿里云生态）
学习曲线 陡峭 平缓 较陡 较陡
复杂度 中等 低 高 高
是否必需 所有项目的基础 推荐使用 微服务必需 可选（替代Netflix组件）

2.2 依赖关系

复制代码 
关系链：
Spring Framework（必需）
    ↓ 包含并简化
Spring Boot（可选但推荐）
    ↓ 提供微服务基础
Spring Cloud（微服务场景必需）
    ↓ 提供阿里云生态组件
Spring Cloud Alibaba（可选，但生产推荐）

依赖示例：

xml 复制代码 
<!-- 1. Spring Framework -->
<!-- 注意：使用 Spring Boot 时，Spring Framework 会自动引入，无需手动配置 -->

<!-- 2. Spring Boot Parent -->
<parent>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-parent</artifactId>
    <version>3.2.1</version>
</parent>

<!-- 3. 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>

<!-- 4. Spring Cloud Alibaba -->
<dependency>
    <groupId>com.alibaba.cloud</groupId>
    <artifactId>spring-cloud-alibaba-dependencies</artifactId>
    <version>2022.0.0.0</version>
    <type>pom</type>
    <scope>import</scope>
</dependency>

2.3 功能对比

2.3.1 配置方式对比

Spring Framework 配置：

xml 复制代码 
<!-- applicationContext.xml -->
<beans>
    <bean id="dataSource" class="org.apache.commons.dbcp.BasicDataSource">
        <property name="driverClassName" value="com.mysql.jdbc.Driver"/>
        <property name="url" value="jdbc:mysql://localhost:3306/mydb"/>
    </bean>

    <bean id="userService" class="com.example.UserService">
        <property name="userDao" ref="userDao"/>
    </bean>
</beans>

Spring Boot 配置：

yaml 复制代码 
# application.yml
spring:
  datasource:
    driver-class-name: com.mysql.cj.jdbc.Driver
    url: jdbc:mysql://localhost:3306/mydb
    username: root
    password: password

# Java 配置
@Service
public class UserService {
    @Autowired
    private UserDao userDao;
}

Spring Cloud 配置：

yaml 复制代码 
# application.yml
spring:
  application:
    name: user-service
  cloud:
    nacos:
      discovery:
        server-addr: 127.0.0.1:8848
      config:
        server-addr: 127.0.0.1:8848
        file-extension: yaml

# 服务注册自动完成
@SpringBootApplication
@EnableDiscoveryClient
public class UserServiceApplication {
    public static void main(String[] args) {
        SpringApplication.run(UserServiceApplication.class, args);
    }
}
2.3.2 服务调用对比

Spring Framework + RestTemplate：

java 复制代码 
@Service
public class OrderService {

    @Autowired
    private RestTemplate restTemplate;

    public User getUser(Long userId) {
        // 硬编码服务地址
        String url = "http://localhost:8080/users/" + userId;
        return restTemplate.getForObject(url, User.class);
    }
}

Spring Cloud + Feign：

java 复制代码 
// 1. 定义 Feign 客户端
@FeignClient(name = "user-service")
public interface UserClient {
    @GetMapping("/users/{id}")
    User getUser(@PathVariable("id") Long id);
}

// 2. 使用（自动负载均衡、服务发现）
@Service
public class OrderService {

    @Autowired
    private UserClient userClient;

    public User getUser(Long userId) {
        return userClient.getUser(userId);  // 自动从Nacos获取服务地址
    }
}

Spring Cloud Alibaba + Sentinel：

java 复制代码 
@FeignClient(name = "user-service", fallback = UserClientFallback.class)
public interface UserClient {
    @GetMapping("/users/{id}")
    User getUser(@PathVariable("id") Long id);
}

// 熔断降级
@Component
public class UserClientFallback implements UserClient {
    @Override
    public User getUser(Long id) {
        // 降级逻辑
        return new User(id, "默认用户", "服务降级");
    }
}

2.4 联系总结

复制代码 
1. 继承关系：
   Spring Framework
      └─ Spring Boot（简化 Spring）
            └─ Spring Cloud（基于 Spring Boot 的微服务工具）
                  └─ Spring Cloud Alibaba（Spring Cloud 的增强）

2. 依赖关系：
   - Spring Boot 依赖 Spring Framework
   - Spring Cloud 依赖 Spring Boot
   - Spring Cloud Alibaba 依赖 Spring Cloud

3. 功能互补：
   - Spring Framework：提供基础能力（IoC、AOP、事务）
   - Spring Boot：简化开发（自动配置、快速启动）
   - Spring Cloud：提供微服务能力（服务发现、配置中心、网关）
   - Spring Cloud Alibaba：提供阿里云生态组件（Nacos、Sentinel、Seata）

4. 可以独立使用：
   - ✅ 只用 Spring Framework：传统企业应用
   - ✅ Spring Framework + Spring Boot：单体应用（推荐）
   - ✅ Spring Boot + Spring Cloud：微服务架构
   - ✅ Spring Boot + Spring Cloud + Spring Cloud Alibaba：微服务架构（阿里云生态）
   - ❌ 不能单独用 Spring Cloud（必须基于 Spring Boot）

三、微服务架构详解

3.1 什么是微服务架构？

定义：微服务架构是一种将单一应用程序拆分成一组小型服务的架构风格，每个服务运行在独立的进程中，服务之间采用轻量级通信机制（通常是 HTTP RESTful API）。

核心特征：

复制代码 
1. 服务独立
   └─ 每个服务独立开发、部署、运行

2. 去中心化
   └─ 服务自治，没有中央控制

3. 技术栈多样
   └─ 不同服务可以使用不同技术

4. 按业务拆分
   └─ 围绕业务能力组织服务

5. 轻量级通信
   └─ RESTful API、消息队列

6. 自动化部署
   └─ CI/CD、容器化

3.2 单体架构 vs 微服务架构

3.2.1 架构对比图
复制代码 
单体架构（Monolithic）：
┌───────────────────────────────────┐
│        单体应用（一个War包）         │
│                                   │
│  ┌─────────────────────────────┐ │
│  │       用户模块               │ │
│  ├─────────────────────────────┤ │
│  │       订单模块               │ │
│  ├─────────────────────────────┤ │
│  │       商品模块               │ │
│  ├─────────────────────────────┤ │
│  │       支付模块               │ │
│  └─────────────────────────────┘ │
│                                   │
│  共享同一个数据库                  │
└───────────────────────────────────┘

微服务架构（Microservices）：
┌─────────────┐  ┌─────────────┐  ┌─────────────┐
│ 用户服务     │  │ 订单服务     │  │ 商品服务     │
│ (独立部署)   │  │ (独立部署)   │  │ (独立部署)   │
│             │  │             │  │             │
│ 用户数据库   │  │ 订单数据库   │  │ 商品数据库   │
└─────────────┘  └─────────────┘  └─────────────┘
      │                 │                 │
      └─────────────────┼─────────────────┘
                        │
                  HTTP/RPC 调用
3.2.2 优缺点对比
维度 单体架构 微服务架构
开发 简单，一个项目 复杂，多个项目
部署 整体部署，简单 独立部署，复杂
扩展 垂直扩展（加配置） 水平扩展（加实例）
可靠性 一处故障全部挂 服务隔离，局部故障
技术栈 统一技术栈 可选不同技术栈
团队协作 代码冲突多 团队独立开发
数据一致性 本地事务，简单 分布式事务，复杂
运维成本 低 高
适用场景 小型应用、团队小 大型应用、团队大

3.3 微服务核心问题与解决方案

3.3.1 微服务面临的挑战
复制代码 
1. 服务发现
   问题：服务 A 如何找到服务 B 的地址？
   方案：Nacos、Eureka、Consul

2. 负载均衡
   问题：服务 A 调用服务 B 的多个实例，如何分配？
   方案：Ribbon、LoadBalancer

3. 服务熔断/降级
   问题：服务 B 挂了，如何避免雪崩？
   方案：Sentinel、Hystrix

4. 配置管理
   问题：10个服务，每个都要改配置？
   方案：Nacos Config、Spring Cloud Config

5. 分布式事务
   问题：跨多个服务的事务如何保证一致性？
   方案：Seata、Saga

6. API 网关
   问题：客户端如何统一访问多个服务？
   方案：Spring Cloud Gateway、Zuul

7. 链路追踪
   问题：请求经过多个服务，如何追踪？
   方案：Sleuth + Zipkin、SkyWalking

8. 服务监控
   问题：服务健康状况如何监控？
   方案：Spring Boot Actuator、Prometheus
3.3.2 Spring Cloud 解决方案
复制代码 
┌─────────────────────────────────────────────────┐
│              Spring Cloud 全家桶                 │
├─────────────────────────────────────────────────┤
│ 服务注册/发现  │ Nacos Discovery / Eureka       │
│ 负载均衡      │ LoadBalancer / Ribbon          │
│ 服务调用      │ OpenFeign / RestTemplate       │
│ 熔断降级      │ Sentinel / Resilience4j        │
│ 配置中心      │ Nacos Config / Config Server   │
│ API 网关      │ Spring Cloud Gateway           │
│ 分布式事务    │ Seata                          │
│ 链路追踪      │ Sleuth + Zipkin / SkyWalking   │
│ 消息驱动      │ Stream (Kafka/RabbitMQ)        │
└─────────────────────────────────────────────────┘

3.4 微服务架构最佳实践

复制代码 
1. 服务拆分原则
   ├─ 单一职责：一个服务只做一件事
   ├─ 高内聚低耦合：服务内部高内聚，服务间低耦合
   ├─ 按业务能力拆分：围绕业务领域
   └─ 数据库独立：每个服务有自己的数据库

2. 服务通信
   ├─ 同步通信：HTTP RESTful、gRPC
   └─ 异步通信：消息队列（RocketMQ、Kafka）

3. 服务治理
   ├─ 服务注册与发现
   ├─ 负载均衡
   ├─ 熔断降级
   └─ 限流

4. 数据一致性
   ├─ 最终一致性（推荐）
   ├─ TCC 事务
   ├─ Saga 事务
   └─ 本地消息表

5. 部署运维
   ├─ 容器化（Docker）
   ├─ 编排（Kubernetes）
   ├─ CI/CD
   └─ 监控告警

四、Spring 框架详解

4.1 Spring Framework 核心

复制代码 
Spring Framework 核心模块：

┌─────────────────────────────────────────────┐
│           Core Container                    │
│  ├─ spring-core（核心工具）                 │
│  ├─ spring-beans（Bean 管理）               │
│  ├─ spring-context（应用上下文）            │
│  └─ spring-expression（SpEL 表达式）        │
├─────────────────────────────────────────────┤
│           AOP + Aspects                      │
│  ├─ spring-aop（面向切面编程）              │
│  └─ spring-aspects（AspectJ 集成）          │
├─────────────────────────────────────────────┤
│           Data Access                        │
│  ├─ spring-jdbc（JDBC 支持）                │
│  ├─ spring-tx（事务管理）                   │
│  └─ spring-orm（ORM 集成）                  │
├─────────────────────────────────────────────┤
│           Web                                │
│  ├─ spring-web（Web 基础）                  │
│  ├─ spring-webmvc（Spring MVC）             │
│  └─ spring-webflux（响应式 Web）            │
└─────────────────────────────────────────────┘

4.2 Spring Framework 核心特性

4.2.1 IoC（控制反转）
java 复制代码 
// 传统方式：手动创建依赖
public class UserService {
    private UserDao userDao = new UserDaoImpl();  // 紧耦合
}

// Spring IoC：依赖注入
@Service
public class UserService {
    @Autowired
    private UserDao userDao;  // Spring 自动注入
}
4.2.2 AOP（面向切面编程）
java 复制代码 
@Aspect
@Component
public class LoggingAspect {

    @Around("execution(* com.example.service..*.*(..))")
    public Object logAround(ProceedingJoinPoint pjp) throws Throwable {
        System.out.println("方法执行前");
        Object result = pjp.proceed();
        System.out.println("方法执行后");
        return result;
    }
}
4.2.3 声明式事务
java 复制代码 
@Service
public class UserService {

    @Transactional
    public void createUser(User user) {
        userDao.save(user);
        accountDao.createAccount(user.getId());
        // 异常自动回滚
    }
}

五、Spring Boot 详解

5.1 Spring Boot 核心特性

复制代码 
Spring Boot 核心价值：

┌─────────────────────────────────────────────┐
│ 1. 自动配置（Auto-Configuration）           │
│    └─ 根据 classpath 自动配置 Bean          │
├─────────────────────────────────────────────┤
│ 2. Starter 依赖                             │
│    └─ 一站式依赖管理                        │
├─────────────────────────────────────────────┤
│ 3. 内嵌服务器                               │
│    └─ Tomcat、Jetty、Undertow             │
├─────────────────────────────────────────────┤
│ 4. 生产就绪特性（Actuator）                 │
│    └─ 健康检查、指标监控                    │
├─────────────────────────────────────────────┤
│ 5. 外部化配置                               │
│    └─ application.yml、环境变量             │
└─────────────────────────────────────────────┘

5.2 Spring vs Spring Boot 对比

5.2.1 依赖管理

Spring Framework：

xml 复制代码 
<dependencies>
    <dependency>
        <groupId>org.springframework</groupId>
        <artifactId>spring-context</artifactId>
        <version>5.3.30</version>
    </dependency>
    <dependency>
        <groupId>org.springframework</groupId>
        <artifactId>spring-webmvc</artifactId>
        <version>5.3.30</version>
    </dependency>
    <dependency>
        <groupId>javax.servlet</groupId>
        <artifactId>javax.servlet-api</artifactId>
        <version>4.0.1</version>
    </dependency>
    <!-- 还需要配置很多其他依赖... -->
</dependencies>

Spring Boot：

xml 复制代码 
<parent>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-parent</artifactId>
    <version>3.2.1</version>
</parent>

<dependencies>
    <!-- 一个 starter 搞定所有 Web 依赖 -->
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-web</artifactId>
    </dependency>
</dependencies>
5.2.2 配置方式

Spring Framework：

xml 复制代码 
<!-- web.xml -->
<servlet>
    <servlet-name>dispatcher</servlet-name>
    <servlet-class>org.springframework.web.servlet.DispatcherServlet</servlet-class>
    <init-param>
        <param-name>contextConfigLocation</param-name>
        <param-value>/WEB-INF/spring-mvc.xml</param-value>
    </init-param>
</servlet>

<!-- spring-mvc.xml -->
<beans>
    <context:component-scan base-package="com.example"/>
    <mvc:annotation-driven/>
    <bean class="org.springframework.web.servlet.view.InternalResourceViewResolver">
        <property name="prefix" value="/WEB-INF/views/"/>
        <property name="suffix" value=".jsp"/>
    </bean>
</beans>

Spring Boot：

java 复制代码 
@SpringBootApplication
public class Application {
    public static void main(String[] args) {
        SpringApplication.run(Application.class, args);
    }
}

// application.yml
spring:
  mvc:
    view:
      prefix: /WEB-INF/views/
      suffix: .jsp

5.3 Spring Boot Starter

Starter 功能 包含的核心依赖
spring-boot-starter-web Web 应用 Spring MVC、Tomcat、Jackson
spring-boot-starter-data-jpa JPA Hibernate、Spring Data JPA
spring-boot-starter-data-redis Redis Lettuce、Spring Data Redis
spring-boot-starter-security 安全 Spring Security
spring-boot-starter-test 测试 JUnit、Mockito、AssertJ
spring-boot-starter-actuator 监控 Micrometer、Actuator
spring-boot-starter-amqp RabbitMQ Spring AMQP
spring-boot-starter-validation 校验 Hibernate Validator

六、Spring Cloud 详解

6.1 Spring Cloud 架构

复制代码 
┌────────────────────────────────────────────────────┐
│                   客户端                            │
└────────────────────────────────────────────────────┘
                        │
                        ↓
┌────────────────────────────────────────────────────┐
│             API Gateway (网关)                      │
│           Spring Cloud Gateway                      │
│  ├─ 路由转发                                        │
│  ├─ 鉴权                                            │
│  └─ 限流                                            │
└────────────────────────────────────────────────────┘
                        │
         ┌──────────────┼──────────────┐
         │              │              │
         ↓              ↓              ↓
┌───────────────┐ ┌───────────────┐ ┌───────────────┐
│  用户服务      │ │  订单服务      │ │  商品服务      │
│  user-service │ │ order-service │ │product-service│
└───────────────┘ └───────────────┘ └───────────────┘
         │              │              │
         └──────────────┼──────────────┘
                        │
                        ↓
         ┌──────────────────────────────┐
         │    服务注册与发现中心          │
         │    Nacos / Eureka            │
         └──────────────────────────────┘
                        │
         ┌──────────────┼──────────────┐
         │              │              │
         ↓              ↓              ↓
┌───────────────┐ ┌───────────────┐ ┌───────────────┐
│  配置中心      │ │  限流熔断      │ │  链路追踪      │
│  Nacos Config │ │   Sentinel    │ │    Zipkin     │
└───────────────┘ └───────────────┘ └───────────────┘

6.2 Spring Cloud 核心组件

6.2.1 Netflix 组件（传统方案）
组件 作用 状态
Eureka 服务注册与发现 维护模式
Ribbon 负载均衡 维护模式
Hystrix 熔断器 停止开发
Zuul API 网关 停止开发
Config 配置中心 活跃
6.2.2 新一代组件（推荐方案）
组件 作用 替代
Nacos 服务注册/发现 + 配置中心 Eureka + Config
LoadBalancer 负载均衡 Ribbon
Sentinel 流控、熔断、降级 Hystrix
Gateway API 网关 Zuul
Seata 分布式事务 -

6.3 Spring Cloud 核心功能

6.3.1 服务注册与发现（Nacos Discovery）
yaml 复制代码 
# application.yml
spring:
  application:
    name: user-service
  cloud:
    nacos:
      discovery:
        server-addr: 127.0.0.1:8848
java 复制代码 
// 启动类
@SpringBootApplication
@EnableDiscoveryClient
public class UserServiceApplication {
    public static void main(String[] args) {
        SpringApplication.run(UserServiceApplication.class, args);
    }
}

// 自动注册到 Nacos
6.3.2 负载均衡（LoadBalancer）
java 复制代码 
// 配置 LoadBalancer
@Configuration
public class LoadBalancerConfig {

    @Bean
    @LoadBalanced  // 启用负载均衡
    public RestTemplate restTemplate() {
        return new RestTemplate();
    }
}

// 使用（自动负载均衡）
@Service
public class OrderService {

    @Autowired
    private RestTemplate restTemplate;

    public User getUser(Long userId) {
        // user-service 自动解析为实际地址，并负载均衡
        return restTemplate.getForObject(
            "http://user-service/users/" + userId,
            User.class
        );
    }
}
6.3.3 声明式服务调用（OpenFeign）
java 复制代码 
// 1. 定义 Feign 客户端
@FeignClient(name = "user-service")
public interface UserClient {

    @GetMapping("/users/{id}")
    User getUser(@PathVariable("id") Long id);

    @PostMapping("/users")
    User createUser(@RequestBody User user);
}

// 2. 使用
@Service
public class OrderService {

    @Autowired
    private UserClient userClient;

    public void createOrder(Order order) {
        User user = userClient.getUser(order.getUserId());
        // 业务逻辑
    }
}
6.3.4 配置中心（Nacos Config）

重要提示：Spring Boot 2.4+ 默认禁用 bootstrap 配置文件，需要添加以下依赖：

xml 复制代码 
<dependency>
    <groupId>org.springframework.cloud</groupId>
    <artifactId>spring-cloud-starter-bootstrap</artifactId>
</dependency>
yaml 复制代码 
# bootstrap.yml（优先级高于 application.yml）
spring:
  application:
    name: user-service
  cloud:
    nacos:
      config:
        server-addr: 127.0.0.1:8848
        file-extension: yaml
        namespace: dev  # 开发环境（建议使用 namespace ID）
        group: DEFAULT_GROUP
java 复制代码 
// 动态刷新配置
@RestController
@RefreshScope  // 配置变更自动刷新
public class ConfigController {

    @Value("${user.max-age:100}")
    private Integer maxAge;

    @GetMapping("/config")
    public Integer getMaxAge() {
        return maxAge;
    }
}
6.3.5 API 网关（Spring Cloud Gateway）
yaml 复制代码 
# application.yml
spring:
  cloud:
    gateway:
      httpclient:
        connect-timeout: 5000      # 连接超时 5秒
        response-timeout: 30s       # 响应超时 30秒
        pool:
          max-connections: 1000     # 连接池最大连接数
          max-idle-time: 30s        # 连接空闲时间
      routes:
        - id: user-service-route
          uri: lb://user-service  # 负载均衡到 user-service
          predicates:
            - Path=/api/users/**
          filters:
            - StripPrefix=1  # 去掉 /api 前缀

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

请求流程：

复制代码 
客户端请求：http://gateway:8080/api/users/1
    ↓
网关路由匹配：/api/users/** → user-service
    ↓
去掉前缀：/api/users/1 → /users/1
    ↓
负载均衡：lb://user-service → http://192.168.1.100:8081
    ↓
实际请求：http://192.168.1.100:8081/users/1

七、Spring Cloud Alibaba 详解

7.1 Spring Cloud Alibaba 核心组件

复制代码 
┌──────────────────────────────────────────────────┐
│         Spring Cloud Alibaba 全家桶               │
├──────────────────────────────────────────────────┤
│ Nacos          │ 服务发现 + 配置中心               │
│ Sentinel       │ 流量控制、熔断降级                │
│ Seata          │ 分布式事务                       │
│ RocketMQ       │ 消息队列                         │
│ Dubbo          │ RPC 通信（可选）                 │
│ Alibaba Cloud  │ 阿里云服务集成                   │
└──────────────────────────────────────────────────┘

7.2 Nacos（服务发现 + 配置中心）

7.2.1 服务注册与发现
xml 复制代码 
<!-- pom.xml -->
<dependency>
    <groupId>com.alibaba.cloud</groupId>
    <artifactId>spring-cloud-starter-alibaba-nacos-discovery</artifactId>
</dependency>
yaml 复制代码 
# application.yml
spring:
  application:
    name: user-service
  cloud:
    nacos:
      discovery:
        server-addr: 127.0.0.1:8848
        namespace: dev  # 可以使用命名空间名称，但生产环境建议使用 ID（如：f5e9a7c3-xxxx-xxxx-xxxx-xxxxxxxxxxxx）
        group: DEFAULT_GROUP
        metadata:
          version: 1.0.0
          region: hangzhou
java 复制代码 
@SpringBootApplication
@EnableDiscoveryClient
public class UserServiceApplication {
    public static void main(String[] args) {
        SpringApplication.run(UserServiceApplication.class, args);
    }
}
7.2.2 配置中心
xml 复制代码 
<dependency>
    <groupId>com.alibaba.cloud</groupId>
    <artifactId>spring-cloud-starter-alibaba-nacos-config</artifactId>
</dependency>
yaml 复制代码 
# bootstrap.yml
spring:
  application:
    name: user-service
  cloud:
    nacos:
      config:
        server-addr: 127.0.0.1:8848
        file-extension: yaml
        namespace: dev
        group: DEFAULT_GROUP
        shared-configs:
          - data-id: common-db.yaml
            group: DEFAULT_GROUP
            refresh: true
          - data-id: common-redis.yaml
            group: DEFAULT_GROUP
            refresh: true

Nacos 配置示例（在 Nacos 控制台创建）：

yaml 复制代码 
# Data ID: user-service-dev.yaml
user:
  max-age: 120
  max-connections: 100

spring:
  datasource:
    url: jdbc:mysql://localhost:3306/userdb
    username: root
    password: password

动态配置刷新：

java 复制代码 
@RestController
@RefreshScope  // 支持配置热更新
public class UserController {

    @Value("${user.max-age:100}")
    private Integer maxAge;

    @GetMapping("/config")
    public Map<String, Object> getConfig() {
        return Map.of("maxAge", maxAge);
    }
}

7.3 Sentinel（流量控制与熔断降级）

7.3.1 添加依赖
xml 复制代码 
<dependency>
    <groupId>com.alibaba.cloud</groupId>
    <artifactId>spring-cloud-starter-alibaba-sentinel</artifactId>
</dependency>
yaml 复制代码 
# application.yml
spring:
  cloud:
    sentinel:
      transport:
        dashboard: localhost:8080  # Sentinel 控制台地址
        port: 8719
      eager: true  # 启动时立即连接
7.3.2 流量控制
java 复制代码 
@RestController
public class OrderController {

    // 1. 注解方式限流
    @GetMapping("/orders/{id}")
    @SentinelResource(
        value = "getOrder",
        blockHandler = "handleBlock",  // 限流处理
        fallback = "handleFallback"    // 异常降级
    )
    public Order getOrder(@PathVariable Long id) {
        return orderService.getOrder(id);
    }

    // 限流处理方法
    public Order handleBlock(Long id, BlockException ex) {
        return new Order(id, "系统繁忙，请稍后重试");
    }

    // 异常降级方法
    public Order handleFallback(Long id, Throwable ex) {
        return new Order(id, "服务异常，请稍后重试");
    }
}

在 Sentinel 控制台配置规则：

复制代码 
资源名：getOrder
限流阈值：QPS = 10
流控效果：快速失败
7.3.3 熔断降级
java 复制代码 
@Service
public class UserService {

    @Autowired
    private UserClient userClient;

    @SentinelResource(
        value = "getUser",
        fallback = "getUserFallback",
        exceptionsToIgnore = {IllegalArgumentException.class}
    )
    public User getUser(Long id) {
        return userClient.getUser(id);
    }

    // 降级方法
    public User getUserFallback(Long id, Throwable ex) {
        log.error("获取用户失败: {}", id, ex);
        return new User(id, "默认用户", "降级数据");
    }
}

熔断规则（Sentinel 控制台配置）：

复制代码 
熔断策略：慢调用比例
最大RT：500ms
比例阈值：0.5（50%）
熔断时长：10s
最小请求数：5

规则说明：
- 1秒内至少5个请求
- 如果超过50%的请求RT > 500ms
- 触发熔断，10秒内直接降级
7.3.4 OpenFeign 集成 Sentinel
yaml 复制代码 
# application.yml
feign:
  sentinel:
    enabled: true  # 启用 Sentinel
java 复制代码 
// Feign 客户端
@FeignClient(
    name = "user-service",
    fallback = UserClientFallback.class  // 降级实现
)
public interface UserClient {
    @GetMapping("/users/{id}")
    User getUser(@PathVariable("id") Long id);
}

// 降级实现类
@Component
public class UserClientFallback implements UserClient {

    @Override
    public User getUser(Long id) {
        return new User(id, "降级用户", "服务降级");
    }
}

7.4 Seata（分布式事务）

7.4.1 分布式事务场景
复制代码 
订单服务（order-service）
  ├─ 创建订单
  ├─ 调用库存服务（扣减库存）
  └─ 调用账户服务（扣减余额）

问题：如何保证三个操作的事务一致性？
7.4.2 Seata AT 模式

前置准备 ：每个业务数据库都需要创建 undo_log 表用于回滚

sql 复制代码 
CREATE TABLE `undo_log` (
  `id` bigint(20) NOT NULL AUTO_INCREMENT,
  `branch_id` bigint(20) NOT NULL,
  `xid` varchar(100) NOT NULL,
  `context` varchar(128) NOT NULL,
  `rollback_info` longblob NOT NULL,
  `log_status` int(11) NOT NULL,
  `log_created` datetime NOT NULL,
  `log_modified` datetime NOT NULL,
  PRIMARY KEY (`id`),
  UNIQUE KEY `ux_undo_log` (`xid`,`branch_id`)
) ENGINE=InnoDB DEFAULT CHARSET=utf8;

添加依赖：

xml 复制代码 
<!-- pom.xml -->
<dependency>
    <groupId>com.alibaba.cloud</groupId>
    <artifactId>spring-cloud-starter-alibaba-seata</artifactId>
</dependency>
yaml 复制代码 
# application.yml
spring:
  cloud:
    alibaba:
      seata:
        tx-service-group: my-tx-group

seata:
  registry:
    type: nacos
    nacos:
      server-addr: 127.0.0.1:8848
      namespace: seata
      group: SEATA_GROUP
  config:
    type: nacos
    nacos:
      server-addr: 127.0.0.1:8848
java 复制代码 
// 订单服务
@Service
public class OrderService {

    @Autowired
    private OrderDao orderDao;

    @Autowired
    private StorageClient storageClient;

    @Autowired
    private AccountClient accountClient;

    @GlobalTransactional(name = "create-order", rollbackFor = Exception.class)
    public void createOrder(Order order) {
        // 1. 创建订单
        orderDao.create(order);

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

        // 3. 扣减账户余额（远程调用）
        accountClient.decrease(order.getUserId(), order.getMoney());

        // 任何一步失败，全部回滚
    }
}

Seata 工作流程：

复制代码 
1. TM（事务管理器）开启全局事务
   └─ 获得全局事务 XID

2. RM（资源管理器）注册分支事务
   ├─ order-service 注册分支事务1
   ├─ storage-service 注册分支事务2
   └─ account-service 注册分支事务3

3. 各分支执行业务逻辑
   └─ 记录前后镜像（回滚日志）

4. 提交或回滚
   ├─ 成功 → TC 通知各 RM 删除回滚日志
   └─ 失败 → TC 通知各 RM 回滚

7.5 RocketMQ（消息队列）

xml 复制代码 
<dependency>
    <groupId>com.alibaba.cloud</groupId>
    <artifactId>spring-cloud-starter-stream-rocketmq</artifactId>
</dependency>
yaml 复制代码 
# application.yml
spring:
  cloud:
    stream:
      rocketmq:
        binder:
          name-server: 127.0.0.1:9876
      bindings:
        output:  # 生产者
          destination: order-topic
          content-type: application/json
        input:   # 消费者
          destination: order-topic
          content-type: application/json
          group: order-group
java 复制代码 
// 生产者
@Service
public class OrderService {

    @Autowired
    private StreamBridge streamBridge;

    public void createOrder(Order order) {
        // 保存订单
        orderDao.save(order);

        // 发送消息
        streamBridge.send("output", order);
    }
}

// 消费者（函数式编程模型，Spring Cloud Stream 3.x+）
@Configuration
public class OrderListener {

    @Bean
    public Consumer<Order> handleOrder() {
        return order -> {
            System.out.println("收到订单: " + order);
            // 处理业务逻辑
        };
    }
}

// 注意：旧版本 @StreamListener 已弃用，建议使用函数式编程模型

7.6 Spring Cloud vs Spring Cloud Alibaba

功能 Spring Cloud（Netflix） Spring Cloud Alibaba
服务发现 Eureka（维护模式） Nacos（活跃）
配置中心 Config Server Nacos Config
负载均衡 Ribbon（维护模式） LoadBalancer / Ribbon
服务调用 OpenFeign OpenFeign / Dubbo
熔断降级 Hystrix（停止开发） Sentinel
API 网关 Zuul（停止）/ Gateway Gateway
分布式事务 - Seata
消息队列 Stream（通用） RocketMQ
链路追踪 Sleuth + Zipkin Sleuth + Zipkin
社区支持 Netflix 已停止维护部分组件 阿里巴巴持续维护
适用场景 通用微服务 阿里云生态、国内项目

八、技术选型与最佳实践

8.1 技术选型决策树

复制代码 
项目类型选择：

小型应用/个人项目（< 10万用户）
  └─ Spring Boot 单体应用
      ├─ Spring Boot + MyBatis/JPA
      ├─ Spring Boot + Redis
      └─ 部署：单机 / Docker

中型应用（10万-100万用户）
  ├─ 选择1：单体应用（垂直扩展）
  │   └─ Spring Boot + 分库分表
  │
  └─ 选择2：微服务（水平扩展）
      └─ Spring Boot + Spring Cloud Alibaba
          ├─ Nacos（服务发现 + 配置）
          ├─ Sentinel（限流熔断）
          └─ Gateway（网关）

大型应用（> 100万用户）
  └─ 微服务架构（必选）
      └─ Spring Boot + Spring Cloud Alibaba
          ├─ Nacos
          ├─ Sentinel
          ├─ Seata（分布式事务）
          ├─ RocketMQ（消息队列）
          ├─ Gateway
          └─ Kubernetes（容器编排）

8.2 微服务架构演进路径

复制代码 
阶段1：单体应用
┌─────────────────────────────┐
│      Spring Boot 应用        │
│  ├─ 所有功能在一个应用        │
│  └─ 单数据库                 │
└─────────────────────────────┘

阶段2：服务拆分（初期）
┌──────────┐  ┌──────────┐  ┌──────────┐
│ 用户服务  │  │ 订单服务  │  │ 商品服务  │
└──────────┘  └──────────┘  └──────────┘
   │              │              │
   └──────────────┼──────────────┘
                  │
            直接调用（硬编码地址）

阶段3：引入服务发现
┌──────────┐  ┌──────────┐  ┌──────────┐
│ 用户服务  │  │ 订单服务  │  │ 商品服务  │
└──────────┘  └──────────┘  └──────────┘
   │              │              │
   └──────────────┼──────────────┘
                  │
         ┌────────────────┐
         │  Nacos Discovery│
         └────────────────┘

阶段4：完善微服务治理
┌──────────┐  ┌──────────┐  ┌──────────┐
│ 用户服务  │  │ 订单服务  │  │ 商品服务  │
└──────────┘  └──────────┘  └──────────┘
   │              │              │
   └──────────────┼──────────────┘
                  │
    ┌─────────────┼─────────────┐
    │             │             │
┌────────┐  ┌──────────┐  ┌──────────┐
│ Nacos  │  │ Sentinel │  │ Gateway  │
└────────┘  └──────────┘  └──────────┘

阶段5：云原生（终极）
┌─────────────────────────────────────┐
│          Kubernetes 集群             │
│  ├─ 服务编排                         │
│  ├─ 自动扩缩容                       │
│  ├─ 服务网格（Istio）                │
│  └─ 监控告警（Prometheus + Grafana） │
└─────────────────────────────────────┘

8.3 依赖版本兼容性

8.3.1 版本对应关系
Spring Boot Spring Cloud Spring Cloud Alibaba JDK 说明
3.2.x 2023.0.x (Leyton) 2022.0.0.0 17+ 最新版本，推荐新项目使用
3.1.x 2022.0.x (Kilburn) 2022.0.0.0-RC2 17+ 稳定版本
3.0.x 2022.0.x (Kilburn) 2022.0.0.0-RC1 17+
2.7.x 2021.0.x (Jubilee) 2021.0.5.0 8/11/17 LTS 推荐，生产环境首选
2.6.x 2021.0.x (Jubilee) 2021.0.4.0 8/11/17 稳定版本
2.4.x 2020.0.x (Ilford) 2021.1 8/11
2.3.x Hoxton.SR12 2.2.x.RELEASE 8/11 已停止维护

版本选择建议：

  • 新项目：Spring Boot 3.2.x + Spring Cloud 2023.0.x + JDK 17
  • 生产环境：Spring Boot 2.7.x + Spring Cloud 2021.0.x + JDK 8/11（更稳定）
  • 老项目升级：建议逐步升级，先升级到 2.7.x，再考虑 3.x
8.3.2 推荐依赖配置
xml 复制代码 
<!-- pom.xml -->
<properties>
    <java.version>17</java.version>
    <spring-boot.version>3.2.1</spring-boot.version>
    <spring-cloud.version>2023.0.0</spring-cloud.version>
    <spring-cloud-alibaba.version>2022.0.0.0</spring-cloud-alibaba.version>
</properties>

<dependencyManagement>
    <dependencies>
        <!-- Spring Boot -->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-dependencies</artifactId>
            <version>${spring-boot.version}</version>
            <type>pom</type>
            <scope>import</scope>
        </dependency>

        <!-- Spring Cloud -->
        <dependency>
            <groupId>org.springframework.cloud</groupId>
            <artifactId>spring-cloud-dependencies</artifactId>
            <version>${spring-cloud.version}</version>
            <type>pom</type>
            <scope>import</scope>
        </dependency>

        <!-- Spring Cloud Alibaba -->
        <dependency>
            <groupId>com.alibaba.cloud</groupId>
            <artifactId>spring-cloud-alibaba-dependencies</artifactId>
            <version>${spring-cloud-alibaba.version}</version>
            <type>pom</type>
            <scope>import</scope>
        </dependency>
    </dependencies>
</dependencyManagement>

8.4 最佳实践

8.4.1 服务拆分原则
复制代码 
1. 单一职责原则
   └─ 一个服务只负责一个业务领域

2. 高内聚低耦合
   ├─ 服务内部功能高度相关
   └─ 服务之间依赖最小化

3. 按业务能力拆分
   └─ 围绕业务领域（DDD）

4. 数据隔离
   └─ 每个服务独立数据库

5. 大小适中
   ├─ 不要过度拆分（10-20个微服务合理）
   └─ 团队能够维护
8.4.2 服务通信方式选择
场景 推荐方式 原因
同步查询 OpenFeign 简单易用、声明式
异步通知 RocketMQ 解耦、削峰
实时通信 WebSocket 双向通信
高性能RPC Dubbo 性能优于HTTP
跨语言 gRPC Protobuf 序列化
8.4.3 配置管理最佳实践
yaml 复制代码 
# bootstrap.yml（优先级最高）
spring:
  application:
    name: user-service
  cloud:
    nacos:
      config:
        server-addr: 127.0.0.1:8848
        namespace: ${spring.profiles.active}
        group: DEFAULT_GROUP
        file-extension: yaml
        shared-configs:  # 共享配置
          - data-id: common-db.yaml
            refresh: true
          - data-id: common-redis.yaml
            refresh: true
  profiles:
    active: @profiles.active@  # Maven 动态替换

# Nacos 配置文件命名规范：
# ${spring.application.name}-${spring.profiles.active}.${file-extension}
# 示例：user-service-dev.yaml
8.4.4 日志链路追踪
xml 复制代码 
<!-- pom.xml -->
<dependency>
    <groupId>org.springframework.cloud</groupId>
    <artifactId>spring-cloud-starter-sleuth</artifactId>
</dependency>
<dependency>
    <groupId>org.springframework.cloud</groupId>
    <artifactId>spring-cloud-sleuth-zipkin</artifactId>
</dependency>
yaml 复制代码 
# application.yml
spring:
  sleuth:
    sampler:
      probability: 1.0  # 采样率 100%
  zipkin:
    base-url: http://localhost:9411

日志输出：

复制代码 
[user-service,abc123,def456,true] INFO  - 查询用户
 │             │      │      │
 │             │      │      └─ 是否导出到 Zipkin
 │             │      └─ Span ID
 │             └─ Trace ID（全链路唯一）
 └─ 服务名

九、完整示例项目

9.1 项目架构

复制代码 
电商微服务项目

┌──────────────────────────────────────────────────┐
│                  Gateway (网关)                   │
│               端口：8080                          │
└──────────────────────────────────────────────────┘
                        │
         ┌──────────────┼──────────────┐
         │              │              │
         ↓              ↓              ↓
┌───────────────┐ ┌───────────────┐ ┌───────────────┐
│  用户服务      │ │  订单服务      │ │  商品服务      │
│  user-service │ │ order-service │ │product-service│
│  端口：8081   │ │  端口：8082   │ │  端口：8083   │
└───────────────┘ └───────────────┘ └───────────────┘
         │              │              │
         └──────────────┼──────────────┘
                        │
         ┌──────────────────────────────┐
         │    Nacos (服务发现+配置中心)    │
         │         端口：8848            │
         └──────────────────────────────┘

9.2 父工程 POM

xml 复制代码 
<!-- mall-parent/pom.xml -->
<project>
    <modelVersion>4.0.0</modelVersion>
    <groupId>com.example</groupId>
    <artifactId>mall-parent</artifactId>
    <version>1.0.0</version>
    <packaging>pom</packaging>

    <modules>
        <module>mall-gateway</module>
        <module>mall-user</module>
        <module>mall-order</module>
        <module>mall-product</module>
    </modules>

    <properties>
        <java.version>17</java.version>
        <spring-boot.version>3.2.1</spring-boot.version>
        <spring-cloud.version>2023.0.0</spring-cloud.version>
        <spring-cloud-alibaba.version>2022.0.0.0</spring-cloud-alibaba.version>
        <mybatis-plus.version>3.5.5</mybatis-plus.version>
    </properties>

    <dependencyManagement>
        <dependencies>
            <dependency>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-dependencies</artifactId>
                <version>${spring-boot.version}</version>
                <type>pom</type>
                <scope>import</scope>
            </dependency>
            <dependency>
                <groupId>org.springframework.cloud</groupId>
                <artifactId>spring-cloud-dependencies</artifactId>
                <version>${spring-cloud.version}</version>
                <type>pom</type>
                <scope>import</scope>
            </dependency>
            <dependency>
                <groupId>com.alibaba.cloud</groupId>
                <artifactId>spring-cloud-alibaba-dependencies</artifactId>
                <version>${spring-cloud-alibaba.version}</version>
                <type>pom</type>
                <scope>import</scope>
            </dependency>
        </dependencies>
    </dependencyManagement>
</project>

9.3 网关服务

xml 复制代码 
<!-- mall-gateway/pom.xml -->
<dependencies>
    <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>
    <dependency>
        <groupId>com.alibaba.cloud</groupId>
        <artifactId>spring-cloud-starter-alibaba-sentinel</artifactId>
    </dependency>
</dependencies>
yaml 复制代码 
# mall-gateway/application.yml
server:
  port: 8080

spring:
  application:
    name: mall-gateway
  cloud:
    nacos:
      discovery:
        server-addr: 127.0.0.1:8848
    gateway:
      discovery:
        locator:
          enabled: true  # 启用服务发现路由
      routes:
        - id: user-service
          uri: lb://mall-user
          predicates:
            - Path=/api/users/**
          filters:
            - StripPrefix=1

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

        - id: product-service
          uri: lb://mall-product
          predicates:
            - Path=/api/products/**
          filters:
            - StripPrefix=1
java 复制代码 
// GatewayApplication.java
@SpringBootApplication
@EnableDiscoveryClient
public class GatewayApplication {
    public static void main(String[] args) {
        SpringApplication.run(GatewayApplication.class, args);
    }
}

9.4 用户服务

xml 复制代码 
<!-- mall-user/pom.xml -->
<dependencies>
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-web</artifactId>
    </dependency>
    <dependency>
        <groupId>com.alibaba.cloud</groupId>
        <artifactId>spring-cloud-starter-alibaba-nacos-discovery</artifactId>
    </dependency>
    <dependency>
        <groupId>com.alibaba.cloud</groupId>
        <artifactId>spring-cloud-starter-alibaba-nacos-config</artifactId>
    </dependency>
    <dependency>
        <groupId>com.alibaba.cloud</groupId>
        <artifactId>spring-cloud-starter-alibaba-sentinel</artifactId>
    </dependency>
    <dependency>
        <groupId>com.baomidou</groupId>
        <artifactId>mybatis-plus-boot-starter</artifactId>
        <version>3.5.5</version>
    </dependency>
    <dependency>
        <groupId>com.mysql</groupId>
        <artifactId>mysql-connector-j</artifactId>
    </dependency>
</dependencies>
yaml 复制代码 
# mall-user/bootstrap.yml
spring:
  application:
    name: mall-user
  cloud:
    nacos:
      discovery:
        server-addr: 127.0.0.1:8848
      config:
        server-addr: 127.0.0.1:8848
        file-extension: yaml
  profiles:
    active: dev

# mall-user/application.yml
server:
  port: 8081

spring:
  datasource:
    driver-class-name: com.mysql.cj.jdbc.Driver
    url: jdbc:mysql://localhost:3306/mall_user?useUnicode=true&characterEncoding=utf8
    username: root
    password: password

mybatis-plus:
  mapper-locations: classpath:mapper/*.xml
  configuration:
    log-impl: org.apache.ibatis.logging.stdout.StdOutImpl
java 复制代码 
// UserServiceApplication.java
@SpringBootApplication
@EnableDiscoveryClient
@MapperScan("com.example.user.mapper")
public class UserServiceApplication {
    public static void main(String[] args) {
        SpringApplication.run(UserServiceApplication.class, args);
    }
}

// User.java
@Data
@TableName("users")
public class User {
    @TableId(type = IdType.AUTO)
    private Long id;
    private String username;
    private String password;
    private String email;
    private Date createdAt;
}

// UserMapper.java
public interface UserMapper extends BaseMapper<User> {
}

// UserService.java
@Service
public class UserService {

    @Autowired
    private UserMapper userMapper;

    public User getById(Long id) {
        return userMapper.selectById(id);
    }

    public List<User> list() {
        return userMapper.selectList(null);
    }

    public boolean save(User user) {
        return userMapper.insert(user) > 0;
    }
}

// UserController.java
@RestController
@RequestMapping("/users")
public class UserController {

    @Autowired
    private UserService userService;

    @GetMapping("/{id}")
    @SentinelResource(value = "getUser", blockHandler = "handleBlock")
    public User getUser(@PathVariable Long id) {
        return userService.getById(id);
    }

    @GetMapping
    public List<User> listUsers() {
        return userService.list();
    }

    @PostMapping
    public boolean createUser(@RequestBody User user) {
        return userService.save(user);
    }

    // 限流处理
    public User handleBlock(Long id, BlockException ex) {
        return new User(id, "系统繁忙", "", "", null);
    }
}

9.5 订单服务

xml 复制代码 
<!-- mall-order/pom.xml -->
<dependencies>
    <!-- 同 user-service -->

    <!-- 添加 Feign 客户端 -->
    <dependency>
        <groupId>org.springframework.cloud</groupId>
        <artifactId>spring-cloud-starter-openfeign</artifactId>
    </dependency>

    <!-- Sentinel 整合 Feign -->
    <dependency>
        <groupId>com.alibaba.cloud</groupId>
        <artifactId>spring-cloud-starter-alibaba-sentinel</artifactId>
    </dependency>
</dependencies>
yaml 复制代码 
# mall-order/application.yml
server:
  port: 8082

spring:
  application:
    name: mall-order
  datasource:
    url: jdbc:mysql://localhost:3306/mall_order

feign:
  sentinel:
    enabled: true  # 启用 Sentinel
java 复制代码 
// OrderServiceApplication.java
@SpringBootApplication
@EnableDiscoveryClient
@EnableFeignClients
@MapperScan("com.example.order.mapper")
public class OrderServiceApplication {
    public static void main(String[] args) {
        SpringApplication.run(OrderServiceApplication.class, args);
    }
}

// Order.java
@Data
@TableName("orders")
public class Order {
    @TableId(type = IdType.AUTO)
    private Long id;
    private Long userId;
    private Long productId;
    private Integer quantity;
    private BigDecimal totalPrice;
    private Date createdAt;
}

// UserClient.java (Feign 客户端)
@FeignClient(name = "mall-user", fallback = UserClientFallback.class)
public interface UserClient {
    @GetMapping("/users/{id}")
    User getUser(@PathVariable("id") Long id);
}

// UserClientFallback.java
@Component
public class UserClientFallback implements UserClient {
    @Override
    public User getUser(Long id) {
        return new User(id, "降级用户", "", "", null);
    }
}

// ProductClient.java
@FeignClient(name = "mall-product", fallback = ProductClientFallback.class)
public interface ProductClient {
    @GetMapping("/products/{id}")
    Product getProduct(@PathVariable("id") Long id);
}

// OrderService.java
@Service
public class OrderService {

    @Autowired
    private OrderMapper orderMapper;

    @Autowired
    private UserClient userClient;

    @Autowired
    private ProductClient productClient;

    public Order createOrder(Order order) {
        // 1. 验证用户
        User user = userClient.getUser(order.getUserId());
        if (user == null) {
            throw new RuntimeException("用户不存在");
        }

        // 2. 验证商品
        Product product = productClient.getProduct(order.getProductId());
        if (product == null) {
            throw new RuntimeException("商品不存在");
        }

        // 3. 计算总价
        order.setTotalPrice(product.getPrice().multiply(new BigDecimal(order.getQuantity())));

        // 4. 创建订单
        orderMapper.insert(order);

        return order;
    }
}

// OrderController.java
@RestController
@RequestMapping("/orders")
public class OrderController {

    @Autowired
    private OrderService orderService;

    @PostMapping
    public Order createOrder(@RequestBody Order order) {
        return orderService.createOrder(order);
    }
}

9.6 启动顺序

复制代码 
1. 启动 Nacos
   └─ sh startup.sh -m standalone

2. 启动 Sentinel Dashboard（可选）
   └─ java -jar sentinel-dashboard.jar

3. 启动微服务
   ├─ 启动 user-service (8081)
   ├─ 启动 product-service (8083)
   ├─ 启动 order-service (8082)
   └─ 启动 gateway (8080)

4. 测试
   └─ http://localhost:8080/api/users/1
相关推荐
腾讯云中间件3 小时前
Kafka 集群上云新突破：腾讯云 CKafka 联邦迁移方案
云原生·kafka·消息队列
腾讯云中间件3 小时前
腾讯云 RocketMQ 5.x：如何兼容 Remoting 全系列客户端
架构·消息队列·rocketmq
程序员老赵7 小时前
Apache RocketMQ Docker 容器化部署指南
docker·rocketmq
阿拉斯攀登10 小时前
Spring Cloud Alibaba 生态中 RocketMQ 最佳实践
分布式·微服务·rocketmq·springcloud·cloudalibaba
有想法的py工程师11 小时前
PostgreSQL × Debezium × Kafka 时间戳机制 [附对照表]
postgresql·kafka·debezium
哇哈哈&11 小时前
如何进行卸载rabbitmq
分布式·rabbitmq
有想法的py工程师11 小时前
PostgreSQL × Debezium × Kafka CDC（Change Data Capture）监控体系
postgresql·kafka·zabbix·grafana·prometheus
ChrisitineTX12 小时前
RocketMQ 消费端卡死？深扒 Rebalance（重平衡）机制在“网络分区”下的致命 Bug
网络·bug·rocketmq
写bug的小屁孩12 小时前
6.Kafka-生产者发送到Broker分区策略和常见配置
分布式·kafka
热门推荐
01GitHub 镜像站点02【超详细教程】手把手教你从微软官网免费下载Windows 10官方原版ISO镜像（2025最新版）03安娜的档案(Anna’s Archive) 镜像网站/国内最新可访问入口（持续更新）04UV安装并设置国内源05Linux下V2Ray安装配置指南06BongoCat - 跨平台键盘猫动画工具07React CVE-2025-55182漏洞排查与修复指南08从入门到实战：Gemini 3 使用指南速览09本地部署阿里最新开源的Z-Image10在VSCode配置Java开发环境的保姆级教程（适配各类AI编程IDE）