如何用Java写一个简单的规则引擎？

本文目录导读：

1. 基础版规则引擎
2. 具体业务示例
3. 高级版：声明式规则引擎
4. 核心特性说明

我来介绍一下如何用Java实现一个简单的规则引擎,这里提供两种实现方式：基础版和函数式版。

基础版规则引擎

1 规则接口和规则类

import java.util.function.Predicate;
// 规则接口
@FunctionalInterface
interface Rule<T> {
    boolean evaluate(T context);
    default Rule<T> and(Rule<T> other) {
        return context -> this.evaluate(context) && other.evaluate(context);
    }
    default Rule<T> or(Rule<T> other) {
        return context -> this.evaluate(context) || other.evaluate(context);
    }
    default Rule<T> negate() {
        return context -> !this.evaluate(context);
    }
}
// 条件规则
class ConditionRule<T> implements Rule<T> {
    private final String name;
    private final Predicate<T> condition;
    public ConditionRule(String name, Predicate<T> condition) {
        this.name = name;
        this.condition = condition;
    }
    @Override
    public boolean evaluate(T context) {
        return condition.test(context);
    }
    @Override
    public String toString() {
        return "Rule{" + name + "}";
    }
}

2 规则引擎核心

import java.util.*;
import java.util.stream.Collectors;
public class SimpleRuleEngine<T> {
    private final List<Rule<T>> rules;
    private final List<RuleAction<T>> actions;
    public SimpleRuleEngine() {
        this.rules = new ArrayList<>();
        this.actions = new ArrayList<>();
    }
    // 添加规则
    public void addRule(Rule<T> rule) {
        rules.add(rule);
    }
    // 添加带动作的规则
    public void addAction(RuleAction<T> action) {
        actions.add(action);
    }
    // 执行所有规则
    public boolean evaluate(T context) {
        return rules.stream().allMatch(rule -> rule.evaluate(context));
    }
    // 执行带动作的规则
    public void execute(T context) {
        actions.stream()
            .filter(action -> action.rule().evaluate(context))
            .forEach(action -> action.action().execute(context));
    }
    // 获取满足的规则
    public List<Rule<T>> getMatchedRules(T context) {
        return rules.stream()
            .filter(rule -> rule.evaluate(context))
            .collect(Collectors.toList());
    }
}
// 动作接口
@FunctionalInterface
interface Action<T> {
    void execute(T context);
}
// 规则动作记录
record RuleAction<T>(Rule<T> rule, Action<T> action) {
    public RuleAction {
        Objects.requireNonNull(rule, "Rule cannot be null");
        Objects.requireNonNull(action, "Action cannot be null");
    }
}

具体业务示例

1 用户风险评估系统

public class UserRiskAssessment {
    public static void main(String[] args) {
        // 创建规则引擎
        SimpleRuleEngine<User> engine = new SimpleRuleEngine<>();
        // 定义规则和动作
        // 规则1：VIP用户
        Rule<User> isVip = new ConditionRule<>("VIP用户", 
            user -> user.isVip());
        // 规则2：高消费用户
        Rule<User> highSpender = new ConditionRule<>("高消费用户",
            user -> user.getTotalSpent() > 10000);
        // 规则3：新用户
        Rule<User> isNew = new ConditionRule<>("新用户",
            user -> user.getRegistrationDays() < 30);
        // 规则4：活跃用户
        Rule<User> isActive = new ConditionRule<>("活跃用户",
            user -> user.getLoginCount() > 100);
        // 组合规则：高风险用户（VIP且高消费但非活跃）
        Rule<User> highRisk = isVip.and(highSpender).and(isActive.negate());
        // 添加规则到引擎
        engine.addAction(new RuleAction<>(isVip, ctx -> 
            System.out.println("VIP用户：提供专属优惠")));
        engine.addAction(new RuleAction<>(highSpender, ctx ->
            System.out.println("高消费用户：提供积分加倍")));
        engine.addAction(new RuleAction<>(highRisk, ctx ->
            System.out.println("高风险用户：需要人工审核")));
        // 测试数据
        User user = new User("张三");
        user.setVip(true);
        user.setTotalSpent(50000);
        user.setRegistrationDays(200);
        user.setLoginCount(50);
        // 执行规则
        System.out.println("====== 用户风险评估 ======");
        System.out.println("用户：" + user.getName());
        engine.execute(user);
        // 检查是否满足特定规则
        System.out.println("\n====== 规则检查 ======");
        System.out.println("是否VIP：" + isVip.evaluate(user));
        System.out.println("是否高消费：" + highSpender.evaluate(user));
        System.out.println("是否高风险：" + highRisk.evaluate(user));
    }
}
// 用户类
class User {
    private String name;
    private boolean vip;
    private double totalSpent;
    private int registrationDays;
    private int loginCount;
    public User(String name) {
        this.name = name;
    }
    // getters and setters
    public String getName() { return name; }
    public boolean isVip() { return vip; }
    public void setVip(boolean vip) { this.vip = vip; }
    public double getTotalSpent() { return totalSpent; }
    public void setTotalSpent(double totalSpent) { this.totalSpent = totalSpent; }
    public int getRegistrationDays() { return registrationDays; }
    public void setRegistrationDays(int days) { this.registrationDays = days; }
    public int getLoginCount() { return loginCount; }
    public void setLoginCount(int count) { this.loginCount = count; }
}

高级版：声明式规则引擎

import java.lang.annotation.*;
import java.lang.reflect.*;
import java.util.*;
// 规则注解
@Retention(RetentionPolicy.RUNTIME)
@Target(ElementType.METHOD)
@interface Rule {
    String name() default "";
    String condition() default "";
}
// 规则引擎注解版本
public class AnnotationRuleEngine<T> {
    private final Map<String, RuleDefinition<T>> rules = new HashMap<>();
    public void registerRules(Object ruleObject) {
        for (Method method : ruleObject.getClass().getMethods()) {
            if (method.isAnnotationPresent(Rule.class)) {
                Rule rule = method.getAnnotation(Rule.class);
                String ruleName = rule.name().isEmpty() ? method.getName() : rule.name();
                rules.put(ruleName, new RuleDefinition<>(
                    ruleName,
                    rule.condition(),
                    context -> {
                        try {
                            return (Boolean) method.invoke(ruleObject, context);
                        } catch (Exception e) {
                            throw new RuntimeException("Rule execution failed", e);
                        }
                    }
                ));
            }
        }
    }
    public List<String> executeRules(T context) {
        List<String> matchedRules = new ArrayList<>();
        for (Map.Entry<String, RuleDefinition<T>> entry : rules.entrySet()) {
            if (entry.getValue().evaluate(context)) {
                matchedRules.add(entry.getKey());
                System.out.println("规则 '" + entry.getKey() + "' 被触发");
            }
        }
        return matchedRules;
    }
}
// 规则定义
class RuleDefinition<T> {
    private final String name;
    private final String condition;
    private final Rule<T> rule;
    public RuleDefinition(String name, String condition, Rule<T> rule) {
        this.name = name;
        this.condition = condition;
        this.rule = rule;
    }
    public boolean evaluate(T context) {
        return rule.evaluate(context);
    }
}
// 使用注解的规则示例
public class OrderRules {
    @Rule(name = "大额订单", condition = "金额 > 10000")
    public boolean isLargeOrder(Order order) {
        return order.getAmount() > 10000;
    }
    @Rule(name = "紧急订单", condition = "需要快速处理")
    public boolean isUrgentOrder(Order order) {
        return order.isUrgent();
    }
    @Rule(name = "新客户订单", condition = "注册时间 < 30天")
    public boolean isNewCustomerOrder(Order order) {
        return order.getCustomer().getRegistrationDays() < 30;
    }
}
class Order {
    private double amount;
    private boolean urgent;
    private User customer;
    // getters and setters...
    public double getAmount() { return amount; }
    public void setAmount(double amount) { this.amount = amount; }
    public boolean isUrgent() { return urgent; }
    public void setUrgent(boolean urgent) { this.urgent = urgent; }
    public User getCustomer() { return customer; }
    public void setCustomer(User customer) { this.customer = customer; }
}
// 使用示例
public class Main {
    public static void main(String[] args) {
        // 声明式规则引擎使用
        AnnotationRuleEngine<Order> engine = new AnnotationRuleEngine<>();
        engine.registerRules(new OrderRules());
        Order order = new Order();
        order.setAmount(15000);
        order.setUrgent(true);
        User customer = new User("李四");
        customer.setRegistrationDays(5);
        order.setCustomer(customer);
        System.out.println("===== 订单规则检查 =====");
        engine.executeRules(order);
    }
}

核心特性说明

1 优势

• 可配置性：规则可以动态添加和修改
• 可组合性：支持规则的逻辑组合（AND, OR, NOT）
• 可扩展性：易于添加新的规则类型
• 解耦性：业务规则和业务逻辑分离

2 适用场景

• 风控系统（风险评估、欺诈检测）
• 推荐系统（用户画像匹配）
• 流程引擎（审批规则、路由规则）
• 价格计算（折扣规则、促销规则）

3 扩展建议

• 支持规则优先级排序
• 添加规则冲突检测
• 实现规则持久化（数据库存储）
• 提供规则管理界面
• 支持规则热加载

这个简单的规则引擎实现展示了核心设计思想,你可以根据实际需求进行扩展和优化。