架构与系统设计 / 系统课时

商户费率计算

商户费率计算

商户费率计算的核心不是简单相乘,而是把比例费、固定费、阶梯档位和封顶规则按确定顺序组合,并使用十进制金额运算,最终得到可复核、可入账的手续费结果。

学习目标

  • 建立统一的商户费率规则模型
  • 使用 BigDecimal 实现四类计费规则
  • 验证舍入、档位边界和异常配置

统一计费顺序

一次交易先确定计费模式,再计算原始手续费,最后应用封顶金额。比例费按交易金额乘费率;固定费与金额无关;阶梯费先根据金额命中档位,再用该档位费率计算;组合模式可以同时叠加比例费和固定费。统一表达式可以写成:

rawFee=amount×effectiveRate+fixedFee\text{rawFee}=\text{amount}\times\text{effectiveRate}+\text{fixedFee}
finalFee=min⁡(rawFee,cap)\text{finalFee}=\min(\text{rawFee},\text{cap})

未配置的部分按零处理,未配置封顶时直接返回原始手续费。费率必须以小数保存,例如 0.006 表示 0.6%,不能用 6 或 0.6 代替。

完整实现

下面的 Java 17 示例采用“命中档位后整笔按该档费率计费”的规则。档位上界使用开区间,因此金额等于 1000 时会进入第二档,避免相邻区间重复命中。

java
import java.math.BigDecimal;
import java.math.RoundingMode;
import java.util.List;

public class MerchantFeeCalculatorDemo {

    enum Mode {
        PERCENTAGE, FIXED, TIERED, COMBINED
    }

    record Tier(BigDecimal minInclusive,
                BigDecimal maxExclusive,
                BigDecimal rate) {

        boolean matches(BigDecimal amount) {
            boolean reachedMin = amount.compareTo(minInclusive) >= 0;
            boolean belowMax = maxExclusive == null
                    || amount.compareTo(maxExclusive) < 0;
            return reachedMin && belowMax;
        }
    }

    record Rule(Mode mode,
                BigDecimal rate,
                BigDecimal fixedFee,
                List<Tier> tiers,
                BigDecimal cap) {

        Rule {
            tiers = tiers == null ? List.of() : List.copyOf(tiers);
        }
    }

    static BigDecimal calculate(BigDecimal amount, Rule rule) {
        if (amount == null || amount.signum() <= 0) {
            throw new IllegalArgumentException("amount must be positive");
        }

        BigDecimal rawFee = switch (rule.mode()) {
            case PERCENTAGE ->
                    amount.multiply(required(rule.rate(), "rate"));
            case FIXED ->
                    required(rule.fixedFee(), "fixedFee");
            case TIERED ->
                    amount.multiply(matchTierRate(amount, rule.tiers()));
            case COMBINED -> {
                BigDecimal rate = rule.tiers().isEmpty()
                        ? required(rule.rate(), "rate")
                        : matchTierRate(amount, rule.tiers());
                yield amount.multiply(rate)
                        .add(required(rule.fixedFee(), "fixedFee"));
            }
        };

        if (rule.cap() != null && rawFee.compareTo(rule.cap()) > 0) {
            rawFee = rule.cap();
        }
        return rawFee.setScale(2, RoundingMode.HALF_UP);
    }

    static BigDecimal matchTierRate(BigDecimal amount, List<Tier> tiers) {
        return tiers.stream()
                .filter(tier -> tier.matches(amount))
                .map(Tier::rate)
                .findFirst()
                .orElseThrow(() ->
                        new IllegalArgumentException("no tier matched"));
    }

    static BigDecimal required(BigDecimal value, String field) {
        if (value == null || value.signum() < 0) {
            throw new IllegalArgumentException(field + " is invalid");
        }
        return value;
    }

    static BigDecimal bd(String value) {
        return new BigDecimal(value);
    }

    public static void main(String[] args) {
        List<Tier> tiers = List.of(
                new Tier(bd("0"), bd("1000"), bd("0.006")),
                new Tier(bd("1000"), bd("5000"), bd("0.005")),
                new Tier(bd("5000"), null, bd("0.004"))
        );

        Rule percentage = new Rule(
                Mode.PERCENTAGE, bd("0.006"), null, null, null);
        Rule fixed = new Rule(
                Mode.FIXED, null, bd("2.50"), null, null);
        Rule tiered = new Rule(
                Mode.TIERED, null, null, tiers, null);
        Rule combinedWithCap = new Rule(
                Mode.COMBINED, null, bd("0.30"), tiers, bd("20.00"));

        System.out.println("比例费: "
                + calculate(bd("1000"), percentage));
        System.out.println("固定费: "
                + calculate(bd("1000"), fixed));
        System.out.println("阶梯费: "
                + calculate(bd("3800"), tiered));
        System.out.println("组合封顶: "
                + calculate(bd("8000"), combinedWithCap));
    }
}

预期输出

text
比例费: 6.00
固定费: 2.50
阶梯费: 19.00
组合封顶: 20.00

边界与配置校验

生产系统应在费率发布时完成配置校验,而不是等到交易发生后才报错。至少要检查档位是否按金额递增、相邻区间是否连续、区间是否重叠、费率和固定费是否为非负数,以及封顶金额是否小于正常的最低手续费。

金额与手续费都应使用 DECIMAL 和 BigDecimal。不要使用 double,否则二进制浮点误差可能造成分级边界判断和最终舍入不一致。订单表还应保存命中的规则版本、原始手续费、封顶前金额和最终手续费,便于退款、对账和审计复算。

验收方法

选择四组数据分别覆盖比例、固定、阶梯和封顶,并额外测试 999.99、1000.00、4999.99、5000.00 等边界金额。验收时不仅比较最终手续费,还要核对命中档位、有效费率、固定费和封顶前金额是否与规则一致。

按自己的节奏,确认真正理解。

目录与阅读设置

阅读设置

17

记录一个想法

商户费率计算

0 / 10000 · 笔记保存到账号。未提交的修改会在关闭、离开或刷新后丢失。

登录哪都通