为什么需要微服务？单体架构的困境与演进

/**
 * 电商系统 - 单体架构实现
 * 特点：所有功能在一个进程内，共享一个数据库
 */
@SpringBootApplication
public class ECommerceMonolithApplication {
    public static void main(String[] args) {
        SpringApplication.run(ECommerceMonolithApplication.class, args);
    }
}

/**
 * 订单服务（单体架构版本）
 * 依赖：用户服务、商品服务、库存服务、支付服务
 * 特点：所有依赖都在同一个进程内，方法调用
 */
@Service
@Slf4j
@Transactional(rollbackFor = Exception.class)
public class OrderService {

    @Autowired
    private UserService userService;           // 本地方法调用

    @Autowired
    private ProductService productService;     // 本地方法调用

    @Autowired
    private InventoryService inventoryService; // 本地方法调用

    @Autowired
    private PaymentService paymentService;     // 本地方法调用

    @Autowired
    private OrderRepository orderRepository;   // 同一个数据库

    /**
     * 创建订单
     * 优势：
     * 1. 本地方法调用，性能极高（纳秒级）
     * 2. 本地事务，ACID保证强一致性
     * 3. 调试方便，堆栈清晰
     *
     * 问题：
     * 1. 单点故障：任何一个模块崩溃，整个系统不可用
     * 2. 部署耦合：改一行代码，整个系统重启
     * 3. 技术栈绑定：整个系统必须用同一种语言、框架
     * 4. 资源竞争：所有模块共享JVM内存、CPU
     */
    public Order createOrder(CreateOrderRequest request) {

        // ========== 1. 用户验证（本地方法调用，1ms） ==========
        User user = userService.getUserById(request.getUserId());
        if (user == null) {
            throw new BusinessException("用户不存在");
        }
        if (user.getStatus() != UserStatus.ACTIVE) {
            throw new BusinessException("用户状态异常");
        }

        // ========== 2. 商品查询（本地方法调用，2ms） ==========
        Product product = productService.getProductById(request.getProductId());
        if (product == null) {
            throw new BusinessException("商品不存在");
        }
        if (product.getStatus() != ProductStatus.ON_SALE) {
            throw new BusinessException("商品已下架");
        }

        // ========== 3. 库存扣减（本地方法调用，3ms） ==========
        boolean deductSuccess = inventoryService.deduct(
            product.getId(),
            request.getQuantity()
        );
        if (!deductSuccess) {
            throw new BusinessException("库存不足");
        }

        // ========== 4. 创建订单（本地数据库写入，5ms） ==========
        Order order = Order.builder()
                .orderNo(generateOrderNo())
                .userId(user.getId())
                .productId(product.getId())
                .productName(product.getName())
                .quantity(request.getQuantity())
                .price(product.getPrice())
                .amount(product.getPrice().multiply(
                    new BigDecimal(request.getQuantity())
                ))
                .status(OrderStatus.UNPAID)
                .createTime(LocalDateTime.now())
                .build();

        order = orderRepository.save(order);

        // ========== 5. 调用支付（本地方法调用，10ms） ==========
        boolean paymentSuccess = paymentService.pay(
            order.getOrderNo(),
            order.getAmount()
        );
        if (!paymentSuccess) {
            throw new BusinessException("支付失败");
        }

        // ========== 6. 更新订单状态（本地数据库更新，2ms） ==========
        order.setStatus(OrderStatus.PAID);
        order.setPayTime(LocalDateTime.now());
        order = orderRepository.save(order);

        log.info("订单创建成功: orderNo={}, amount={}", order.getOrderNo(), order.getAmount());

        // 总耗时约23ms（都是本地调用）
        return order;
    }

    /**
     * 生成订单号
     */
    private String generateOrderNo() {
        return "ORD" + System.currentTimeMillis() +
               ThreadLocalRandom.current().nextInt(1000);
    }
}

/**
 * 用户服务
 */
@Service
public class UserService {

    @Autowired
    private UserRepository userRepository;

    public User getUserById(Long userId) {
        return userRepository.findById(userId).orElse(null);
    }
}

/**
 * 商品服务
 */
@Service
public class ProductService {

    @Autowired
    private ProductRepository productRepository;

    public Product getProductById(Long productId) {
        return productRepository.findById(productId).orElse(null);
    }
}

/**
 * 库存服务
 */
@Service
public class InventoryService {

    @Autowired
    private InventoryRepository inventoryRepository;

    /**
     * 扣减库存
     * 优势：本地事务，强一致性保证
     */
    public boolean deduct(Long productId, Integer quantity) {
        Inventory inventory = inventoryRepository.findByProductId(productId);
        if (inventory == null || inventory.getStock() < quantity) {
            return false;
        }

        inventory.setStock(inventory.getStock() - quantity);
        inventoryRepository.save(inventory);
        return true;
    }
}

/**
 * 支付服务
 */
@Service
public class PaymentService {

    @Autowired
    private PaymentRepository paymentRepository;

    /**
     * 支付
     * 优势：本地事务，要么都成功，要么都失败
     */
    public boolean pay(String orderNo, BigDecimal amount) {
        // 调用第三方支付（这里模拟）
        boolean paySuccess = callThirdPartyPayment(orderNo, amount);

        if (paySuccess) {
            // 记录支付流水
            Payment payment = Payment.builder()
                    .orderNo(orderNo)
                    .amount(amount)
                    .status(PaymentStatus.SUCCESS)
                    .payTime(LocalDateTime.now())
                    .build();
            paymentRepository.save(payment);
        }

        return paySuccess;
    }

    private boolean callThirdPartyPayment(String orderNo, BigDecimal amount) {
        // 模拟第三方支付调用
        return true;
    }
}

/**
 * 数据库实体：订单
 */
@Entity
@Table(name = "t_order")
@Data
@Builder
public class Order {
    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    private Long id;

    private String orderNo;
    private Long userId;
    private Long productId;
    private String productName;
    private Integer quantity;
    private BigDecimal price;
    private BigDecimal amount;

    @Enumerated(EnumType.STRING)
    private OrderStatus status;

    private LocalDateTime createTime;
    private LocalDateTime payTime;
}

/**
 * 数据库实体：用户、商品、库存、支付记录
 * （省略具体实现）
 */

/**
 * 订单服务（微服务架构版本）
 * 特点：独立进程，独立数据库，通过RPC调用其他服务
 */
@SpringBootApplication
@EnableDiscoveryClient  // 服务注册
@EnableFeignClients     // 远程调用
public class OrderServiceApplication {
    public static void main(String[] args) {
        SpringApplication.run(OrderServiceApplication.class, args);
    }
}

/**
 * 订单服务实现
 * 依赖：远程调用用户服务、商品服务、库存服务、支付服务
 */
@Service
@Slf4j
public class OrderService {

    @Autowired
    private UserServiceClient userServiceClient;         // 远程调用（HTTP/gRPC）

    @Autowired
    private ProductServiceClient productServiceClient;   // 远程调用

    @Autowired
    private InventoryServiceClient inventoryServiceClient; // 远程调用

    @Autowired
    private PaymentServiceClient paymentServiceClient;   // 远程调用

    @Autowired
    private OrderRepository orderRepository;             // 独立数据库

    @Autowired
    private RocketMQTemplate rocketMQTemplate;           // 消息队列

    /**
     * 创建订单（微服务版本）
     *
     * 优势：
     * 1. 服务独立部署：订单服务可以独立发布，不影响其他服务
     * 2. 技术栈自由：订单服务用Java，用户服务可以用Go，商品服务可以用Python
     * 3. 独立扩展：订单服务压力大，可以只扩容订单服务
     * 4. 故障隔离：支付服务挂了，不影响订单创建（降级返回"支付中"）
     *
     * 挑战：
     * 1. 网络调用：性能下降（本地纳秒级 → 远程毫秒级）
     * 2. 分布式事务：无法保证强一致性（ACID → BASE）
     * 3. 调用链路长：5个服务，任何一个超时都影响整体
     * 4. 运维复杂：5个服务 × 3个环境 = 15套部署
     */
    public Order createOrder(CreateOrderRequest request) {

        // ========== 1. 远程调用用户服务（网络调用，10ms + 超时风险） ==========
        try {
            UserDTO user = userServiceClient.getUserById(request.getUserId());
            if (user == null || user.getStatus() != UserStatus.ACTIVE) {
                throw new BusinessException("用户不存在或状态异常");
            }
        } catch (FeignException e) {
            log.error("调用用户服务失败: {}", e.getMessage());
            throw new BusinessException("用户服务不可用");
        }

        // ========== 2. 远程调用商品服务（网络调用，15ms + 超时风险） ==========
        ProductDTO product;
        try {
            product = productServiceClient.getProductById(request.getProductId());
            if (product == null || product.getStatus() != ProductStatus.ON_SALE) {
                throw new BusinessException("商品不存在或已下架");
            }
        } catch (FeignException e) {
            log.error("调用商品服务失败: {}", e.getMessage());
            throw new BusinessException("商品服务不可用");
        }

        // ========== 3. 远程调用库存服务（网络调用，20ms + 超时风险） ==========
        boolean deductSuccess;
        try {
            deductSuccess = inventoryServiceClient.deduct(
                product.getId(),
                request.getQuantity()
            );
            if (!deductSuccess) {
                throw new BusinessException("库存不足");
            }
        } catch (FeignException e) {
            log.error("调用库存服务失败: {}", e.getMessage());
            throw new BusinessException("库存服务不可用");
        }

        // ========== 4. 创建订单（本地数据库写入，5ms） ==========
        Order order = Order.builder()
                .orderNo(generateOrderNo())
                .userId(request.getUserId())
                .productId(product.getId())
                .productName(product.getName())
                .quantity(request.getQuantity())
                .price(product.getPrice())
                .amount(product.getPrice().multiply(
                    new BigDecimal(request.getQuantity())
                ))
                .status(OrderStatus.UNPAID)
                .createTime(LocalDateTime.now())
                .build();

        order = orderRepository.save(order);

        // ========== 5. 异步调用支付服务（通过消息队列，解耦） ==========
        // 不直接调用支付服务，而是发送消息到MQ，支付服务异步消费
        PaymentMessage paymentMessage = PaymentMessage.builder()
                .orderNo(order.getOrderNo())
                .amount(order.getAmount())
                .build();

        rocketMQTemplate.syncSend("PAYMENT_TOPIC", paymentMessage);

        log.info("订单创建成功: orderNo={}, amount={}", order.getOrderNo(), order.getAmount());

        // 总耗时约50ms（网络调用 + 超时重试）
        // 相比单体架构的23ms，慢了2倍，但换来了独立部署、独立扩展、故障隔离
        return order;
    }

    /**
     * 生成订单号（分布式唯一ID）
     * 单体架构：可以用数据库自增ID
     * 微服务架构：需要用雪花算法、UUID等分布式ID生成策略
     */
    private String generateOrderNo() {
        // 雪花算法生成分布式唯一ID
        return "ORD" + SnowflakeIdWorker.generateId();
    }
}

/**
 * 用户服务客户端（Feign声明式HTTP客户端）
 */
@FeignClient(
    name = "user-service",                    // 服务名（从注册中心获取）
    fallback = UserServiceFallback.class      // 降级策略
)
public interface UserServiceClient {

    @GetMapping("/api/users/{userId}")
    UserDTO getUserById(@PathVariable("userId") Long userId);
}

/**
 * 用户服务降级策略（熔断后的备选方案）
 */
@Component
public class UserServiceFallback implements UserServiceClient {

    @Override
    public UserDTO getUserById(Long userId) {
        log.warn("用户服务调用失败，触发降级策略");
        // 返回一个默认用户，或者抛出异常
        throw new BusinessException("用户服务不可用，请稍后重试");
    }
}

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

    @GetMapping("/api/products/{productId}")
    ProductDTO getProductById(@PathVariable("productId") Long productId);
}

/**
 * 库存服务客户端
 */
@FeignClient(
    name = "inventory-service",
    fallback = InventoryServiceFallback.class
)
public interface InventoryServiceClient {

    @PostMapping("/api/inventory/deduct")
    boolean deduct(@RequestParam("productId") Long productId,
                   @RequestParam("quantity") Integer quantity);
}

/**
 * 支付服务（独立的微服务，监听MQ消息）
 */
@Service
@Slf4j
public class PaymentService {

    @Autowired
    private PaymentRepository paymentRepository;

    @Autowired
    private OrderServiceClient orderServiceClient;

    /**
     * 监听支付消息（异步处理）
     * 优势：解耦订单服务和支付服务，支付失败不影响订单创建
     */
    @RocketMQMessageListener(
        topic = "PAYMENT_TOPIC",
        consumerGroup = "payment-consumer-group"
    )
    public class PaymentMessageListener implements RocketMQListener<PaymentMessage> {

        @Override
        public void onMessage(PaymentMessage message) {
            log.info("接收到支付消息: {}", message);

            try {
                // 调用第三方支付
                boolean paySuccess = callThirdPartyPayment(
                    message.getOrderNo(),
                    message.getAmount()
                );

                if (paySuccess) {
                    // 记录支付流水
                    Payment payment = Payment.builder()
                            .orderNo(message.getOrderNo())
                            .amount(message.getAmount())
                            .status(PaymentStatus.SUCCESS)
                            .payTime(LocalDateTime.now())
                            .build();
                    paymentRepository.save(payment);

                    // 回调订单服务，更新订单状态
                    orderServiceClient.updateOrderStatus(
                        message.getOrderNo(),
                        OrderStatus.PAID
                    );

                    log.info("支付成功: orderNo={}", message.getOrderNo());
                } else {
                    log.error("支付失败: orderNo={}", message.getOrderNo());
                    // 支付失败，可以重试或者发送通知
                }

            } catch (Exception e) {
                log.error("支付处理异常: orderNo={}, error={}",
                    message.getOrderNo(), e.getMessage());
                // 异常时，消息会重新入队，重试机制
                throw new RuntimeException("支付处理失败", e);
            }
        }
    }

    private boolean callThirdPartyPayment(String orderNo, BigDecimal amount) {
        // 模拟第三方支付调用
        return true;
    }
}