java

Spring Cloud 微服务全栈实践

Spring Cloud Alibaba 全栈微服务实战指南：Nacos 服务注册与配置中心、Gateway 网关、OpenFeign 声明式调用、Sentinel 熔断限流、Seata 分布式事务、Sleuth+Zipkin 链路追踪，到安全加固与 Docker Compose 部署的完整闭环。

Leeting Yan 2026-09-01 8 分钟阅读 3914 字

1. 微服务架构与 Spring Cloud Alibaba

1.1 微服务核心特征

微服务将单体拆分为围绕业务能力构建的小型自治服务，独立部署扩展：DDD 限界上下文拆分、独立 CI/CD、容错设计（熔断/限流/隔离）、基础设施自动化。

1.2 Spring Cloud vs Spring Cloud Alibaba

组件类型	Netflix 方案	Alibaba 方案	说明
注册中心	Eureka	Nacos Discovery	同时支持 CP/AP 模式
配置中心	Spring Cloud Config	Nacos Config	原生支持动态刷新与灰度发布
网关	Zuul（已停更）	Spring Cloud Gateway	基于 Reactor 的异步非阻塞网关
熔断限流	Hystrix（已停更）	Sentinel	支持流量塑形与热点参数限流
负载均衡	Ribbon	Spring Cloud LoadBalancer	新一代负载均衡器
分布式事务	无原生方案	Seata	AT/TCC/SAGA/XA 四种模式

本文示例系统包含 product-service（8081）、order-service（8082）、gateway-service（8080）三个服务。

2. Nacos 服务注册发现

2.1 启动 Nacos

# 单节点快速启动
docker run -d --name nacos \
  -e MODE=standalone \
  -p 8848:8848 -p 9848:9848 \
  nacos/nacos-server:v2.2.3

2.2 添加依赖

父工程统一管理版本：

<dependencyManagement>
    <dependencies>
        <dependency>
            <groupId>com.alibaba.cloud</groupId>
            <artifactId>spring-cloud-alibaba-dependencies</artifactId>
            <version>2022.0.0.0</version>
            <type>pom</type>
            <scope>import</scope>
        </dependency>
    </dependencies>
</dependencyManagement>

<!-- 子工程引入 -->
<dependency>
    <groupId>com.alibaba.cloud</groupId>
    <artifactId>spring-cloud-starter-alibaba-nacos-discovery</artifactId>
</dependency>

2.3 配置与启动

spring:
  application:
    name: product-service
  cloud:
    nacos:
      discovery:
        server-addr: 127.0.0.1:8848
server:
  port: 8081

启动类：

package com.example.product;

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

/** 商品服务启动类 */
@EnableDiscoveryClient
@SpringBootApplication
public class ProductServiceApplication {
    public static void main(String[] args) {
        SpringApplication.run(ProductServiceApplication.class, args);
        System.out.println("=== 商品服务已启动，注册到 Nacos ===");
    }
}

2.4 商品接口

package com.example.product.controller;

import org.springframework.web.bind.annotation.*;
import java.math.BigDecimal;
import java.util.HashMap;
import java.util.Map;

/** 商品控制器 */
@RestController
@RequestMapping("/product")
public class ProductController {

    @GetMapping("/{id}")
    public Map<String, Object> getById(@PathVariable Long id) {
        Map<String, Object> product = new HashMap<>();
        product.put("id", id);
        product.put("name", "iPhone 16 Pro");
        product.put("price", new BigDecimal("8999.00"));
        product.put("stock", 100);
        return product;
    }

    @PostMapping("/deductStock")
    public String deductStock(@RequestParam Long productId, @RequestParam Integer quantity) {
        System.out.println("扣减库存: productId=" + productId + ", quantity=" + quantity);
        return "库存扣减成功";
    }
}

3. Nacos Config 配置中心

3.1 添加依赖

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

3.2 bootstrap.yml

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

3.3 Nacos 中创建配置

Data ID：order-service-dev.yaml
Group：DEFAULT_GROUP
格式：YAML

order:
  timeout-minutes: 30
  max-concurrent-orders: 100
  email-notification-enabled: true

3.4 配置类与热刷新

package com.example.order.config;

import org.springframework.boot.context.properties.ConfigurationProperties;
import org.springframework.cloud.context.config.annotation.RefreshScope;
import org.springframework.stereotype.Component;

/**
 * 订单配置属性类
 * @RefreshScope 开启配置热更新
 */
@Component
@RefreshScope
@ConfigurationProperties(prefix = "order")
public class OrderProperties {

    /** 订单超时时间（分钟） */
    private Integer timeoutMinutes = 15;

    /** 最大允许并发下单数 */
    private Integer maxConcurrentOrders = 50;

    /** 是否开启邮件通知 */
    private Boolean emailNotificationEnabled = false;

    public Integer getTimeoutMinutes() { return timeoutMinutes; }
    public void setTimeoutMinutes(Integer v) { this.timeoutMinutes = v; }
    public Integer getMaxConcurrentOrders() { return maxConcurrentOrders; }
    public void setMaxConcurrentOrders(Integer v) { this.maxConcurrentOrders = v; }
    public Boolean getEmailNotificationEnabled() { return emailNotificationEnabled; }
    public void setEmailNotificationEnabled(Boolean v) { this.emailNotificationEnabled = v; }
}

配置变更监听（精简版）：

@Component
public class NacosConfigListener {
    @Autowired
    private NacosConfigManager manager;

    @PostConstruct
    public void init() throws Exception {
        manager.getConfigService().addListener(
            "order-service-dev.yaml", "DEFAULT_GROUP",
            new Listener() {
                @Override public java.util.concurrent.Executor getExecutor() { return null; }
                @Override public void receiveConfigInfo(String config) {
                    System.out.println("配置已更新: " + config);
                }
            }
        );
    }
}

4. Spring Cloud Gateway 路由与过滤器

4.1 添加依赖

<dependency>
    <groupId>org.springframework.cloud</groupId>
    <artifactId>spring-cloud-starter-gateway</artifactId>
</dependency>
<dependency>
    <groupId>com.alibaba.cloud</groupId>
    <artifactId>spring-cloud-starter-alibaba-nacos-discovery</artifactId>
</dependency>

4.2 网关路由配置

server:
  port: 8080

spring:
  application:
    name: gateway-service
  cloud:
    nacos:
      discovery:
        server-addr: 127.0.0.1:8848
    gateway:
      routes:
        - id: product-service-route
          uri: lb://product-service
          predicates:
            - Path=/product/**
          filters:
            - StripPrefix=1
        - id: order-service-route
          uri: lb://order-service
          predicates:
            - Path=/order/**
          filters:
            - StripPrefix=1

4.3 全局 JWT 鉴权过滤器

package com.example.gateway.filter;

import org.springframework.cloud.gateway.filter.GatewayFilterChain;
import org.springframework.cloud.gateway.filter.GlobalFilter;
import org.springframework.core.Ordered;
import org.springframework.http.HttpStatus;
import org.springframework.http.server.reactive.ServerHttpRequest;
import org.springframework.http.server.reactive.ServerHttpResponse;
import org.springframework.stereotype.Component;
import org.springframework.web.server.ServerWebExchange;
import reactor.core.publisher.Mono;

/**
 * 全局 JWT 鉴权过滤器
 */
@Component
public class AuthGlobalFilter implements GlobalFilter, Ordered {

    @Override
    public Mono<Void> filter(ServerWebExchange exchange, GatewayFilterChain chain) {
        ServerHttpRequest request = exchange.getRequest();
        String path = request.getURI().getPath();

        if (path.startsWith("/user/login") || path.startsWith("/user/register")) {
            return chain.filter(exchange);
        }
        String token = request.getHeaders().getFirst("Authorization");
        if (token == null || !token.startsWith("Bearer ")) {
            ServerHttpResponse response = exchange.getResponse();
            response.setStatusCode(HttpStatus.UNAUTHORIZED);
            return response.setComplete();
        }
        String jwt = token.substring(7);
        if (jwt.length() <= 10) {
            ServerHttpResponse response = exchange.getResponse();
            response.setStatusCode(HttpStatus.FORBIDDEN);
            return response.setComplete();
        }
        // 透传用户信息给下游服务
        ServerHttpRequest mutatedRequest = request.mutate()
            .header("X-User-Id", "10001")
            .header("X-User-Role", "USER")
            .build();
        return chain.filter(exchange.mutate().request(mutatedRequest).build());
    }

    @Override
    public int getOrder() { return -1; }
}

5. OpenFeign 声明式客户端

5.1 添加依赖

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

5.2 启动类

package com.example.order;

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

/**
 * 订单服务启动类
 */
@EnableFeignClients(basePackages = "com.example.order.feign")
@EnableDiscoveryClient
@SpringBootApplication
public class OrderServiceApplication {
    public static void main(String[] args) {
        SpringApplication.run(OrderServiceApplication.class, args);
    }
}

5.3 Feign 客户端与降级

package com.example.order.feign;

import org.springframework.cloud.openfeign.FeignClient;
import org.springframework.web.bind.annotation.*;
import java.util.Map;

/**
 * 商品服务 Feign 客户端
 */
@FeignClient(name = "product-service", fallback = ProductServiceFallback.class)
public interface ProductServiceClient {

    @GetMapping("/product/{id}")
    Map<String, Object> getProductById(@PathVariable("id") Long id);

    @PostMapping("/product/deductStock")
    String deductStock(@RequestParam("productId") Long productId,
                       @RequestParam("quantity") Integer quantity);
}

降级处理类：

package com.example.order.feign;

import org.springframework.stereotype.Component;
import java.util.HashMap;
import java.util.Map;

/** 商品服务降级处理类 */
@Component
public class ProductServiceFallback implements ProductServiceClient {
    @Override
    public Map<String, Object> getProductById(Long id) {
        Map<String, Object> fallback = new HashMap<>();
        fallback.put("id", id);
        fallback.put("name", "默认商品（服务暂不可用）");
        return fallback;
    }
    @Override
    public String deductStock(Long productId, Integer quantity) {
        return "库存扣减失败，请稍后重试";
    }
}

5.4 Feign 配置

package com.example.order.feign;

import feign.Logger;
import feign.RequestInterceptor;
import feign.RequestTemplate;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;

/**
 * Feign 全局配置
 */
@Configuration
public class FeignConfig {
    @Bean
    Logger.Level feignLoggerLevel() {
        return Logger.Level.FULL;
    }

    @Bean
    public RequestInterceptor requestInterceptor() {
        return template -> template.header("X-Request-From", "order-service");
    }
}

5.5 订单服务调用商品服务

package com.example.order.controller;

import com.example.order.feign.ProductServiceClient;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.*;
import java.util.Map;

/**
 * 订单控制器
 */
@RestController
@RequestMapping("/order")
public class OrderController {
    @Autowired
    private ProductServiceClient productServiceClient;

    @PostMapping("/create")
    public String createOrder(@RequestParam Long productId, @RequestParam Integer quantity) {
        Map<String, Object> product = productServiceClient.getProductById(productId);
        String result = productServiceClient.deductStock(productId, quantity);
        return "订单创建成功，商品: " + product.get("name");
    }
}

6. Sentinel 熔断限流

6.1 添加依赖与配置

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

spring:
  cloud:
    sentinel:
      transport:
        dashboard: 127.0.0.1:8858
      eager: true
      datasource:
        flow:
          nacos:
            server-addr: ${spring.cloud.nacos.discovery.server-addr}
            dataId: ${spring.application.name}-flow-rules
            groupId: SENTINEL_GROUP
            rule-type: flow

6.2 注解方式定义流控

package com.example.order.service;

import com.alibaba.csp.sentinel.annotation.SentinelResource;
import com.alibaba.csp.sentinel.slots.block.BlockException;
import org.springframework.stereotype.Service;

/**
 * 订单业务服务
 */
@Service
public class OrderService {

    @SentinelResource(value = "createOrder",
        blockHandler = "createOrderBlockHandler",
        fallback = "createOrderFallback")
    public String createOrder(Long productId, Integer quantity) {
        if (quantity > 10) throw new RuntimeException("单笔订单数量不能超过 10");
        return "订单创建成功: productId=" + productId + ", quantity=" + quantity;
    }

    public String createOrderBlockHandler(Long productId, Integer quantity, BlockException ex) {
        return "系统繁忙，请稍后再试 (被 Sentinel 限流)";
    }

    public String createOrderFallback(Long productId, Integer quantity, Throwable ex) {
        return "订单创建失败: " + ex.getMessage();
    }
}

6.3 Sentinel 规则字段说明

在 Nacos 中持久化规则 order-service-flow-rules：

[
  {
    "resource": "createOrder",
    "limitApp": "default",
    "grade": 1,
    "count": 100,
    "strategy": 0,
    "controlBehavior": 0,
    "clusterMode": false
  }
]

字段	含义	可选值
`grade`	阈值类型	`1`=QPS, `0`=并发线程数
`count`	阈值	QPS 上限或并发线程数上限
`strategy`	流控模式	`0`=直接, `1`=关联, `2`=链路
`controlBehavior`	流控效果	`0`=快速失败, `1`=Warm Up, `2`=匀速排队

7. Seata 分布式事务（AT 模式）

7.1 AT 模式原理

Seata AT 模式基于 Undo Log 实现自动回滚：

一阶段：业务 SQL 直接提交，记录更新前后的镜像到 undo_log 表
二阶段（成功）：异步清理 undo_log
二阶段（回滚）：用 before_image 生成反向 SQL 回滚数据

7.2 Seata 服务端启动

docker run -d --name seata-server \
  -e SEATA_PORT=8091 \
  -e STORE_MODE=db \
  -p 8091:8091 -p 7091:7091 \
  seataio/seata-server:1.7.1

7.3 配置 Seata 客户端

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

seata:
  enabled: true
  application-id: ${spring.application.name}
  tx-service-group: my_tx_group
  registry:
    type: nacos
    nacos:
      server-addr: 127.0.0.1:8848
      group: SEATA_GROUP
  config:
    type: nacos
    nacos:
      server-addr: 127.0.0.1:8848
      group: SEATA_GROUP

7.4 全局事务使用

package com.example.order.service;

import com.example.order.feign.ProductServiceClient;
import com.example.order.feign.UserServiceClient;
import io.seata.spring.annotation.GlobalTransactional;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;

/**
 * 订单业务服务（含分布式事务）
 */
@Service
public class OrderServiceTx {
    @Autowired
    private ProductServiceClient productServiceClient;
    @Autowired
    private UserServiceClient userServiceClient;

    @GlobalTransactional(name = "create-order-tx", rollbackFor = Exception.class)
    public String createOrderWithTx(Long userId, Long productId, Integer quantity, Long totalAmount) {
        System.out.println("[Seata] 一阶段：创建订单记录");
        productServiceClient.deductStock(productId, quantity);
        userServiceClient.deductBalance(userId, totalAmount);
        if (quantity > 100) {
            throw new RuntimeException("库存不足，触发全局回滚");
        }
        return "订单创建成功（全局事务已提交）";
    }
}

7.5 undo_log 表结构

每个参与事务的数据库必须创建此表：

CREATE TABLE IF NOT EXISTS `undo_log` (
  `branch_id`     BIGINT       NOT NULL COMMENT '分支事务 ID',
  `xid`           VARCHAR(128) NOT NULL COMMENT '全局事务 ID',
  `context`       VARCHAR(128) NOT NULL COMMENT '上下文',
  `rollback_info` LONGBLOB     NOT NULL COMMENT '回滚信息（before_image / after_image）',
  `log_status`    INT          NOT NULL COMMENT '0=正常，1=防御性清理',
  `log_created`   DATETIME(6)  NOT NULL COMMENT '创建时间',
  `log_modified`  DATETIME(6)  NOT NULL COMMENT '修改时间',
  UNIQUE KEY `ux_undo_log` (`xid`, `branch_id`)
) ENGINE = InnoDB DEFAULT CHARSET = utf8mb4 COMMENT ='AT 模式回滚日志表';

8. 链路追踪 Sleuth + Zipkin

8.1 添加依赖与配置

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

spring:
  sleuth:
    enabled: true
    sampler:
      probability: 1.0
  zipkin:
    base-url: http://127.0.0.1:9411

启动 Zipkin：

docker run -d --name zipkin -p 9411:9411 openzipkin/zipkin:latest

8.2 自定义链路信息

@Service
public class TracedOrderService {
    @Autowired
    private Tracer tracer;

    public String processOrder(Long orderId) {
        Span currentSpan = tracer.currentSpan();
        currentSpan.tag("order.id", String.valueOf(orderId));
        currentSpan.annotate("订单处理开始");

        Span childSpan = tracer.nextSpan().name("save-order-to-db").start();
        try (Tracer.SpanInScope ws = tracer.withSpanInScope(childSpan)) {
            childSpan.tag("db.table", "t_order");
        } finally {
            childSpan.finish();
        }
        currentSpan.annotate("订单处理完成");
        return "订单处理成功";
    }
}

8.3 日志中打印 Trace ID

logback-spring.xml：

<?xml version="1.0" encoding="UTF-8"?>
<configuration>
    <appender name="CONSOLE" class="ch.qos.logback.core.ConsoleAppender">
        <encoder>
            <pattern>%d{yyyy-MM-dd HH:mm:ss.SSS} [%thread] %-5level [%X{traceId:-},%X{spanId:-}] %logger{36} - %msg%n</pattern>
        </encoder>
    </appender>
    <root level="INFO">
        <appender-ref ref="CONSOLE"/>
    </root>
</configuration>

日志输出示例：

2026-09-01 14:23:45.123 [http-nio-8082-exec-1] INFO  [a1b2c3d4e5f6,a1b2c3d4e5f6] c.e.o.c.OrderController - 接收到订单创建请求
2026-09-01 14:23:45.345 [http-nio-8081-exec-3] INFO  [a1b2c3d4e5f6,3a4b5c6d7e8f] c.e.p.c.ProductController - 收到商品查询请求

9. 微服务安全

9.1 JWT 过滤器

package com.example.product.config;

import jakarta.servlet.FilterChain;
import jakarta.servlet.ServletException;
import jakarta.servlet.http.HttpServletRequest;
import jakarta.servlet.http.HttpServletResponse;
import org.springframework.web.filter.OncePerRequestFilter;
import java.io.IOException;

/**
 * JWT 认证过滤器
 * 从请求头解析网关透传的用户信息
 */
public class JwtAuthenticationFilter extends OncePerRequestFilter {

    @Override
    protected void doFilterInternal(HttpServletRequest request,
                                    HttpServletResponse response,
                                    FilterChain filterChain) throws ServletException, IOException {
        String userId = request.getHeader("X-User-Id");
        String userRole = request.getHeader("X-User-Role");

        if (userId != null) {
            System.out.println("当前用户 ID: " + userId + ", 角色: " + userRole);
        }

        filterChain.doFilter(request, response);
    }
}

9.2 Spring Security 配置

package com.example.product.config;

import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.security.config.annotation.web.builders.HttpSecurity;
import org.springframework.security.config.annotation.web.configuration.EnableWebSecurity;
import org.springframework.security.config.http.SessionCreationPolicy;
import org.springframework.security.web.SecurityFilterChain;
import org.springframework.security.web.authentication.UsernamePasswordAuthenticationFilter;

/**
 * 服务内安全配置
 */
@Configuration
@EnableWebSecurity
public class SecurityConfig {

    @Bean
    public SecurityFilterChain filterChain(HttpSecurity http) throws Exception {
        http
            .csrf(csrf -> csrf.disable())
            .sessionManagement(session ->
                session.sessionCreationPolicy(SessionCreationPolicy.STATELESS))
            .authorizeHttpRequests(auth -> auth
                .requestMatchers("/product/public/**").permitAll()
                .anyRequest().authenticated()
            )
            .addFilterBefore(new JwtAuthenticationFilter(),
                UsernamePasswordAuthenticationFilter.class);
        return http.build();
    }
}

10. Docker Compose 部署

10.1 docker-compose.yml

version: '3.8'

services:
  mysql:
    image: mysql:8.0.34
    container_name: mysql
    environment:
      MYSQL_ROOT_PASSWORD: root
      MYSQL_DATABASE: nacos
    ports:
      - "3306:3306"

  nacos:
    image: nacos/nacos-server:v2.2.3
    container_name: nacos
    environment:
      MODE: standalone
      SPRING_DATASOURCE_PLATFORM: mysql
      MYSQL_SERVICE_HOST: mysql
      MYSQL_SERVICE_DB_NAME: nacos
      MYSQL_SERVICE_PORT: 3306
      MYSQL_SERVICE_USER: root
      MYSQL_SERVICE_PASSWORD: root
    ports:
      - "8848:8848"
      - "9848:9848"
    depends_on:
      - mysql

  zipkin:
    image: openzipkin/zipkin:latest
    container_name: zipkin
    ports:
      - "9411:9411"

  seata-server:
    image: seataio/seata-server:1.7.1
    container_name: seata-server
    ports:
      - "8091:8091"
      - "7091:7091"
    environment:
      SEATA_PORT: 8091
      STORE_MODE: db
    depends_on:
      - mysql
      - nacos

  gateway-service:
    build: ./gateway-service
    container_name: gateway-service
    ports:
      - "8080:8080"
    environment:
      - SPRING_CLOUD_NACOS_DISCOVERY_SERVER_ADDR=nacos:8848
    depends_on:
      - nacos

  product-service:
    build: ./product-service
    container_name: product-service
    ports:
      - "8081:8081"
    environment:
      - SPRING_CLOUD_NACOS_DISCOVERY_SERVER_ADDR=nacos:8848
      - SEATA_REGISTRY_NACOS_SERVER_ADDR=nacos:8848
    depends_on:
      - nacos
      - mysql
      - seata-server

  order-service:
    build: ./order-service
    container_name: order-service
    ports:
      - "8082:8082"
    environment:
      - SPRING_CLOUD_NACOS_DISCOVERY_SERVER_ADDR=nacos:8848
      - SPRING_CLOUD_NACOS_CONFIG_SERVER_ADDR=nacos:8848
      - SEATA_REGISTRY_NACOS_SERVER_ADDR=nacos:8848
      - SPRING_ZIPKIN_BASE_URL=http://zipkin:9411
    depends_on:
      - nacos
      - mysql
      - seata-server
      - zipkin

10.2 服务 Dockerfile

# 构建阶段
FROM eclipse-temurin:17-jdk-alpine AS builder
WORKDIR /app
COPY . .
RUN ./mvnw clean package -DskipTests

# 运行阶段
FROM eclipse-temurin:17-jre-alpine
WORKDIR /app
COPY --from=builder /app/target/order-service-*.jar app.jar

HEALTHCHECK --interval=30s --timeout=3s --start-period=60s --retries=3 \
  CMD wget --no-verbose --tries=1 --spider http://localhost:8082/actuator/health || exit 1

ENV JAVA_OPTS="-XX:+UseContainerSupport -XX:MaxRAMPercentage=75.0"
EXPOSE 8082
ENTRYPOINT ["sh", "-c", "java $JAVA_OPTS -jar app.jar"]

常见问题 FAQ

Q1：Spring Cloud Alibaba 与 Spring Cloud Netflix 有什么区别？

Netflix 组件（Eureka、Hystrix、Zuul）已进入维护模式。Spring Cloud Alibaba 是当前推荐替代方案：Nacos 替代 Eureka + Config，Sentinel 替代 Hystrix，Gateway 替代 Zuul，LoadBalancer 替代 Ribbon。Alibaba 组件在国内社区更活跃，中文文档也更完善。

Q2：Nacos 配置更新后 Bean 为什么没有热刷新？

需满足三个条件：配置类添加 @RefreshScope；配置值通过 @Value 或 @ConfigurationProperties 注入，不能硬编码；Data ID 必须严格遵循 ${spring.application.name}-${profile}.${file-extension} 命名规范。缺少任一条件都不会触发热刷新。

Q3：Seata AT 模式在什么场景下不合适？

AT 模式依赖 undo_log 和全局锁，限制包括：不支持非关系型数据库、不支持无主键表、不支持多表复杂关联更新、全局锁会降低并发性能。超高并发场景或需精确控制回滚逻辑时，建议改用 TCC 或 SAGA 模式。

Q4：Gateway 的性能瓶颈通常在哪里？

Gateway 本身基于 Netty 性能优异，但以下因素会成为瓶颈：过滤链过于复杂（尤其包含同步阻塞操作）、缺少连接池导致后端服务连接数耗尽、Redis RequestRateLimiter 在高 QPS 下产生大量连接。优化策略：精简过滤器、配置连接池、将限流下移到 Sentinel。

Q5：微服务拆分到什么程度比较合适？

拆分没有固定标准。拆分过细会导致服务数量爆炸、运维复杂度上升、分布式事务增多；拆分过粗则无法享受独立部署和扩展优势。经验法则：以业务能力（Bounded Context）为边界，确保单个服务可在两周内由 2-5 人团队独立重写。初期适度粗粒度，随业务发展逐步细化。

总结

本文系统介绍了基于 Spring Cloud Alibaba 的全栈微服务架构实践，覆盖 Nacos（服务注册发现 + 配置中心）、Gateway（路由网关）、OpenFeign（声明式调用）、Sentinel（熔断限流）、Seata AT（分布式事务）、Sleuth + Zipkin（链路追踪）、安全加固和 Docker Compose 部署的完整技术栈。

微服务架构的本质是通过技术手段解决组织协作和系统演进的复杂度问题。实践中不应盲目堆砌技术栈，而应根据团队规模、业务特点和技术成熟度选择合适组件。Spring Cloud Alibaba 提供了国内最成熟的企业级微服务解决方案，值得在生产环境中深入使用。

继续阅读

探索更多技术文章

浏览归档，发现更多关于系统设计、工具链和工程实践的内容。

全部文章返回首页