拼团交易系统设计

@Service
public class GroupBuyTrialService {
    
    /**
     * 拼团优惠试算
     */
    public GroupBuyTrialResult trial(GroupBuyTrialRequest request) {
        // 1. 获取商品原价
        Money originalPrice = productService.getPrice(request.getSkuId());
        
        // 2. 获取拼团优惠
        GroupBuyActivity activity = groupBuyActivityService
            .getActivity(request.getActivityId());
        Money groupBuyPrice = activity.getGroupBuyPrice();
        
        // 3. 计算团长优惠（如有）
        Money leaderDiscount = Money.ZERO;
        if (request.isLeader()) {
            leaderDiscount = activity.getLeaderDiscount();
        }
        
        // 4. 计算其他优惠（优惠券、积分）
        Money otherDiscount = calculateOtherDiscounts(request);
        
        // 5. 计算最终价格
        Money finalPrice = groupBuyPrice
            .subtract(leaderDiscount)
            .subtract(otherDiscount);
        
        return GroupBuyTrialResult.builder()
            .originalPrice(originalPrice)
            .groupBuyPrice(groupBuyPrice)
            .leaderDiscount(leaderDiscount)
            .otherDiscount(otherDiscount)
            .finalPrice(finalPrice)
            .savedAmount(originalPrice.subtract(finalPrice))
            .build();
    }
}

@Service
public class GroupBuyService {
    
    /**
     * 免拼下单
     */
    public OrderResult createInstantOrder(CreateOrderRequest request) {
        // 1. 校验是否支持免拼
        GroupBuyActivity activity = getActivity(request.getActivityId());
        if (!activity.isAllowInstantBuy()) {
            throw new BizException("该商品不支持免拼下单");
        }
        
        // 2. 创建订单（直接成单，跳过拼团等待）
        GroupBuyOrder groupBuyOrder = GroupBuyOrder.builder()
            .activityId(activity.getId())
            .targetCount(1)  // 目标1人（自己）
            .completeCount(1)
            .status(GroupBuyStatus.SUCCESS)  // 直接标记成功
            .successTime(LocalDateTime.now())
            .build();
        
        // 3. 创建交易订单并支付
        TradeOrder tradeOrder = createTradeOrder(request, groupBuyOrder);
        
        // 4. 立即触发发货流程（无需等待）
        triggerDelivery(tradeOrder);
        
        return OrderResult.success(tradeOrder.getOrderNo());
    }
}

@Service
public class GroupBuyCallbackService {
    
    @Autowired
    private RestTemplate restTemplate;
    
    /**
     * 拼团成功回调
     */
    public void onGroupBuySuccess(GroupBuyOrder groupBuyOrder) {
        CallbackRequest callback = CallbackRequest.builder()
            .eventType("GROUP_BUY_SUCCESS")
            .groupBuyOrderId(groupBuyOrder.getId())
            .activityId(groupBuyOrder.getActivityId())
            .userIds(getUserIds(groupBuyOrder))
            .successTime(groupBuyOrder.getSuccessTime())
            .build();
        
        // 异步发送回调通知
        sendCallback(groupBuyOrder.getCallbackUrl(), callback);
    }
    
    /**
     * 拼团失败/退款回调
     */
    public void onGroupBuyFailed(GroupBuyOrder groupBuyOrder) {
        CallbackRequest callback = CallbackRequest.builder()
            .eventType("GROUP_BUY_FAILED")
            .groupBuyOrderId(groupBuyOrder.getId())
            .activityId(groupBuyOrder.getActivityId())
            .reason("TIMEOUT")  // 或 "REFUND"
            .build();
        
        sendCallback(groupBuyOrder.getCallbackUrl(), callback);
    }
    
    /**
     * 发送回调（带重试机制）
     */
    private void sendCallback(String callbackUrl, CallbackRequest request) {
        int maxRetry = 3;
        for (int i = 0; i < maxRetry; i++) {
            try {
                ResponseEntity<String> response = restTemplate.postForEntity(
                    callbackUrl, request, String.class
                );
                if (response.getStatusCode().is2xxSuccessful()) {
                    log.info("回调发送成功，url={}", callbackUrl);
                    return;
                }
            } catch (Exception e) {
                log.error("回调发送失败，重试次数={}，url={}", i + 1, callbackUrl, e);
                if (i < maxRetry - 1) {
                    Thread.sleep(1000 * (i + 1));  // 指数退避
                }
            }
        }
        // 重试耗尽，记录到补偿表
        saveFailedCallback(callbackUrl, request);
    }
}

// 策略接口
public interface GroupBuyStrategy {
    
    /**
     * 验证用户是否有资格参与
     */
    boolean canJoin(GroupBuyOrder groupBuyOrder, User user);
    
    /**
     * 计算拼团价格
     */
    Money calculatePrice(Product product, GroupBuyActivity activity);
    
    /**
     * 成团成功处理
     */
    void onSuccess(GroupBuyOrder groupBuyOrder);
    
    /**
     * 成团失败处理
     */
    void onFailure(GroupBuyOrder groupBuyOrder);
    
    /**
     * 获取策略类型
     */
    StrategyType getType();
}

// 新用户专享策略实现
@Component
public class NewUserGroupBuyStrategy implements GroupBuyStrategy {
    
    @Autowired
    private UserService userService;
    
    @Override
    public boolean canJoin(GroupBuyOrder groupBuyOrder, User user) {
        // 仅新用户可参与
        return userService.isNewUser(user.getId());
    }
    
    @Override
    public Money calculatePrice(Product product, GroupBuyActivity activity) {
        // 新用户专享价 = 原价 * 新用户折扣
        return product.getOriginalPrice()
                      .multiply(activity.getNewUserDiscount());
    }
    
    @Override
    public void onSuccess(GroupBuyOrder groupBuyOrder) {
        // 发送新用户专享优惠券
        sendNewUserCoupon(groupBuyOrder);
    }
    
    @Override
    public void onFailure(GroupBuyOrder groupBuyOrder) {
        // 发送挽留优惠券
        sendRetentionCoupon(groupBuyOrder);
    }
    
    @Override
    public StrategyType getType() {
        return StrategyType.NEW_USER;
    }
}

// 策略工厂
@Component
public class GroupBuyStrategyFactory {
    
    @Autowired
    private List<GroupBuyStrategy> strategies;
    
    public GroupBuyStrategy getStrategy(StrategyType type) {
        return strategies.stream()
            .filter(s -> s.getType() == type)
            .findFirst()
            .orElseThrow(() -> new IllegalArgumentException("Unknown strategy: " + type));
    }
}

// 策略上下文
@Service
public class GroupBuyService {
    
    @Autowired
    private GroupBuyStrategyFactory strategyFactory;
    
    public GroupBuyResult joinGroupBuy(GroupBuyRequest request) {
        GroupBuyActivity activity = getActivity(request.getActivityId());
        GroupBuyStrategy strategy = strategyFactory.getStrategy(activity.getStrategyType());
        
        // 验证参与资格
        if (!strategy.canJoin(request.getGroupBuyOrder(), request.getUser())) {
            return GroupBuyResult.fail("不符合参与条件");
        }
        
        // 执行参团逻辑...
    }
}

@Service
public class OrderCreateService {
    
    /**
     * 创建订单前检查掉单
     * 防止用户重复点击或网络超时导致的重复订单
     */
    public OrderCreateResult createOrder(CreateOrderRequest request) {
        String userId = request.getUserId();
        String activityId = request.getActivityId();
        
        // 1. 检查是否存在未支付订单（掉单检查）
        PayOrder existingOrder = payOrderRepository
            .findUnpaidOrder(userId, activityId);
        
        if (existingOrder != null) {
            // 存在未支付订单，返回已有订单
            log.info("存在未支付订单，直接返回，orderNo={}", existingOrder.getOrderNo());
            return OrderCreateResult.success(existingOrder);
        }
        
        // 2. 检查是否存在处理中的订单（幂等性）
        PayOrder processingOrder = payOrderRepository
            .findProcessingOrder(userId, activityId);
        
        if (processingOrder != null) {
            // 存在处理中订单，返回等待
            log.info("存在处理中订单，请稍后再试，orderNo={}", processingOrder.getOrderNo());
            return OrderCreateResult.waiting(processingOrder);
        }
        
        // 3. 创建新订单
        return createNewOrder(request);
    }
}

public class GroupBuyOrder {
    
    /** 拼团订单ID */
    private String groupBuyOrderId;
    
    /** 活动ID */
    private String activityId;
    
    /** 目标成团人数 */
    private Integer targetCount;
    
    /** 已完成人数（已支付） */
    private Integer completeCount;
    
    /** 锁单人数（已下单未支付） */
    private Integer lockCount;
    
    /** 团长用户ID */
    private String leaderUserId;
    
    /** 拼团状态 */
    private GroupBuyStatus status;
    
    /** 成团截止时间 */
    private LocalDateTime expireTime;
    
    /**
     * 获取剩余可参与人数
     */
    public int getRemainingCount() {
        return targetCount - completeCount - lockCount;
    }
    
    /**
     * 判断是否可参与
     */
    public boolean canJoin() {
        return status == GroupBuyStatus.IN_PROGRESS 
               && getRemainingCount() > 0 
               && expireTime.isAfter(LocalDateTime.now());
    }
}

public enum GroupBuyStatus {
    IN_PROGRESS,    // 拼团中
    SUCCESS,        // 已成团
    FAILED,         // 拼团失败
    VIRTUAL_SUCCESS // 虚拟成团
}

@Service
public class GroupBuyLockService {
    
    @Autowired
    private StringRedisTemplate redisTemplate;
    
    private static final String LOCK_KEY_PREFIX = "group_buy:lock:";
    private static final long LOCK_TIMEOUT = 30; // 30分钟
    
    /**
     * 尝试锁定拼团名额
     */
    public LockResult tryLock(String groupBuyOrderId, String userId) {
        String lockKey = LOCK_KEY_PREFIX + groupBuyOrderId;
        
        // 使用Redis Lua脚本保证原子性
        String luaScript = 
            "local lockCount = redis.call('GET', KEYS[1] .. ':lock_count') " +
            "local completeCount = redis.call('GET', KEYS[1] .. ':complete_count') " +
            "local targetCount = redis.call('GET', KEYS[1] .. ':target_count') " +
            "if tonumber(lockCount) + tonumber(completeCount) < tonumber(targetCount) then " +
            "    redis.call('INCR', KEYS[1] .. ':lock_count') " +
            "    redis.call('EXPIRE', KEYS[1] .. ':lock_count', ARGV[1]) " +
            "    return 1 " +
            "else " +
            "    return 0 " +
            "end";
        
        Long result = redisTemplate.execute(
            new DefaultRedisScript<>(luaScript, Long.class),
            Collections.singletonList(lockKey),
            String.valueOf(LOCK_TIMEOUT * 60)
        );
        
        if (result != null && result == 1) {
            // 锁定成功，记录用户锁单信息
            recordUserLock(groupBuyOrderId, userId);
            return LockResult.success();
        } else {
            return LockResult.fail("拼团名额已满");
        }
    }
    
    /**
     * 释放锁定的名额（支付超时或取消）
     */
    public void releaseLock(String groupBuyOrderId, String userId) {
        String lockKey = LOCK_KEY_PREFIX + groupBuyOrderId;
        
        // 使用Redis Lua脚本保证原子性
        String luaScript = 
            "local currentLock = redis.call('GET', KEYS[1] .. ':lock_count') " +
            "if tonumber(currentLock) > 0 then " +
            "    redis.call('DECR', KEYS[1] .. ':lock_count') " +
            "    return 1 " +
            "else " +
            "    return 0 " +
            "end";
        
        redisTemplate.execute(
            new DefaultRedisScript<>(luaScript, Long.class),
            Collections.singletonList(lockKey)
        );
        
        // 清除用户锁单记录
        clearUserLock(groupBuyOrderId, userId);
    }
    
    /**
     * 锁定转完成（支付成功）
     */
    public void lockToComplete(String groupBuyOrderId, String userId) {
        String lockKey = LOCK_KEY_PREFIX + groupBuyOrderId;
        
        String luaScript = 
            "redis.call('DECR', KEYS[1] .. ':lock_count') " +
            "redis.call('INCR', KEYS[1] .. ':complete_count') " +
            "return 1";
        
        redisTemplate.execute(
            new DefaultRedisScript<>(luaScript, Long.class),
            Collections.singletonList(lockKey)
        );
        
        // 更新用户状态为已完成
        updateUserStatus(groupBuyOrderId, userId, UserGroupBuyStatus.COMPLETED);
    }
}

/**
 * 结算规则过滤器链
 * 根据结算图：SCRuleFilter -> OutTradeNoRuleFilter -> SettableRuleFilter -> EndRuleFilter
 */
@Component
public class SettlementRuleFilterChain {
    
    @Autowired
    private List<SettlementRuleFilter> filters;
    
    public FilterResult execute(SettlementContext context) {
        for (SettlementRuleFilter filter : filters) {
            FilterResult result = filter.doFilter(context);
            if (!result.isSuccess()) {
                return result;
            }
        }
        return FilterResult.success();
    }
}

/**
 * 结算规则过滤器接口
 */
public interface SettlementRuleFilter {
    FilterResult doFilter(SettlementContext context);
    int getOrder();
}

/**
 * SCRuleFilter：渠道黑名单拦截
 */
@Component
@Order(1)
public class SCRuleFilter implements SettlementRuleFilter {
    
    @Autowired
    private BlacklistService blacklistService;
    
    @Override
    public FilterResult doFilter(SettlementContext context) {
        String channel = context.getChannel();
        String userId = context.getUserId();
        
        // 1. 检查渠道是否在黑名单
        if (blacklistService.isChannelBlocked(channel)) {
            return FilterResult.fail("当前渠道暂不支持该活动");
        }
        
        // 2. 检查用户是否在黑名单
        if (blacklistService.isUserBlocked(userId)) {
            return FilterResult.fail("用户无法参与该活动");
        }
        
        return FilterResult.success();
    }
    
    @Override
    public int getOrder() {
        return 1;
    }
}

/**
 * OutTradeNoRuleFilter：外部单号校验
 */
@Component
@Order(2)
public class OutTradeNoRuleFilter implements SettlementRuleFilter {
    
    @Autowired
    private TradeOrderRepository tradeOrderRepository;
    
    @Override
    public FilterResult doFilter(SettlementContext context) {
        String outTradeNo = context.getOutTradeNo();
        
        if (StringUtils.isBlank(outTradeNo)) {
            return FilterResult.fail("外部单号不能为空");
        }
        
        // 检查外部单号是否已存在（幂等性）
        TradeOrder existingOrder = tradeOrderRepository
            .findByOutTradeNo(outTradeNo);
        
        if (existingOrder != null) {
            // 已存在，返回已有订单信息
            context.setExistingOrder(existingOrder);
            return FilterResult.skip("订单已存在");
        }
        
        return FilterResult.success();
    }
    
    @Override
    public int getOrder() {
        return 2;
    }
}

/**
 * SettableRuleFilter：有效时间校验
 */
@Component
@Order(3)
public class SettableRuleFilter implements SettlementRuleFilter {
    
    @Override
    public FilterResult doFilter(SettlementContext context) {
        GroupBuyActivity activity = context.getActivity();
        LocalDateTime now = LocalDateTime.now();
        
        // 1. 检查活动是否开始
        if (now.isBefore(activity.getStartTime())) {
            return FilterResult.fail("活动尚未开始");
        }
        
        // 2. 检查活动是否已结束
        if (now.isAfter(activity.getEndTime())) {
            return FilterResult.fail("活动已结束");
        }
        
        // 3. 检查订单是否在有效时间内创建
        if (context.getOrderCreateTime() != null) {
            Duration duration = Duration.between(context.getOrderCreateTime(), now);
            if (duration.toMinutes() > 30) {
                return FilterResult.fail("订单已过期，请重新下单");
            }
        }
        
        return FilterResult.success();
    }
    
    @Override
    public int getOrder() {
        return 3;
    }
}

/**
 * EndRuleFilter：结束过滤器（最后执行）
 */
@Component
@Order(4)
public class EndRuleFilter implements SettlementRuleFilter {
    
    @Override
    public FilterResult doFilter(SettlementContext context) {
        // 可以在这里进行最终的校验或日志记录
        log.info("结算规则过滤完成，context={}", context);
        return FilterResult.success();
    }
    
    @Override
    public int getOrder() {
        return 4;
    }
}

/**
 * 营销交易结算服务
 */
@Service
@Slf4j
public class MarketingSettlementService {
    
    @Autowired
    private SettlementRuleFilterChain filterChain;
    
    @Autowired
    private GroupBuyOrderRepository groupBuyOrderRepository;
    
    @Autowired
    private UserGroupBuyOrderRepository userOrderRepository;
    
    @Autowired
    private RedissonClient redissonClient;
    
    @Autowired
    private RocketMQTemplate rocketMQTemplate;
    
    @Autowired
    private RestTemplate restTemplate;
    
    /**
     * 交易结算（根据结算图）
     */
    @Transactional
    public SettlementResult settle(SettlementRequest request) {
        // ========== 1. 结算规则过滤（左侧）==========
        
        // 1.1 参数验证
        ValidationResult validation = validateParams(request);
        if (!validation.isSuccess()) {
            return SettlementResult.fail(validation.getErrorMsg());
        }
        
        // 1.2 执行结算规则过滤链
        SettlementContext context = buildSettlementContext(request);
        FilterResult filterResult = filterChain.execute(context);
        
        if (!filterResult.isSuccess()) {
            if (filterResult.isSkip()) {
                // 订单已存在，返回已有结果
                return SettlementResult.success(context.getExistingOrder());
            }
            return SettlementResult.fail(filterResult.getErrorMsg());
        }
        
        // 1.3 查询组团信息，构建聚合对象
        GroupBuyOrder groupBuyOrder = groupBuyOrderRepository
            .findById(request.getGroupBuyOrderId());
        
        // ========== 2. 拼团状态更新（中间）==========
        
        // 2.1 更新订单完成状态
        boolean orderUpdated = updateOrderStatus(request.getOrderId(), OrderStatus.COMPLETED);
        if (!orderUpdated) {
            throw new BizException("更新订单状态失败");
        }
        
        // 2.2 更新拼团达成数量
        boolean countUpdated = incrementCompleteCount(groupBuyOrder.getId());
        if (!countUpdated) {
            throw new BizException("更新拼团数量失败");
        }
        
        // 2.3 检查是否成团，更新拼团完成状态
        boolean isGroupComplete = checkAndUpdateGroupStatus(groupBuyOrder);
        
        // 2.4 查询拼团交易完成外部单号列表
        List<String> completedOutTradeNos = userOrderRepository
            .findCompletedOutTradeNos(groupBuyOrder.getId());
        
        // 2.5 写入回调任务
        CallbackTask callbackTask = CallbackTask.builder()
            .groupBuyOrderId(groupBuyOrder.getId())
            .callbackUrl(groupBuyOrder.getCallbackUrl())
            .callbackType(groupBuyOrder.getCallbackType())
            .completedOutTradeNos(completedOutTradeNos)
            .build();
        
        saveCallbackTask(callbackTask);
        
        // ========== 3. 回调执行（右侧）==========
        
        executeCallback(callbackTask);
        
        return SettlementResult.success();
    }
    
    /**
     * 执行回调（支持HTTP和MQ两种方式）
     */
    private void executeCallback(CallbackTask task) {
        String lockKey = "callback:lock:" + task.getGroupBuyOrderId();
        RLock lock = redissonClient.getLock(lockKey);
        
        try {
            // 获取分布式锁，防止重复回调
            boolean acquired = lock.tryLock(5, 30, TimeUnit.SECONDS);
            if (!acquired) {
                log.warn("获取回调锁失败，taskId={}", task.getId());
                return;
            }
            
            try {
                CallbackType callbackType = task.getCallbackType();
                
                if (callbackType == CallbackType.HTTP) {
                    // HTTP回调方式
                    executeHttpCallback(task);
                } else if (callbackType == CallbackType.MQ) {
                    // MQ回调方式
                    executeMqCallback(task);
                }
                
                // 更新回调任务状态
                updateCallbackStatus(task.getId(), CallbackStatus.SUCCESS);
                
            } finally {
                lock.unlock();
            }
            
        } catch (InterruptedException e) {
            Thread.currentThread().interrupt();
            log.error("回调执行被中断", e);
        }
    }
    
    /**
     * 执行HTTP回调
     */
    private void executeHttpCallback(CallbackTask task) {
        CallbackRequest request = CallbackRequest.builder()
            .groupBuyOrderId(task.getGroupBuyOrderId())
            .completedOutTradeNos(task.getCompletedOutTradeNos())
            .timestamp(System.currentTimeMillis())
            .build();
        
        // 带重试的HTTP调用
        int maxRetry = 3;
        for (int i = 0; i < maxRetry; i++) {
            try {
                ResponseEntity<String> response = restTemplate.postForEntity(
                    task.getCallbackUrl(),
                    request,
                    String.class
                );
                
                if (response.getStatusCode().is2xxSuccessful()) {
                    log.info("HTTP回调成功，url={}", task.getCallbackUrl());
                    return;
                }
            } catch (Exception e) {
                log.error("HTTP回调失败，重试次数={}，url={}", i + 1, task.getCallbackUrl(), e);
                if (i < maxRetry - 1) {
                    Thread.sleep(1000 * (i + 1));
                }
            }
        }
        
        // 重试耗尽，标记为失败
        throw new CallbackException("HTTP回调失败，已重试" + maxRetry + "次");
    }
    
    /**
     * 执行MQ回调
     */
    private void executeMqCallback(CallbackTask task) {
        CallbackMessage message = CallbackMessage.builder()
            .groupBuyOrderId(task.getGroupBuyOrderId())
            .completedOutTradeNos(task.getCompletedOutTradeNos())
            .build();
        
        Message<CallbackMessage> mqMessage = MessageBuilder
            .withPayload(message)
            .setHeader("KEYS", task.getGroupBuyOrderId())
            .build();
        
        SendResult sendResult = rocketMQTemplate.syncSend(
            "group-buy-callback-topic",
            mqMessage
        );
        
        if (!sendResult.getSendStatus().equals(SendStatus.SEND_OK)) {
            throw new CallbackException("MQ回调发送失败");
        }
        
        log.info("MQ回调发送成功，groupBuyOrderId={}", task.getGroupBuyOrderId());
    }
}

/**
 * 活动策略工厂
 * 负责计算拼团优惠价格
 */
@Component
public class ActivityStrategyFactory {
    
    @Autowired
    private GroupBuyActivityRepository activityRepository;
    
    /**
     * 构建策略节点树并执行优惠试算
     * RootNode -> SwitchNode -> MarketNode -> TagNode
     */
    public MarketResult calculateDiscount(GroupBuyContext context) {
        // 1. RootNode：根节点，初始化上下文
        RootNode rootNode = new RootNode();
        StrategyContext strategyContext = rootNode.execute(context);
        
        // 2. SwitchNode：根据活动类型选择策略分支
        SwitchNode switchNode = new SwitchNode();
        strategyContext = switchNode.execute(strategyContext);
        
        // 3. MarketNode：计算市场优惠价格
        MarketNode marketNode = new MarketNode();
        MarketResult marketResult = marketNode.calculate(strategyContext);
        
        // 4. TagNode：验证用户标签和参与资格
        TagNode tagNode = new TagNode();
        boolean canJoin = tagNode.validate(strategyContext);
        
        if (!canJoin) {
            return MarketResult.fail("用户不符合参与条件");
        }
        
        return marketResult;
    }
}

/**
 * 策略节点抽象类
 */
public abstract class StrategyNode {
    protected StrategyNode nextNode;
    
    public void setNext(StrategyNode nextNode) {
        this.nextNode = nextNode;
    }
    
    public abstract StrategyContext execute(StrategyContext context);
}

/**
 * 根节点：初始化策略上下文
 */
@Component
public class RootNode extends StrategyNode {
    @Override
    public StrategyContext execute(StrategyContext context) {
        // 加载活动配置
        GroupBuyActivity activity = activityRepository
            .findById(context.getActivityId());
        context.setActivity(activity);
        
        // 加载用户信息
        UserInfo userInfo = userService.getUserInfo(context.getUserId());
        context.setUserInfo(userInfo);
        
        return context;
    }
}

/**
 * 开关节点：根据活动类型选择策略
 */
@Component
public class SwitchNode extends StrategyNode {
    @Override
    public StrategyContext execute(StrategyContext context) {
        StrategyType strategyType = context.getActivity().getStrategyType();
        
        // 根据策略类型设置不同的处理逻辑
        switch (strategyType) {
            case NEW_USER:
                context.setStrategy(new NewUserStrategy());
                break;
            case REFERRAL:
                context.setStrategy(new ReferralStrategy());
                break;
            default:
                context.setStrategy(new NormalStrategy());
        }
        
        return context;
    }
}

/**
 * 市场节点：计算优惠价格
 */
@Component
public class MarketNode {
    
    public MarketResult calculate(StrategyContext context) {
        GroupBuyActivity activity = context.getActivity();
        
        // 计算拼团价
        Money groupBuyPrice = activity.getGroupBuyPrice();
        
        // 计算团长优惠
        Money leaderDiscount = Money.ZERO;
        if (context.isLeader()) {
            leaderDiscount = activity.getLeaderDiscount();
        }
        
        // 应用策略特定的优惠
        Money strategyDiscount = context.getStrategy()
            .calculateDiscount(context);
        
        Money finalPrice = groupBuyPrice
            .subtract(leaderDiscount)
            .subtract(strategyDiscount);
        
        return MarketResult.builder()
            .originalPrice(activity.getOriginalPrice())
            .groupBuyPrice(groupBuyPrice)
            .leaderDiscount(leaderDiscount)
            .strategyDiscount(strategyDiscount)
            .finalPrice(finalPrice)
            .build();
    }
}

/**
 * 标签节点：验证用户参与资格
 */
@Component
public class TagNode {
    
    public boolean validate(StrategyContext context) {
        GroupBuyActivity activity = context.getActivity();
        UserInfo userInfo = context.getUserInfo();
        
        // 1. 验证活动是否存在且有效
        if (activity == null || !activity.isValid()) {
            return false;
        }
        
        // 2. 验证用户标签
        List<String> requiredTags = activity.getUserTags();
        if (!CollectionUtils.isEmpty(requiredTags)) {
            boolean hasTag = requiredTags.stream()
                .anyMatch(tag -> userInfo.hasTag(tag));
            if (!hasTag) {
                return false;
            }
        }
        
        // 3. 验证用户是否已参与
        if (activity.isLimitOnePerUser() && 
            hasUserJoined(activity.getId(), userInfo.getUserId())) {
            return false;
        }
        
        return true;
    }
}

/**
 * 交易规则过滤工厂
 * 根据流程图，包含多个规则过滤器
 */
@Component
public class TransactionRuleFilterFactory {
    
    @Autowired
    private List<RuleFilter> ruleFilters;
    
    /**
     * 执行规则过滤链
     */
    public FilterResult executeFilters(FilterContext context) {
        for (RuleFilter filter : ruleFilters) {
            FilterResult result = filter.doFilter(context);
            if (!result.isSuccess()) {
                return result;
            }
        }
        return FilterResult.success();
    }
}

/**
 * 规则过滤器接口
 */
public interface RuleFilter {
    FilterResult doFilter(FilterContext context);
    int getOrder();  // 过滤顺序
}

/**
 * 活动可用性规则过滤器
 */
@Component
@Order(1)
public class ActivityUsabilityRuleFilter implements RuleFilter {
    
    @Autowired
    private GroupBuyActivityRepository activityRepository;
    
    @Override
    public FilterResult doFilter(FilterContext context) {
        GroupBuyActivity activity = activityRepository
            .findById(context.getActivityId());
        
        // 1. 检查活动是否存在
        if (activity == null) {
            return FilterResult.fail("活动不存在");
        }
        
        // 2. 检查活动状态
        if (activity.getStatus() != ActivityStatus.IN_PROGRESS) {
            return FilterResult.fail("活动未开始或已结束");
        }
        
        // 3. 检查活动时间
        LocalDateTime now = LocalDateTime.now();
        if (now.isBefore(activity.getStartTime()) || 
            now.isAfter(activity.getEndTime())) {
            return FilterResult.fail("不在活动有效期内");
        }
        
        return FilterResult.success();
    }
    
    @Override
    public int getOrder() {
        return 1;
    }
}

/**
 * 用户参与次数限制过滤器
 */
@Component
@Order(2)
public class UserTakeLimitRuleFilter implements RuleFilter {
    
    @Autowired
    private UserGroupBuyOrderRepository userOrderRepository;
    
    @Override
    public FilterResult doFilter(FilterContext context) {
        String userId = context.getUserId();
        String activityId = context.getActivityId();
        
        // 1. 检查用户在该活动下的参与次数
        int joinCount = userOrderRepository
            .countUserJoinTimes(userId, activityId);
        
        if (joinCount >= context.getMaxJoinTimes()) {
            return FilterResult.fail("您已达到该活动的参与次数上限");
        }
        
        // 2. 检查用户是否已在当前团中
        if (context.getGroupBuyOrderId() != null) {
            boolean alreadyInGroup = userOrderRepository
                .existsByGroupBuyOrderIdAndUserId(
                    context.getGroupBuyOrderId(), userId);
            if (alreadyInGroup) {
                return FilterResult.fail("您已参与该拼团");
            }
        }
        
        return FilterResult.success();
    }
    
    @Override
    public int getOrder() {
        return 2;
    }
}

/**
 * 团队库存占用过滤器
 */
@Component
@Order(3)
public class TeamStockOccupyRuleFilter implements RuleFilter {
    
    @Autowired
    private StringRedisTemplate redisTemplate;
    
    private static final String STOCK_KEY_PREFIX = "group_buy:stock:";
    
    @Override
    public FilterResult doFilter(FilterContext context) {
        String activityId = context.getActivityId();
        String stockKey = STOCK_KEY_PREFIX + activityId;
        
        // 1. 检查Redis库存
        Long stock = redisTemplate.opsForValue().get(stockKey);
        if (stock == null || stock <= 0) {
            return FilterResult.fail("库存不足");
        }
        
        // 2. 预占库存（使用Lua脚本保证原子性）
        String luaScript = 
            "local stock = tonumber(redis.call('GET', KEYS[1])) " +
            "if stock > 0 then " +
            "    redis.call('DECR', KEYS[1]) " +
            "    return 1 " +
            "else " +
            "    return 0 " +
            "end";
        
        Long result = redisTemplate.execute(
            new DefaultRedisScript<>(luaScript, Long.class),
            Collections.singletonList(stockKey)
        );
        
        if (result == null || result == 0) {
            return FilterResult.fail("库存不足");
        }
        
        // 记录预占的库存，用于回滚
        context.setStockPreoccupied(true);
        
        return FilterResult.success();
    }
    
    @Override
    public int getOrder() {
        return 3;
    }
}