MingJunDuan的博客
热爱可抵一切,探索未知之境
全站访问量 次

jqwik 属性测试:穷举边界与组合,替代人工用例

先看一个”看起来必然通过”的测试:

import net.jqwik.api.*;

class AbsTest {
    @Property
    boolean absoluteValueIsNeverNegative(@ForAll int i) {
        return Math.abs(i) >= 0;
    }
}

「绝对值永远非负」,还有比这更显然的性质吗?运行结果:

AssertionFailedError: Property [AbsTest:absoluteValueIsNeverNegative]
    falsified with sample [i=-2147483648]

tries = 2
checks = 2
generation = RANDOMIZED
seed = -8925365419009802571

Integer.MIN_VALUE(-2147483648)的绝对值还是它自己:取反溢出,绕回负数。手写用例时你会想到 Integer.MIN_VALUE 吗?大概率不会——但线上数据会。

这就是属性测试(Property-Based Testing,PBT)的核心思路:你不枚举输入,你声明性质;框架负责成千上万次地生成输入、往边界上钻,找出你没想到的反例。


一、手写用例为什么永远测不全

以一个服务端最常见的业务函数为例——订单优惠计算:

// 会员等级 × 优惠券类型 × 商品类型 × 金额区间
long calcDiscount(MemberLevel level, CouponType coupon,
                  ProductType product, long amount);

假设:会员等级 4 种、优惠券 3 种、商品类型 5 种、金额区间 5 档,纯笛卡尔积就是 4 × 3 × 5 × 5 = 300 种组合。再加上边界值(金额为 0、恰好压档位线、Long.MAX_VALUE 溢出),组合数继续翻倍。

现实中团队怎么测?挑二三十条”代表性”用例写完收工,剩下两百多条路径交给 code review 和线上事故去覆盖。这不是态度问题,是手写用例的方式本身有天花板:

  • 边界靠拍脑袋:想到的边界才写进用例,没想到的就是盲区。Math.abs 的反例就是典型。
  • 组合靠运气:N 个维度相乘,人工只能挑对角线上的”典型组合”,交叉组合(比如”铂金会员 + 无券 + 生鲜 + 临界金额”)几乎没人写。
  • 回归靠信仰:每次改规则,用例矩阵要人工增删,漏改一条就是一条线上隐患。

AI 编程时代这个问题更尖锐。AI 生成代码的主流路径写得飞快,但边界意识取决于训练数据里的概率——Integer.MIN_VALUE 溢出、空串、Unicode 特殊字符这种冷知识,恰恰是模型最容易漏的。你需要的是一个自动化的验收手段,而不是把”想边界”的负担继续压在人(或另一个 AI)身上。

jqwik 就是这个手段。


二、jqwik 是什么

jqwik(发音类似 “jay-quick”)是 JVM 生态的属性测试库,作者 Johannes Link。两个关键定位:

  1. 它是 JUnit Platform 上的一个测试引擎(Test Engine),与 Jupiter(JUnit 5)、Vintage(JUnit 4)平级共存。不是替代 JUnit 的框架——一个项目里 @Test 和 @Property 可以混写,互不干扰,IDE 里运行方式完全一样。
  2. 它把 QuickCheck 的思想带进了 Java。谱系大致是:Haskell QuickCheck → ScalaCheck / Erlang QuickCheck → Hypothesis(Python)→ fast-check(TS/JS)→ jqwik(Java)。

各生态术语对照:

概念 jqwik (Java) Hypothesis (Python) fast-check (TS)
数据生成器 Arbitrary strategy Arbitrary
属性注解 @Property @given fc.assert / test.prop
前置假设 Assume.that(...) assume(...) fc.pre(...)
反例最小化 shrinking shrinking shrink

它的工作方式可以拆成三件套:

① 生成(Generation)。Arbitrary 按类型生成随机值,但绝不是纯均匀随机——默认会优先混入边界值(edge cases):int 的 0、±1、MIN_VALUE、MAX_VALUE;String 的空串和超长串;集合的空集和单元素集等。失败报告里的 edge-cases#mode = MIXIN 就是指边界值先跑。

② 断言(Verification)。每个样本跑一遍属性方法,断言失败即属性被证伪。默认每个属性跑 1000 次(tries = 1000,可配置)。

③ 收缩(Shrinking)。失败后不是把原始样本甩给你,而是自动把样本最小化——jqwik 用的是 integrated shrinking(与 Hypothesis 同源思路)。比如失败输入是一个 300 长的字符串,收缩到最后可能只剩 3 个字符,且这 3 个字符就是触发 bug 的最简形式。

上手配置,Maven:

<dependency>
    <groupId>net.jqwik</groupId>
    <artifactId>jqwik</artifactId>
    <version>1.10.2</version>
    <scope>test</scope>
</dependency>

Gradle:

testImplementation("net.jqwik:jqwik:1.10.2")

Maven Surefire 2.22+ 和 Gradle 原生支持 JUnit Platform,jqwik 的引擎随依赖自动注册,零额外配置,mvn test 就能跑 @Property。


三、解决什么问题

3.1 边界自动覆盖

手写用例时,边界是”想到的才有”;jqwik 的 edge cases 是”内置的、先跑的”。一个校验函数,手工测试顶多测 null、空串、超长串;jqwik 每次运行都会先扫一遍类型相关的全部边界,然后才进入随机采样。你还可用约束注解主动扩大边界集:

@Property
void handleExtremes(@ForAll @IntRange(min = -5, max = 5) int small,
                    @ForAll @WithNull(0.05) String maybeNull,
                    @ForAll @StringLength(min = 0, max = 1000) String anyLength) {
    // small 必含 -5/-1/0/1/5 等边界;maybeNull 有 5% 概率为 null
    // anyLength 必含空串和超长串
}

3.2 组合自动采样(笛卡尔积)

多个 @ForAll 参数会被独立生成再自动组合,天然在组合空间里采样,不需要手写嵌套循环。更进一步:当值域足够小(组合总数 ≤ tries),jqwik 的 GenerationMode.AUTO(默认)会自动切换到穷举模式,把全部组合一个不落地跑完;也可以显式声明:

@Property(generation = GenerationMode.EXHAUSTIVE)
void everyCombination(@ForAll MemberLevel level,
                      @ForAll CouponType coupon,
                      @ForAll ProductType product) {
    // 4 × 3 × 5 = 60 种组合全部执行,无一遗漏
}

手写 300 条用例 vs 一个注解全穷举——这就是对”人工写用例覆盖所有组合”问题的直接解法。

3.3 反例收缩(Shrinking)

假设某业务代码有个隐藏 bug:只要字符串包含 "xyz" 就会出错。手写测试要恰好想到写 "xyz" 这个用例;jqwik 的流程是——随机生成撞上一个含 "xyz" 的失败样本,然后自动收缩:

AssertionFailedError: Property [ShrinkDemo:noXyz] falsified with sample {0="xyz"}

original sample: {0="kqXyZ!9wxyz..."}

把 300 个字符缩到 3 个字符,而且告诉你最简触发条件就是 "xyz" 本身。这个最小反例直接就能写进 bug 单,比原始样本好定位一个数量级。

3.4 状态与时序问题

微服务里大量 bug 不是单输入单输出的,而是动作序列触发的:订单状态乱跳、重试造成重复扣款、限流器计数漂移。jqwik 用 ActionSequence 支持状态机测试(第 5.5 节展开)。

3.5 与 @ParameterizedTest 的对比

JUnit 5 的 @ParameterizedTest 也能跑多组数据,但本质仍是”手写数据 + 逐个执行”:

维度 @ParameterizedTest @Property
用例来源 手写枚举(@CsvSource / @MethodSource) 生成器 + 约束自动产出
边界覆盖 想到才有 内置 edge cases 先跑
组合覆盖 手写笛卡尔积 自动采样 / 值域小则全穷举
失败定位 挂在哪条看哪条 shrink 到最小反例
适用场景 固定的少量典型场景、快照式断言 规则性、不变量、逆向性、状态机

两者是互补关系,不是替代关系(第 7 节细说)。


四、核心 API 速览

4.1 生成器与约束注解

@Property
void constraintsDemo(@ForAll @Positive int positive,        // 正整数
                     @ForAll @IntRange(min = 1, max = 99) int percent,
                     @ForAll @AlphaChars @StringLength(min = 5, max = 10) String code,
                     @ForAll @UniqueElements List<Integer> distinct) { ... }

常用约束:@Positive / @Negative、@IntRange、@StringLength、@AlphaChars / @NumericChars、@WithNull(概率)、@UniqueElements、@NotEmpty、@Size。

4.2 自定义生成器:@Provide + Combinators

真实业务对象不可能只靠注解拼出来,需要”业务数据工厂”。@Provide 方法负责生产,@ForAll("方法名") 引用:

@Provide
Arbitrary<Order> orders() {
    Arbitrary<String> orderNo =
        Arbitraries.strings().alpha().numeric().withChars("-_").ofLength(1, 32);
    Arbitrary<OrderItem> item = Combinators.combine(
        Arbitraries.strings().alpha().numeric().ofMaxLength(10),   // sku
        Arbitraries.integers().between(1, 100)                     // quantity
    ).as(OrderItem::new);
    return Combinators.combine(
        orderNo,
        item.list().ofMaxSize(5),
        Arbitraries.bigDecimals()
            .between(new BigDecimal("0.01"), new BigDecimal("99999.99")).ofScale(2)
    ).as(Order::new);
}

@Property
void usesCustomGenerator(@ForAll("orders") Order order) { ... }

要点:生成器之间的依赖组合用 Combinators.combine(...).as(...)(最多 4 个),条件依赖用 flatMap,按权重混合用 Arbitraries.frequencyOf,枚举全集用 Arbitraries.of(MyEnum.class)。

4.3 前置假设 Assume.that

有些性质只在特定条件下成立(前提条件),用 Assume.that 过滤,被过滤的样本不计入 checks:

@Property
void onlyForPositiveNumbers(@ForAll int a, @ForAll int b) {
    Assume.that(b != 0);
    assertEquals(a, (a / b) * b + a % b);
}

4.4 数据表 @Data / @FromData

穷举适合规则性矩阵,但有些组合是”产品/合规指定的固定清单”,直接列数据表:

@Data
Iterable<Tuple.Tuple3<String, Integer, Boolean>> settlementCases() {
    return Table.of(
        Tuple.of("NORMAL", 100, true),
        Tuple.of("SILVER", 100, false),   // 历史特殊政策:银卡 100 元不走补贴
        Tuple.of("GOLD", 99999, true)
    );
}

@Property
@FromData("settlementCases")
void settlementRules(@ForAll String level, @ForAll int amount, @ForAll boolean subsidized) {
    assertEquals(subsidized, settlementService.subsidized(level, amount));
}

4.5 复现与观察

  • 复现:失败报告自带 seed,加 @Property(seed = "报告里的值") 即可 100% 重放同一批样本。
  • 观察生成值:@Report(Reporting.GENERATED) 打印每轮生成的参数,适合排查”生成器是不是测了个寂寞”。
  • 观察分布:@StatisticsReport(format = Histogram.class) + Statistics.collect(...) 输出各分类命中直方图,验证采样是否均匀覆盖组合空间。

五、微服务 / 服务端 Java 实战

以下六个场景按落地优先级排序,全部是服务端日常代码。

5.1 接口入参校验:实现 vs 规格(oracle)

参数校验是最容易”实现与需求口径不一致”的地方。经典写法:把需求口径(正则/规则)作为 oracle,属性测试拿它与实现对照:

class PhoneValidator {
    private static final Pattern IMPL = Pattern.compile("^\\d{11}$"); // 实现口径(有 bug)

    static boolean isValid(String phone) {
        return phone != null && IMPL.matcher(phone).matches();
    }
}

class PhoneValidatorProperties {
    private static final Pattern ORACLE = Pattern.compile("^1[3-9]\\d{9}$"); // 需求口径

    @Provide
    Arbitrary<String> phoneCandidates() {
        // 贴输入空间:大部分是"形似手机号"的 11 位数字,少部分是各种垃圾串
        return Arbitraries.frequencyOf(
            Tuple.of(8, Arbitraries.strings().numeric().ofLength(11)),
            Tuple.of(2, Arbitraries.strings().alpha().numeric()
                            .withChars("-+ ()").ofMaxLength(20))
        );
    }

    @Property(tries = 2000)
    void implMatchesSpec(@ForAll("phoneCandidates") String candidate) {
        boolean expected = candidate != null && ORACLE.matcher(candidate).matches();
        assertEquals(expected, PhoneValidator.isValid(candidate));
    }
}

几轮之内就会失败并收缩到 "00000000000"——实现认为合法,需求口径不认。注意生成器的设计:如果你写 @ForAll String candidate 用默认字符串生成器,11 位纯数字的命中率极低,跑 2000 次也未必撞上反例——这就是”测了个寂寞”(第 7 节细说)。生成器必须贴近输入空间。

5.2 业务规则笛卡尔积:穷举替代用例矩阵

回到开篇的优惠计算。手写 300 条用例不现实,用穷举一行覆盖:

enum MemberLevel { NORMAL, SILVER, GOLD, PLATINUM }        // 4
enum CouponType  { NONE, DISCOUNT, CASHBACK }              // 3
enum ProductType { DIGITAL, FRESH, CLOTHING, BOOK, HOME }  // 5

@Property(generation = GenerationMode.EXHAUSTIVE)
void discountRulesHoldForAllCombinations(
        @ForAll MemberLevel level,
        @ForAll CouponType coupon,
        @ForAll ProductType product,
        @ForAll @IntRange(min = 0, max = 4) int priceBand) {

    long amount = representativeAmount(priceBand);   // 档位 → 代表金额
    DiscountResult result = pricingService.calc(level, coupon, product, amount);

    // 不变量 1:折扣永远落在 [0, 原价],金额非负
    assertThat(result.discount).isBetween(0L, amount);

    // 不变量 2:与独立参考实现一致(oracle 双算)
    assertEquals(manualCalc(level, coupon, product, amount), result);
}

4 × 3 × 5 × 5 = 300 种组合一个不落地执行,每次规则调整(比如新增会员等级)穷举空间自动扩大,不需要人工维护用例矩阵。manualCalc 建议用最直白的 if-else 写(越直白越不像被测代码越好),或者用上一版本的实现做迁移对照。

值域变大后(比如金额连续取值),切回随机采样并加大 tries,配合 @StatisticsReport 直方图确认组合覆盖没有偏斜。

5.3 序列化往返(round-trip):任意对象进出还原

RPC 框架、消息队列、缓存的公共底座是序列化。round-trip 是最经典的属性:任意对象序列化再反序列化,必须与自身相等。

record Order(String orderNo, List<OrderItem> items, BigDecimal amount) {}
record OrderItem(String sku, int quantity) {}

@Property(tries = 500)
void jsonRoundTrip(@ForAll("orders") Order order) throws Exception {
    String json = MAPPER.writeValueAsString(order);
    Order restored = MAPPER.readValue(json, Order.class);
    assertEquals(order, restored);
}

配套 4.2 节的 @Provide 订单工厂(记得给 sku 加 @WithNull 概率、给 items 留空列表的概率——线上脏数据恰恰长这样),500 次采样覆盖了几千个人工用例才能覆盖的形态组合:空集合、null 字段、超长字符串、Unicode、极端数值。

同理适用于 Protobuf、Hessian——把中间的序列化器换掉即可。写过 Hessian 的读者应该能体会这种测试的价值:协议实现的 bug 几乎都藏在”某个字段是 null / 空集合 / 特殊字符”的组合里,而这正是 round-trip 属性自动轰炸的区域。

5.4 编解码 / 加解密幂等

任何 encode/decode、加密/解密、压缩/解压、签名/验签,都天然存在”逆向性”属性:

@Property
boolean base64RoundTrip(@ForAll byte[] bytes) {
    byte[] decoded = Base64.getDecoder().decode(Base64.getEncoder().encode(bytes));
    return Arrays.equals(bytes, decoded);
}

@Property
void aesGcmRoundTrip(@ForAll byte[] plaintext) throws Exception {
    Cipher enc = initCipher(Cipher.ENCRYPT_MODE);
    byte[] ciphertext = enc.doFinal(plaintext);
    Cipher dec = initCipher(Cipher.DECRYPT_MODE);
    assertArrayEquals(plaintext, dec.doFinal(ciphertext));
}

注意 byte[] 的生成器会自动带上空数组这个边界——空明文、空密文、空压缩输入是这类工具函数最常炸的地方。

5.5 状态机测试:订单流转与幂等

微服务里最难测的不是纯函数,而是状态流转。订单状态机的规则:CREATED → PAID → SHIPPED → COMPLETED,任意节点可 CANCELLED,但 SHIPPED/COMPLETED 不可取消,非法流转必须被拒绝。用 jqwik 状态机建模:

class OrderModel {
    OrderState state = OrderState.CREATED;
    boolean refunded = false;

    boolean isConsistent() {
        // 不变量:已取消必须已退款;已发货/已完成不可再取消
        if (state == OrderState.CANCELLED) return refunded;
        return true;
    }
    // pay() / ship() / complete() / cancel() 修改状态,非法流转抛异常
}

class PayAction implements Action<OrderModel> {
    @Override
    public boolean precondition(OrderModel model) {
        return model.state == OrderState.CREATED;   // 只有新建单能支付
    }
    @Override
    public OrderModel run(OrderModel model) {
        return model.pay();
    }
    @Override
    public String toString() { return "pay"; }      // 失败时动作序列可读
}
// ShipAction / CompleteAction / CancelAction 同理

@Provide
Arbitrary<Action<OrderModel>> orderActions() {
    return Arbitraries.oneOf(
        Arbitraries.just(new PayAction()),
        Arbitraries.just(new ShipAction()),
        Arbitraries.just(new CompleteAction()),
        Arbitraries.just(new CancelAction()));
}

@Property
void orderStateMachineIsConsistent(@ForAll("sequences") ActionSequence<OrderModel> sequence) {
    OrderModel model = sequence.run(new OrderModel());
    assertTrue(model.isConsistent());
}

@Provide
Arbitrary<ActionSequence<OrderModel>> sequences() {
    return Arbitraries.sequences(orderActions());
}

jqwik 随机生成任意长度的合法动作序列(precondition 保证序列合法),跑完断言不变量。规则改坏(比如允许未支付直接发货)时,框架会收缩动作序列——失败报告会给出类似 [pay, cancel, refund] 这种最短触发路径。

同一套机制可以建模具他场景:幂等接口(动作 = 相同请求重复投递,不变量 = 只产生一次副作用)、限流器(动作 = 突发请求,不变量 = 计数不漂移、窗口滑移正确)、重试队列(动作 = 投递/超时/重试,不变量 = 消息不丢不重)。

5.6 Spring Boot 集成与 CI 策略

jqwik 官方提供 Spring 扩展模块 jqwik-spring(0.12.0,需 Java 17+,支持 Spring Framework 5.2/5.3/6.1、Spring Boot 2.6/2.7/3.2):

<dependency>
    <groupId>net.jqwik</groupId>
    <artifactId>jqwik-spring</artifactId>
    <version>0.12.0</version>
    <scope>test</scope>
</dependency>
@JqwikSpringSupport
@SpringBootTest
class PricingServiceSpringProperties {

    @Property(tries = 100)
    void discountWithinBounds(@ForAll("orders") Order order,
                              @Autowired PricingService service) {
        DiscountResult r = service.calc(order);
        assertThat(r.discount).isBetween(0L, order.amount());
    }
}

@Autowired 支持字段注入,也支持参数注入(@ForAll 和 @Autowired 可以共存于同一方法)。三个工程注意点:

  1. 上下文生命周期:Spring 上下文按测试类创建一次,类内所有属性共享 bean 状态。若某个属性会污染 bean 状态(如计数器),加 @DirtiesContext 让它每次重来。
  2. 控制 tries:@SpringBootTest 起一次上下文可能就要几秒,默认 1000 tries 不现实,集成级属性建议 tries = 50~100,把穷举留给纯领域层(不依赖 Spring 的测试)。
  3. 分层策略:PBT 的主战场是领域层和工具层(纯逻辑,无 Spring,1000 tries 毫秒级跑完);Spring 集成层只做装配验证。别让属性测试背上集成测试的重量。

CI 上的闭环流程:属性在流水线失败 → 从报告中取 seed 和收缩后的样本 → 在 bug 单里记录两者 → 本地加 @Property(seed = "...") 复现修复 → 回归。jqwik 默认 afterFailure = SAMPLE_FIRST,下次运行会先重放上次失败样本,所以即使不锁 seed,失败也能稳定复现。


六、最佳实践

6.1 属性的来源套路

不知道写什么属性?四类模板基本覆盖服务端场景:

套路 形式 示例
逆向性 decode(encode(x)) == x 序列化、编解码、加解密、压缩
幂等性 f(f(x)) == f(x) 去重、幂等接口、Set.add
不变量 任意输入下恒成立的事实 折扣 ≤ 原价、排序后首元素最小、状态机终态不可逆
oracle 对照 实现 == 参考实现 正则规格、直白 if-else 双算、旧版本实现

6.2 生成器贴业务分布

均匀随机 ≠ 有效覆盖。@ForAll String 生成 11 位纯数字手机号的概率趋近于零(见 5.1),这种属性跑一年也找不到反例。生成器要回答:”生产环境的输入长什么样“——用 frequencyOf 加权、用 @WithNull 注入脏数据、用 @Provide 建业务工厂并全局复用。一个团队沉淀一套 Orders / Users / Payments 生成器,属性测试的编写成本会断崖式下降。

6.3 失败必可复现

属性测试最怕”偶发失败查无对证”。jqwik 的失败报告自带 seed 和 shrink 后样本,两个都写进 bug 单;复现用 @Property(seed = "...")。修完 bug 后,把最小反例转成一条普通 @Test留在测试库里——它是对未来回归最便宜的一道锁。

6.4 穷举优先于随机

值域小(组合数 ≤ 1000 量级)时,穷举完胜随机:100% 覆盖、零重复、零运气成分。GenerationMode.AUTO 会自动切换,但你心里要有这根弦——发现属性用了枚举参数,就顺手确认它在穷举。覆盖是穷举出来的,不是概率保证的。

6.5 属性要纯

属性方法里不要读系统时间、不要依赖全局静态状态、不要直接打网络。这些会让属性今天过、明天挂,摧毁团队对 PBT 的信任。IO 依赖放外层 mock,集成场景用 Testcontainers 且控制 tries。

6.6 与 AI 编程的闭环

属性测试在 AI 时代有个新角色:可执行规格(executable specification)。

① 用属性描述规则(@Property + 不变量/oracle)
② AI 生成实现(属性文件作为上下文喂给模型)
③ 跑 PBT 验收
④ 失败 → 把 seed + 最小反例喂回 AI 修复
⑤ 循环直到属性通过

属性代码比自然语言规格精确得多——”折扣不能超过原价、金额非负”这类约束写成断言,AI 不会理解偏差;而 Integer.MIN_VALUE 这类反例,PBT 替人想好了。这是目前”AI 写代码、人/工具管验收”组合里,自动化程度最高的验收形态之一。

6.7 落地节奏

不要在存量项目里全面铺开。按收益/成本排序推进:

  1. 工具层(编解码、序列化、校验器)——纯函数,属性好写,当天见效;
  2. 业务规则(优惠、费率、结算)——穷举 + oracle 双算,直接替代用例矩阵;
  3. 状态机(订单、幂等、重试)——最难的时序 bug 高发区;
  4. Spring 集成层——小 tries 冒烟,作为补充而非主力。

七、局限与注意

  • 不替代示例测试。@Test 锚定具体行为(快照式断言、可读的典型场景),@Property 验证普遍性质,两者互补。最小反例转 @Test(6.3)就是两者的桥梁。
  • 生成器质量决定一切。生成器不贴业务分布,属性测试就是”测了个寂寞”,还会给人虚假安全感。写完属性先看 @Report(Reporting.GENERATED) 确认生成值长什么样子。
  • 有副作用/依赖 IO 的属性要谨慎。数据库、消息、缓存的属性测试需要 mock 或容器化环境,样本量一大成本陡增,tries 必须收敛。
  • 团队学习成本。属性测试的思维切换(从”构造用例”到”声明性质”)需要时间,报告解读、生成器设计都需要培训。建议先在工具层小范围试点,用真实抓到的 bug 建立信任,再推广。

八、总结

回到开篇的问题:人工写用例怎么覆盖所有组合和边界?答案是换一种方式提问——不问”我要测哪些输入”,而问”这个函数对任意输入恒成立的性质是什么”。组合交给穷举(值域小)或采样(值域大),边界交给内置 edge cases,失败定位交给 shrinking,时序问题交给状态机。300 条用例矩阵被一个注解替代,且每次规则变更自动扩围。

在 AI 写代码的时代,这套机制的角色更清晰:AI 负责生成实现,jqwik 负责把边界和组合的验收自动化,反例回流修复。人从”想用例”中解放出来,去做只有人能做的事——把业务规则提炼成性质。

参考:

本文阅读量 次