EasyRules：轻量级规则引擎的实战入门-深圳市維司達科技有限公司

1. 为什么你需要了解EasyRules？

如果你是一名开发者，肯定遇到过这样的场景：业务逻辑越来越复杂，代码里充斥着大量的if-else嵌套，每次修改都要小心翼翼，生怕影响其他逻辑。我曾经维护过一个用户积分系统，光是判断用户等级就有十几层条件判断，后来新增一个"特殊会员"类型时，差点把原有逻辑改崩。

这时候你就需要一个规则引擎来解救你。但传统的规则引擎如Drools学习曲线陡峭，配置复杂，对于中小型项目来说有点杀鸡用牛刀的感觉。EasyRules就是为解决这个问题而生的轻量级方案，它的核心代码只有几个类，学习成本低，却能帮你把业务规则从代码中彻底解耦。

我最近在一个电商促销系统中使用EasyRules实现了优惠券规则管理，原本需要一周开发的功能，用EasyRules两天就搞定了，而且后续业务调整时，产品经理直接改YAML配置文件就能上线新规则，再也不用等着开发排期了。

2. 快速理解EasyRules核心概念

2.1 三大核心组件

EasyRules的核心设计非常简洁，主要包含三个关键组件：

Fact：可以理解为事实数据，就是你的业务对象。比如在用户积分场景中，用户的当前积分、注册时长、最近消费金额等都可以作为Fact。在代码中通常用Map或者POJO来表示。
Rule：规则的定义，包含条件(condition)和动作(action)两部分。当条件满足时，就会执行对应的动作。比如"如果用户积分大于1000，则升级为黄金会员"就是一条典型规则。
RulesEngine：规则引擎，负责评估所有规则并执行符合条件的动作。EasyRules提供了两种引擎实现：默认引擎会按顺序执行所有符合条件的规则，而流式引擎则会在第一条符合条件的规则执行后就停止。

// 示例：用Map存储Fact Map<String, Object> facts = new HashMap<>(); facts.put("userScore", 1200); facts.put("userAge", 2); // 示例：一个简单的Rule定义 @Rule(name = "goldUserRule", description = "如果积分超过1000就是黄金用户") public class GoldUserRule { @Condition public boolean when(@Fact("userScore") int score) { return score > 1000; } @Action public void then() { System.out.println("恭喜升级为黄金会员！"); } }

2.2 与传统if-else的对比

为了更直观地理解EasyRules的价值，我们来看一个实际对比。假设要实现以下业务规则：

积分≥1000：黄金会员
积分≥500且注册满1年：白银会员
积分≥200：青铜会员

传统if-else实现：

if(score >= 1000) { user.setLevel("gold"); } else if(score >= 500 && user.getRegisterYears() >= 1) { user.setLevel("silver"); } else if(score >= 200) { user.setLevel("bronze"); }

使用EasyRules实现：

@Rule(name = "goldRule", priority = 1) public class GoldRule { @Condition public boolean when(@Fact("score") int score) { return score >= 1000; } @Action public void then() { user.setLevel("gold"); } } @Rule(name = "silverRule", priority = 2) public class SilverRule { @Condition public boolean when(@Fact("score") int score, @Fact("registerYears") int years) { return score >= 500 && years >= 1; } @Action public void then() { user.setLevel("silver"); } } // 其他规则类似...

优势显而易见：规则之间完全解耦，新增或修改规则不会影响其他规则；规则定义更接近自然语言，可读性更好；规则可以动态加载，无需重新部署应用。

3. 三种方式玩转规则定义

EasyRules最强大的地方在于它提供了多种规则定义方式，适应不同场景需求。下面我就以"用户积分等级评定"为例，分别演示三种主流方式。

3.1 注解方式：最适合Java开发者

注解方式是最直观的Java原生支持方式，适合规则相对固定的场景。我在实际项目中最常用的就是这种方式，它的优点是类型安全，IDE支持好，重构方便。

@Rule(name = "vipRule", description = "特殊VIP用户规则", priority = 1) public class VipUserRule { @Condition public boolean isVip( @Fact("score") int score, @Fact("consumption") double consumption) { return score > 5000 || consumption > 10000; } @Action public void setVip() { user.setVip(true); System.out.println("授予VIP身份"); } } // 使用方式 RulesEngineParameters params = new RulesEngineParameters() .skipOnFirstAppliedRule(true); // 使用流式引擎 RulesEngine engine = new DefaultRulesEngine(params); Rules rules = new Rules(); rules.register(new GoldUserRule()); rules.register(new VipUserRule()); engine.fire(rules, facts);

实战技巧：

通过priority属性控制规则执行顺序，数字越小优先级越高
使用skipOnFirstAppliedRule参数可以开启流式模式，匹配到第一条规则后就停止
规则类可以像普通Spring Bean一样被管理，方便集成到现有系统中

3.2 流式API：适合动态规则构建

当你需要根据运行时条件动态构建规则时，流式API是不二之选。我曾经做过一个动态促销系统，规则需要根据库存情况实时调整，流式API完美解决了这个问题。

Rule weatherRule = new RuleBuilder() .name("weatherPromotionRule") .description("下雨天雨伞打折") .when(facts -> "rainy".equals(facts.get("weather"))) .then(facts -> { product.setDiscount(0.8); System.out.println("启动雨天促销"); }) .build(); Rule stockRule = new RuleBuilder() .name("clearanceRule") .description("库存清理规则") .when(facts -> (int)facts.get("stock") > 1000) .then(facts -> { product.setDiscount(0.6); System.out.println("启动清仓促销"); }) .build(); Rules rules = new Rules(); rules.register(weatherRule); rules.register(stockRule); engine.fire(rules, facts);

适用场景：

规则需要根据用户输入或其他运行时条件动态生成
规则条件简单，不需要复杂逻辑判断
需要快速原型开发时

3.3 YAML配置：业务人员友好的方式

YAML方式是我最推荐给需要业务人员参与规则配置的场景。产品经理可以直接修改YAML文件调整业务规则，完全不需要开发介入。在我们的电商系统中，促销规则都是用这种方式管理的。

name: "newUserRule" description: "新用户首单优惠" priority: 1 condition: "user.new == true && order.first == true" actions: - "order.discount = 0.9" - "system.out.println('新用户首单享受9折')"

加载YAML规则：

Rules rules = YamlRuleFactory.createRulesFrom( new File("rules/new-user-rule.yml")); engine.fire(rules, facts);

最佳实践：

将不同业务领域的规则放在不同的YAML文件中
使用版本控制管理规则变更历史
可以配合Spring Cloud Config实现规则的热更新

4. 实战：用户积分等级系统

现在让我们把这些知识综合起来，实现一个完整的用户积分等级系统。这个案例来自我实际参与过的一个会员体系重构项目。

4.1 系统需求分析

我们需要实现以下业务规则：

基础等级规则：
- 积分≥5000：钻石会员
- 积分≥3000：白金会员
- 积分≥1000：黄金会员
- 积分≥500：白银会员
- 积分≥100：青铜会员
特殊规则：
- 连续签到7天：提升一个等级（最高到黄金）
- 最近30天消费满5000元：直接升级为白金
降级规则：
- 连续90天无消费：降一级
- 积分低于当前等级要求：降级到对应等级

4.2 实现步骤

首先定义我们的Fact对象：

public class User { private String userId; private int score; private String level; private int consecutiveCheckins; private double last30DaysConsumption; private LocalDate lastConsumptionDate; // getters/setters }

然后实现核心规则（以注解方式为例）：

@Rule(name = "diamondRule", priority = 1) public class DiamondRule { @Condition public boolean when(@Fact("user") User user) { return user.getScore() >= 5000; } @Action public void then(@Fact("user") User user) { if(!"diamond".equals(user.getLevel())) { user.setLevel("diamond"); sendNotification(user, "恭喜升级为钻石会员！"); } } } @Rule(name = "checkinBoostRule", priority = 10) public class CheckinBoostRule { @Condition public boolean when(@Fact("user") User user) { return user.getConsecutiveCheckins() >= 7 && !"gold".equals(user.getLevel()); } @Action public void then(@Fact("user") User user) { String newLevel = calculateUpgradedLevel(user.getLevel()); user.setLevel(newLevel); user.setConsecutiveCheckins(0); // 重置签到计数 } private String calculateUpgradedLevel(String current) { // 升级逻辑实现 } }

最后是引擎配置和执行：

public class LevelService { private RulesEngine engine; private Rules rules; @PostConstruct public void init() { engine = new DefaultRulesEngine( new RulesEngineParameters() .skipOnFirstNonTriggeredRule(false)); rules = new Rules(); rules.register(new DiamondRule()); rules.register(new CheckinBoostRule()); // 注册其他规则... } public void evaluate(User user) { Facts facts = new Facts(); facts.put("user", user); engine.fire(rules, facts); } }

4.3 遇到的坑与解决方案

在实际实现过程中，我遇到过几个典型问题：

规则执行顺序问题：最初没有设置priority，导致降级规则先于升级规则执行。解决方案是为所有规则明确设置优先级，确保升级规则先执行。
性能问题：当规则数量超过100条时，引擎执行时间明显变长。通过以下方式优化：
- 将规则按业务领域分组，不同场景使用不同的规则组
- 使用skipOnFirstNonTriggeredRule参数减少不必要的评估
- 对高频规则设置更高的优先级
规则冲突问题：两条规则的条件有重叠时可能产生冲突。我们引入了规则冲突检测机制，在测试阶段就发现并解决这类问题。

5. 进阶技巧与最佳实践

经过多个项目的实践，我总结出以下经验，能帮你更好地使用EasyRules。

5.1 如何组织大型规则集

当规则数量增多时，良好的组织方式至关重要：

按业务领域分包：例如将用户相关规则放在user包下，订单规则放在order包下。
使用规则组：通过组合模式将相关规则打包：

Rules userLevelRules = new Rules(); userLevelRules.register(new GoldRule()); userLevelRules.register(new SilverRule()); Rules promotionRules = new Rules(); promotionRules.register(new CouponRule()); promotionRules.register(new DiscountRule()); // 按需执行不同规则组 engine.fire(userLevelRules, userFacts); engine.fire(promotionRules, orderFacts);

版本化管理：为规则定义版本号，支持多版本规则共存，便于灰度发布和回滚。

5.2 测试策略

规则引擎的测试需要特别关注：

单元测试每个规则：确保每个规则的condition和action都正确：

@Test public void testGoldRule() { // 准备 GoldRule rule = new GoldRule(); User user = new User(); user.setScore(1200); Facts facts = new Facts(); facts.put("user", user); // 执行 & 验证 assertTrue(rule.when(facts)); rule.then(facts); assertEquals("gold", user.getLevel()); }

集成测试规则组合：验证多个规则一起执行时的效果。
性能测试：模拟生产环境的数据量，确保引擎性能达标。

5.3 与Spring集成

在Spring项目中使用EasyRules非常方便：

将规则类声明为Spring组件：

@Component @Rule(name = "springRule") public class SpringIntegrationRule { @Autowired private UserService userService; // 规则实现... }

自动发现并注册所有规则：

@Configuration public class RulesConfig { @Autowired private List<Object> ruleBeans; // 收集所有带有@Rule注解的Bean @Bean public Rules rules() { Rules rules = new Rules(); ruleBeans.forEach(rules::register); return rules; } }

在Service中使用：

@Service public class UserLevelService { @Autowired private RulesEngine engine; @Autowired private Rules rules; public void evaluateUser(User user) { Facts facts = new Facts(); facts.put("user", user); engine.fire(rules, facts); } }