一、优惠券叠加算法的业务背景与核心挑战

在电商、O2O等场景中，优惠券叠加功能直接影响用户决策与平台收益。一个典型的业务场景包含：满减券、折扣券、免运费券、品类专属券等多种类型，用户可能同时持有多个可叠加使用的优惠券。此时，系统需要自动计算最优组合方案，既满足用户利益最大化，又避免平台过度让利。

核心挑战：

规则复杂性：不同优惠券可能存在互斥关系（如满减券与折扣券不可叠加）、优先级差异（如会员专享券优先于普通券）
组合爆炸：当用户持有N张券时，理论上存在2^N种组合可能，需高效筛选最优解
实时性要求：高并发场景下需在毫秒级完成计算
规则可扩展性：需支持动态添加新优惠券类型与叠加规则

二、算法设计核心原则

1. 规则建模与优先级定义

采用”规则引擎+优先级矩阵”模式，将每类优惠券抽象为规则对象：

public interface CouponRule {
    boolean isApplicable(Order order, User user);
    BigDecimal calculateDiscount(Order order);
    int getPriority(); // 数值越小优先级越高
    Set<String> getExclusiveTypes(); // 声明互斥的优惠券类型
}

示例实现（满减券规则）：

public class FullReductionRule implements CouponRule {
    private BigDecimal minAmount;
    private BigDecimal discount;
    @Override
    public boolean isApplicable(Order order, User user) {
        return order.getTotalAmount().compareTo(minAmount) >= 0;
    }
    @Override
    public BigDecimal calculateDiscount(Order order) {
        return discount;
    }
    @Override
    public int getPriority() {
        return 2; // 中等优先级
    }
    @Override
    public Set<String> getExclusiveTypes() {
        return Set.of("DISCOUNT", "PERCENT_OFF"); // 与折扣券互斥
    }
}

2. 组合计算算法设计

采用”两阶段过滤法”：

预过滤阶段：根据商品类型、订单金额等基础条件筛选可用券
组合计算阶段：基于优先级和互斥关系生成有效组合

关键实现代码：

public class CouponCombinator {
    public List<CouponGroup> findOptimalCombinations(List<CouponRule> rules, Order order) {
        // 阶段1：基础过滤
        List<CouponRule> applicableRules = rules.stream()
            .filter(r -> r.isApplicable(order, order.getUser()))
            .collect(Collectors.toList());
        // 阶段2：生成所有可能组合（排除明显无效组合）
        List<List<CouponRule>> candidateGroups = generateCombinations(applicableRules);
        // 阶段3：筛选有效组合（无互斥冲突）
        List<CouponGroup> validGroups = candidateGroups.stream()
            .filter(this::checkNoConflict)
            .collect(Collectors.toList());
        // 阶段4：计算最优解（按节省金额排序）
        return validGroups.stream()
            .sorted(Comparator.comparing(g -> -calculateTotalDiscount(g, order)))
            .collect(Collectors.toList());
    }
    private boolean checkNoConflict(List<CouponRule> group) {
        Map<String, Integer> typeCount = new HashMap<>();
        for (CouponRule rule : group) {
            for (String type : rule.getExclusiveTypes()) {
                typeCount.merge(type, 1, Integer::sum);
                if (typeCount.get(type) > 1) return false;
            }
        }
        return true;
    }
}

三、性能优化策略

1. 组合剪枝优化

采用”优先级优先+贪心算法”混合策略：

public List<CouponRule> findOptimalSingleCombination(List<CouponRule> rules, Order order) {
    // 按优先级排序
    rules.sort(Comparator.comparingInt(CouponRule::getPriority));
    List<CouponRule> result = new ArrayList<>();
    Set<String> usedTypes = new HashSet<>();
    for (CouponRule rule : rules) {
        if (!rule.getExclusiveTypes().stream().anyMatch(usedTypes::contains) 
            && rule.isApplicable(order, order.getUser())) {
            result.add(rule);
            usedTypes.addAll(rule.getExclusiveTypes());
        }
    }
    return result;
}

2. 缓存机制设计

对高频访问的订单场景（如相同商品组合）建立缓存：

public class CouponCache {
    private static final Cache<String, List<CouponRule>> CACHE = 
        Caffeine.newBuilder()
            .maximumSize(10_000)
            .expireAfterWrite(10, TimeUnit.MINUTES)
            .build();
    public List<CouponRule> getCachedCombination(OrderKey key) {
        return CACHE.getIfPresent(key.toString());
    }
    public void putCachedCombination(OrderKey key, List<CouponRule> combination) {
        CACHE.put(key.toString(), combination);
    }
}

四、实际业务中的特殊处理

1. 品类专属券处理

public class CategoryExclusiveRule implements CouponRule {
    private Set<String> allowedCategories;
    @Override
    public boolean isApplicable(Order order, User user) {
        return order.getItems().stream()
            .anyMatch(item -> allowedCategories.contains(item.getCategory()));
    }
    // 实现其他必要方法...
}

2. 阶梯式优惠券处理

public class TieredCouponRule implements CouponRule {
    private List<Tier> tiers; // 按金额排序的阶梯规则
    @Override
    public BigDecimal calculateDiscount(Order order) {
        return tiers.stream()
            .filter(t -> order.getTotalAmount().compareTo(t.getMinAmount()) >= 0)
            .findFirst()
            .map(Tier::getDiscount)
            .orElse(BigDecimal.ZERO);
    }
}

五、测试验证方案

1. 单元测试用例设计

public class CouponCombinatorTest {
    @Test
    public void testExclusiveRuleConflict() {
        CouponRule rule1 = new MockRule("DISCOUNT", 1);
        CouponRule rule2 = new MockRule("DISCOUNT", 2); // 同类型
        CouponCombinator combinator = new CouponCombinator();
        List<CouponGroup> result = combinator.findOptimalCombinations(
            Arrays.asList(rule1, rule2), 
            new MockOrder()
        );
        assertEquals(0, result.size()); // 应无有效组合
    }
    @Test
    public void testPriorityOrder() {
        CouponRule highPriority = new MockRule("TYPE1", 0); // 优先级0最高
        CouponRule lowPriority = new MockRule("TYPE2", 1);
        List<CouponGroup> result = combinator.findOptimalCombinations(
            Arrays.asList(highPriority, lowPriority),
            new MockOrder()
        );
        assertTrue(result.get(0).getRules().contains(highPriority));
    }
}

2. 压力测试指标

单次计算耗时：<50ms（1000个SKU订单）
组合生成速度：>1000组合/秒
缓存命中率：>70%（稳定流量场景）

六、系统扩展建议

规则动态加载：通过数据库或配置中心实时更新规则
AB测试支持：为不同用户群体分配不同叠加策略
用户行为学习：根据历史使用数据优化推荐组合
分布式计算：对超大规模订单采用Spark等分布式框架

最佳实践建议：

优先实现单券最优计算，再逐步扩展到多券组合
建立完善的监控体系，跟踪优惠券使用率与成本占比
定期进行规则合理性检查，避免出现”0元购”等极端情况

通过上述算法设计与实现，系统可在保证业务规则准确性的前提下，实现毫秒级的优惠券叠加计算，为电商平台的促销活动提供坚实的技术支撑。实际开发中，建议结合具体业务场景进行参数调优，并建立完善的测试验证机制。

Java优惠券叠加算法设计与实现：从规则到代码的完整指南