#淘宝架构演进

// 淘宝早期数据分片策略
public class ShardingStrategy {

    // 按用户 ID 哈希分片
    public int getShardIndex(Long userId, int shardCount) {
        return (int) (userId % shardCount);
    }

    // 获取分片对应的数据源
    public DataSource getDataSource(Long userId) {
        int shardIndex = getShardIndex(userId, shardCount);
        return dataSources[shardIndex];
    }

    // 分片内查询
    public List<Order> findOrders(Long userId, int page, int pageSize) {
        DataSource ds = getDataSource(userId);
        try (Connection conn = ds.getConnection()) {
            String sql = "SELECT * FROM orders WHERE user_id = ? LIMIT ? OFFSET ?";
            return jdbcTemplate.query(sql, userId, pageSize, page * pageSize);
        }
    }
}

// HSF 服务提供者
@HSFService(serviceVersion = "1.0.0", serviceGroup = "taobao")
public class ItemServiceImpl implements ItemService {

    @Autowired private ItemRepository itemRepository;

    @Override
    public ItemDetail getItemDetail(Long itemId) {
        Item item = itemRepository.findById(itemId);
        if (item == null) {
            throw new ItemNotFoundException(itemId);
        }
        return convertToDetail(item);
    }
}

// HSF 服务消费者
public class ItemController {

    // 从注册中心获取服务实例，负载均衡调用
    @HSFReference(serviceVersion = "1.0.0", clientTimeout = 3000)
    private ItemService itemService;

    public ItemDetail getItem(Long itemId) {
        return itemService.getItemDetail(itemId);
    }
}

// Notify 消息发送
public class OrderService {

    @Autowired private NotifyServer notifyServer;

    // 创建订单后，发送消息通知库存服务
    public void createOrder(Long userId, List<Long> itemIds) {
        // 1. 创建订单记录
        Order order = orderRepository.save(new Order(userId, itemIds));

        // 2. 发送消息（Notify 保证消息可靠送达）
        OrderCreatedMessage message = new OrderCreatedMessage();
        message.setOrderId(order.getId());
        message.setUserId(userId);
        message.setItemIds(itemIds);
        message.setTimestamp(System.currentTimeMillis());

        // 消息先持久化，再发送；失败会重试
        notifyServer.send("order-created", message);

        return order;
    }
}

// Notify 消息消费
@NotifyListener(topic = "order-created")
public class InventoryService {

    // 消息回调
    public void onOrderCreated(OrderCreatedMessage message) {
        // 幂等处理：检查是否已经扣减过
        if (inventoryService.hasDeducted(message.getOrderId())) {
            return;
        }

        // 扣减库存
        inventoryService.deductStock(message.getItemIds());

        // 标记已处理
        inventoryService.markDeducted(message.getOrderId());
    }
}

// Tair 缓存使用
public class ItemService {

    @Autowired private TairClient tairClient;
    @Autowired private ItemRepository itemRepository;

    private static final int CACHE_EXPIRE_SECONDS = 3600; // 1 小时过期
    private static final int CACHE_NAMESPACE = 1;

    // 查询商品：先查缓存，再查数据库
    public Item getItem(Long itemId) {
        String cacheKey = "item:" + itemId;

        // 1. 从 Tair 获取
        Item cached = tairClient.get(CACHE_NAMESPACE, cacheKey);
        if (cached != null) {
            return cached;
        }

        // 2. 缓存未命中，从数据库加载
        Item item = itemRepository.findById(itemId);
        if (item != null) {
            // 3. 写入缓存
            tairClient.put(CACHE_NAMESPACE, cacheKey, item, CACHE_EXPIRE_SECONDS);
        }

        return item;
    }

    // 商品更新时删除缓存（Cache Aside 策略）
    public void updateItem(Long itemId, ItemUpdateRequest request) {
        itemRepository.update(itemId, request);

        // 删除缓存，让下次查询重新加载最新数据
        String cacheKey = "item:" + itemId;
        tairClient.delete(CACHE_NAMESPACE, cacheKey);
    }
}

// Dubbo 服务提供者
@Service(version = "1.0.0")
public class TradeServiceImpl implements TradeService {

    @Override
    public TradeResult createTrade(Long userId, Long orderId) {
        // 创建交易记录
        Trade trade = new Trade();
        trade.setUserId(userId);
        trade.setOrderId(orderId);
        trade.setStatus(TradeStatus.PENDING);
        tradeRepository.save(trade);

        // 同步调用库存服务
        inventoryService.deduct(orderId);

        // 异步发送交易事件
        tradeEventPublisher.publishCreated(trade);

        return TradeResult.success(trade.getId());
    }
}

// Dubbo 服务消费者
@RestController
@RequestMapping("/trade")
public class TradeController {

    @Reference(version = "1.0.0", loadbalance = "roundrobin", timeout = 3000)
    private TradeService tradeService;

    @PostMapping
    public Response createTrade(@RequestBody TradeRequest request) {
        TradeResult result = tradeService.createTrade(
            request.getUserId(), request.getOrderId());
        return Response.success(result);
    }
}

// RocketMQ 事务消息
@Service
public class TradeService {

    @Autowired private RocketMQTemplate rocketMQTemplate;

    public void createTrade(Long userId, Long orderId) {
        // 发��半消息（此时消费者看不到）
        rocketMQTemplate.sendMessageInTransaction(
            "trade-topic:create",
            MessageBuilder.withPayload(new TradeMessage(userId, orderId))
                .setHeader("tradeId", UUID.randomUUID().toString())
                .build(),
            // 本地事务 + 事务状态回查
            (msg, arg) -> {
                try {
                    // 执行本地事务
                    Trade trade = new Trade();
                    trade.setUserId(userId);
                    trade.setOrderId(orderId);
                    tradeRepository.save(trade);

                    // 扣减库存
                    boolean deducted = inventoryService.deduct(orderId);
                    if (!deducted) {
                        throw new StockException("库存不足");
                    }

                    return LocalTransactionState.COMMIT_MESSAGE;
                } catch (Exception e) {
                    return LocalTransactionState.ROLLBACK_MESSAGE;
                }
            },
            null
        );
    }
}