Spring Cloud Alibaba 微服务架构核心实战

3.2 项目结构设计

spring-cloud-alibaba-demo/
├── pom.xml # 父工程
├── gateway-service/ # 网关服务
├── user-service/ # 用户服务
├── order-service/ # 订单服务
├── product-service/ # 商品服务
├── common/ # 公共模块
│   ├── common-core/ # 核心工具类
│   ├── common-web/ # Web 配置
│   └── common-api/ # API 接口定义
└── docs/ # 文档目录

3.3 Nacos 环境搭建

Docker 快速部署：

# 单机模式启动 Nacos
docker run -d \
--name nacos-standalone \
-e MODE=standalone \
-e PREFER_HOST_MODE=hostname \
-p8848:8848 \
-p9848:9848 \
nacos/nacos-server:v2.3.0
# 访问控制台 http://localhost:8848/nacos 默认账号密码：nacos/nacos

服务注册配置：

# application.yml
spring:
  application:
    name: user-service
  cloud:
    nacos:
      discovery:
        server-addr: localhost:8848
        namespace: dev
        group: DEFAULT_GROUP
        metadata:
          version: 1.0.0
          region: cn-east

四、核心组件实战

4.1 服务发现与调用

在实际开发中，我们通常采用 OpenFeign 进行声明式调用，这样代码更简洁且易于维护。

服务提供者

@RestController
@RequestMapping("/api/users")
public class UserController {
    @Value("${server.port}")
    private String port;

    @GetMapping("/{id}")
    public Result<User> getUser(@PathVariable Long id) {
        User user = User.builder()
                .id(id)
                .name("张三")
                .email("[email protected]")
                .port(port)
                .build();
        return Result.success(user);
    }

    @PostMapping
    public Result<User> createUser(@RequestBody User user) {
        // 业务逻辑处理
        return Result.success(user);
    }
}

服务消费者

@Service
public class OrderService {
    @Autowired
    private RestTemplate restTemplate;
    @Autowired
    private FeignClientService feignClientService;

    // 方式一：RestTemplate 调用
    public User getUserByIdRestTemplate(Long userId) {
        String url = "http://user-service/api/users/" + userId;
        return restTemplate.getForObject(url, User.class);
    }

    // 方式二：OpenFeign 声明式调用（推荐）
    public User getUserByIdFeign(Long userId) {
        return feignClientService.getUser(userId);
    }
}

@FeignClient(name = "user-service", path = "/api/users", fallbackFactory = UserClientFallback.class)
public interface FeignClientService {
    @GetMapping("/{id}")
    User getUser(@PathVariable("id") Long id);

    @PostMapping
    User createUser(@RequestBody User user);
}

// 降级处理工厂
@Component
public class UserClientFallback implements FallbackFactory<FeignClientService> {
    @Override
    public FeignClientService create(Throwable cause) {
        return new FeignClientService() {
            @Override
            public User getUser(Long id) {
                log.error("调用用户服务失败，触发降级", cause);
                return User.getDefaultUser();
            }

            @Override
            public User createUser(User user) {
                throw new ServiceException("服务暂时不可用");
            }
        };
    }
}

4.2 Sentinel 流量防护

Sentinel 提供了丰富的流量控制功能，包括限流、熔断和热点参数限流。实际运行时，请求会先经过 Sentinel 检查，再执行业务逻辑。

限流规则配置

@Configuration
public class SentinelConfig {
    @PostConstruct
    public void initFlowRules() {
        List<FlowRule> rules = new ArrayList<>();
        
        // 订单创建接口限流：QPS = 50
        FlowRule orderRule = new FlowRule();
        orderRule.setResource("createOrder");
        orderRule.setGrade(RuleConstant.FLOW_GRADE_QPS);
        orderRule.setCount(50);
        orderRule.setStrategy(RuleConstant.STRATEGY_DIRECT);
        orderRule.setControlBehavior(RuleConstant.CONTROL_BEHAVIOR_DEFAULT);
        rules.add(orderRule);

        // 用户查询接口限流：线程数 = 20
        FlowRule userRule = new FlowRule();
        userRule.setResource("getUser");
        userRule.setGrade(RuleConstant.FLOW_GRADE_THREAD);
        userRule.setCount(20);
        rules.add(userRule);

        FlowRuleManager.loadRules(rules);
    }
}

代码式限流

@RestController
public class OrderController {
    @GetMapping("/orders/create")
    @SentinelResource(value = "createOrder", blockHandler = "handleBlock", fallback = "handleFallback")
    public Result<Order> createOrder(@RequestBody OrderRequest request) {
        // 业务逻辑
        Order order = orderService.create(request);
        return Result.success(order);
    }

    // 限流异常处理
    public Result<Order> handleBlock(OrderRequest request, BlockException ex) {
        return Result.error(429, "系统繁忙，请稍后再试");
    }

    // 业务异常降级
    public Result<Order> handleFallback(OrderRequest request, Throwable ex) {
        return Result.error(500, "订单创建失败");
    }
}

4.3 Seata 分布式事务

在分布式系统中，保证数据一致性是关键。Seata 支持 AT、TCC 和 Saga 等多种模式，其中 AT 模式因无侵入和自动回滚特性成为首选。

AT 模式实战

@Service
public class OrderServiceImpl implements OrderService {
    @Autowired
    private OrderMapper orderMapper;
    @Autowired
    private ProductClient productClient;
    @Autowired
    private AccountClient accountClient;

    // 全局事务：创建订单 + 扣减库存 + 扣减账户余额
    @GlobalTransactional(name = "create-order-tx", rollbackFor = Exception.class)
    @Override
    public void createOrder(Order order) {
        log.info("开始创建订单，全局事务 XID: {}", RootContext.getXID());
        
        // 1. 创建订单
        orderMapper.insert(order);
        log.info("订单创建成功：{}", order.getId());

        // 2. 扣减库存（远程调用）
        productClient.deductStock(order.getProductId(), order.getCount());
        log.info("库存扣减成功");

        // 3. 扣减账户余额（远程调用）
        accountClient.deductBalance(order.getUserId(), order.getAmount());
        log.info("余额扣减成功");
        log.info("全局事务执行成功");
    }
}

库存服务（分支事务）

@Service
public class ProductServiceImpl implements ProductService {
    @Autowired
    private ProductMapper productMapper;

    @Override
    public void deductStock(Long productId, Integer count) {
        log.info("库存分支事务，XID: {}", RootContext.getXID());
        
        // 查询产品
        Product product = productMapper.selectById(productId);
        if (product.getStock() < count) {
            throw new BusinessException("库存不足");
        }
        
        // 扣减库存（Seata 会自动记录 undo log）
        product.setStock(product.getStock() - count);
        productMapper.updateById(product);
        log.info("库存扣减完成：productId={}, count={}", productId, count);
    }
}

五、微服务治理最佳实践

5.1 配置管理

动态配置刷新

@RestController
@RefreshScope // 支持配置动态刷新
public class ConfigController {
    @Value("${app.feature.switch:false}")
    private Boolean featureSwitch;
    @Value("${app.max.order.amount:10000}")
    private Long maxOrderAmount;

    @GetMapping("/config")
    public Result<Map<String, Object>> getConfig() {
        Map<String, Object> config = new HashMap<>();
        config.put("featureSwitch", featureSwitch);
        config.put("maxOrderAmount", maxOrderAmount);
        return Result.success(config);
    }
}

配置优先级

本地配置文件 > Nacos 配置中心 (Data ID) > Nacos 命名空间 (Namespace) > Nacos 分组 (Group) > 环境变量。

5.2 灰度发布策略

基于流量比例、用户标签、请求头或 IP 地域的灰度发布策略能有效降低上线风险。

灰度发布实现

@Configuration
public class GrayReleaseConfig {
    @Bean
    public RuleBasedServiceInstanceSelector graySelector() {
        return new RuleBasedServiceInstanceSelector() {
            @Override
            public List<ServiceInstance> select(List<ServiceInstance> instances, HttpServletRequest request) {
                String version = request.getHeader("X-Service-Version");
                return instances.stream().filter(instance -> {
                    String metadataVersion = instance.getMetadata().get("version");
                    return version == null || version.equals(metadataVersion);
                }).collect(Collectors.toList());
            }
        };
    }
}

5.3 消息驱动架构

RocketMQ 事件驱动

通过 RocketMQ 实现订单创建后的异步解耦，通知服务、支付服务和库存服务可以独立消费事件。

消息生产者

@Service
public class OrderEventPublisher {
    @Autowired
    private RocketMQTemplate rocketMQTemplate;

    public void publishOrderCreatedEvent(Order order) {
        OrderCreatedEvent event = OrderCreatedEvent.builder()
                .orderId(order.getId())
                .userId(order.getUserId())
                .productId(order.getProductId())
                .amount(order.getAmount())
                .timestamp(System.currentTimeMillis())
                .build();
        
        // 同步发送（重要业务）
        rocketMQTemplate.syncSend("order-created-topic", event);
        
        // 异步发送（非重要业务）
        rocketMQTemplate.asyncSend("order-log-topic", event, new SendCallback() {
            @Override
            public void onSuccess(SendResult sendResult) {
                log.info("消息发送成功：{}", sendResult);
            }

            @Override
            public void onException(Throwable e) {
                log.error("消息发送失败", e);
            }
        });
    }
}

消息消费者

@Service
@RocketMQMessageListener(topic = "order-created-topic", consumerGroup = "stock-consumer-group", mode = MessageModel.CLUSTERING)
public class StockConsumer implements RocketMQListener<OrderCreatedEvent> {
    @Autowired
    private StockService stockService;

    @Override
    public void onMessage(OrderCreatedEvent event) {
        log.info("接收到订单创建事件：{}", event);
        try {
            // 处理库存扣减
            stockService.deductStock(event.getProductId(), event.getQuantity());
            log.info("库存扣减成功：orderId={}", event.getOrderId());
        } catch (Exception e) {
            log.error("库存扣减失败，将触发重试", e);
            throw e; // 抛出异常触发 MQ 重试
        }
    }
}

六、性能优化与监控

6.1 链路追踪集成

集成 SkyWalking 可以帮助我们在复杂调用链中快速定位性能瓶颈。

<!-- SkyWalking Agent 配置 -->
<dependency>
    <groupId>org.apache.skywalking</groupId>
    <artifactId>apm-toolkit-trace</artifactId>
    <version>8.16.0</version>
</dependency>

JVM 启动参数：

java -javaagent:/path/to/skywalking-agent.jar \
-Dskywalking.agent.service_name=user-service \
-Dskywalking.collector.backend_service=localhost:11800 \
-jar user-service.jar

6.2 性能指标监控

系统健康度主要关注 QPS/TPS、响应时间、错误率、CPU 使用率、内存使用率和 GC 频率。

监控指标采集

@Component
public class MetricsCollector {
    private final MeterRegistry meterRegistry;

    @Autowired
    public MetricsCollector(MeterRegistry meterRegistry) {
        this.meterRegistry = meterRegistry;
    }

    // 自定义业务指标
    public void recordOrderCreated(String region, double amount) {
        Counter.builder("order.created.count")
                .tag("region", region)
                .register(meterRegistry)
                .increment();

        DistributionSummary.builder("order.created.amount")
                .tag("region", region)
                .register(meterRegistry)
                .record(amount);
    }

    // 接口响应时间
    @Timed(value = "api.request.duration", description = "API 请求耗时", percentiles = {0.5, 0.95, 0.99})
    public ResponseEntity<?> handleRequest() {
        // 业务逻辑
        return ResponseEntity.ok().build();
    }
}

6.3 缓存策略设计

采用多级缓存（本地 Caffeine + 分布式 Redis）能显著提升读取性能。

多级缓存实现

@Service
public class ProductServiceImpl {
    // 本地缓存
    private final Cache<Long, Product> localCache = Caffeine.newBuilder()
            .maximumSize(1000)
            .expireAfterWrite(5, TimeUnit.MINUTES)
            .build();

    @Autowired
    private RedisTemplate<String, Product> redisTemplate;
    @Autowired
    private ProductMapper productMapper;

    public Product getProduct(Long productId) {
        String cacheKey = "product:" + productId;

        // L1: 本地缓存
        Product product = localCache.getIfPresent(productId);
        if (product != null) {
            return product;
        }

        // L2: Redis 缓存
        product = redisTemplate.opsForValue().get(cacheKey);
        if (product != null) {
            localCache.put(productId, product);
            return product;
        }

        // L3: 数据库
        product = productMapper.selectById(productId);
        if (product != null) {
            // 写入 Redis，过期时间 30 分钟
            redisTemplate.opsForValue().set(cacheKey, product, 30, TimeUnit.MINUTES);
            localCache.put(productId, product);
        }
        return product;
    }
}

七、总结与展望

7.1 核心要点回顾

• 服务治理：Nacos（服务发现/配置管理）
• 流量防护：Sentinel（限流降级/熔断保护）
• 数据一致性：Seata（AT/TCC/Saga）
• 异步解耦：RocketMQ（事件驱动）
• 性能分析：SkyWalking（故障定位）

7.2 2026 技术趋势

1. 云原生深度融合：Kubernetes 成为微服务部署标配
2. Service Mesh 兴起：Istio 等 Mesh 技术解决服务间通信
3. Serverless 架构：函数计算降低运维成本
4. AI 赋能运维：智能诊断、自动扩缩容

7.3 官方资源推荐

Spring Cloud Alibaba 作为成熟的微服务解决方案，已经在众多企业项目中得到验证。掌握其核心组件和最佳实践，将帮助您构建稳定、高效的分布式系统。持续学习，不断实践，才是掌握微服务的正确姿势！