解释器模式
1、四则运算问题
通过解释器模式来实现四则运算，如计算a+b-c的值，具体要求
1）先输入表达式的形式，比如a+b+c-d+e，要求表达式的字母不能重复。
2）在分别输入a，b，c，d，e的值。
3）最后求出结果。
【传统方案解决四则运算问题】
1）编写一个方法，接收表达式的形式，然后根据用户输入的数值进行解析，得到结果。
2）问题分析：如果加入新的运算符，比如*/（等等，不利于扩展，另外让一个方法来解析会造成程序结构混乱，不够清晰）。
3）解决方案：可以考虑使用解释器模式，即：表达式——>解释器（可以有多种）——>结果。
2、解释器模式基本介绍
【1】解释器
在编译原理中，一个算术表达式通过词法分析器形成词法单元，而后这些词法单元再通过语法分析器构建语法分析树，最终形成一颗抽象的语法分析树。这里的词法分析器和语法分析器都可以看作是解释器。
【2】解释器模式
解释器模式（Interpreter Pattern）：是指给定一个语言（表达式），定义它的文法的一种表示，并定义一个解释器，使用该解释器来解释语言中的句子（表达式）。
在解释器模式中，我们需要将待解决的问题，提取出规则，抽象为一种”语言”。比如加减法运算，规则为：由数值和+-符号组成的合法序列，”1+3-2”就是这种语言的句子。
【3】应用场景
应用可以将一个需要解释执行的语言中的句子表示为一个抽象语法树。
一些重复出现的问题可以用一种简单的语言来表达。
一个简单语法需要解释的场景。
这样的例子还有，比如编译器、运算表达式计算、正则表达式、机器人等。
【4】文法（语法）规则
文法是用于描述语言的语法结构的形式规则。
1
2
3
4
| expression ::= value | plus | minus
plus ::= expression '+' expression
minus ::= expression '-' expression
value ::= integer
|
注意：这里的符号::=表示定义为的意思，竖线|表示或，左右的其中一个，引号内为字符本身，引号外为语法。
表达式可以是一个值，也可以是plus或者minus运算，而plus和minus又是由表达式结合运算符构成，值的类型为整形数。
【5】抽象语法树
在计算机科学中，抽象语法树（AbstractSyntaxTree，AST），或简称语法树（Syntax tree），是原代码语法结构的一种抽象表示。它以树状的形式表现编程语言的语法结构，树上的每个节点都表示源代码中的一种结构。
用树形来表示符合文法规则的句子。
3、结构
1）抽象表达式（Abstract Expression）角色：定义解释器的接口，声明一个抽象的解释操作，这个方法为抽象语法树中所有的节点所共享。主要包含解释方法interpret()。
2）终结符表达式（Terminal Expression）角色：是抽象表达式的子类，用来实现文法中与终结符相关的操作。文法中的每一个终结符都有一个具体终结表达式与之相对应。
3）非终结符表达式（NonTerminal Expression）角色：也是抽象表达式的子类，用来实现文法中与非终结符相关的操作，文法中的每条规则都对应于一个非终结符表达式。
4）环境（Context）角色：通常包含各个解释器需要的数据或是公共的功能，一般用来传递被所有解释器共享的数据，后面的解释器可以从这里获取这些值。
5）客户端（Client）：主要任务是将需要分析的句子或表达式转换成使用解释器对象描述的抽象语法树，然后调用解释器的解释方法，当然也可以通过环境角色间接访问解释器的解释方法。
6）说明：输入Context和TerminalExpression信息通过Client输入即可。
4、应用实例代码实现
1
2
3
4
5
6
7
|
public abstract class Expression {
public abstract int interpreter(HashMap<String, Integer> var);
}
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
|
public class VarExpression extends Expression {
private String key;
public VarExpression(String key) {
this.key = key;
}
@Override
public int interpreter(HashMap<String, Integer> var) {
return var.get(this.key);
}
}
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
|
public class SymbolExpression extends Expression {
protected Expression left;
protected Expression right;
public SymbolExpression(Expression left, Expression right) {
this.left = left;
this.right = right;
}
@Override
public int interpreter(HashMap<String, Interger> var) {
return 0;
}
}
|
1
2
3
4
5
6
7
8
9
10
11
12
|
public class AddExpression extends SymbolExpression {
public AddExpression(Expression left, Expression right) {
super(left, right);
}
public int interpreter(HashMap<String, Integer> var) {
return super.left.interpreter(var) + super.right.interpreter(var);
}
}
|
1
2
3
4
5
6
7
8
9
10
11
|
public class SubExpression extends SymbolExpression {
public SubExpression(Expression left, Expression right) {
super(left, right);
}
public int interpreter(HashMap<String, Integer> var) {
return super.left.interpreter(var) - super.right.interpreter(var);
}
}
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
| public class Calculator {
private Expression expression;
public Calculator(String expStr) {
Stack<Expression> stack = new Stack<>();
char[] charArray = expStr.toCharArray();
Expression left = null;
Expression right = null;
for(int i = 0, i < charArray.length, i++) {
switch(charArray[i]) {
case '+':
left = stack.pop();
right = new VarExpression(String.valueOf(charArray[++i]));
stack.push(new AddExpression(left, right));
break;
case '-':
left = stack.pop();
right = new VarExpression(String.valueOf(charArray[++i]));
stack.push(new SubExpression(left, right));
break;
default:
stack.push(new VarExpression(String.valueOf(charArray[i])));
break;
}
}
this.expression = stack.pop();
}
public int run(HashMap<String, Integer> var) {
return this.expression.interpreter(var);
}
}
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
| public class Client {
public static void main(String[] args) {
String expStr = getExpStr();
HashMap<String, Integer> var = getValue(expStr);
Calculator calculator = new Calculator(expStr);
System.out.println("运算结果：" + expStr + "=" + calculator.run(var));
}
public static String getExpStr() throws IOException {
System.out.print("请输入表达式：");
return (new BufferedReader(new InputStreamReader(System.in))).readLine();
}
public static HashMap<String, Integer> getValue(String expStr) throws IOException {
HashMap<String, Integer> map = new HashMap();
Scanner scanner = new Scanner(System.in);
for(char ch: expStr.toCharArray()) {
if(ch != '+' && ch != '-') {
System.out.print("请输入"+ String.valueOf(ch) + "的值：");
int value = scanner.nextInt();
map.put(ch, value);
}
}
return map;
}
}
|
5、解释器模式的注意事项和细节
【1】优点
1）易于改变和扩展文法。
由于在解释器模式中使用类来表示语言的文法规则，因此可以通过继承等机制来改变或扩展文法，每一条文法规则都可以表示为一个类，因此可以方便地实现一个简单的语言。
2）实现文法较为容易。
在抽象语法树中每一个表达式节点类的实现方式都是相似的，这些类的代码编写都不会特别复杂。
3）增加新的解释表达式较为方便。
如果用户需要增加新的解释表达式只需要对应增加一个新的终结符表达式或非终结符表达式类，原有表达式类代码无需修改，符合”开闭原则”。
【2】缺点
1）对于复杂文法难以维护。
在解释器模式中，每一条规则至少需要定义一个类，因此如果一个语言包含太多文法规则，类的个数将会急剧增加，导致系统难以管理和维护。
2）执行效率较低。
由于在解释器模式中使用了大量的循环和递归调用，因此在解释较为复杂的句子时其速度很慢，而且代码的调试过程也比较麻烦。
【3】应用场景
1）当语言的文法较为简单，且执行效率不是关键问题时。
2）当问题重复出现，且可以用一种简单的语言来进行表达时。
3）当有一个语言需要解释执行，可将该语言中的句子表示为一个抽象语法树，就可以考虑使用解释器模式，让程序具有良好的扩展性。
4）应用场景：编译器、运算表达式计算、正则表达式、机器人等。
6、解释器模式再Spring框架中的应用
1）Spring框架中SpelExpressionParser就使用到解释器模式。
2）代码分析 + Debug源码
1
2
3
4
5
6
7
8
9
10
11
12
| public class Interpreter {
public static void main(String[] args) {
SpelExpressionParser parser = new SpelExpressionParser();
Expression expression = parser.parseExpression("10 * (2 + 5) + 10");
int result = (Integer) expression.getValue();
System.out.println(result);
}
}
|
