1、定义

给定一个语言（表达式），定义它的文法的一种表示，并定义一个解释器，使用该解释器来解释语言中的句子（表达式）。

2、模式结构

解释器（Interpreter）模式 - 图1

解释器模式由四部分组成：

  • AbstractExpression（抽象表达式）：声明一个所有的具体表达式角色都需要实现的抽象接口。这个接口主要是一个interpret()方法，称做解释操作。
  • TerminalExpression（终结符表示式）：实现了抽象表达式所要求的接口，主要是一个interpret()方法；文法中的每个终结符都有一个具体终结表达式与之相对应。比如有一个简单的公式R=R1+R2，在里面R1和R2就是终结符，对应的解析R1和R2的解释器就是终结符表达式。
  • NonTerminalExpression（非终结符表达式）：文法中的每一调规则都需要一个具体的非终结符表达式，非终结符表达式一般式文法中的运算符或者其他关键字，比如公式R=R1+R2中，“+”就是非终结符，解析“+”的解释器就是一个非终结符表达式。
  • Context（环境）：环境类又称为上下文，一般是用来存放文法中各个终结符所对应的具体值，比如R=R1+R2，我们给R1赋值100，给R2赋值200.这些信息需要存放到环境中，很多情况下我们使用Map来充当环境就足够了。

3、实例

3.1 Expression（AbstractExpression）

  1. public abstract class Expression {
  3.     public abstract int interpreter(HashMap<String, Integer> map);
  4. }

3.2 VarExpression（TerminalExpression）

  1. public class VarExpression extends Expression {
  3.     private String key;
  5.     public VarExpression(String key) {
  6.         this.key = key;
  7.     }
  9.     @Override
  10.     public int interpreter(HashMap<String, Integer> map) {
  11.         return map.get(key);
  12.   }
  13. }

3.3 SymbolExpression（NonTerminalExpression）

  1. public class SymbolExpression extends Expression {
  3.     protected Expression left;
  5.     protected Expression right;
  7.     public SymbolExpression(Expression left, Expression right) {
  8.         this.left = left;
  9.         this.right = right;
  10.     }
  12.     @Override
  13.     public int interpreter(HashMap<String, Integer> map) {
  14.         return 0;
  15.     }
  16. }

3.4 加减解释器

  1. public class AddExpression extends SymbolExpression {
  3.     public AddExpression(Expression left, Expression right) {
  4.         super(left, right);
  5.     }
  7.     @Override
  8.     public int interpreter(HashMap<String, Integer> map) {
  9.         return super.left.interpreter(map) + super.right.interpreter(map);
  10.     }
  11. }
  1. public class SubExpression extends SymbolExpression {
  3.     public SubExpression(Expression left, Expression right) {
  4.         super(left, right);
  5.     }
  7.     @Override
  8.     public int interpreter(HashMap<String, Integer> map) {
  9.         return super.left.interpreter(map) - super.right.interpreter(map);
  10.     }
  11. }

3.5 Calculator（Context）

  1. public class Calculator {
  3.     private Expression expression;
  5.     public Calculator(String expStr) {
  7.         // 使得运算先后顺序
  8.         Stack<Expression> stack = new Stack<>();
  10.         char[] charArray = expStr.toCharArray();
  12.         Expression left = null;
  13.         Expression right = null;
  15.         for (int i = 0; i < charArray.length; i++) {
  16.             switch (charArray[i]) {
  17.                 case '+':
  18.                     left = stack.pop();
  19.                     right = new VarExpression(String.valueOf(charArray[++i]));
  20.                     stack.push(new AddExpression(left, right));
  21.                     break;
  22.                 case '-':
  23.                     left = stack.pop();
  24.                     right = new VarExpression(String.valueOf(charArray[++i]));
  25.                     stack.push(new SubExpression(left, right));
  26.                     break;
  27.                 default:
  28.                 stack.push(new VarExpression(String.valueOf(charArray[i)));
  29.                 break;
  30.             }
  31.         }
  32.         this.expression = stack.pop();
  33.     }
  35.     public int run(HashMap<String, Integer> map) {
  36.         return this.expression.interpreter(map);
  37.     }
  38. }

3.6 客户端调用

  1. public class Client {
  3.     public static void main(String[] args) throws IOException {
  4.         String expStr = getExpStr();
  5.         HashMap<String, Integer> map = getValue(expStr);
  6.         Calculator calculator = new Calculator(expStr);
  7.         System.out.println("运算结果：" + expStr + "=" + calculator.run(map));
  8.     }
  10.     public static String getExpStr() throws IOException {
  11.         System.out.print("请输入表达式：");
  12.         return (new BufferedReader(new InputStreamReader(System.in))).readLine();
  13.     }
  15.     public static HashMap<String, Integer> getValue(String expStr) throws IOException {
  16.         java.util.HashMap<String, Integer> map = new HashMap<>();
  17.         for (char ch : expStr.toCharArray()) {
  18.             if (ch != '+' && ch != '-') {
  19.                 System.out.print("请输入" + ch + "的值：");
  20.                 String in = (new BufferedReader(new InputStreamReader(System.in))).readLine();
  21.                 map.put(String.valueOf(ch), Integer.valueOf(in));
  22.             }
  23.         }
  24.         return map;
  25.     }
  26. }

4、适用场景

  • 可以将一个需要解释执行的语言中的句子表示一个抽象语法树。
  • 一些重复出现的问题可以用一种简单的语言来进行表达。
  • 一个语言的文法较为简单。
  • 执行效率不是关键问题。（注：高效的解释器通常不是通过直接解释抽象语法树来实现的，而是需要将它们转换为其他形式，使用解释器模式的执行效率并不高。）

5、在Spring中的应用

解释器（Interpreter）模式 - 图2

6、优缺点

6.1 优点
  • 易于实现文法。在解释器模式中，一条语法规则用一个解释器对象来解释执行。对于解释器的实现来讲，功能就变得比较简单，只需要考虑这一条语法规则的实现就可以了，其他的都不用管。
  • 易于扩展新的语法。由于解释器采用类来描述语法规则，因此可以通过继承等机制创建相应的解释器对象，在创建抽象语法树的时候使用这个新的解释器对象就可以了。

6.2 缺点
  • 执行效率低。由于在解释器模式中使用了大量的循环和递归调用，因此在解释较为复杂的句子时其速度很慢，而且代码的调试过程也比较麻烦。
  • 对于复杂的文法难以维护。在解释器模式中，每一条规则至少需要定义一个类，因此如果一个语言包含太多文法规则，类的个数将会急剧增加，导致系统难以管理和维护，此时可以考虑使用语法分析程序等方式来取代解释器模式。