解释器模式深度解析：如何用代码“说”一门自定义语言
在软件开发中，我们经常会遇到需要解析和执行特定语法或表达式的情况。比如，解析数学表达式、处理SQL查询条件、或者执行自定义的业务规则。这时候，解释器模式（Interpreter Pattern）就派上了用场。
什么是解释器模式？
解释器模式是一种行为型设计模式，它定义了一个语言的文法，并使用该文法来解释语言中的句子。简单来说，它提供了一种方式来表示语言的语法规则，并定义一个解释器来解释这些规则。
核心概念
解释器模式包含以下几个核心角色：
- 抽象表达式（Abstract Expression）：定义解释操作的接口
- 终结符表达式（Terminal Expression）：实现与文法中的终结符相关的解释操作
- 非终结符表达式（Nonterminal Expression）：实现与文法中的非终结符相关的解释操作
- 上下文（Context）：包含解释器之外的一些全局信息
- 客户端（Client）：构建表示特定语言中指定句子的抽象语法树
解释器模式的适用场景
解释器模式在以下场景中特别有用：
- 需要解释执行的语言的语法较为简单
- 效率不是关键问题（解释器模式通常效率不高）
- 需要频繁扩展语言的语法
- 处理重复出现的问题
实战：构建SQL条件表达式解析器
让我们通过一个实际的例子来理解解释器模式。我们将构建一个能够解析和执行简单SQL WHERE条件表达式的解释器。
定义表达式接口
首先，我们定义所有表达式都要实现的接口：
// 抽象表达式接口
public interface Expression {
boolean interpret(Map<String, Object> context);
}
实现终结符表达式
终结符表达式是语法树中的叶子节点，它们代表语言中的基本元素：
// 等于表达式
public class EqualsExpression implements Expression {
private String key;
private Object value;
public EqualsExpression(String key, Object value) {
this.key = key;
this.value = value;
}
@Override
public boolean interpret(Map<String, Object> context) {
return context.containsKey(key) &&
context.get(key).equals(value);
}
}
// 大于表达式
public class GreaterThanExpression implements Expression {
private String key;
private Comparable value;
public GreaterThanExpression(String key, Comparable value) {
this.key = key;
this.value = value;
}
@Override
public boolean interpret(Map<String, Object> context) {
if (!context.containsKey(key)) return false;
Object contextValue = context.get(key);
return contextValue instanceof Comparable &&
((Comparable) contextValue).compareTo(value) > 0;
}
}
实现非终结符表达式
非终结符表达式组合其他表达式来构建复杂的逻辑：
// 与表达式
public class AndExpression implements Expression {
private Expression left;
private Expression right;
public AndExpression(Expression left, Expression right) {
this.left = left;
this.right = right;
}
@Override
public boolean interpret(Map<String, Object> context) {
return left.interpret(context) && right.interpret(context);
}
}
// 或表达式
public class OrExpression implements Expression {
private Expression left;
private Expression right;
public OrExpression(Expression left, Expression right) {
this.left = left;
this.right = right;
}
@Override
public boolean interpret(Map<String, Object> context) {
return left.interpret(context) || right.interpret(context);
}
}
// 非表达式
public class NotExpression implements Expression {
private Expression expression;
public NotExpression(Expression expression) {
this.expression = expression;
}
@Override
public boolean interpret(Map<String, Object> context) {
return !expression.interpret(context);
}
}
构建表达式解析器
现在我们需要一个解析器，能够将字符串表达式转换为表达式对象：
public class ExpressionParser {
private String expression;
private int position;
public ExpressionParser(String expression) {
this.expression = expression.replaceAll("\\s+", "");
this.position = 0;
}
public Expression parse() {
return parseOrExpression();
}
private Expression parseOrExpression() {
Expression left = parseAndExpression();
while (position < expression.length()) {
if (match("OR")) {
Expression right = parseAndExpression();
left = new OrExpression(left, right);
} else {
break;
}
}
return left;
}
private Expression parseAndExpression() {
Expression left = parsePrimaryExpression();
while (position < expression.length()) {
if (match("AND")) {
Expression right = parsePrimaryExpression();
left = new AndExpression(left, right);
} else {
break;
}
}
return left;
}
private Expression parsePrimaryExpression() {
if (match("(")) {
Expression expr = parseOrExpression();
expect(")");
return expr;
} else if (match("NOT")) {
Expression expr = parsePrimaryExpression();
return new NotExpression(expr);
} else {
return parseComparisonExpression();
}
}
private Expression parseComparisonExpression() {
// 解析字段名
int start = position;
while (position < expression.length() &&
Character.isLetterOrDigit(expression.charAt(position))) {
position++;
}
String field = expression.substring(start, position);
// 解析操作符
if (match("=")) {
Object value = parseValue();
return new EqualsExpression(field, value);
} else if (match(">")) {
Comparable value = (Comparable) parseValue();
return new GreaterThanExpression(field, value);
} else {
throw new RuntimeException("Unknown operator at position " + position);
}
}
private Object parseValue() {
if (position >= expression.length()) {
throw new RuntimeException("Unexpected end of expression");
}
char current = expression.charAt(position);
if (current == '\'' || current == '"') {
// 字符串值
position++; // 跳过引号
int start = position;
while (position < expression.length() &&
expression.charAt(position) != current) {
position++;
}
String value = expression.substring(start, position);
position++; // 跳过结束引号
return value;
} else if (Character.isDigit(current)) {
// 数字值
int start = position;
while (position < expression.length() &&
(Character.isDigit(expression.charAt(position)) ||
expression.charAt(position) == '.')) {
position++;
}
String valueStr = expression.substring(start, position);
if (valueStr.contains(".")) {
return Double.parseDouble(valueStr);
} else {
return Integer.parseInt(valueStr);
}
} else {
throw new RuntimeException("Unexpected character at position " + position);
}
}
private boolean match(String expected) {
if (expression.startsWith(expected, position)) {
position += expected.length();
return true;
}
return false;
}
private void expect(String expected) {
if (!match(expected)) {
throw new RuntimeException("Expected '" + expected + "' at position " + position);
}
}
}
使用示例
现在让我们看看如何使用这个解释器：
public class SQLInterpreterDemo {
public static void main(String[] args) {
// 构建测试数据
Map<String, Object> user1 = new HashMap<>();
user1.put("name", "Alice");
user1.put("age", 25);
user1.put("salary", 50000.0);
Map<String, Object> user2 = new HashMap<>();
user2.put("name", "Bob");
user2.put("age", 30);
user2.put("salary", 60000.0);
Map<String, Object> user3 = new HashMap<>();
user3.put("name", "Charlie");
user3.put("age", 35);
user3.put("salary", 70000.0);
List<Map<String, Object>> users = Arrays.asList(user1, user2, user3);
// 解析并执行查询
String query = "age > 28 AND salary > 55000";
ExpressionParser parser = new ExpressionParser(query);
Expression expression = parser.parse();
System.out.println("Users matching: " + query);
for (Map<String, Object> user : users) {
if (expression.interpret(user)) {
System.out.println("Found: " + user);
}
}
// 测试更复杂的查询
String complexQuery = "(age > 25 OR salary > 65000) AND NOT name = 'Bob'";
ExpressionParser complexParser = new ExpressionParser(complexQuery);
Expression complexExpression = complexParser.parse();
System.out.println("\nUsers matching: " + complexQuery);
for (Map<String, Object> user : users) {
if (complexExpression.interpret(user)) {
System.out.println("Found: " + user);
}
}
}
}
解释器模式的优缺点
优点
- 易于扩展语法：添加新的表达式类即可扩展语言功能
- 易于实现：每个表达式类都相对简单，易于实现和测试
- 可维护性：将语法规则表示为类，使得语法更易于理解和修改
缺点
- 性能问题：解释器模式通常效率较低，特别是对于复杂语法
- 复杂性：对于复杂语法，需要定义大量的类，导致系统复杂
- 难以维护：当语法规则很多时，维护大量的表达式类变得困难
实际应用场景
解释器模式在以下场景中有实际应用：
- 正则表达式引擎：将正则表达式编译为可执行的匹配逻辑
- 数学表达式计算器：解析和计算数学表达式
- SQL查询解析：如我们示例中展示的
- 业务规则引擎：执行复杂的业务规则
- 模板引擎：解析和执行模板语言
总结
解释器模式为处理自定义语言和表达式提供了一种优雅的解决方案。通过将语法规则表示为对象，我们可以构建灵活且可扩展的解释器。虽然它在处理复杂语法时可能不是最高效的选择，但对于中等复杂度的领域特定语言来说，它是一个非常强大的工具。
在实际应用中，解释器模式常常与其他模式结合使用，比如与访问者模式结合来遍历语法树，或者与工厂模式结合来创建表达式对象。理解解释器模式不仅有助于解决特定的解析问题，还能加深对编译原理和语言设计的理解。
当你下次需要处理自定义语法或表达式时，不妨考虑使用解释器模式，它可能会为你提供一个清晰而强大的解决方案。