解释器模式

解释器模式用于为一种简单语言定义语法，并用对象结构解释执行这些语法。

一句话理解：把一段表达式解析成对象，再由对象负责计算。

解决什么问题

有些系统允许用户写规则：

amount > 1000 and vip = true

或者：

department = "devops" or role = "admin"

如果规则简单、语法稳定，可以用解释器模式把规则拆成表达式对象，再执行判断。

基本结构

Expression
  -> TerminalExpression
  -> NonTerminalExpression
Context

角色：

• Expression：表达式接口。
• TerminalExpression：终结表达式，例如具体字段判断。
• NonTerminalExpression：非终结表达式，例如 and、or。
• Context：表达式执行时需要的上下文数据。

Java 示例

上下文：

import java.util.Map;

class RuleContext {
    private final Map<String, Object> values;

    RuleContext(Map<String, Object> values) {
        this.values = values;
    }

    public Object get(String key) {
        return values.get(key);
    }
}

表达式接口：

interface Expression {
    boolean interpret(RuleContext context);
}

字段等值表达式：

class EqualsExpression implements Expression {
    private final String key;
    private final Object expected;

    EqualsExpression(String key, Object expected) {
        this.key = key;
        this.expected = expected;
    }

    public boolean interpret(RuleContext context) {
        return expected.equals(context.get(key));
    }
}

大于表达式：

class GreaterThanExpression implements Expression {
    private final String key;
    private final int min;

    GreaterThanExpression(String key, int min) {
        this.key = key;
        this.min = min;
    }

    public boolean interpret(RuleContext context) {
        Object value = context.get(key);
        return value instanceof Number && ((Number) value).intValue() > min;
    }
}

组合表达式：

class AndExpression implements Expression {
    private final Expression left;
    private final Expression right;

    AndExpression(Expression left, Expression right) {
        this.left = left;
        this.right = right;
    }

    public boolean interpret(RuleContext context) {
        return left.interpret(context) && right.interpret(context);
    }
}

使用：

import java.util.HashMap;
import java.util.Map;

Map<String, Object> values = new HashMap<>();
values.put("amount", 1500);
values.put("vip", true);

Expression rule = new AndExpression(
        new GreaterThanExpression("amount", 1000),
        new EqualsExpression("vip", true)
);

RuleContext context = new RuleContext(values);

System.out.println(rule.interpret(context)); // true

使用场景

• 简单规则引擎。
• 表达式计算。
• 权限表达式。
• 查询条件解析。
• 模板变量解析。

优点

• 语法规则可以对象化。
• 新增表达式类型比较清晰。
• 适合表达式结构稳定的场景。

缺点

• 语法复杂后类数量会迅速增加。
• 性能通常不如专门解析器。
• 不适合复杂语言实现。
• 维护解析器本身有成本。

实战注意

解释器模式适合“小语言”。如果规则非常复杂，优先考虑成熟规则引擎、表达式引擎或脚本引擎，不要自己硬写一套大型解释器。