Spring Cloud 微服务架构实战：核心组件与实践

// 启动类
@EnableFeignClients
@SpringBootApplication
public class OrderApplication { }

// Feign 客户端
@FeignClient(name = "user-service", fallbackFactory = UserClientFallback.class)
public interface UserClient {

    @GetMapping("/api/users/{id}")
    Result<User> getUserById(@PathVariable("id") Long id);

    @PostMapping("/api/users/batch")
    Result<List<User>> getUsersByIds(@RequestBody List<Long> ids);
}

// 降级处理
@Component
public class UserClientFallback implements FallbackFactory<UserClient> {
    @Override
    public UserClient create(Throwable cause) {
        return new UserClient() {
            @Override
            public Result<User> getUserById(Long id) {
                return Result.fail(500, "用户服务不可用");
            }

            @Override
            public Result<List<User>> getUsersByIds(List<Long> ids) {
                return Result.fail(500, "用户服务不可用");
            }
        };
    }
}

@Configuration
public class FeignConfig {

    @Bean
    public RequestInterceptor requestInterceptor() {
        return template -> {
            // 传递请求头（如认证信息）
            ServletRequestAttributes attributes =
                (ServletRequestAttributes) RequestContextHolder.getRequestAttributes();
            if (attributes != null) {
                String token = attributes.getRequest().getHeader("Authorization");
                template.header("Authorization", token);
            }
        };
    }
}

@Component
public class AuthGlobalFilter implements GlobalFilter, Ordered {

    @Override
    public Mono<Void> filter(ServerWebExchange exchange, GatewayFilterChain chain) {
        String token = exchange.getRequest().getHeaders().getFirst("Authorization");

        // 白名单
        String path = exchange.getRequest().getURI().getPath();
        if (path.startsWith("/api/auth/")) {
            return chain.filter(exchange);
        }

        // 验证 token
        if (token == null || !JwtUtils.validate(token)) {
            exchange.getResponse().setStatusCode(HttpStatus.UNAUTHORIZED);
            return exchange.getResponse().setComplete();
        }

        return chain.filter(exchange);
    }

    @Override
    public int getOrder() {
        return -1; // 优先级
    }
}

@RestController
@RefreshScope  // 支持动态刷新
public class ConfigController {

    @Value("${app.custom.value}")
    private String customValue;

    @GetMapping("/config")
    public String getConfig() {
        return customValue;
    }
}

// 注解方式
@Service
public class ProductService {

    @SentinelResource(
        value = "getProduct",
        fallback = "getProductFallback",
        blockHandler = "getProductBlock"
    )
    public Product getProduct(Long id) {
        // 远程调用可能失败
        return productClient.getById(id);
    }

    // 降级方法
    public Product getProductFallback(Long id, Throwable e) {
        return new Product(id, "默认商品", BigDecimal.ZERO);
    }

    // 限流方法
    public Product getProductBlock(Long id, BlockException e) {
        throw new RuntimeException("服务限流，请稍后重试");
    }
}

@Service
public class OrderService {

    @GlobalTransactional  // 开启全局事务
    public void createOrder(OrderDTO dto) {
        // 1. 创建订单（本地事务）
        orderMapper.insert(order);

        // 2. 扣减库存（远程调用）
        inventoryClient.deduct(dto.getProductId(), dto.getCount());

        // 3. 扣减余额（远程调用）
        accountClient.debit(dto.getUserId(), dto.getTotalAmount());

        // 任一环节失败，全局回滚
    }
}

// 生产者
@Service
public class OrderMessageProducer {
    @Autowired
    private StreamBridge streamBridge;

    public void sendOrderCreated(Long orderId) {
        streamBridge.send("order-created-out-0",
            MessageBuilder.withPayload(orderId).build());
    }
}

// 消费者
@Component
public class OrderMessageConsumer {

    @Bean
    public Consumer<Message<Long>> orderCreated() {
        return message -> {
            Long orderId = message.getPayload();
            System.out.println("收到订单消息: " + orderId);
            // 处理业务逻辑
        };
    }
}

// 延迟消息（如订单超时取消）
Message<Long> message = MessageBuilder
    .withPayload(orderId)
    .setHeader("DELAY", 18)  // 延迟级别
    .build();
streamBridge.send("order-timeout-out-0", message);