完整微服务设计 功能实现

发布于:2024-12-21 ⋅ 阅读:(15) ⋅ 点赞:(0)

        我们将以一个简单的电商系统为例,实现微服务架构,逐步用Java代码详细实现每个模块,并配合注释帮助小白理解。在这个实现中,我们使用以下工具和框架:

  • Spring Boot:用于构建微服务。
  • Spring Cloud:用于服务注册、发现、负载均衡等。
  • Docker:用于容器化服务。
  • Kubernetes (K8s):用于部署到生产环境。
  • MySQL/MongoDB/PostgreSQL:不同服务独立数据库。
  • RabbitMQ:用于消息队列。
  • Prometheus + Grafana:用于监控。

以下是完整的实现步骤。


一、用户服务 (User Service)的实现

1. 环境搭建

1.1 必备工具安装

确保安装以下工具:

  • Java 17+
  • Maven
  • Docker
  • Kubernetes (minikube 或云上的K8s服务)
  • RabbitMQ
  • 数据库(MySQL/PostgreSQL/MongoDB)
  • IDE(IntelliJ IDEA 或 VS Code)

2. 功能

        管理用户信息(用户注册、查询)。

2.1 数据库准备

我们使用 PostgreSQL 来存储用户数据。

  • 创建数据库和表
CREATE DATABASE user_service;
CREATE TABLE users (
    id SERIAL PRIMARY KEY,
    username VARCHAR(255) NOT NULL UNIQUE,
    email VARCHAR(255) NOT NULL UNIQUE,
    created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP
);
2.2 创建 Spring Boot 项目

生成项目Spring Initializr
依赖:

  • Spring Web
  • Spring Data JPA
  • PostgreSQL Driver

2.3 实现用户服务

application.yml 配置文件

配置数据库连接:

server:
  port: 8081  # 服务运行的端口号

spring:
  datasource:
    url: jdbc:postgresql://localhost:5432/user_service
    username: postgres  # 数据库用户名
    password: password  # 数据库密码
  jpa:
    hibernate:
      ddl-auto: update  # 自动更新数据库结构
    show-sql: true      # 显示 SQL 查询日志
User 实体类
package com.example.userservice.model;

import jakarta.persistence.*;
import java.time.LocalDateTime;

/**
 * 用户实体类,对应数据库表 users。
 */
@Entity
@Table(name = "users")
public class User {

    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    private Long id;  // 用户唯一 ID

    @Column(nullable = false, unique = true)
    private String username;  // 用户名(唯一)

    @Column(nullable = false, unique = true)
    private String email;  // 用户邮箱(唯一)

    @Column(name = "created_at", updatable = false)
    private LocalDateTime createdAt = LocalDateTime.now();  // 用户注册时间

    // Getters 和 Setters,用于封装字段访问
    public Long getId() {
        return id;
    }

    public void setId(Long id) {
        this.id = id;
    }

    public String getUsername() {
        return username;
    }

    public void setUsername(String username) {
        this.username = username;
    }

    public String getEmail() {
        return email;
    }

    public void setEmail(String email) {
        this.email = email;
    }

    public LocalDateTime getCreatedAt() {
        return createdAt;
    }

    public void setCreatedAt(LocalDateTime createdAt) {
        this.createdAt = createdAt;
    }
}
UserRepository 接口

package com.example.userservice.repository;

import com.example.userservice.model.User;
import org.springframework.data.jpa.repository.JpaRepository;
import org.springframework.stereotype.Repository;

/**
 * 用户数据访问接口,提供 CRUD 操作。
 */
@Repository
public interface UserRepository extends JpaRepository<User, Long> {
    User findByUsername(String username);  // 根据用户名查询用户
}
UserService 服务层
package com.example.userservice.service;

import com.example.userservice.model.User;
import com.example.userservice.repository.UserRepository;
import org.springframework.stereotype.Service;

import java.util.Optional;

/**
 * 用户服务类,包含业务逻辑。
 */
@Service
public class UserService {

    private final UserRepository userRepository;

    public UserService(UserRepository userRepository) {
        this.userRepository = userRepository;
    }

    /**
     * 注册新用户。
     * 
     * @param user 包含用户名和邮箱的用户对象
     * @return 保存后的用户对象,包含生成的 ID 和注册时间
     */
    public User registerUser(User user) {
        return userRepository.save(user);  // 保存到数据库
    }

    /**
     * 根据用户名查找用户。
     * 
     * @param username 要查询的用户名
     * @return 包含用户对象的 Optional,如果未找到则为空
     */
    public Optional<User> findUserByUsername(String username) {
        return Optional.ofNullable(userRepository.findByUsername(username));
    }
}
UserController 控制器
package com.example.userservice.controller;

import com.example.userservice.model.User;
import com.example.userservice.service.UserService;
import org.springframework.http.ResponseEntity;
import org.springframework.web.bind.annotation.*;

import java.util.Optional;

/**
 * 用户服务的 REST 控制器。
 */
@RestController
@RequestMapping("/api/users")
public class UserController {

    private final UserService userService;

    public UserController(UserService userService) {
        this.userService = userService;
    }

    /**
     * 注册新用户的 API。
     * 
     * @param user 从请求体接收的用户对象
     * @return 返回注册成功的用户
     */
    @PostMapping
    public ResponseEntity<User> registerUser(@RequestBody User user) {
        return ResponseEntity.ok(userService.registerUser(user));
    }

    /**
     * 根据用户名查找用户的 API。
     * 
     * @param username 请求路径中的用户名
     * @return 返回找到的用户或 404
     */
    @GetMapping("/{username}")
    public ResponseEntity<User> findUserByUsername(@PathVariable String username) {
        Optional<User> user = userService.findUserByUsername(username);
        return user.map(ResponseEntity::ok).orElse(ResponseEntity.notFound().build());
    }
}

2.4 测试用户服务

启动服务后:

  1. 注册用户

    curl -X POST -H "Content-Type: application/json" \
    -d '{"username": "haha_jam", "email": "haha@example.com"}' \
    http://localhost:8081/api/users
    

    响应

    {
        "id": 1,
        "username": "haha_jam",
        "email": "haha@example.com",
        "createdAt": "2024-12-20T10:00:00"
    }
    
  2. 查询用户

    curl http://localhost:8081/api/users/haha_jam
    

    响应

    {
        "id": 1,
        "username": "haha_jam",
        "email": "haha@example.com",
        "createdAt": "2024-12-20T10:00:00"
    }
    

3. 服务注册与发现

        在完整微服务中,我们使用 Spring Cloud Eureka 来实现服务注册和发现。

3.1 什么是服务注册与发现?

        在微服务架构中,服务是分布式的,每个服务都可能运行在不同的主机或容器中。为了让服务之间能够互相通信,需要一种机制来找到其他服务的地址和端口。

服务注册与发现原理:
  1. Eureka Server:服务注册中心,用来维护所有服务的地址列表。每个服务(如用户服务、订单服务)都会向 Eureka Server 注册自己。
  2. Eureka Client:微服务实例本身会向 Eureka Server 注册,并定期发送心跳来告诉注册中心它是健康的。
  3. 服务发现:当一个服务需要调用另一个服务时,它会向 Eureka Server 查询目标服务的地址列表。

配置步骤包括:

  1. 创建 Eureka Server
  2. 将用户服务注册到 Eureka
  3. 添加 API 网关

3.2 创建 Eureka Server

Eureka Server 是服务注册中心,所有服务都会向它注册。

3.2.1 生成 Eureka Server 项目
  1. 打开 Spring Initializr

  2. 配置项目:

    • Project: Maven
    • Language: Java
    • Spring Boot: 3.0.0+
    • Dependencies:
      • Spring Cloud Eureka Server
  3. 下载生成的项目并解压。


3.2.2 配置 Eureka Server
1. 添加依赖

在 pom.xml 中确认以下依赖已经存在:

<dependency>
    <groupId>org.springframework.cloud</groupId>
    <artifactId>spring-cloud-starter-netflix-eureka-server</artifactId>
</dependency>
2. 配置 application.yml

在 src/main/resources/application.yml 中配置 Eureka Server:

server:
  port: 8761  # Eureka Server 的默认端口

spring:
  application:
    name: eureka-server  # 应用名称

eureka:
  client:
    register-with-eureka: false  # Eureka Server 本身不需要向其他注册中心注册
    fetch-registry: false        # Eureka Server 不需要获取注册信息
  server:
    enable-self-preservation: false  # 关闭自我保护模式(测试环境可以关闭,生产环境建议打开)
3. 启动类

在 src/main/java/com/example/eurekaserver/EurekaServerApplication.java 文件中添加 @EnableEurekaServer 注解。

package com.example.eurekaserver;

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.cloud.netflix.eureka.server.EnableEurekaServer;

/**
 * Eureka Server Application - 服务注册中心
 */
@SpringBootApplication
@EnableEurekaServer  // 启用 Eureka Server 功能
public class EurekaServerApplication {

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

3.2.3 启动 Eureka Server
  1. 使用 IDE 或命令行运行 EurekaServerApplication
  2. 打开浏览器访问:http://localhost:8761
    • 你会看到 Eureka Server 的管理页面,显示 "No instances available"。

3.3 将用户服务注册到 Eureka

现在我们需要将前面实现的 用户服务(User Service) 注册到 Eureka Server。

3.3.1 添加依赖

在用户服务的 pom.xml 中添加 Eureka Client 依赖:

<dependency>
    <groupId>org.springframework.cloud</groupId>
    <artifactId>spring-cloud-starter-netflix-eureka-client</artifactId>
</dependency>
3.3.2 配置 application.yml

在 src/main/resources/application.yml 中添加 Eureka Client 配置:

server:
  port: 8081  # 用户服务运行的端口

spring:
  application:
    name: user-service  # 服务名称,Eureka 注册时的标识

eureka:
  client:
    service-url:
      defaultZone: http://localhost:8761/eureka/  # Eureka Server 的地址
3.3.3 修改启动类

在用户服务的启动类中添加 @EnableEurekaClient 注解:

package com.example.userservice;

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.cloud.netflix.eureka.EnableEurekaClient;

/**
 * User Service Application - 用户服务
 */
@SpringBootApplication
@EnableEurekaClient  // 启用 Eureka Client 功能
public class UserServiceApplication {

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

3.3.4 验证注册
  1. 启动 Eureka Server
  2. 启动 用户服务
  3. 在浏览器访问:http://localhost:8761
    • 你会看到 user-service 出现在 "Instances currently registered with Eureka" 列表中。

3.4 添加 API 网关

API 网关用于转发客户端请求到具体的微服务,并支持负载均衡。

3.4.1 创建 API 网关项目
  1. 打开 Spring Initializr
  2. 配置项目:
    • Project: Maven
    • Language: Java
    • Spring Boot: 3.0.0+
    • Dependencies:
      • Spring Cloud Gateway
      • Spring Cloud Eureka Discovery

3.4.2 配置 API 网关
1. 添加依赖

在 pom.xml 中确认以下依赖:

<dependency>
    <groupId>org.springframework.cloud</groupId>
    <artifactId>spring-cloud-starter-gateway</artifactId>
</dependency>
<dependency>
    <groupId>org.springframework.cloud</groupId>
    <artifactId>spring-cloud-starter-netflix-eureka-client</artifactId>
</dependency>
2. 配置 application.yml

在 src/main/resources/application.yml 中配置网关:

server:
  port: 8080  # API 网关运行的端口

spring:
  application:
    name: api-gateway  # 应用名称
  cloud:
    gateway:
      routes:
        - id: user-service  # 路由 ID
          uri: lb://user-service  # 用户服务(通过 Eureka 注册的服务名)
          predicates:
            - Path=/api/users/**  # 匹配以 /api/users 开头的请求

eureka:
  client:
    service-url:
      defaultZone: http://localhost:8761/eureka/  # Eureka Server 地址
3. 启动类

在 src/main/java/com/example/apigateway/ApiGatewayApplication.java 文件中添加 @EnableEurekaClient 注解。

package com.example.apigateway;

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.cloud.netflix.eureka.EnableEurekaClient;

/**
 * API Gateway Application - 网关服务
 */
@SpringBootApplication
@EnableEurekaClient  // 启用 Eureka Client 功能
public class ApiGatewayApplication {

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

3.4.3 验证 API 网关
  1. 启动 Eureka Server
  2. 启动 用户服务
  3. 启动 API 网关
  4. 测试 API:
    curl http://localhost:8080/api/users/john_doe
    
    • API 网关会将请求转发到用户服务,返回用户数据。

4. 部署到K8S

4.1 容器化服务 (Docker)

在项目根目录下创建 Dockerfile

FROM openjdk:17-jdk-slim
COPY target/user-service-0.0.1-SNAPSHOT.jar user-service.jar
ENTRYPOINT ["java", "-jar", "/user-service.jar"]

4.2 构建Docker镜像

  1. 打包项目

    mvn clean package -DskipTests
    
  2. 构建镜像

    docker build -t user-service:1.0 .
    
  3. 运行容器

    docker run -d -p 8081:8081 user-service:1.0

4.3 部署到 Kubernetes

创建 user-service-deployment.yml
apiVersion: apps/v1
kind: Deployment
metadata:
  name: user-service
spec:
  replicas: 3
  selector:
    matchLabels:
      app: user-service
  template:
    metadata:
      labels:
        app: user-service
    spec:
      containers:
        - name: user-service
          image: user-service:1.0
          ports:
            - containerPort: 8081
---
apiVersion: v1
kind: Service
metadata:
  name: user-service
spec:
  selector:
    app: user-service
  ports:
    - protocol: TCP
      port: 80
      targetPort: 8081
  type: LoadBalancer


4.4 部署到 K8s 集群

  1. 应用配置

    kubectl apply -f user-service-deployment.yml
    
  2. 查看服务

    kubectl get services

二、产品服务 (Product Service) 和订单服务 (Order Service)的实现

        每个服务有自己的数据库,提供REST API,并实现服务注册和发现,确保服务之间的解耦和可扩展性。

1. 产品服务 (Product Service)

功能:管理商品信息,包括商品的添加、修改和查询。

1.1 数据库准备

我们使用 MongoDB 来存储商品数据。

  • 创建数据库和集合
use product_service;
db.createCollection("products");
1.2 创建 Spring Boot 项目

生成项目Spring Initializr
依赖:

  • Spring Web
  • Spring Data MongoDB
1.3 实现产品服务
application.yml 配置文件

配置MongoDB连接:

server:
  port: 8082

spring:
  data:
    mongodb:
      uri: mongodb://localhost:27017/product_service
Product 实体类
package com.example.productservice.model;

import org.springframework.data.annotation.Id;
import org.springframework.data.mongodb.core.mapping.Document;

/**
 * 在MongoDB中表示产品文档的产品实体类。
 */
@Document(collection = "products")
public class Product {

    @Id
    private String id;  // 商品ID,由MongoDB生成

    private String name;  // 商品名称
    private String description;  // 商品描述
    private double price;  // 商品价格
    private int stock;  // 商品库存

    // Getters and Setters
    public String getId() {
        return id;
    }

    public void setId(String id) {
        this.id = id;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public String getDescription() {
        return description;
    }

    public void setDescription(String description) {
        this.description = description;
    }

    public double getPrice() {
        return price;
    }

    public void setPrice(double price) {
        this.price = price;
    }

    public int getStock() {
        return stock;
    }

    public void setStock(int stock) {
        this.stock = stock;
    }
}

ProductRepository 接口

package com.example.productservice.repository;

import com.example.productservice.model.Product;
import org.springframework.data.mongodb.repository.MongoRepository;
import org.springframework.stereotype.Repository;

/**
 * 用于在Product实体上执行CRUD操作的存储库接口。
 */
@Repository
public interface ProductRepository extends MongoRepository<Product, String> {
    Product findByName(String name);  // 根据商品名称查询商品
}
ProductService 服务层
package com.example.productservice.service;

import com.example.productservice.model.Product;
import com.example.productservice.repository.ProductRepository;
import org.springframework.stereotype.Service;

import java.util.Optional;

/**
 * 管理产品的服务类。包含产品相关操作的业务逻辑。
 */
@Service
public class ProductService {

    private final ProductRepository productRepository;

    public ProductService(ProductRepository productRepository) {
        this.productRepository = productRepository;
    }

    /**
     * 添加新产品。
     * 
     * @param product 包含产品详细信息的产品对象。
     * @return Saved 带生成ID的产品对象
     */
    public Product addProduct(Product product) {
        return productRepository.save(product);
    }

    /**
     * 按名称查找产品。
     * 
     * @param name 产品名称。
     * @return 含有找到的产品,如果没有找到则为空。
     */
    public Optional<Product> findProductByName(String name) {
        return Optional.ofNullable(productRepository.findByName(name));
    }

    /**
     * 按指定数量减少库存。
     * 
     * @param productId 产品ID。
     * @param quantity 数量减少。
     * @return 更新了Product对象。
     */
    public Product decreaseStock(String productId, int quantity) {
        Product product = productRepository.findById(productId).orElseThrow(() -> new RuntimeException("Product not found"));
        if (product.getStock() >= quantity) {
            product.setStock(product.getStock() - quantity);
            return productRepository.save(product);
        } else {
            throw new RuntimeException("Insufficient stock");
        }
    }
}

ProductController 控制器

package com.example.productservice.controller;

import com.example.productservice.model.Product;
import com.example.productservice.service.ProductService;
import org.springframework.http.ResponseEntity;
import org.springframework.web.bind.annotation.*;

/**
 * 与产品相关的端点的REST控制器。
 */
@RestController
@RequestMapping("/api/products")
public class ProductController {

    private final ProductService productService;

    public ProductController(ProductService productService) {
        this.productService = productService;
    }

    /**
     * 添加新产品的端点。
     * 
     * @param product 请求体中的产品对象。
     * @return 包含已保存产品的responseentity。
     */
    @PostMapping
    public ResponseEntity<Product> addProduct(@RequestBody Product product) {
        return ResponseEntity.ok(productService.addProduct(product));
    }

    /**
     * 根据名称查找产品的端点。
     * 
     * @param name 产品名称作为路径变量传递。
     * @return 包含产品,如果找到。
     */
    @GetMapping("/{name}")
    public ResponseEntity<Product> findProductByName(@PathVariable String name) {
        return productService.findProductByName(name)
                .map(ResponseEntity::ok)
                .orElse(ResponseEntity.notFound().build());
    }

    /**
     * 减少产品库存的终点。
     * 
     * @param productId 产品ID。
     * @param quantity 数量减少。
     * @return 包含更新后的产品。
     */
    @PutMapping("/{productId}/decrease-stock/{quantity}")
    public ResponseEntity<Product> decreaseStock(@PathVariable String productId, @PathVariable int quantity) {
        return ResponseEntity.ok(productService.decreaseStock(productId, quantity));
    }
}
1.4 测试产品服务

启动服务后:

  1. 添加商品

    curl -X POST -H "Content-Type: application/json" \
    -d '{"name": "Laptop", "description": "High-performance laptop", "price": 1000, "stock": 50}' \
    http://localhost:8082/api/products
    

    响应

    {
        "id": "605c72ef1532072a20b0f119",
        "name": "Laptop",
        "description": "High-performance laptop",
        "price": 1000,
        "stock": 50
    }
    
  2. 查询商品

    curl http://localhost:8082/api/products/Laptop
    

    响应

    {
        "id": "605c72ef1532072a20b0f119",
        "name": "Laptop",
        "description": "High-performance laptop",
        "price": 1000,
        "stock": 50
    }
    

2. 订单服务 (Order Service)

功能:管理用户的订单,包括创建订单、查询订单、更新订单状态等。

2.1 数据库准备

我们使用 MySQL 来存储订单数据。

  • 创建数据库和表
CREATE DATABASE order_service;
CREATE TABLE orders (
    id INT AUTO_INCREMENT PRIMARY KEY,
    user_id INT NOT NULL,
    product_id VARCHAR(255) NOT NULL,
    quantity INT NOT NULL,
    total_price DOUBLE NOT NULL,
    order_status VARCHAR(255) DEFAULT 'PENDING',
    created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP
);
2.2 创建 Spring Boot 项目

生成项目Spring Initializr
依赖:

  • Spring Web
  • Spring Data JPA
  • MySQL Driver
2.3 实现订单服务
application.yml 配置文件

配置MySQL连接:

server:
  port: 8083

spring:
  datasource:
    url: jdbc:mysql://localhost:3306/order_service
    username: root
    password: root
  jpa:
    hibernate:
      ddl-auto: update
    show-sql: true
Order 实体类
package com.example.orderservice.model;

import jakarta.persistence.*;
import java.time.LocalDateTime;

/**
 * 表示数据库中的订单表的订单实体类。
 */
@Entity
@Table(name = "orders")
public class Order {

    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    private Long id;

    @Column(nullable = false)
    private Long userId;  // 用户ID

    @Column(nullable = false)
    private String productId;  // 商品ID

    @Column(nullable = false)
    private int quantity;  // 购买数量

    @Column(nullable = false)
    private double totalPrice;  // 总金额

    @Column(name = "order_status", nullable = false)
    private String orderStatus = "PENDING";  // 订单状态

    @Column(name = "created_at", updatable = false
)
    private LocalDateTime createdAt = LocalDateTime.now();  // 订单创建时间

    // Getters and Setters
}

OrderRepository 接口

package com.example.orderservice.repository;

import com.example.orderservice.model.Order;
import org.springframework.data.jpa.repository.JpaRepository;
import org.springframework.stereotype.Repository;

/**
 * 用于在Order实体上执行CRUD操作的存储库接口。
 */
@Repository
public interface OrderRepository extends JpaRepository<Order, Long> {
    Order findByUserIdAndOrderStatus(Long userId, String orderStatus);  // 根据用户ID和订单状态查询订单
}
OrderService 服务层
package com.example.orderservice.service;

import com.example.orderservice.model.Order;
import com.example.orderservice.repository.OrderRepository;
import org.springframework.stereotype.Service;

import java.util.Optional;

/**
 * 用于管理订单的服务类。包含订单相关操作的业务逻辑。
 */
@Service
public class OrderService {

    private final OrderRepository orderRepository;

    public OrderService(OrderRepository orderRepository) {
        this.orderRepository = orderRepository;
    }

    /**
     * 创建一个新订单。
     * 
     * @param order 包含订单详细信息的订单对象。
     * @return 保存订单对象。
     */
    public Order createOrder(Order order) {
        return orderRepository.save(order);
    }

    /**
     * 通过用户ID和状态查找订单。
     * 
     * @param userId 用户ID。
     * @param orderStatus 订单状态(例如,‘PENDING’)。
     * @return 可选,包含找到的订单,如果没有找到则为空。
     */
    public Optional<Order> findOrderByUserIdAndStatus(Long userId, String orderStatus) {
        return Optional.ofNullable(orderRepository.findByUserIdAndOrderStatus(userId, orderStatus));
    }
}
OrderController 控制器
package com.example.orderservice.controller;

import com.example.orderservice.model.Order;
import com.example.orderservice.service.OrderService;
import org.springframework.http.ResponseEntity;
import org.springframework.web.bind.annotation.*;

/**
 * 与订单相关的端点的REST控制器。
 */
@RestController
@RequestMapping("/api/orders")
public class OrderController {

    private final OrderService orderService;

    public OrderController(OrderService orderService) {
        this.orderService = orderService;
    }

    /**
     * 创建新订单的端点。
     * 
     * @param order 从请求体中订购对象。
     * @return ResponseEntity包含保存的订单。
     */
    @PostMapping
    public ResponseEntity<Order> createOrder(@RequestBody Order order) {
        return ResponseEntity.ok(orderService.createOrder(order));
    }

    /**
     * 根据用户ID和状态查找订单的端点。
     * 
     * @param userId 用户ID。
     * @param orderStatus 订单状态作为路径变量传递。
     * @return ResponseEntity包含找到的订单,如果存在。
     */
    @GetMapping("/{userId}/{orderStatus}")
    public ResponseEntity<Order> findOrderByUserIdAndStatus(@PathVariable Long userId, @PathVariable String orderStatus) {
        return orderService.findOrderByUserIdAndStatus(userId, orderStatus)
                .map(ResponseEntity::ok)
                .orElse(ResponseEntity.notFound().build());
    }
}

总结

        在这个扩展中,我们设计了三个服务:用户服务,产品服务订单服务。每个服务具有自己的数据库,提供REST API,能够完成各自的功能,如商品管理、订单创建与查询。服务之间通过HTTP协议相互通信,服务之间通过微服务架构进行解耦,确保系统可扩展和维护。