解释器模式
在软件开发中，会遇到有些问题多次重复出现，而且有一定的相似性和规律性。如果将它们归纳成一种简单的语言，那么这些问题实例将是该语言的一些句子，这样就可以用“编译原理”中的解释器模式来实现了。
虽然使用解释器模式的实例不是很多，但对于满足以上特点，且对运行效率要求不是很高的应用实例，如果用解释器模式来实现，其效果是非常好的，本文将介绍其工作原理与使用方法。
四则运算问题
通过解释器模式来实现四则运算，如计算a+b-c的值，具体要求如下：
- 先输入表达式的形式，比如 a+b+c-d+e, 要求表达式的字母不能重复
- 在分别输入a ,b, c, d, e 的值
- 最后求出结果：如图
传统方案解决四则运算问题分析
- 编写一个方法，接收表达式的形式，然后根据用户输入的数值进行解析，得到结果
- 问题分析：如果加入新的运算符，比如 * / （等等，不利于扩展，另外让一个方法来解析会造成程序结构混乱，不够清晰
- 解决方案：可以考虑使用解释器模式， 即：表达式 -> 解释器（可以有多种） -> 结果
解释器模式基本介绍
基本介绍
- 在编译原理中，一个算术表达式通过词法分析器形成词法单元，而后这些词法单元再通过语法分析器构建语法分析树，最终形成一颗抽象的语法分析树。这里的词法分析器和语法分析器都可以看做是解释器
- 解释器模式（InterpreterPattern）：是指给定一个语言（表达式），定义它的文法的一种表示，并定义一个解释器，使用该解释器来解释语言中的句子（表达式）
- 应用场景：1、应用可以将一个需要解释执行的语言中的句子表示为一个抽象语法树；2、一些重复出现的问题可以用一种简单的语言来表达；3、一个简单语法需要解释的场景
- 这样的例子还有，比如编译器、运算表达式计算、正则表达式、机器人等
其主要优点如下：
- 扩展性好。由于在解释器模式中使用类来表示语言的文法规则，因此可以通过继承等机制来改变或扩展文法
- 容易实现。在语法树中的每个表达式节点类都是相似的，所以实现其文法较为容易
其主要缺点如下：
- 执行效率较低。解释器模式中通常使用大量的循环和递归调用，当要解释的句子较复杂时，其运行速度很慢，且代码的调试过程也比较麻烦
- 会引起类膨胀。解释器模式中的每条规则至少需要定义一个类，当包含的文法规则很多时，类的个数将急剧增加，导致系统难以管理与维护
- 可应用的场景比较少。在软件开发中，需要定义语言文法的应用实例非常少，所以这种模式很少被使用到
解释器模式的结构与实现
解释器模式常用于对简单语言的编译或分析实例中，为了掌握好它的结构与实现，必须先了解编译原理中的“文法、句子、语法树”等相关概念。
1) 文法
文法是用于描述语言的语法结构的形式规则。没有规矩不成方圆，例如，有些人认为完美爱情的准则是“相互吸引、感情专一、任何一方都没有恋爱经历”，虽然最后一条准则较苛刻，但任何事情都要有规则，语言也一样，不管它是机器语言还是自然语言，都有它自己的文法规则。例如，中文中的“句子”的文法如下。
〈句子〉::=〈主语〉〈谓语〉〈宾语〉
〈主语〉::=〈代词〉|〈名词〉
〈谓语〉::=〈动词〉
〈宾语〉::=〈代词〉|〈名词〉
〈代词〉你|我|他
〈名词〉7大学生I筱霞I英语
〈动词〉::=是|学习注：这里的符号“::=”表示“定义为”的意思，用“〈”和“〉”括住的是非终结符，没有括住的是终结符。
2) 句子
句子是语言的基本单位，是语言集中的一个元素，它由终结符构成，能由“文法”推导出。例如，上述文法可以推出“我是大学生”，所以它是句子。
3) 语法树
语法树是句子结构的一种树型表示，它代表了句子的推导结果，它有利于理解句子语法结构的层次。图 1 所示是“我是大学生”的语法树。
有了以上基础知识，现在来介绍解释器模式的结构就简单了。解释器模式的结构与组合模式相似，不过其包含的组成元素比组合模式多，而且组合模式是对象结构型模式，而解释器模式是类行为型模式。
解释器模式的原理类图
对原理类图的说明-即（解释器模式的角色及职责）：
- Context：是环境角色，含有解释器之外的全局信息
- AbstractExpression：抽象表达式，声明一个抽象的解释操作，这个方法为抽象语法树中所有的节点所共享
- TerminalExpression：为终结符表达式，实现与文法中的终结符相关的解释操作
- NonTermialExpression：为非终结符表达式，为文法中的非终结符实现解释操作
- 说明：输入ContextheTerminalExpression信息通过Client输入即可
模式的实现
解释器模式实现的关键是定义文法规则、设计终结符类与非终结符类、画出结构图，必要时构建语法树，其代码结构如下：
// 抽象表达式类
interface AbstractExpression {
// 解释方法
public Object interpret(String info);
}
// 终结符表达式类
class TerminalExpression implements AbstractExpression {
public Object interpret(String info) {
// 对终结符表达式的处理
}
}
// 非终结符表达式类
class NonterminalExpression implements AbstractExpression {
private AbstractExpression exp1;
private AbstractExpression exp2;
public Object interpret(String info) {
// 非对终结符表达式的处理
}
}
// 环境类
class Context {
private AbstractExpression exp;
public Context() {
// 数据初始化
}
public void operation(String info) {
// 调用相关表达式类的解释方法
}
}
解释器模式来实现四则
1）应用实例要求
通过解释器模式来实现四则运算，如计算 a+b-c 的值
2）思路分析和图解（类图）
package com.atguigu.interpreter;
import java.util.HashMap;
/**
* 加法解释器
*
* @author Administrator
*/
public class AddExpression extends SymbolExpression {
public AddExpression(Expression left, Expression right) {
super(left, right);
}
// 处理相加
// var 仍然是 {a=10,b=20}..
// 一会我们 debug 源码，就 ok
public int interpreter(HashMap<String, Integer> var) {
//super.left.interpreter(var) : 返回 left 表达式对应的值 a = 10
//super.right.interpreter(var): 返回 right 表达式对应值 b = 20
return super.left.interpreter(var) + super.right.interpreter(var);
}
}package com.atguigu.interpreter;
import java.util.HashMap;
import java.util.Stack;
public class Calculator {
// 定义表达式
private Expression expression;
// 构造函数传参，并解析
public Calculator(String expStr) {
// expStr = a+b
// 安排运算先后顺序
Stack<Expression> stack = new Stack<>();
// 表达式拆分成字符数组
// [a, +, b]
char[] charArray = expStr.toCharArray();
Expression left = null;
Expression right = null;
// 遍历我们的字符数组，即遍历 [a, +, b]
// 针对不同的情况，做处理
for (int i = 0; i < charArray.length; i++) {
switch (charArray[i]) {
case '+':
// 从 stack 取出 left => "a"
left = stack.pop();
// 取出右表达式 "b"
right = new VarExpression(String.valueOf(charArray[++i]));
// 然后根据得到 left 和 right 构建 AddExpresson 加入stack
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:
// 如果是一个 Var 就创建要给 VarExpression 对象，并 push 到 stack
stack.push(new VarExpression(String.valueOf(charArray[i])));
break;
}
}
// 当遍历完整个 charArray 数组后，stack 就得到最后 Expression
this.expression = stack.pop();
}
public int run(HashMap<String, Integer> var) {
// 最后将表达式 a+b 和 var = {a=10,b=20}
// 然后传递给 expression 的 interpreter 进行解释执行
return this.expression.interpreter(var);
}
}package com.atguigu.interpreter;
import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.util.HashMap;
public class ClientTest {
public static void main(String[] args) throws IOException {
// a+b
String expStr = getExpStr();
// var {a=10, b=20}
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<>();
for (char ch : expStr.toCharArray()) {
if (ch != '+' && ch != '-') {
if (!map.containsKey(String.valueOf(ch))) {
System.out.print("请输入" + String.valueOf(ch) + "的值:");
String in = (new BufferedReader(new InputStreamReader(System.in))).readLine();
map.put(String.valueOf(ch), Integer.valueOf(in));
}
}
}
return map;
}
}package com.atguigu.interpreter;
import java.util.HashMap;
/**
* 抽象类表达式，通过 HashMap 键值对，可以获取到变量的值
*
* @author Administrator
*/
public abstract class Expression {
// a + b - c
// 解释公式和数值，key 就是公式（表达式）参数[a,b,c]，value 就是就是具体值
// HashMap {a=10, b=20}
public abstract int interpreter(HashMap<String, Integer> var);
}package com.atguigu.interpreter;
import java.util.HashMap;
public class SubExpression extends SymbolExpression {
public SubExpression(Expression left, Expression right) {
super(left, right);
}
// 求出 left 和 right 表达式相减后的结果
public int interpreter(HashMap<String, Integer> var) {
return super.left.interpreter(var) - super.right.interpreter(var);
}
}package com.atguigu.interpreter;
import java.util.HashMap;
/**
* 抽象运算符号解析器 这里，每个运算符号，都只和自己左右两个数字有关系，
* 但左右两个数字有可能也是一个解析的结果，无论何种类型，都是 Expression 类的实现类
*
* @author Administrator
*/
public class SymbolExpression extends Expression {
protected Expression left;
protected Expression right;
public SymbolExpression(Expression left, Expression right) {
this.left = left;
this.right = right;
}
// 因为 SymbolExpression 是让其子类来实现，因此 interpreter 是一个默认实现
@Override
public int interpreter(HashMap<String, Integer> var) {
return 0;
}
}package com.atguigu.interpreter;
import java.util.HashMap;
/**
* 变量的解释器
*
* @author Administrator
*/
public class VarExpression extends Expression {
// key=a,key=b,key=c
private String key;
public VarExpression(String key) {
this.key = key;
}
// var 就是{a=10, b=20}
// interpreter 根据 变量名称，返回对应值
@Override
public int interpreter(HashMap<String, Integer> var) {
return var.get(this.key);
}
}模式的应用场景
前面介绍了解释器模式的结构与特点，下面分析它的应用场景：
- 当语言的文法较为简单，且执行效率不是关键问题时
- 当问题重复出现，且可以用一种简单的语言来进行表达时
- 当一个语言需要解释执行，并且语言中的句子可以表示为一个抽象语法树的时候，如 XML 文档解释
注意：解释器模式在实际的软件开发中使用比较少，因为它会引起效率、性能以及维护等问题。如果碰到对表达式的解释，在Java 中可以用 Expression4J 或 Jep 等来设计。
解释器模式在 Spring 框架应用的源码剖析
- Spring 框架中 SpelExpressionParser 就使用到解释器模式
- 代码分析+Debug源码
- 说明
扫一扫
296
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
