完整微服务设计功能实现

我们将以一个简单的电商系统为例，实现微服务架构，逐步用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 测试用户服务

启动服务后：

注册用户：

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"
}

查询用户：

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 什么是服务注册与发现？

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

服务注册与发现原理：

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

配置步骤包括：

创建 Eureka Server。
将用户服务注册到 Eureka。
添加 API 网关。

3.2 创建 Eureka Server

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

3.2.1 生成 Eureka Server 项目

打开 Spring Initializr。
配置项目：
- Project: Maven
- Language: Java
- Spring Boot: 3.0.0+
- Dependencies:
  - Spring Cloud Eureka Server
下载生成的项目并解压。

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

使用 IDE 或命令行运行 EurekaServerApplication。
打开浏览器访问：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 验证注册

启动 Eureka Server。
启动 用户服务。
在浏览器访问：http://localhost:8761
- 你会看到 user-service 出现在 "Instances currently registered with Eureka" 列表中。

3.4 添加 API 网关

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

3.4.1 创建 API 网关项目

打开 Spring Initializr。
配置项目：
- 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 网关

启动 Eureka Server。
启动 用户服务。
启动 API 网关。
测试 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镜像：

打包项目：
```
mvn clean package -DskipTests
```
构建镜像：
```
docker build -t user-service:1.0 .
```

运行容器：

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 集群

应用配置：

kubectl apply -f user-service-deployment.yml

查看服务：
```
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 测试产品服务

启动服务后：

添加商品：

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
}

查询商品：

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());
    }
}