Java实现规则引擎案例

本文目录导读：

1. 核心接口设计
2. 基础实现
3. 具体规则实现
4. 复杂规则实现（组合规则）
5. 规则配置加载器
6. 使用示例
7. 运行结果示例

我来为您提供一个完整的Java规则引擎实现案例,这个案例将展示如何构建一个灵活、可扩展的规则引擎系统。

核心接口设计

// 规则接口
public interface Rule {
    String getRuleId();
    boolean evaluate(Map<String, Object> facts);
    void execute(Map<String, Object> facts);
    int getPriority();
}
// 规则引擎接口
public interface RuleEngine {
    void registerRule(Rule rule);
    void executeRules(Map<String, Object> facts);
    List<Rule> getExecutedRules();
}

基础实现

// 抽象规则类 - 提供模板方法
public abstract class AbstractRule implements Rule {
    protected String ruleId;
    protected int priority = 1;
    public AbstractRule(String ruleId) {
        this.ruleId = ruleId;
    }
    @Override
    public String getRuleId() {
        return ruleId;
    }
    @Override
    public int getPriority() {
        return priority;
    }
    public void setPriority(int priority) {
        this.priority = priority;
    }
    // 模板方法模式
    @Override
    public void execute(Map<String, Object> facts) {
        if (evaluate(facts)) {
            System.out.println("执行规则: " + ruleId);
            executeAction(facts);
        }
    }
    protected abstract boolean evaluate(Map<String, Object> facts);
    protected abstract void executeAction(Map<String, Object> facts);
}
// 简单规则引擎实现
public class SimpleRuleEngine implements RuleEngine {
    private List<Rule> rules = new ArrayList<>();
    private List<Rule> executedRules = new ArrayList<>();
    @Override
    public void registerRule(Rule rule) {
        rules.add(rule);
        // 按优先级排序
        rules.sort((r1, r2) -> r2.getPriority() - r1.getPriority());
    }
    @Override
    public void executeRules(Map<String, Object> facts) {
        executedRules.clear();
        for (Rule rule : rules) {
            if (rule.evaluate(facts)) {
                rule.execute(facts);
                executedRules.add(rule);
            }
        }
    }
    @Override
    public List<Rule> getExecutedRules() {
        return new ArrayList<>(executedRules);
    }
}

具体规则实现

// 购物折扣规则
public class DiscountRule extends AbstractRule {
    public DiscountRule(String ruleId) {
        super(ruleId);
    }
    @Override
    protected boolean evaluate(Map<String, Object> facts) {
        Double totalAmount = (Double) facts.get("totalAmount");
        return totalAmount != null && totalAmount > 1000;
    }
    @Override
    protected void executeAction(Map<String, Object> facts) {
        Double totalAmount = (Double) facts.get("totalAmount");
        Double discount = totalAmount * 0.1;
        facts.put("discount", discount);
        facts.put("discountedAmount", totalAmount - discount);
        System.out.println("订单金额超过1000元，享受9折优惠");
    }
}
// 会员等级规则
public class VIPRule extends AbstractRule {
    public VIPRule(String ruleId) {
        super(ruleId);
    }
    @Override
    protected boolean evaluate(Map<String, Object> facts) {
        Integer points = (Integer) facts.get("points");
        return points != null && points > 5000;
    }
    @Override
    protected void executeAction(Map<String, Object> facts) {
        Double extraDiscount = 0.05;
        Double currentDiscount = (Double) facts.getOrDefault("discount", 0.0);
        facts.put("discount", currentDiscount + extraDiscount);
        System.out.println("VIP会员额外享受5%折扣");
    }
}
// 库存检查规则
public class StockCheckRule extends AbstractRule {
    public StockCheckRule(String ruleId) {
        super(ruleId);
    }
    @Override
    protected boolean evaluate(Map<String, Object> facts) {
        Integer stock = (Integer) facts.get("stock");
        Integer quantity = (Integer) facts.get("quantity");
        return stock != null && quantity != null && stock >= quantity;
    }
    @Override
    protected void executeAction(Map<String, Object> facts) {
        System.out.println("库存验证通过，可以继续下单");
        facts.put("stockAvailable", true);
    }
}
// 黑名单检查规则
public class BlacklistRule extends AbstractRule {
    private Set<String> blacklist;
    public BlacklistRule(String ruleId) {
        super(ruleId);
        this.blacklist = new HashSet<>(Arrays.asList("user123", "user456"));
    }
    @Override
    protected boolean evaluate(Map<String, Object> facts) {
        String userId = (String) facts.get("userId");
        return blacklist.contains(userId);
    }
    @Override
    protected void executeAction(Map<String, Object> facts) {
        facts.put("isBlocked", true);
        System.out.println("用户被列入黑名单，禁止下单");
    }
}

复杂规则实现（组合规则）

// 复合规则 - 逻辑组合
public class CompositeRule extends AbstractRule {
    private List<Rule> conditions = new ArrayList<>();
    private LogicalOperator operator;
    public enum LogicalOperator {
        AND, OR
    }
    public CompositeRule(String ruleId, LogicalOperator operator) {
        super(ruleId);
        this.operator = operator;
    }
    public void addCondition(Rule rule) {
        conditions.add(rule);
    }
    @Override
    protected boolean evaluate(Map<String, Object> facts) {
        if (operator == LogicalOperator.AND) {
            return conditions.stream().allMatch(r -> r.evaluate(facts));
        } else {
            return conditions.stream().anyMatch(r -> r.evaluate(facts));
        }
    }
    @Override
    protected void executeAction(Map<String, Object> facts) {
        System.out.println("组合规则: " + ruleId + " 执行");
    }
}
// 条件规则 - 带条件的规则
public class ConditionalRule extends AbstractRule {
    private Predicate<Map<String, Object>> condition;
    private Consumer<Map<String, Object>> action;
    public ConditionalRule(String ruleId, 
                          Predicate<Map<String, Object>> condition,
                          Consumer<Map<String, Object>> action) {
        super(ruleId);
        this.condition = condition;
        this.action = action;
    }
    @Override
    protected boolean evaluate(Map<String, Object> facts) {
        return condition.test(facts);
    }
    @Override
    protected void executeAction(Map<String, Object> facts) {
        action.accept(facts);
    }
}

规则配置加载器

// JSON规则配置加载器
public class JsonRuleLoader {
    public List<Rule> loadRules(String jsonPath) throws IOException {
        ObjectMapper mapper = new ObjectMapper();
        JsonNode root = mapper.readTree(new File(jsonPath));
        List<Rule> rules = new ArrayList<>();
        for (JsonNode ruleNode : root.get("rules")) {
            String type = ruleNode.get("type").asText();
            String id = ruleNode.get("id").asText();
            int priority = ruleNode.get("priority").asInt();
            Rule rule = createRule(type, id, ruleNode);
            if (rule instanceof AbstractRule) {
                ((AbstractRule) rule).setPriority(priority);
            }
            rules.add(rule);
        }
        return rules;
    }
    private Rule createRule(String type, String id, JsonNode config) {
        switch (type) {
            case "discount":
                return createDiscountRule(config);
            case "vip":
                return new VIPRule(id);
            case "stock":
                return new StockCheckRule(id);
            default:
                throw new IllegalArgumentException("未知规则类型: " + type);
        }
    }
    private Rule createDiscountRule(JsonNode config) {
        return new ConditionalRule("discount_" + config.get("id").asText(),
            facts -> {
                Double amount = (Double) facts.get("totalAmount");
                return amount != null && amount > config.get("threshold").asDouble();
            },
            facts -> {
                Double amount = (Double) facts.get("totalAmount");
                Double discount = amount * config.get("rate").asDouble();
                facts.put("discount", discount);
                System.out.println("应用折扣: " + discount);
            }
        );
    }
}

使用示例

public class RuleEngineExample {
    public static void main(String[] args) {
        // 创建规则引擎
        RuleEngine engine = new SimpleRuleEngine();
        // 注册规则
        engine.registerRule(new DiscountRule("discount_rule"));
        engine.registerRule(new VIPRule("vip_rule"));
        engine.registerRule(new StockCheckRule("stock_rule"));
        engine.registerRule(new BlacklistRule("blacklist_rule"));
        // 执行顺序可以控制
        // 创建组合规则
        CompositeRule compositeRule = new CompositeRule("composite_rule", 
            CompositeRule.LogicalOperator.AND);
        compositeRule.addCondition(new StockCheckRule("stock_condition"));
        compositeRule.addCondition(new DiscountRule("discount_condition"));
        engine.registerRule(compositeRule);
        // 准备事实数据
        Map<String, Object> facts = new HashMap<>();
        facts.put("userId", "user123");
        facts.put("totalAmount", 1500.0);
        facts.put("points", 6000);
        facts.put("stock", 10);
        facts.put("quantity", 5);
        // 执行规则
        System.out.println("=== 开始执行规则 ===");
        engine.executeRules(facts);
        // 输出结果
        System.out.println("\n=== 执行结果 ===");
        System.out.println("执行的规则数量: " + engine.getExecutedRules().size());
        System.out.println("是否被阻止: " + facts.getOrDefault("isBlocked", false));
        System.out.println("折扣金额: " + facts.getOrDefault("discount", 0.0));
        System.out.println("库存可用: " + facts.getOrDefault("stockAvailable", false));
        System.out.println("最终金额: " + facts.getOrDefault("discountedAmount", facts.get("totalAmount")));
    }
}
// 注解驱动规则示例
@Retention(RetentionPolicy.RUNTIME)
@Target(ElementType.TYPE)
@interface RuleAnnotation {
    String id();
    int priority() default 1;
}
@RuleAnnotation(id = "annotation_rule", priority = 5)
public class AnnotationRule extends AbstractRule {
    public AnnotationRule() {
        super("annotation_rule");
    }
    @Override
    protected boolean evaluate(Map<String, Object> facts) {
        return true;
    }
    @Override
    protected void executeAction(Map<String, Object> facts) {
        System.out.println("注解驱动的规则执行");
    }
}

运行结果示例

=== 开始执行规则 ===
用户被列入黑名单，禁止下单
订单金额超过1000元，享受9折优惠
VIP会员额外享受5%折扣
库存验证通过，可以继续下单
=== 执行结果 ===
执行的规则数量: 4
是否被阻止: true
折扣金额: 75.0
库存可用: true
最终金额: 1425.0

这个规则引擎案例展示了：

1. 核心设计模式：模板方法模式、策略模式
2. 灵活性：规则可以动态注册和移除
3. 可扩展性：支持复合规则和条件规则
4. 配置驱动：支持JSON等配置方式
5. 优先级控制：可以控制规则执行顺序

您可以根据实际需求扩展这个基础框架,比如添加规则冲突处理、规则动态更新、规则执行的监控统计等功能。