解释器模式的原理和实现

解释器模式的英文翻译是 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.

翻译成中文就是：解释器模式为某个语言定义它的语法表示，并定义一个解释器用来处理这个语法。实际上，这里的“语言”不仅仅指我们平时说的中、英、日、法等各种语言。从广义上来讲，只要是能承载信息的载体，我们都可以称之为“语言”，比如，盲文、手语、摩斯密码等。

要想了解“语言”表达的信息，我们就必须定义相应的语法规则。这样，书写者就可以根据语法规则来书写“句子”（专业的叫法应该是“表达式”），阅读者根据语法规则来阅读“句子”，这样才能做到信息的正确传递。而解释器模式，其实就是用来实现根据语法规则解读“句子”的解释器。

我们再举个更加贴近编程的例子。假设我们定义了一个新的加减乘除计算“语言”，语法规则如下：

  • 运算符只包含加、减、乘、除，并且没有优先级的概念；
  • 表达式（也就是前面提到的“句子”）中，先书写数字，后书写运算符，空格隔开；
  • 按照先后顺序，取出两个数字和一个运算符计算结果，结果重新放入数字的最头部位置，循环上述过程，直到只剩下一个数字，这个数字就是表达式最终的计算结果。

比如“ 8 3 2 4 - + ”这样一个表达式，我们按照上面的语法规则来处理，取出数字“8 3”和“-”运算符，计算得到 5，于是表达式就变成了“ 5 2 4 + ”。然后再取出“ 5 2 ”和“ + ”运算符，计算得到 7，表达式就变成了“ 7 4 ”。最后，我们取出“ 7 4”和“ ”运算符，最终得到的结果就是 28。具体的代码实现如下：

  1. public class ExpressionInterpreter {
  3.     private Deque<Long> numbers = new LinkedList<>();
  5.     public long interpret(String expression) {
  6.         String[] elements = expression.split(" ");
  7.         int length = elements.length;
  8.         for (int i = 0; i < (length+1)/2; ++i) {
  9.             numbers.addLast(Long.parseLong(elements[i]));
  10.         }
  11.         for (int i = (length+1)/2; i < length; ++i) {
  12.             String operator = elements[i];
  13.             boolean isValid = "+".equals(operator) || "-".equals(operator)
  14.                 || "*".equals(operator) || "/".equals(operator);
  15.             if (!isValid) {
  16.                 throw new RuntimeException("Expression is invalid: " + expression);
  17.             }
  18.             long number1 = numbers.pollFirst();
  19.             long number2 = numbers.pollFirst();
  20.             long result = 0;
  21.             if (operator.equals("+")) {
  22.                 result = number1 + number2;
  23.             } else if (operator.equals("-")) {
  24.                 result = number1 - number2;
  25.             } else if (operator.equals("*")) {
  26.                 result = number1 * number2;
  27.             } else if (operator.equals("/")) {
  28.                 result = number1 / number2;
  29.             }
  30.             numbers.addFirst(result);
  31.         }
  32.         if (numbers.size() != 1) {
  33.             throw new RuntimeException("Expression is invalid: " + expression);
  34.         }
  35.         return numbers.pop();
  36.     }
  37. }

在上面的代码实现中，语法规则的解析逻辑（第 21 到 28 行）都集中在一个函数中，对于简单的语法规则的解析，这样的设计就足够了。但是，对于复杂的语法规则的解析，逻辑复杂，代码量多，所有的解析逻辑都耦合在一个函数中，这样显然是不合适的。这个时候，我们就要考虑拆分代码，将解析逻辑拆分到独立的小类中。

该怎么拆分呢？我们可以借助解释器模式。

解释器模式的代码实现比较灵活，没有固定的模板。我们前面也说过，应用设计模式主要是应对代码的复杂性，实际上，解释器模式也不例外。它的代码实现的核心思想，就是将语法解析的工作拆分到各个小类中，以此来避免大而全的解析类。一般的做法是，将语法规则拆分成一些小的独立的单元，然后对每个单元进行解析，最终合并为对整个语法规则的解析。

前面定义的语法规则有两类表达式，一类是数字，一类是运算符，运算符又包括加减乘除。利用解释器模式，我们把解析的工作拆分到 NumberExpression、AdditionExpression、SubstractionExpression、MultiplicationExpression、DivisionExpression 这样五个解析类中。按照这个思路，我们对代码进行重构，重构后的代码如下所示。

  1. public interface Expression {
  2.     long interpret();
  3. }
  5. public class NumberExpression implements Expression {
  6.     private long number;
  8.     public NumberExpression(long number) {
  9.         this.number = number;
  10.     }
  12.     public NumberExpression(String number) {
  13.         this.number = Long.parseLong(number);
  14.     }
  16.     @Override
  17.     public long interpret() {
  18.         return this.number;
  19.     }
  20. }
  22. public class AdditionExpression implements Expression {
  23.     private Expression exp1;
  24.     private Expression exp2;
  26.     public AdditionExpression(Expression exp1, Expression exp2) {
  27.         this.exp1 = exp1;
  28.         this.exp2 = exp2;
  29.     }
  31.     @Override
  32.     public long interpret() {
  33.         return exp1.interpret() + exp2.interpret();
  34.     }
  35. }
  37. // SubstractionExpression/MultiplicationExpression/DivisionExpression与AdditionExpression代码结构类似
  39. public class ExpressionInterpreter {
  40.     private Deque<Expression> numbers = new LinkedList<>();
  42.     public long interpret(String expression) {
  43.         String[] elements = expression.split(" ");
  44.         int length = elements.length;
  45.         for (int i = 0; i < (length+1)/2; ++i) {
  46.             numbers.addLast(new NumberExpression(elements[i]));
  47.         }
  48.         for (int i = (length+1)/2; i < length; ++i) {
  49.             String operator = elements[i];
  50.             boolean isValid = "+".equals(operator) || "-".equals(operator)
  51.                 || "*".equals(operator) || "/".equals(operator);
  52.             if (!isValid) {
  53.                 throw new RuntimeException("Expression is invalid: " + expression);
  54.             }
  55.             Expression exp1 = numbers.pollFirst();
  56.             Expression exp2 = numbers.pollFirst();
  57.             Expression combinedExp = null;
  58.             if (operator.equals("+")) {
  59.                 combinedExp = new AdditionExpression(exp1, exp2);
  60.             } else if (operator.equals("-")) {
  61.                 combinedExp = new SubstractionExpression(exp1, exp2);
  62.             } else if (operator.equals("*")) {
  63.                 combinedExp = new MultiplicationExpression(exp1, exp2);
  64.             } else if (operator.equals("/")) {
  65.                 combinedExp = new DivisionExpression(exp1, exp2);
  66.             }
  67.             long result = combinedExp.interpret();
  68.             numbers.addFirst(new NumberExpression(result));
  69.         }
  70.         if (numbers.size() != 1) {
  71.             throw new RuntimeException("Expression is invalid: " + expression);
  72.         }
  73.         return numbers.pop().interpret();
  74.     }
  75. }

当然，因为加减乘除表达式的解析比较简单，利用解释器模式的设计思路，看起来有点过度设计。不过，这里我主要是为了解释原理，你明白意思就好，不用过度细究。

解释器模式实战举例

接下来，我们再来看一个更加接近实战的例子：如何实现一个自定义接口告警规则功能？在我们平时的项目开发中，监控系统非常重要，它可以时刻监控业务系统的运行情况，及时将异常报告给开发者。比如，如果每分钟接口出错数超过 100，监控系统就通过短信、微信、邮件等方式发送告警给开发者。

一般来讲，监控系统支持开发者自定义告警规则，比如我们可以用下面这样一个表达式，来表示一个告警规则，它表达的意思是：每分钟 API 总出错数超过 100 或者每分钟 API 总调用数超过 10000 就触发告警。

  1. api_error_per_minute > 100 || api_count_per_minute > 10000

在监控系统中，告警模块只负责根据统计数据和告警规则，判断是否触发告警。至于每分钟 API 接口出错数、每分钟接口调用数等统计数据的计算，是由其他模块来负责的。其他模块将统计数据放到一个 Map 中（数据的格式如下所示），发送给告警模块。接下来，我们只关注告警模块。

  1. Map<String, Long> apiStat = new HashMap<>();
  2. apiStat.put("api_error_per_minute", 103);
  3. apiStat.put("api_count_per_minute", 987);

我们假设自定义的告警规则只包含“||、&&、>、<、==”这五个运算符，其中，“>、<、==”运算符的优先级高于“||、&&”运算符，“&&”运算符优先级高于“||”。在表达式中，任意元素之间需要通过空格来分隔。除此之外，用户可以自定义要监控的 key，比如前面的 api_error_per_minute、api_count_per_minute。

那如何实现上面的需求呢？实际上，我们可以把自定义的告警规则，看作一种特殊“语言”的语法规则。我们实现一个解释器，能够根据规则，针对用户输入的数据，判断是否触发告警。利用解释器模式，我们把解析表达式的逻辑拆分到各个小类中，避免大而复杂的大类的出现。按照这个思路的代码实现如下所示：

  1. public interface Expression {
  2.     boolean interpret(Map<String, Long> stats);
  3. }
  5. public class GreaterExpression implements Expression {
  6.     private String key;
  7.     private long value;
  9.     public GreaterExpression(String strExpression) {
  10.         String[] elements = strExpression.trim().split("\\s+");
  11.         if (elements.length != 3 || !elements[1].trim().equals(">")) {
  12.             throw new RuntimeException("Expression is invalid: " + strExpression);
  13.         }
  14.         this.key = elements[0].trim();
  15.         this.value = Long.parseLong(elements[2].trim());
  16.     }
  18.     public GreaterExpression(String key, long value) {
  19.         this.key = key;
  20.         this.value = value;
  21.     }
  23.     @Override
  24.     public boolean interpret(Map<String, Long> stats) {
  25.         if (!stats.containsKey(key)) {
  26.             return false;
  27.         }
  28.         long statValue = stats.get(key);
  29.         return statValue > value;
  30.     }
  31. }
  33. // LessExpression/EqualExpression跟GreaterExpression代码类似
  35. public class AndExpression implements Expression {
  36.     private List<Expression> expressions = new ArrayList<>();
  38.     public AndExpression(String strAndExpression) {
  39.         String[] strExpressions = strAndExpression.split("&&");
  40.         for (String strExpr : strExpressions) {
  41.             if (strExpr.contains(">")) {
  42.                 expressions.add(new GreaterExpression(strExpr));
  43.             } else if (strExpr.contains("<")) {
  44.                 expressions.add(new LessExpression(strExpr));
  45.             } else if (strExpr.contains("==")) {
  46.                 expressions.add(new EqualExpression(strExpr));
  47.             } else {
  48.                 throw new RuntimeException("Expression is invalid: " + strAndExpression);
  49.             }
  50.         }
  51.     }
  53.     public AndExpression(List<Expression> expressions) {
  54.         this.expressions.addAll(expressions);
  55.     }
  57.     @Override
  58.     public boolean interpret(Map<String, Long> stats) {
  59.         for (Expression expr : expressions) {
  60.             if (!expr.interpret(stats)) {
  61.                 return false;
  62.             }
  63.         }
  64.         return true;
  65.     }
  67. }
  69. public class OrExpression implements Expression {
  70.     private List<Expression> expressions = new ArrayList<>();
  72.     public OrExpression(String strOrExpression) {
  73.         String[] andExpressions = strOrExpression.split("\\|\\|");
  74.         for (String andExpr : andExpressions) {
  75.             expressions.add(new AndExpression(andExpr));
  76.         }
  77.     }
  79.     public OrExpression(List<Expression> expressions) {
  80.         this.expressions.addAll(expressions);
  81.     }
  83.     @Override
  84.     public boolean interpret(Map<String, Long> stats) {
  85.         for (Expression expr : expressions) {
  86.             if (expr.interpret(stats)) {
  87.                 return true;
  88.             }
  89.         }
  90.         return false;
  91.     }
  92. }
  94. public class AlertRuleInterpreter {
  95.     private Expression expression;
  97.     public AlertRuleInterpreter(String ruleExpression) {
  98.         this.expression = new OrExpression(ruleExpression);
  99.     }
  101.     public boolean interpret(Map<String, Long> stats) {
  102.         return expression.interpret(stats);
  103.     }
  104. } 
  106. public class DemoTest {
  107.     public static void main(String[] args) {
  108.         String rule = "key1 > 100 && key2 < 30 || key3 < 100 || key4 == 88";
  109.         AlertRuleInterpreter interpreter = new AlertRuleInterpreter(rule);
  110.         Map<String, Long> stats = new HashMap<>();
  111.         stats.put("key1", 101l);
  112.         stats.put("key3", 121l);
  113.         stats.put("key4", 88l);
  114.         System.out.println(interpreter.interpret(stats));
  115.     }
  116. }