当前位置：首页 > article >正文

国内主流的Spring微服务方案指南

article 2025/1/14 23:26:31

构建一个完整的 Spring 微服务方案涉及多个关键组件的集成与配置，包括服务注册与发现、配置管理、API 网关、负载均衡、服务调用、熔断与限流、消息中间件、分布式追踪、服务网格、容器编排以及数据库与缓存等。以下将结合前述内容，详细介绍一个完整的中国国内主流的 Spring 微服务架构方案，涵盖各个核心部分的选择、配置和集成方法，帮助你系统地学习和构建微服务架构。

架构概述
核心组件与功能
- 服务注册与发现：Nacos
- 配置管理：Nacos 配置中心
- API 网关：Spring Cloud Gateway + Sentinel
- 负载均衡：Spring Cloud LoadBalancer + Nacos
- 服务调用：OpenFeign 和 RestTemplate
- 熔断与限流：Sentinel
- 消息中间件：RocketMQ
- 分布式追踪：SkyWalking
- 服务网格：Istio
- 容器编排：Kubernetes（阿里云 ACK）
- 数据库与缓存：MyBatis + Redis
项目结构与示例
详细配置与代码示例
- 1. 服务注册与发现配置（Nacos）
- 2. 配置管理配置（Nacos 配置中心）
- 3. API 网关配置（Spring Cloud Gateway + Sentinel）
- 4. 负载均衡配置（Spring Cloud LoadBalancer + Nacos）
- 5. 服务调用配置（OpenFeign 和 RestTemplate）
- 6. 熔断与限流配置（Sentinel）
- 7. 消息中间件配置（RocketMQ）
- 8. 分布式追踪配置（SkyWalking）
- 9. 服务网格配置（Istio）
- 10. 容器编排配置（Kubernetes）
- 11. 数据库与缓存配置（MyBatis + Redis）
部署与运行
最佳实践与优化
结语

架构概述

一个完整的 Spring 微服务架构通常包含以下几个层次：

客户端层：如前端应用或移动端，通过 API 网关与后端服务交互。
API 网关：统一入口，负责路由、负载均衡、安全、限流等功能。
微服务层：由多个独立的微服务组成，每个服务负责特定的业务功能。
基础设施层：包括服务注册与发现、配置管理、消息中间件、数据库、缓存、监控与追踪等。

核心组件与功能

服务注册与发现：Nacos

Nacos（Naming and Configuration Service）是阿里巴巴开源的一个动态服务发现、配置管理和服务管理平台。它支持 DNS 和 RPC 两种服务发现模式，提供丰富的管理控制台和 API，广泛应用于微服务架构中。

主要功能：

服务注册与发现：支持多种服务发现模式，动态管理服务实例。
健康检查：自动检测服务实例的健康状态，剔除不健康的实例。
动态配置管理：集中化管理配置文件，支持灰度发布和多环境配置。
服务治理：支持分组、权重等高级功能，便于实现复杂的服务治理策略。

配置管理：Nacos 配置中心

Nacos 配置中心作为 Nacos 的一部分，提供了集中化的配置管理能力，支持动态配置更新、灰度发布和多环境配置管理，简化了微服务的配置管理流程。

主要功能：

动态配置：支持实时推送配置变更，无需重启服务。
配置分组与版本管理：便于管理不同环境和版本的配置。
配置加密：确保敏感配置的安全性。
配置灰度发布：逐步发布配置变更，降低风险。

API 网关：Spring Cloud Gateway + Sentinel

Spring Cloud Gateway 是 Spring 官方的 API 网关解决方案，负责处理所有进入微服务的请求，提供路由、过滤、限流等功能。

Sentinel 是阿里巴巴开源的流量控制组件，集成到 API 网关中，可以提供更强大的熔断、降级和限流能力。

主要功能：

路由转发：将客户端请求路由到对应的微服务。
过滤器：对请求进行预处理或后处理，如鉴权、日志记录等。
限流与熔断：基于 Sentinel 实现的高级流量控制策略。
统一安全控制：实现统一的认证与授权机制。

负载均衡：Spring Cloud LoadBalancer + Nacos

Spring Cloud LoadBalancer 是 Spring 官方推荐的客户端负载均衡解决方案，替代已弃用的 Ribbon。结合 Nacos 进行服务发现，可以实现动态的负载均衡策略。

主要功能：

多种负载均衡策略：轮询、随机、权重等。
与 Nacos 集成：实时感知服务实例的变化，动态调整负载均衡策略。
可扩展性：支持自定义负载均衡策略，满足特定业务需求。

服务调用：OpenFeign 和 RestTemplate

在微服务架构中，服务调用是各个服务之间通信的关键。Spring 提供了多种服务调用方式，OpenFeign 和 RestTemplate 是其中最常用的两种。

主要特点：

OpenFeign：
- 声明式调用：通过接口和注解定义服务调用，代码简洁易读。
- 集成负载均衡：与 Spring Cloud LoadBalancer 无缝集成，支持动态负载均衡。
- 可扩展性强：支持自定义拦截器、编码器、解码器等。
RestTemplate：
- 灵活性高：适用于各种复杂的 HTTP 请求场景。
- 广泛支持：支持多种 HTTP 方法和请求类型。
- 可扩展性：支持自定义拦截器、消息转换器等。

熔断与限流：Sentinel

Sentinel 提供了强大的熔断、降级、限流和系统负载保护等功能，确保系统在高并发或异常情况下的稳定性。

主要功能：

熔断机制：防止故障传播，保护下游服务。
限流控制：限制请求的并发数或 QPS，避免过载。
降级策略：在服务不可用时提供备用响应。
系统自适应保护：根据系统负载自动调整流量控制策略。

消息中间件：RocketMQ

RocketMQ 是阿里巴巴开源的分布式消息中间件，具有高吞吐量、低延迟和高可靠性，适用于异步通信和事件驱动架构。

主要功能：

高性能：支持大规模的消息传输和处理。
事务消息：保证消息的可靠性和一致性。
多种消息模式：支持发布/订阅、点对点等模式。
分布式集群：支持多节点部署，提升系统的可用性。

分布式追踪：SkyWalking

SkyWalking 是 Apache 开源的分布式追踪和性能监控工具，支持微服务架构下的链路追踪、性能监控和告警。

主要功能：

链路追踪：跟踪请求在各个微服务中的调用链路。
性能监控：实时监控各个服务的性能指标。
告警机制：基于自定义规则的告警，及时发现问题。
可视化分析：提供丰富的图表和仪表盘，便于分析系统状态。

服务网格：Istio

Istio 是一个开源的服务网格平台，提供流量管理、服务安全和可观察性等功能。它与 Kubernetes 深度集成，适用于复杂的微服务架构。

主要功能：

流量管理：细粒度的流量路由、分流和故障注入。
安全性：服务间的身份认证、授权和加密通信。
可观察性：丰富的监控、日志和追踪功能。
策略控制：基于策略的流量控制和资源管理。

容器编排：Kubernetes（阿里云 ACK）

Kubernetes 是容器编排的事实标准，负责自动化部署、扩展和管理容器化应用。阿里云容器服务（ACK） 是基于 Kubernetes 的托管服务，提供高可用性和自动化管理，适合企业级应用。

主要功能：

自动化部署：简化应用的部署和更新过程。
弹性伸缩：根据负载自动调整服务实例数量。
自愈能力：自动重启失败的容器，确保服务的高可用性。
服务发现与负载均衡：内置的服务发现和负载均衡机制。

数据库与缓存：MyBatis + Redis

MyBatis 是一个优秀的持久层框架，简化了数据库操作，支持动态 SQL 和缓存机制。
Redis 是一个高性能的内存缓存数据库，常用于缓存热点数据，提升系统的响应速度和并发处理能力。

主要功能：

MyBatis：
- 简化数据库操作，支持自定义 SQL、存储过程和高级映射。
- 提供缓存机制，减少数据库访问次数。
Redis：
- 提供多种数据结构，如字符串、哈希、列表、集合等，满足不同的缓存需求。
- 支持持久化和高可用部署，确保数据的安全性和可靠性。
- 与 Spring Cache 结合，简化缓存管理。

项目结构与示例

一个典型的 Spring 微服务项目结构如下：

spring-microservices-demo/
├── api-gateway/
│   ├── src/
│   │   └── main/
│   │       ├── java/com/example/apigateway/
│   │       └── resources/
│   │           └── application.yml
│   └── pom.xml
├── service-user/
│   ├── src/
│   │   └── main/
│   │       ├── java/com/example/serviceuser/
│   │       └── resources/
│   │           └── application.yml
│   └── pom.xml
├── service-order/
│   ├── src/
│   │   └── main/
│   │       ├── java/com/example/serviceorder/
│   │       │   ├── config/
│   │       │   ├── controller/
│   │       │   ├── feign/
│   │       │   ├── service/
│   │       │   └── model/
│   │       └── resources/
│   │           └── application.yml
│   └── pom.xml
├── service-product/
│   ├── src/
│   │   └── main/
│   │       ├── java/com/example/serviceproduct/
│   │       └── resources/
│   │           └── application.yml
│   └── pom.xml
├── common/
│   ├── src/
│   │   └── main/
│   │       ├── java/com/example/common/
│   │       └── resources/
│   └── pom.xml
├── config/
│   ├── src/
│   │   └── main/
│   │       ├── java/com/example/config/
│   │       └── resources/
│   │           └── application.yml
│   └── pom.xml
├── docker/
│   └── Dockerfile
├── kubernetes/
│   ├── deployment.yaml
│   └── service.yaml
└── README.md

说明：

api-gateway：API 网关服务，负责路由、负载均衡、安全控制等。
service-user、service-order、service-product：具体的业务微服务，每个服务负责不同的业务模块。
common：公共模块，如通用工具类、常量定义等。
config：配置中心服务，统一管理各个微服务的配置。
docker：Docker 配置文件，用于容器化部署。
kubernetes：Kubernetes 部署文件，用于在 Kubernetes 集群中部署服务。

详细配置与代码示例

下面将逐步介绍各个核心组件的配置和集成方法，以 service-order 调用 service-user 为例，展示完整的集成流程。

1. 服务注册与发现配置（Nacos）

1.1. 添加依赖

在每个微服务的 pom.xml 中添加以下依赖：

<dependencies>
    <!-- Spring Boot Starter -->
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter</artifactId>
    </dependency>

    <!-- Spring Cloud Alibaba Nacos Discovery -->
    <dependency>
        <groupId>com.alibaba.cloud</groupId>
        <artifactId>spring-cloud-starter-alibaba-nacos-discovery</artifactId>
        <version>2023.x.x</version>
    </dependency>

    <!-- Spring Cloud Starter LoadBalancer -->
    <dependency>
        <groupId>org.springframework.cloud</groupId>
        <artifactId>spring-cloud-starter-loadbalancer</artifactId>
    </dependency>

    <!-- Spring Cloud OpenFeign -->
    <dependency>
        <groupId>org.springframework.cloud</groupId>
        <artifactId>spring-cloud-starter-openfeign</artifactId>
    </dependency>

    <!-- Sentinel -->
    <dependency>
        <groupId>com.alibaba.cloud</groupId>
        <artifactId>spring-cloud-starter-alibaba-sentinel</artifactId>
        <version>2023.x.x</version>
    </dependency>

    <!-- RocketMQ -->
    <dependency>
        <groupId>org.apache.rocketmq</groupId>
        <artifactId>rocketmq-spring-boot-starter</artifactId>
        <version>2.2.0</version>
    </dependency>

    <!-- MyBatis -->
    <dependency>
        <groupId>org.mybatis.spring.boot</groupId>
        <artifactId>mybatis-spring-boot-starter</artifactId>
        <version>2.2.0</version>
    </dependency>

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

    <!-- SkyWalking -->
    <dependency>
        <groupId>org.apache.skywalking</groupId>
        <artifactId>apm-toolkit-logback-1.x</artifactId>
        <version>8.x.x</version>
    </dependency>

    <!-- 其他依赖 -->
</dependencies>

确保与其他 Spring Cloud 依赖版本兼容，具体版本号可参考 Spring Cloud Alibaba 的官方文档。

1.2. 配置文件

在每个微服务的 application.yml 中配置 Nacos：

spring:
  application:
    name: service-user # 对于其他服务，替换为相应的服务名
  cloud:
    nacos:
      discovery:
        server-addr: nacos-server:8848
      config:
        server-addr: nacos-server:8848

# 配置日志级别（可选）
logging:
  level:
    com.alibaba.cloud.nacos.discovery: DEBUG

1.3. 启动类

在每个微服务的启动类上添加 @EnableDiscoveryClient 注解：

package com.example.serviceuser;

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

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

2. 配置管理（Nacos 配置中心）

2.1. 添加依赖

在 config 模块的 pom.xml 中添加：

<dependencies>
    <dependency>
        <groupId>com.alibaba.cloud</groupId>
        <artifactId>spring-cloud-starter-alibaba-nacos-config</artifactId>
        <version>2023.x.x</version>
    </dependency>
    <!-- 其他依赖 -->
</dependencies>

2.2. 配置文件

在 config 模块的 application.yml 中配置 Nacos 配置中心：

spring:
  application:
    name: config
  cloud:
    nacos:
      config:
        server-addr: nacos-server:8848
        file-extension: yaml

2.3. 配置数据

在 Nacos 控制台中创建配置，例如 service-user.yaml：

server:
  port: 8081

spring:
  datasource:
    url: jdbc:mysql://mysql:3306/user_db
    username: root
    password: password
    driver-class-name: com.mysql.cj.jdbc.Driver
  redis:
    host: redis-server
    port: 6379
    password: your-redis-password
    jedis:
      pool:
        max-active: 10
        max-idle: 5
        min-idle: 1
        max-wait: -1ms

mybatis:
  mapper-locations: classpath:/mappers/*.xml
  type-aliases-package: com.example.serviceuser.model

# SkyWalking 配置
skywalking:
  agent:
    service_name: service-user
    namespace: default
    collector_backend_service: skywalking-collector:11800

2.4. 使用配置

在微服务中通过 @Value 或 @ConfigurationProperties 使用配置：

package com.example.serviceuser.config;

import org.springframework.boot.context.properties.ConfigurationProperties;
import org.springframework.context.annotation.Configuration;

@Configuration
@ConfigurationProperties(prefix = "spring.datasource")
public class DataSourceConfig {
    private String url;
    private String username;
    private String password;
    private String driverClassName;

    // Getters and Setters
}

3. API 网关配置（Spring Cloud Gateway + Sentinel）

3.1. 添加依赖

在 api-gateway 模块的 pom.xml 中添加：

<dependencies>
    <!-- Spring Cloud Gateway -->
    <dependency>
        <groupId>org.springframework.cloud</groupId>
        <artifactId>spring-cloud-starter-gateway</artifactId>
    </dependency>

    <!-- Sentinel -->
    <dependency>
        <groupId>com.alibaba.cloud</groupId>
        <artifactId>spring-cloud-starter-alibaba-sentinel</artifactId>
        <version>2023.x.x</version>
    </dependency>

    <!-- Nacos Discovery -->
    <dependency>
        <groupId>com.alibaba.cloud</groupId>
        <artifactId>spring-cloud-starter-alibaba-nacos-discovery</artifactId>
        <version>2023.x.x</version>
    </dependency>

    <!-- 其他依赖 -->
</dependencies>

3.2. 配置文件

在 api-gateway 的 application.yml 中配置 Spring Cloud Gateway 和 Sentinel：

server:
  port: 8080

spring:
  application:
    name: api-gateway
  cloud:
    nacos:
      discovery:
        server-addr: nacos-server:8848
      config:
        server-addr: nacos-server:8848
    gateway:
      routes:
        - id: service-user
          uri: lb://service-user
          predicates:
            - Path=/user/**
          filters:
            - StripPrefix=1
        - id: service-order
          uri: lb://service-order
          predicates:
            - Path=/order/**
          filters:
            - StripPrefix=1
    sentinel:
      transport:
        dashboard: localhost:8080
      eager: true

logging:
  level:
    com.alibaba.csp.sentinel: DEBUG

3.3. 启动类

在 api-gateway 的启动类上添加 @EnableDiscoveryClient 和 @EnableGateway 注解：

package com.example.apigateway;

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

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

3.4. Sentinel 控制台配置

Sentinel 控制台通常集成在 API 网关中，便于集中管理。启动 API 网关后，通过访问 http://localhost:8080/sentinel 可以进入 Sentinel 控制台。

4. 负载均衡配置（Spring Cloud LoadBalancer + Nacos）

4.1. 添加依赖

在需要进行客户端负载均衡的微服务（如 service-order）中，确保已经包含 spring-cloud-starter-loadbalancer 依赖：

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

4.2. 配置文件

在 service-order 的 application.yml 中禁用 Ribbon 并启用 LoadBalancer：

spring:
  cloud:
    loadbalancer:
      ribbon:
        enabled: false

4.3. 示例代码

定义 RestTemplate Bean

在 service-order 中创建 RestTemplateConfig 类：

package com.example.serviceorder.config;

import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.web.client.RestTemplate;
import org.springframework.cloud.client.loadbalancer.LoadBalanced;

@Configuration
public class RestTemplateConfig {

    @Bean
    @LoadBalanced
    public RestTemplate restTemplate() {
        return new RestTemplate();
    }
}

使用 RestTemplate 调用服务

在 service-order 的业务服务类中使用 RestTemplate：

package com.example.serviceorder.service;

import com.example.serviceorder.model.Order;
import com.example.serviceorder.model.User;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import org.springframework.web.client.RestTemplate;

@Service
public class OrderService {

    @Autowired
    private RestTemplate restTemplate;

    public Order createOrder(Long userId, OrderDetails details) {
        String url = "http://service-user/user/" + userId;
        User user = restTemplate.getForObject(url, User.class);
        // 创建订单逻辑
        Order order = new Order();
        order.setUserId(user.getId());
        order.setUserName(user.getName());
        // 其他订单信息
        return order;
    }
}

5. 服务调用配置（OpenFeign 和 RestTemplate）

5.1. OpenFeign 配置

5.1.1. 添加依赖

在 service-order 的 pom.xml 中已添加 spring-cloud-starter-openfeign 依赖。

5.1.2. 启用 Feign 客户端

在 ServiceOrderApplication 启动类中添加 @EnableFeignClients 注解：

package com.example.serviceorder;

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.cloud.client.discovery.EnableDiscoveryClient;
import org.springframework.cloud.openfeign.EnableFeignClients;
import org.springframework.cache.annotation.EnableCaching;

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

5.1.3. 定义 Feign 客户端接口

创建 UserServiceFeignClient 接口：

package com.example.serviceorder.feign;

import com.example.serviceorder.model.User;
import org.springframework.cloud.openfeign.FeignClient;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.PathVariable;

@FeignClient(name = "service-user", fallback = UserServiceFeignClientFallback.class)
public interface UserServiceFeignClient {

    @GetMapping("/user/{id}")
    User getUserById(@PathVariable("id") Long id);
}

5.1.4. 实现降级逻辑

创建 UserServiceFeignClientFallback 类：

package com.example.serviceorder.feign;

import com.example.serviceorder.model.User;
import org.springframework.stereotype.Component;

@Component
public class UserServiceFeignClientFallback implements UserServiceFeignClient {

    @Override
    public User getUserById(Long id) {
        // 返回默认用户或处理降级逻辑
        return new User(id, "Default User", "default@example.com");
    }
}

5.1.5. 使用 Feign 客户端

在 OrderService 中注入并使用 Feign 客户端：

package com.example.serviceorder.service;

import com.example.serviceorder.feign.UserServiceFeignClient;
import com.example.serviceorder.model.Order;
import com.example.serviceorder.model.User;
import com.example.serviceorder.model.OrderDetails;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import com.alibaba.csp.sentinel.annotation.SentinelResource;

@Service
public class OrderService {

    @Autowired
    private UserServiceFeignClient userServiceFeignClient;

    @SentinelResource(value = "createOrder", fallback = "createOrderFallback")
    public Order createOrder(Long userId, OrderDetails details) {
        User user = userServiceFeignClient.getUserById(userId);
        // 创建订单逻辑
        Order order = new Order();
        order.setUserId(user.getId());
        order.setUserName(user.getName());
        // 其他订单信息
        return order;
    }

    public Order createOrderFallback(Long userId, OrderDetails details, Throwable throwable) {
        // 返回默认订单或处理降级逻辑
        return new Order();
    }
}

5.2. RestTemplate 配置

5.2.1. 添加依赖

确保 service-order 的 pom.xml 中包含 spring-cloud-starter-loadbalancer 依赖。

5.2.2. 配置 RestTemplate Bean

在 service-order 中创建 RestTemplateConfig 类（已在第4步中介绍）。

5.2.3. 使用 RestTemplate 调用服务

在 OrderService 中使用 RestTemplate（已在第4步中介绍）。

5.2.4. 增加熔断与降级

结合 Sentinel 实现熔断与降级（已在第5.1.5步和第5.2.4步中介绍）。

6. 熔断与限流配置（Sentinel）

6.1. 添加依赖

在所有需要使用 Sentinel 的微服务中，确保已添加 spring-cloud-starter-alibaba-sentinel 依赖。

6.2. 配置文件

在各个微服务的 application.yml 中配置 Sentinel：

spring:
  cloud:
    sentinel:
      transport:
        dashboard: localhost:8080 # Sentinel 控制台地址
      eager: true

6.3. 使用 Sentinel 注解

在业务方法上使用 @SentinelResource：

package com.example.serviceorder.service;

import com.example.serviceorder.feign.UserServiceFeignClient;
import com.example.serviceorder.model.Order;
import com.example.serviceorder.model.User;
import com.example.serviceorder.model.OrderDetails;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import com.alibaba.csp.sentinel.annotation.SentinelResource;

@Service
public class OrderService {

    @Autowired
    private UserServiceFeignClient userServiceFeignClient;

    @SentinelResource(value = "createOrder", fallback = "createOrderFallback")
    public Order createOrder(Long userId, OrderDetails details) {
        User user = userServiceFeignClient.getUserById(userId);
        // 创建订单逻辑
        Order order = new Order();
        order.setUserId(user.getId());
        order.setUserName(user.getName());
        // 其他订单信息
        return order;
    }

    public Order createOrderFallback(Long userId, OrderDetails details, Throwable throwable) {
        // 返回默认订单或处理降级逻辑
        return new Order();
    }
}

6.4. 配置 Sentinel 规则

通过 Sentinel 控制台（通常集成在 API 网关中）配置流量控制、熔断降级等规则。

7. 消息中间件配置（RocketMQ）

7.1. 添加依赖

在需要使用 RocketMQ 的微服务中添加 RocketMQ 依赖（已在第1步中介绍）。

7.2. 配置文件

在微服务的 application.yml 中配置 RocketMQ：

spring:
  rocketmq:
    name-server: rocketmq-server:9876
    producer:
      group: my-producer-group
    consumer:
      group: my-consumer-group
      topic: order-topic

7.3. 发送消息

在 service-order 中创建消息发送逻辑：

package com.example.serviceorder.service;

import com.example.serviceorder.model.Order;
import org.apache.rocketmq.spring.core.RocketMQTemplate;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;

@Service
public class OrderService {

    @Autowired
    private RocketMQTemplate rocketMQTemplate;

    public void createOrder(Order order) {
        // 订单创建逻辑
        rocketMQTemplate.convertAndSend("order-topic", order);
    }
}

7.4. 接收消息

在 service-product 中创建消息接收逻辑：

package com.example.serviceproduct.listener;

import com.example.serviceproduct.model.Order;
import org.apache.rocketmq.spring.annotation.RocketMQMessageListener;
import org.apache.rocketmq.spring.core.RocketMQListener;
import org.springframework.stereotype.Component;

@Component
@RocketMQMessageListener(topic = "order-topic", consumerGroup = "order-consumer-group")
public class OrderListener implements RocketMQListener<Order> {

    @Override
    public void onMessage(Order order) {
        // 处理订单消息
    }
}

8. 分布式追踪配置（SkyWalking）

8.1. 添加依赖

在每个微服务中添加 SkyWalking 依赖（已在第1步中介绍）。

8.2. 配置文件

在每个微服务的 application.yml 中配置 SkyWalking：

skywalking:
  agent:
    service_name: service-user # 对应的服务名
    namespace: default
    collector_backend_service: skywalking-collector:11800

8.3. 启动 SkyWalking Agent

在运行微服务时，添加 SkyWalking Agent 参数：

-javaagent:/path/to/skywalking-agent.jar

例如，在 Dockerfile 中配置：

FROM openjdk:11-jdk

ARG JAR_FILE=target/*.jar

COPY ${JAR_FILE} app.jar

COPY skywalking-agent /skywalking-agent

ENTRYPOINT ["java", "-javaagent:/skywalking-agent/skywalking-agent.jar", "-jar", "/app.jar"]

9. 服务网格配置（Istio）

9.1. 安装 Istio

在 Kubernetes 集群中安装 Istio，可以使用 Istio 官方提供的安装方式或通过 KubeSphere 集成。以下是使用 Istio 官方安装的示例：

curl -L https://istio.io/downloadIstio | sh -
cd istio-1.x.x
export PATH=$PWD/bin:$PATH
istioctl install --set profile=demo -y

9.2. 配置命名空间自动注入 Envoy 代理

为微服务所在的命名空间启用 Istio 注入：

kubectl label namespace default istio-injection=enabled

9.3. 定义 VirtualService 和 DestinationRule

例如，配置 service-user 的流量路由：

apiVersion: networking.istio.io/v1alpha3
kind: VirtualService
metadata:
  name: service-user
spec:
  hosts:
    - service-user
  http:
    - route:
        - destination:
            host: service-user
            subset: v1
          weight: 80
        - destination:
            host: service-user
            subset: v2
          weight: 20
---
apiVersion: networking.istio.io/v1alpha3
kind: DestinationRule
metadata:
  name: service-user
spec:
  host: service-user
  subsets:
    - name: v1
      labels:
        version: v1
    - name: v2
      labels:
        version: v2

10. 容器编排配置（Kubernetes）

10.1. 编写部署文件

以 service-user 为例，编写 Kubernetes 部署文件 deployment.yaml：

apiVersion: apps/v1
kind: Deployment
metadata:
  name: service-user
spec:
  replicas: 3
  selector:
    matchLabels:
      app: service-user
      version: v1
  template:
    metadata:
      labels:
        app: service-user
        version: v1
    spec:
      containers:
        - name: service-user
          image: your-repo/service-user:latest
          ports:
            - containerPort: 8081
          env:
            - name: SPRING_PROFILES_ACTIVE
              value: "prod"
          resources:
            requests:
              memory: "512Mi"
              cpu: "500m"
            limits:
              memory: "1Gi"
              cpu: "1"
          readinessProbe:
            httpGet:
              path: /actuator/health
              port: 8081
            initialDelaySeconds: 10
            periodSeconds: 5
          livenessProbe:
            httpGet:
              path: /actuator/health
              port: 8081
            initialDelaySeconds: 15
            periodSeconds: 20

10.2. 服务暴露

编写 service.yaml：

apiVersion: v1
kind: Service
metadata:
  name: service-user
spec:
  selector:
    app: service-user
  ports:
    - protocol: TCP
      port: 80
      targetPort: 8081
  type: ClusterIP

10.3. 部署到 Kubernetes

在 Kubernetes 集群中应用部署文件：

kubectl apply -f kubernetes/deployment.yaml
kubectl apply -f kubernetes/service.yaml

11. 数据库与缓存配置（MyBatis + Redis）

11.1. 添加依赖

在微服务的 pom.xml 中添加：

<dependencies>
    <!-- MyBatis Spring Boot Starter -->
    <dependency>
        <groupId>org.mybatis.spring.boot</groupId>
        <artifactId>mybatis-spring-boot-starter</artifactId>
        <version>2.2.0</version>
    </dependency>

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

    <!-- Spring Boot Starter Cache -->
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-cache</artifactId>
    </dependency>

    <!-- 其他依赖 -->
</dependencies>

11.2. 配置文件

在 application.yml 中配置数据库和 Redis：

spring:
  datasource:
    url: jdbc:mysql://mysql:3306/user_db
    username: root
    password: password
    driver-class-name: com.mysql.cj.jdbc.Driver
  redis:
    host: redis-server
    port: 6379
    password: your-redis-password
    jedis:
      pool:
        max-active: 10
        max-idle: 5
        min-idle: 1
        max-wait: -1ms
  cache:
    type: redis

mybatis:
  mapper-locations: classpath:/mappers/*.xml
  type-aliases-package: com.example.serviceuser.model

11.3. MyBatis 配置

创建 MyBatis Mapper 接口和 XML 文件，例如 UserMapper.java：

package com.example.serviceuser.mapper;

import com.example.serviceuser.model.User;
import org.apache.ibatis.annotations.Mapper;
import org.apache.ibatis.annotations.Select;
import org.apache.ibatis.annotations.Insert;
import org.apache.ibatis.annotations.Update;

@Mapper
public interface UserMapper {
    @Select("SELECT * FROM users WHERE id = #{id}")
    User selectUserById(Long id);

    @Insert("INSERT INTO users (name, email) VALUES (#{name}, #{email})")
    void insertUser(User user);

    @Update("UPDATE users SET name = #{name}, email = #{email} WHERE id = #{id}")
    void updateUser(User user);
}

对应的 UserMapper.xml（如果使用 XML 配置）：

<?xml version="1.0" encoding="UTF-8" ?>
<!DOCTYPE mapper
  PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN"
  "http://mybatis.org/dtd/mybatis-3-mapper.dtd">

<mapper namespace="com.example.serviceuser.mapper.UserMapper">
    <select id="selectUserById" parameterType="Long" resultType="com.example.serviceuser.model.User">
        SELECT * FROM users WHERE id = #{id}
    </select>

    <insert id="insertUser" parameterType="com.example.serviceuser.model.User">
        INSERT INTO users (name, email) VALUES (#{name}, #{email})
    </insert>

    <update id="updateUser" parameterType="com.example.serviceuser.model.User">
        UPDATE users SET name = #{name}, email = #{email} WHERE id = #{id}
    </update>
</mapper>

11.4. Redis 缓存使用

启用缓存

在启动类上添加 @EnableCaching 注解（已在之前步骤中介绍）。

使用缓存注解

在服务类中使用缓存注解：

package com.example.serviceuser.service;

import com.example.serviceuser.mapper.UserMapper;
import com.example.serviceuser.model.User;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.cache.annotation.Cacheable;
import org.springframework.cache.annotation.CacheEvict;
import org.springframework.stereotype.Service;

@Service
public class UserService {

    @Autowired
    private UserMapper userMapper;

    @Cacheable(value = "users", key = "#id")
    public User getUserById(Long id) {
        return userMapper.selectUserById(id);
    }

    @CacheEvict(value = "users", key = "#user.id")
    public void updateUser(User user) {
        userMapper.updateUser(user);
    }

    @CacheEvict(value = "users", key = "#user.id")
    public void createUser(User user) {
        userMapper.insertUser(user);
    }
}

部署与运行

1. 搭建基础设施

Nacos：
- 部署 Nacos 服务注册与发现组件。
- 参考 Nacos 官方文档进行部署。
RocketMQ：
- 部署 RocketMQ 消息中间件。
- 参考 RocketMQ 官方文档进行部署。
Redis：
- 部署 Redis 缓存。
- 可使用 Helm Chart 或 Docker 容器部署。
SkyWalking：
- 部署 SkyWalking 监控系统。
- 参考 SkyWalking 官方文档进行部署。
Istio：
- 安装 Istio 服务网格。
- 参考前述步骤进行安装。
Kubernetes 集群（阿里云 ACK）：
- 创建并配置阿里云容器服务（ACK）集群。
- 参考阿里云 ACK 官方文档进行部署。

2. 构建与发布微服务

2.1. 构建 Docker 镜像

在每个微服务项目中创建 Dockerfile：

FROM openjdk:11-jdk

ARG JAR_FILE=target/*.jar

COPY ${JAR_FILE} app.jar

COPY skywalking-agent /skywalking-agent

ENTRYPOINT ["java", "-javaagent:/skywalking-agent/skywalking-agent.jar", "-jar", "/app.jar"]

2.2. 构建 Docker 镜像

在项目根目录下执行：

docker build -t your-repo/service-user:latest ./service-user
docker build -t your-repo/service-order:latest ./service-order
docker build -t your-repo/service-product:latest ./service-product
docker build -t your-repo/api-gateway:latest ./api-gateway

2.3. 推送镜像到镜像仓库

将构建好的镜像推送到容器镜像仓库（如阿里云容器镜像服务）：

docker push your-repo/service-user:latest
docker push your-repo/service-order:latest
docker push your-repo/service-product:latest
docker push your-repo/api-gateway:latest

2.4. 部署到 Kubernetes

在 Kubernetes 集群中应用部署文件：

kubectl apply -f kubernetes/deployment.yaml
kubectl apply -f kubernetes/service.yaml

重复此步骤，部署所有微服务。

3. 配置 API 网关

确保 API 网关服务能够访问 Nacos、Sentinel 控制台等组件。通过 application.yml 配置正确的路由和 Sentinel 规则。

4. 监控与追踪

配置 SkyWalking Agent，确保微服务能够将追踪数据发送到 SkyWalking 服务器。在 SkyWalking 控制台中查看分布式追踪和性能指标。

5. 测试与验证

API 网关：通过 API 网关访问各个微服务，验证路由和负载均衡是否正常。
高并发场景：模拟高并发请求，验证 Sentinel 的限流和熔断效果。
消息中间件：通过发送和接收消息，确保 RocketMQ 的稳定性。
分布式追踪：在 SkyWalking 控制台中查看调用链路，验证追踪功能。

最佳实践与优化

1. 服务拆分

高内聚低耦合：根据业务功能将单体应用拆分为多个微服务，每个服务专注于特定业务。
避免过度拆分：保持适度的服务数量，避免管理复杂性过高。

2. 配置管理

集中管理：使用 Nacos 配置中心集中管理配置文件，确保配置的一致性和可维护性。
版本控制：利用配置版本和灰度发布功能，安全地更新配置。

3. 安全性

统一认证与授权：在 API 网关层实现统一的认证与授权机制，如 OAuth2。
服务间加密通信：使用 Istio 提供的服务间加密，确保数据传输的安全性。

4. 监控与报警

实时监控：通过 SkyWalking 实时监控服务的健康状态和性能指标。
合理报警：配置合理的报警策略，及时发现和处理系统异常。

5. 容器化与持续集成/持续部署（CI/CD）

Docker 容器化：使用 Docker 容器化微服务，确保环境一致性。
自动化部署：配置 CI/CD 流水线，自动化构建、测试和部署流程，提升开发效率。

6. 数据库设计与优化

独立数据库：为每个微服务设计独立的数据库，避免服务间的数据库耦合。
缓存策略：使用 MyBatis 的缓存机制，结合 Redis 提升数据访问性能。

7. 故障恢复

Kubernetes 自愈：利用 Kubernetes 的自愈能力，确保服务在故障时能够自动恢复。
Sentinel 熔断：使用 Sentinel 的熔断降级功能，防止故障蔓延。

8. 日志管理

统一日志收集：统一收集和管理各个微服务的日志，便于故障排查和性能分析。
日志管理工具：使用 ELK（Elasticsearch、Logstash、Kibana）或类似工具进行日志管理。

结语

构建一个完整的 Spring 微服务方案需要综合运用多个组件和工具，每个组件在系统中扮演着重要的角色。通过上述介绍，你可以系统地了解和搭建一个高效、稳定且易于维护的微服务架构。以下是一些学习和实践的建议：

逐步学习：不要试图一次性掌握所有组件，建议按照项目的需求逐步引入和学习每个组件。
实践项目：通过实际项目的搭建和迭代，深入理解各个组件的配置和使用方法。
关注社区：积极参与 Spring Cloud Alibaba、Nacos、Sentinel 等开源项目的社区，获取最新的资讯和最佳实践。
优化性能：在项目上线后，持续监控和优化系统的性能，确保系统的高可用性和高性能。

查看全文

http://www.kler.cn/a/502817.html

SpringCloud系列教程：微服务的未来（十一）服务注册、服务发现、OpenFeign快速入门

【华为云开发者学堂】基于华为云 CodeArts CCE 开发微服务电商平台

LiveNVR监控流媒体Onvif/RTSP常见问题-二次开发接口jquery调用示例如何解决JS|axios调用接口时遇到的跨域问题

重塑视频创作的格局！ComfyUI-Mochi本地部署教程

MongoDB如何使用

什么是MVCC

苹果电脑docker突然没有响应已解决

Java聊天小程序

CF 357A.Group of Students(Java实现)

Excel中双引号问题

【20250112】TRO论文：下肢外骨骼机器人的“触感透明度”与交互力实时控制新方法...

某香水制造企业组织分工项目纪实

uniapp中h5使用地图

【C语言】标准IO

Java爬虫能处理哪些反爬虫措施？

MySQL 如何实现可重复读？

HarmonyOS应用开发者初级认证最新版– 2025/1/13号题库新版

49_Lua调试

leetcode_1678. 设计 Goal 解析器

标准Android开发jdk和gradle和gradle AGP和AndroidStudio对应版本

基于Android的嵌入式车载导航系统(源码+lw+部署文档+讲解)，源码可白嫖!

串行总线详解 I2C（IIC）

从前端视角看设计模式之创建型模式篇

初识C++(二)

windows和linux的抓包方式

C# Winform：项目引入SunnyUI后，显示模糊