分布式系统设计与实战：Java 微服务架构落地

分布式系统设计与实战：Java 微服务架构落地 | 极客日志

特性	单体架构	微服务架构
架构复杂度	低（所有功能集成在一个应用）	高（多个独立服务协同）
开发效率（初期）	高（无需关注服务拆分与通信）	低（需设计服务拆分、通信等）
开发效率（后期）	低（代码量庞大，维护困难）	高（服务独立维护，迭代灵活）
扩展性	差（只能垂直扩展，成本高）	好（支持横向扩展，按需扩容）
可用性	差（单个模块故障导致整个应用崩溃）	好（单个服务故障不影响其他服务）
部署成本	低（一次部署整个应用）	高（需部署多个服务，依赖 DevOps 支持）

<!-- Spring Boot 父依赖 -->
<parent>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-parent</artifactId>
    <version>2.7.15</version>
    <relativePath/>
</parent>
<!-- Spring Cloud Alibaba 依赖管理 -->
<dependencyManagement>
    <dependencies>
        <dependency>
            <groupId>com.alibaba.cloud</groupId>
            <artifactId>spring-cloud-alibaba-dependencies</artifactId>
            <version>2021.0.4.0</version>
            <type>pom</type>
            <scope>import</scope>
        </dependency>
    </dependencies>
</dependencyManagement>
<dependencies>
    <!-- Spring Web -->
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-web</artifactId>
    </dependency>
    <!-- Nacos 服务注册发现 -->
    <dependency>
        <groupId>com.alibaba.cloud</groupId>
        <artifactId>spring-cloud-starter-alibaba-nacos-discovery</artifactId>
    </dependency>
    <!-- Lombok -->
    <dependency>
        <groupId>org.projectlombok</groupId>
        <artifactId>lombok</artifactId>
        <optional>true</optional>
    </dependency>
</dependencies>

spring:
  application:
    name: user-service # 服务名称（注册到 Nacos 的服务名）
  cloud:
    nacos:
      discovery:
        server-addr: localhost:8848 # Nacos 服务地址
server:
  port: 8081 # 服务端口

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.cloud.client.discovery.EnableDiscoveryClient;

@SpringBootApplication
@EnableDiscoveryClient // 开启服务注册发现功能（Spring Cloud 2020+ 可省略）
public class UserServiceApplication {
    public static void main(String[] args) {
        SpringApplication.run(UserServiceApplication.class, args);
    }
}

import lombok.Data;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.PathVariable;
import org.springframework.web.bind.annotation.RestController;

@RestController
public class UserController {
    // 模拟数据库查询用户信息
    @GetMapping("/user/{id}")
    public User getUserById(@PathVariable Long id) {
        // 实际开发中应从数据库查询，此处模拟数据
        User user = new User();
        user.setId(id);
        user.setUsername("张三" + id);
        user.setPhone("1380013800" + id % 10);
        user.setAddress("北京市朝阳区");
        return user;
    }

    // 用户实体类
    @Data
    static class User {
        private Long id;
        private String username;
        private String phone;
        private String address;
    }
}

<!-- OpenFeign 依赖（服务调用） -->
<dependency>
    <groupId>org.springframework.cloud</groupId>
    <artifactId>spring-cloud-starter-openfeign</artifactId>
</dependency>

spring:
  application:
    name: order-service # 服务名称
  cloud:
    nacos:
      discovery:
        server-addr: localhost:8848 # Nacos 服务地址
server:
  port: 8082 # 服务端口

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.cloud.openfeign.EnableFeignClients;

@SpringBootApplication
@EnableFeignClients // 开启 Feign 声明式调用
public class OrderServiceApplication {
    public static void main(String[] args) {
        SpringApplication.run(OrderServiceApplication.class, args);
    }
}

import org.springframework.cloud.openfeign.FeignClient;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.PathVariable;

// name：目标服务名称（Nacos 中注册的服务名）
@FeignClient(name = "user-service")
public interface UserFeignClient {
    // 与 user-service 的接口路径、请求方式一致
    @GetMapping("/user/{id}")
    User getUserById(@PathVariable("id") Long id);

    // 与 user-service 中的 User 实体类结构一致
    @lombok.Data
    class User {
        private Long id;
        private String username;
        private String phone;
        private String address;
    }
}

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.PathVariable;
import org.springframework.web.bind.annotation.RestController;

@RestController
public class OrderController {
    @Autowired
    private UserFeignClient userFeignClient;

    // 创建订单（模拟：根据用户 ID 查询用户信息，生成订单）
    @GetMapping("/order/{userId}")
    public Order createOrder(@PathVariable Long userId) {
        // 1. 调用 user-service 获取用户信息
        UserFeignClient.User user = userFeignClient.getUserById(userId);
        // 2. 生成订单（模拟数据）
        Order order = new Order();
        order.setOrderId(System.currentTimeMillis());
        order.setUserId(userId);
        order.setUsername(user.getUsername());
        order.setProductName("Java 编程思想");
        order.setPrice(89.0);
        order.setStatus("已创建");
        return order;
    }

    // 订单实体类
    @lombok.Data
    static class Order {
        private Long orderId;
        private Long userId;
        private String username;
        private String productName;
        private Double price;
        private String status;
    }
}

{"orderId":1695888888888,"userId":1,"username":"张三 1","productName":"Java 编程思想","price":89.0,"status":"已创建"}

<!-- Nacos 配置中心依赖 -->
<dependency>
    <groupId>com.alibaba.cloud</groupId>
    <artifactId>spring-cloud-starter-alibaba-nacos-config</artifactId>
</dependency>

spring:
  application:
    name: user-service # 服务名称（与 Nacos 配置的 Data ID 关联）
  cloud:
    nacos:
      config:
        server-addr: localhost:8848 # Nacos 配置中心地址
        file-extension: yaml # 配置文件格式（yaml/xml/properties）
        namespace: public # 命名空间（默认 public，用于隔离环境）
        group: DEFAULT_GROUP # 配置分组（默认 DEFAULT_GROUP）

user:
  config:
    default-age: 18
    welcome-msg: "欢迎使用用户服务！"

import org.springframework.beans.factory.annotation.Value;
import org.springframework.cloud.context.config.annotation.RefreshScope;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RestController;

@RestController
@RefreshScope // 开启动态刷新配置（修改 Nacos 配置后无需重启服务）
public class ConfigController {
    // 读取 Nacos 中的配置
    @Value("${user.config.default-age}")
    private Integer defaultAge;

    @Value("${user.config.welcome-msg}")
    private String welcomeMsg;

    @GetMapping("/config")
    public String getConfig() {
        return "默认年龄：" + defaultAge + "，欢迎语：" + welcomeMsg;
    }
}

<!-- Sentinel 核心依赖 -->
<dependency>
    <groupId>com.alibaba.cloud</groupId>
    <artifactId>spring-cloud-starter-alibaba-sentinel</artifactId>
</dependency>
<!-- Sentinel 与 OpenFeign 整合依赖（支持 Feign 调用熔断） -->
<dependency>
    <groupId>com.alibaba.cloud</groupId>
    <artifactId>spring-cloud-alibaba-sentinel-feign</artifactId>
</dependency>

spring:
  cloud:
    sentinel:
      transport:
        dashboard: localhost:8080 # Sentinel 控制台地址
        port: 8719 # 与 Sentinel 控制台通信的端口（默认 8719，若被占用自动递增）
      feign:
        enabled: true # 开启 Sentinel 对 Feign 的支持（熔断功能）

import org.springframework.stereotype.Component;

// Feign 客户端降级处理类（需实现对应的 FeignClient 接口）
@Component
public class UserFeignFallback implements UserFeignClient {
    // 当调用 user-service 的 getUserById 接口失败时，执行此降级方法
    @Override
    public User getUserById(Long id) {
        User user = new User();
        user.setId(id);
        user.setUsername("默认用户");
        user.setPhone("13800000000");
        user.setAddress("默认地址");
        return user;
    }
}

import org.springframework.cloud.openfeign.FeignClient;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.PathVariable;

// fallback：指定降级处理类
@FeignClient(name = "user-service", fallback = UserFeignFallback.class)
public interface UserFeignClient {
    @GetMapping("/user/{id}")
    User getUserById(@PathVariable("id") Long id);

    @lombok.Data
    class User {
        private Long id;
        private String username;
        private String phone;
        private String address;
    }
}

import com.alibaba.csp.sentinel.adapter.spring.webmvc.callback.BlockExceptionHandler;
import com.alibaba.csp.sentinel.slots.block.BlockException;
import com.alibaba.csp.sentinel.slots.block.flow.FlowException;
import org.springframework.stereotype.Component;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import java.io.IOException;

@Component
public class SentinelBlockHandler implements BlockExceptionHandler {
    @Override
    public void handle(HttpServletRequest request, HttpServletResponse response, BlockException e) throws IOException {
        response.setContentType("application/json;charset=utf-8");
        String msg = "";
        if (e instanceof FlowException) {
            msg = "{\"code\":429,\"msg\":\"当前请求过于频繁，请稍后再试！\"}";
        }
        response.getWriter().write(msg);
    }
}

@GetMapping("/user/{id}")
public User getUserById(@PathVariable Long id) throws InterruptedException {
    // 模拟 600ms 延迟（超过熔断规则的 500ms）
    Thread.sleep(600);
    User user = new User();
    user.setId(id);
    user.setUsername("张三" + id);
    user.setPhone("1380013800" + id % 10);
    user.setAddress("北京市朝阳区");
    return user;
}

feign:
  client:
    config:
      default: # 全局配置（若需针对单个服务，将 default 改为服务名，如 user-service）
        connect-timeout: 5000 # 连接超时时间（5 秒）
        read-timeout: 5000 # 读取超时时间（5 秒)
  httpclient:
    enabled: false # 关闭默认 HttpClient
  okhttp:
    enabled: true # 启用 OKHttp 客户端（需引入依赖）
# 重试配置（Spring Retry）
spring:
  cloud:
    loadbalancer:
      retry:
        enabled: true # 开启负载均衡重试
        # 针对 user-service 的重试配置
        user-service:
          ribbon:
            ConnectTimeout: 5000
            ReadTimeout: 5000
            MaxAutoRetries: 1 # 同一服务实例的重试次数
            MaxAutoRetriesNextServer: 1 # 切换服务实例的重试次数
            OkToRetryOnAllOperations: false # 仅对 GET 请求重试（POST 请求可能导致重复提交）

<!-- OpenFeign OKHttp 客户端依赖 -->
<dependency>
    <groupId>io.github.openfeign</groupId>
    <artifactId>feign-okhttp</artifactId>
</dependency>
<!-- Spring Retry 依赖（重试功能） -->
<dependency>
    <groupId>org.springframework.retry</groupId>
    <artifactId>spring-retry</artifactId>
</dependency>

<!-- Spring Cloud Alibaba RocketMQ 依赖 -->
<dependency>
    <groupId>com.alibaba.cloud</groupId>
    <artifactId>spring-cloud-starter-stream-rocketmq</artifactId>
</dependency>

spring:
  cloud:
    stream:
      rocketmq:
        binder:
          name-server: localhost:9876 # RocketMQ NameServer 地址
      bindings:
        # 生产者配置（订单创建消息）
        order-output:
          destination: order_topic # 主题名称
          content-type: application/json # 消息格式
        # 消费者配置（订单支付消息）
        pay-input:
          destination: pay_topic # 主题名称
          content-type: application/json
          group: pay_consumer_group # 消费者组

import org.springframework.cloud.stream.annotation.EnableBinding;
import org.springframework.cloud.stream.messaging.Source;
import org.springframework.messaging.MessageChannel;
import org.springframework.messaging.support.MessageBuilder;
import org.springframework.stereotype.Component;

// 绑定 Source 接口（默认输出通道 output，此处自定义为 order-output）
@EnableBinding(Source.class)
@Component
public class OrderMessageProducer {
    private final MessageChannel output;

    // 注入输出通道（对应配置中的 order-output）
    public OrderMessageProducer(Source source) {
        this.output = source.output();
    }

    // 发送订单创建消息
    public boolean sendOrderCreatedMsg(OrderCreatedMsg msg) {
        return output.send(MessageBuilder.withPayload(msg).build());
    }

    // 订单创建消息实体
    @lombok.Data
    public static class OrderCreatedMsg {
        private Long orderId;
        private Long userId;
        private Double amount;
        private Long createTime;
    }
}

@RestController
public class OrderController {
    @Autowired
    private UserFeignClient userFeignClient;
    @Autowired
    private OrderMessageProducer orderMessageProducer;

    @GetMapping("/order/{userId}")
    public Order createOrder(@PathVariable Long userId) {
        // 1. 调用用户服务获取用户信息
        UserFeignClient.User user = userFeignClient.getUserById(userId);
        // 2. 生成订单
        Order order = new Order();
        Long orderId = System.currentTimeMillis();
        order.setOrderId(orderId);
        order.setUserId(userId);
        order.setUsername(user.getUsername());
        order.setProductName("Java 编程思想");
        order.setPrice(89.0);
        order.setStatus("已创建");
        // 3. 发送订单创建消息（异步通知其他服务，如物流服务、积分服务）
        OrderMessageProducer.OrderCreatedMsg msg = new OrderMessageProducer.OrderCreatedMsg();
        msg.setOrderId(orderId);
        msg.setUserId(userId);
        msg.setAmount(89.0);
        msg.setCreateTime(System.currentTimeMillis());
        orderMessageProducer.sendOrderCreatedMsg(msg);
        return order;
    }

    // 订单实体类（略，同前）
}

import org.springframework.cloud.stream.annotation.EnableBinding;
import org.springframework.cloud.stream.messaging.Sink;
import org.springframework.cloud.stream.annotation.StreamListener;
import org.springframework.stereotype.Component;

// 绑定 Sink 接口（默认输入通道 input，对应配置中的 pay-input）
@EnableBinding(Sink.class)
@Component
public class PayMessageConsumer {
    // 监听 pay-input 通道的消息
    @StreamListener(Sink.INPUT)
    public void handlePayResult(PayResultMsg msg) {
        // 处理支付结果（如更新订单状态）
        System.out.println("收到支付结果消息：" + msg);
        // 实际开发中应更新数据库中的订单状态
    }

    // 支付结果消息实体
    @lombok.Data
    public static class PayResultMsg {
        private Long orderId;
        private String payStatus; // SUCCESS/FAIL
        private Long payTime;
        private String tradeNo;
    }
}

┌─────────────────────────────────────────────────────────────┐
│  客户端（Web/APP）                                          │
└───────────────────────────────┬─────────────────────────────┘
                                │
┌───────────────────────────────▼─────────────────────────────┐
│  网关（Spring Cloud Gateway）                               │
└─┬───────────────┬───────────────┬───────────────┬───────────┘
  │               │               │               │
┌─▼───────┐ ┌───▼───────┐ ┌───▼───────┐ ┌───▼───────┐
│用户服务 │ │商品服务 │ │订单服务 │ │支付服务 │
└─┬───────┘ └───┬───────┘ └───┬───────┘ └───┬───────┘
  │             │             │             │
┌─▼───────┐ ┌───▼───────┐ ┌───▼───────┐ ┌───▼───────┐
│用户数据库│ │商品数据库│ │订单数据库│ │支付数据库│
└─────────┘ └───────────┘ └───────────┘ └───────────┘
  │             │             │             │
┌─▼───────────────▼───────────────▼───────────────▼───────┐
│  中间件层（Nacos/Sentinel/RocketMQ）                     │
└─────────────────────────────────────────────────────────┘

@lombok.Data
public class Product {
    private Long id;
    private String name;
    private Double price;
    private Integer stock; // 库存
    private String category;
}

@RestController
public class ProductController {
    // 模拟商品库存（实际开发中从数据库查询）
    private final Map<Long, Product> productMap = new HashMap<>();

    public ProductController() {
        // 初始化商品数据
        Product product = new Product();
        product.setId(1L);
        product.setName("Java 编程思想");
        product.setPrice(89.0);
        product.setStock(100);
        product.setCategory("图书");
        productMap.put(1L, product);
    }

    // 查询商品信息
    @GetMapping("/product/{id}")
    public Product getProductById(@PathVariable Long id) {
        return productMap.get(id);
    }

    // 扣减库存（订单创建时调用）
    @PostMapping("/product/stock/deduct")
    public boolean deductStock(@RequestBody DeductStockReq req) {
        Product product = productMap.get(req.getProductId());
        if (product == null || product.getStock() < req.getCount()) {
            return false; // 库存不足
        }
        product.setStock(product.getStock() - req.getCount());
        return true;
    }

    // 扣减库存请求实体
    @lombok.Data
    static class DeductStockReq {
        private Long productId;
        private Integer count;
    }
}

@FeignClient(name = "product-service", fallback = ProductFeignFallback.class)
public interface ProductFeignClient {
    @GetMapping("/product/{id}")
    Product getProductById(@PathVariable("id") Long id);

    @PostMapping("/product/stock/deduct")
    boolean deductStock(@RequestBody DeductStockReq req);

    @lombok.Data
    class Product {
        private Long id;
        private String name;
        private Double price;
        private Integer stock;
        private String category;
    }

    @lombok.Data
    class DeductStockReq {
        private Long productId;
        private Integer count;
    }
}

// 商品服务降级处理类
@Component
class ProductFeignFallback implements ProductFeignClient {
    @Override
    public Product getProductById(Long id) {
        Product product = new Product();
        product.setId(id);
        product.setName("默认商品");
        product.setPrice(0.0);
        return product;
    }

    @Override
    public boolean deductStock(DeductStockReq req) {
        return false; // 库存扣减失败
    }
}

@GetMapping("/order/{userId}")
public Order createOrder(@PathVariable Long userId) {
    // 1. 选择商品（模拟用户购买商品 ID=1，数量=1）
    Long productId = 1L;
    Integer count = 1;
    // 2. 调用商品服务查询商品信息
    ProductFeignClient.Product product = productFeignClient.getProductById(productId);
    if (product == null) {
        throw new RuntimeException("商品不存在");
    }
    // 3. 调用商品服务扣减库存
    ProductFeignClient.DeductStockReq deductReq = new ProductFeignClient.DeductStockReq();
    deductReq.setProductId(productId);
    deductReq.setCount(count);
    boolean deductSuccess = productFeignClient.deductStock(deductReq);
    if (!deductSuccess) {
        throw new RuntimeException("库存不足");
    }
    // 4. 调用用户服务获取用户信息
    UserFeignClient.User user = userFeignClient.getUserById(userId);
    // 5. 生成订单
    Order order = new Order();
    Long orderId = System.currentTimeMillis();
    order.setOrderId(orderId);
    order.setUserId(userId);
    order.setUsername(user.getUsername());
    order.setProductName(product.getName());
    order.setPrice(product.getPrice());
    order.setCount(count);
    order.setTotalAmount(product.getPrice() * count);
    order.setStatus("已创建");
    // 6. 发送订单创建消息
    OrderMessageProducer.OrderCreatedMsg msg = new OrderMessageProducer.OrderCreatedMsg();
    msg.setOrderId(orderId);
    msg.setUserId(userId);
    msg.setAmount(order.getTotalAmount());
    msg.setCreateTime(System.currentTimeMillis());
    orderMessageProducer.sendOrderCreatedMsg(msg);
    return order;
}

// 订单实体类添加 count 和 totalAmount 字段
@lombok.Data
static class Order {
    private Long orderId;
    private Long userId;
    private String username;
    private String productName;
    private Double price;
    private Integer count;
    private Double totalAmount;
    private String status;
}

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

seata:
  application-id: ${spring.application.name}
  tx-service-group: my_test_tx_group # 事务组名称
  registry:
    type: nacos # 注册中心类型（与 Nacos 集成）
    nacos:
      server-addr: localhost:8848
      group: SEATA_GROUP
      namespace: ""
  config:
    type: nacos
    nacos:
      server-addr: localhost:8848
      group: SEATA_GROUP
      namespace: ""

@GetMapping("/order/{userId}")
@GlobalTransactional(name = "create-order-transaction", rollbackFor = Exception.class)
public Order createOrder(@PathVariable Long userId) {
    // 订单创建、库存扣减逻辑（同前）
}

分布式系统设计与实战：Java 微服务架构落地

分布式系统设计与实战：Java 微服务架构落地

一、章节学习目标与重点

1.1 学习目标

1.2 学习重点

二、分布式系统与微服务架构基础

2.1 分布式系统核心概念

2.1.1 分布式系统的优势

2.1.2 分布式系统的挑战

2.2 微服务架构核心思想

2.2.1 微服务架构的设计原则

2.2.2 微服务与单体架构的对比

2.3 微服务拆分实战：领域驱动设计（DDD）

2.3.1 DDD 核心概念

2.3.2 微服务拆分步骤（以电商系统为例）

三、Spring Cloud Alibaba 生态核心组件实战

3.1 生态介绍

3.2 环境准备

3.2.1 技术栈选型

3.2.2 环境搭建步骤

3.3 服务注册与发现（Nacos）

3.3.1 搭建服务提供者（user-service）

3.3.2 搭建服务消费者（order-service）

3.4 配置中心（Nacos Config）

3.4.1 集成 Nacos Config（以 user-service 为例）

3.5 服务熔断与限流（Sentinel）

3.5.1 核心概念

3.5.2 集成 Sentinel（以 order-service 为例）

3.5.3 配置限流规则（Sentinel 控制台）

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

四、微服务通信实战：同步与异步

4.1 同步通信：OpenFeign 进阶

4.1.1 配置 OpenFeign 超时与重试

4.2 异步通信：RocketMQ 实战

4.2.1 RocketMQ 环境准备

4.2.2 集成 RocketMQ（以订单服务为例）

五、分布式系统实战：电商微服务系统设计与实现

5.1 系统整体架构设计

5.1.1 架构图

5.1.2 核心服务职责

5.2 核心功能实现：订单创建全流程

5.2.1 流程说明

5.2.2 商品服务核心代码（库存扣减）

5.2.3 订单服务整合商品服务（扣减库存）

5.3 分布式事务问题与解决方案

5.3.1 最终一致性方案：基于消息队列的可靠消息投递

5.3.2 集成 Seata 实现分布式事务（可选）

六、本章总结

微信扫一扫，关注极客日志

更多推荐文章

相关免费在线工具