概述
上篇文章,我们学习了命令模式。本章,我们来学习解释器模式,它用来描述如何构建一个简单的 “语言” 解释器。比如命令模式,解释器模式更加小众,只在一些特定的领域内会被用到,比如编译器、规则引擎、正则表达式。所以,解释器模式,只要稍微了解即可。
解释器模式的原理和实现
解释器模式的英文翻译是 Interpreter Design Pattern。在 GoF 的《设计模式》中,是这样定义的:
Interpreter pattern is used to defines a grammatical representation for a language and provides an Interpreter to deal with this grammar.
翻译成中文:解释器模式为某个语言定义它的语法(或者叫文法)表示,并定义一个解释器来处理这个语法。
看了定义,你估计会一头雾水,因为这里面有很多我们平时开发中很少接触的概念,比如 “语言” “解释器”。实际上,这里的 “语言” 不仅仅指我们平时说的 中、英、法等各种语言。从广义上来讲,只要是能承载信息的载体,我们都可以称之为 “语言”,比如,古代的结绳记事、盲文、哑语、摩斯密码等。
要想来了解 “语言” 表达的意思,就必须定义相应的语法规则。这样,书写者就可以根据语法规则来书写 “句子” (专业点的叫法应该是 “表达式”),阅读者根据语法规则来阅读 “句子”,这样才能做到信息的正确传递。而我们要讲的解释器模式,其实就是用来实现语法规则解读 “句子” 的解释器。
我们来举一个比较贴近生活的例子。比如中英文翻译。我们知道,把英文翻译成中文是有一定的规则的。这个规则就是定义种的 “语法”。我们开发一个类似 Google Translate 这样的翻译器,这个翻译器能够根据语法规则,将输入的中文翻译成英文。这里的翻译器就是解释器模式定义种的 “解释器”。
现在,我们再来举一个更加贴近编程的例子。
假设我们定义了一个新的加减乘除计算 “语言”,语法规则如下:
- 运算符质保函加、减、乘、除,并且没有优先级概念
- 表达式(也就是前面的句子)中,先书写数字,后书写运算符,空格隔开。
- 按照先后顺序,取出两个数字和一个运算符计算结果,结果重新放入数字的最头部位置,循环上述过程,直到剩下一个数字,这个数字就是表达式最终的计算结果。
比如,“ 8 3 2 4 - + *
” 这样一个表达式,按照上面的语法规则来处理:
- 取出数字
8 3
和-
运算符,计算得到5
,于是表达式就变成了5 2 4 + *
。 - 然后,我们再取出
5 2
和+
,计算得到7,表达式就变成了7 4 *
。 - 最后取出
7 4
和*
运算符,最终得到的结果是28
。
看懂了上面的语法规则,下面的具体的代码实现。代码非常简单,用户按照上面的规则书写表达式,传递给 interpret()
函数,就可以得到最终的计算结果。
public class ExpressionInterpreter {
private Deque<Long> numbers = new LinkedList<>();
public long interpret(String expression) {
String[] elements = expression.split(" ");
int length = elements.length;
for (int i = 0; i < (length+1)/2; i++) {
numbers.addLast(Long.parseLong(elements[i]));
}
for (int i = (length+1)/2; i < length; i++) {
String operator = elements[i];
boolean isValid = "+".equals(operator) || "-".equals(operator)
|| "*".equals(operator) || "/".equals(operator);
if (isValid) {
throw new RuntimeException("Invalid expression: " + expression);
}
long number1 = numbers.pollFirst();
long number2 = numbers.pollFirst();
long result = 0;
if ("+".equals(operator)) {
result = number1 + number2;
} else if ("-".equals(operator)) {
result = number1 - number2;
} else if ("*".equals(operator)) {
result = number1 * number2;
} else if ("/".equals(operator)) {
result = number1 / number2;
}
numbers.addFirst(result);
}
if (numbers.size() != 1) {
throw new RuntimeException("Invalid expression: " + expression);
}
return numbers.pop();
}
}
上面的代码实现中,语法规则的解析逻辑都集中在一个函数,对于简单的语法规则解析,这样的设计足够了。但是,对于复杂的语法规则的解析,逻辑复杂,代码量多,所有的解析都耦合在一个函数中,这样显然是不合适的。这个时候,我们就要考虑拆分代码,将解析逻辑拆分到独立的小类中。
该怎么拆分?这个时候就需要解释器模式了。
解释器模式的代码实现比较灵活,没有固定的模板。前面我们说过,应用设计模式主要是应对代码的复杂性,实际上,解释器模式也不例外。它的代码实现的核心思想,就是将语法解析的工作拆分到各个小类中,以此来避免大而全的解析类。一般的做法是,将语法规则拆分成一些小的独立的单元,然后对每个单元进行解析,最终合并为对整个语法规则的解析。
前面定义的语法规则有两类表达式,一类是数字,一类是运算符,运算符包括加减乘除。利用解释器模式,我们把解析的工作拆分为 NumberExpression
、AdditionExpression
、SubstractionExpression
、MultiplicationExpression
、DivisionExpression
这样五个解析类中。
按照这个思路,我们对代码进行重构,重构之后的代码如下所示。当然,因为加减乘除比较简单,利用解释器模式的设计思路,看起来有点过度设计。不过呢,这里我主要是为了解释原理,你明白意思就好,不用过度细究这个例子。
public interface Expression {
long interpret();
}
public class NumberExpression implements Expression {
private long number;
public NumberExpression(long number) {
this.number = number;
}
public NumberExpression(String number) {
this.number = Long.parseLong(number);
}
@Override
public long interpret() {
return this.number;
}
}
public class SubstractionExpression implements Expression {
private Expression exp1;
private Expression exp2;
public SubstractionExpression(Expression exp1, Expression exp2) {
this.exp1 = exp1;
this.exp2 = exp2;
}
@Override
public long interpret() {
return exp1.interpret() - exp2.interpret();
}
}
public class MultiplicationExpression implements Expression {
private Expression exp1;
private Expression exp2;
public MultiplicationExpression(Expression exp1, Expression exp2) {
this.exp1 = exp1;
this.exp2 = exp2;
}
@Override
public long interpret() {
return exp1.interpret() * exp2.interpret();
}
}
public class DivisionExpression implements Expression {
private Expression exp1;
private Expression exp2;
public DivisionExpression(Expression exp1, Expression exp2) {
this.exp1 = exp1;
this.exp2 = exp2;
}
@Override
public long interpret() {
return exp1.interpret() / exp2.interpret();
}
}
public class ExpressionInterpreter {
private Deque<Expression> numbers = new LinkedList<>();
public long interpret(String expression) {
String[] elements = expression.split(" ");
int length = elements.length;
for (int i = 0; i < (length+1)/2; i++) {
numbers.addLast(new NumberExpression(elements[i]));
}
for (int i = (length+1)/2; i < length; i++) {
String operator = elements[i];
boolean isValid = "+".equals(operator) || "-".equals(operator)
|| "*".equals(operator) || "/".equals(operator);
if (isValid) {
throw new RuntimeException("Invalid expression: " + expression);
}
Expression exp1 = numbers.pollFirst();
Expression exp2 = numbers.pollFirst();
Expression combineExp = null;
if ("+".equals(operator)) {
combineExp = new AdditionExpression(exp1, exp2);
} else if ("-".equals(operator)) {
combineExp = new SubstractionExpression(exp1, exp2);
} else if ("*".equals(operator)) {
combineExp = new MultiplicationExpression(exp1, exp2);
} else if ("/".equals(operator)) {
combineExp = new DivisionExpression(exp1, exp2);
}
long result = combineExp.interpret();
numbers.addFirst(new NumberExpression(result));
}
if (numbers.size() != 1) {
throw new RuntimeException("Invalid expression: " + expression);
}
return numbers.pop().interpret();
}
}
解释器模式实战举例
接下来,再来看一个更加贴近实战的例子:如何实现一个自定义接口告警规则功能?
在我们平时的开发中,监控系统非常重要,它可以时刻监控业务系统的运行情况,及时将异常报告给开发者。比如,如果接口每分钟出错数超过 100,监控系统就通过短信、微信、邮件等方式发送告警给开发者。
一般来讲,监控系统支持开发者自定义告警规则,比如我们可以用下面这样一个表达式,来表示一个告警规则,它表达的意思是:每分钟 API 总出错数超过 100 或者每分钟 API 总调用数超过 10000 就出发告警。
api_error_per_minute > 100 || api_count_per_minute > 10000
在监控系统重,告警模块只负责统计数据和告警规则,判断是否出发告警。至于每分钟 API 接口出错数、每分钟接口调用总数等统计数据的计算,是由其他模块来负责的。其他模块将统计数据放到一个 Map 中(数据的格式如下所示),发送给告警模块。接下来,我们只关注告警模块。
Map<String, Long> apiStat = new HashMap<>();
apiStat.put("api_error_per_minute", 103L);
apiStat.put("api_count_per_minute", 987L);
为了简化讲解和代码实现,我们假设自定义的告警规则只包含 ||、&&、>、<、==
这五个运算符:
- 其中,
>、<、==
运算符的优先级高于||、&&
运算符, -
&&
优先级高于||
。 - 在表达式中,任意元素之间需要通过空格来分隔。
- 此外,用户要可以自定义要监控的 key,比如前面的
api_error_per_minute
、api_count_per_minute
。
那如何实现上面的需求呢?下面写了一个骨架代码,其中的核心思想我没有给出,你可以自己试着补全一下。
public class AlertRuleInterpreter {
// key1 > 100 && key2 < 1000 || key3 == 200
public AlertRuleInterpreter(String ruleExpression) {
// 由你来完善
}
//<String, Long> apiStat = new HashMap<>();
//apiStat.put("key1", 103);
//apiStat.put("key2", 987);
public boolean interpret(Map<String, Long> stats) {
boolean result = false;
// 由你来完善
return result;
}
}
public class DemoTest {
public static void main(String[] args) {
String rule = "key1 > 100 && key2 < 30 || key3 < 100 || key4 == 88";
AlertRuleInterpreter interpreter = new AlertRuleInterpreter(rule);
Map<String, Long> stats = new HashMap<>();
stats.put("key1", 101L);
stats.put("key3", 121L);
stats.put("key4", 88L);
boolean alert = interpreter.interpret(stats);
System.out.println(alert);
}
}
实际上,我们可以把自定义的告警规则,看作一种特殊 “语言” 的语法规则。我们实现一个解释器,能够根据规则,针对用户输入的数据,判断是否出发告警。利用解释器模式,我们把解析表达式的逻辑拆分到各个小类中,避免大而复杂的大量出现。按照这个实现思路,我把刚刚的代码补全,如下所示。
public interface Expression {
boolean interpret(Map<String, Long> stats);
}
public class GreaterExpression implements Expression {
private String key;
private long value;
public GreaterExpression(String strExpression) {
String[] elements = strExpression.trim().split("\\s+");
if (elements.length != 3 || !elements[1].trim().equals(">")) {
throw new RuntimeException("Invalid expression: " + strExpression);
}
this.key = elements[0];
this.value = Long.parseLong(elements[2].trim());
}
public GreaterExpression(String key, long value) {
this.key = key;
this.value = value;
}
@Override
public boolean interpret(Map<String, Long> stats) {
if (!stats.containsKey(this.key)) {
return false;
}
long statValue = stats.get(this.key);
return statValue > this.value;
}
}
public class LessExpression implements Expression {
private String key;
private long value;
public LessExpression(String strExpression) {
String[] elements = strExpression.trim().split("\\s+");
if (elements.length != 3 || !elements[1].trim().equals("<")) {
throw new RuntimeException("Invalid expression: " + strExpression);
}
this.key = elements[0];
this.value = Long.parseLong(elements[2].trim());
}
public LessExpression(String key, long value) {
this.key = key;
this.value = value;
}
@Override
public boolean interpret(Map<String, Long> stats) {
if (!stats.containsKey(this.key)) {
return false;
}
long statValue = stats.get(this.key);
return statValue < this.value;
}
}
public class EqualsExpression implements Expression {
private String key;
private long value;
public EqualsExpression(String strExpression) {
String[] elements = strExpression.trim().split("\\s+");
if (elements.length != 3 || !elements[1].trim().equals("==")) {
throw new RuntimeException("Invalid expression: " + strExpression);
}
this.key = elements[0];
this.value = Long.parseLong(elements[2].trim());
}
public EqualsExpression(String key, long value) {
this.key = key;
this.value = value;
}
@Override
public boolean interpret(Map<String, Long> stats) {
if (!stats.containsKey(this.