设计模式之21解释器模式（笔记）

1 定义：

1.1 定义：Given a language, define a representation for its grammar along with an interpreter that uses the representation to interpret sentences in the language.(给定一门语言，定义它的方法的一种表示，并定义一个解释器，该解释器使用表示来解释语言中的句子。)

1.2 通用类图：

角色说明：

AbstractExpression——抽象解释器

具体的解释任务由各个子类完成，然而首先通过它，来向下递归解析。

TerminalExpression——终结符表达式

实现与文法中的元素相关联的解释操作，通常一个解释器模式中只有一个终结符表达式（类），但有多个实例，对应不同的终结符。

NonterminalExpression——非终结符表达式

文法中的每条规则对应于一个非终结符表达式（类）（例如：加减法规则分别对应到AddExpression, SubExpression两个类）。非终结符表达式根据逻辑的复杂程度而增加，原则上每个文法规则都对应一个非终结符表达式。

Context——环境角色

解释器之外的一些全局信息（多为：终结符与值的映射表）。

Client——客户角色

构建表示该方法定义的语言中的一个特定的句子的抽象语法树，并调用解释操作

运行流程：将一个待解析的输入语句构建成一个抽象语法树（该语法树此时由解释器中定义的表达式构成），然后将该语法树（表达式）交给表达式对象去解释（当然是递归的）。

1.3 通用代码：

public abstract class Expression {
	// 每个表达式必须有一个解析任务
	public abstract Object interpreter(Context ctx);
}

public class TerminalExpression extends Expression {
	// 通常终结符表达式只有一个，但是有多个对象
	public Object interpreter(Context ctx) {
		return null;
	}
}

public class NonterminalExpression extends Expression {
	// 每个非终结符表达式都会对其他表达式产生依赖
	public NonterminalExpression(Expression... expression) {
	}

	public Object interpreter(Context ctx) {
		// 进行文法处理
		return null;
	}
}

public class Context {
}

public class Client {
	public static void main(String[] args) {
		Context ctx = new Context();
		// 通常定一个语法容器，容纳一个具体的表达式，通常为ListArray,LinkedList,Stack等类型
		Stack<Expression> stack = null;
		/*
		 * for(;;){ //进行语法判断，并产生递归调用 }
		 */
		// 产生一个完整的语法树，由各各个具体的语法分析进行解析
		Expression exp = stack.pop();
		// 具体元素进入场景
		exp.interpreter(ctx);
	}
}

2 优点

解释器是一个简单语法分析工具，它最显著的特点就是扩展性，修改语法规则只要修改相应的非终结符表达式就可以了，若扩展语法，则只要增加非终结符类就可以了。

3 缺点

3.1 类膨胀：每个语法都要产生一个非终结符表达式，语法规则比较复杂时，就可能产生大量的类文件，为维护带来了非常多的麻烦；

3.2 不便于调试：因为采用递归调用，若要排查错误，则非常复杂；

3.3 效率问题：由于使用了大量的循环和递归，效率是一个不容忽视的问题。

4 应用场景

4.1 重复发生的问题可以使用解释器模式：如服务器日志文件的分析处理；

4.2 简单语法需要解释：不过已逐步被被专用工具所取代；

5 注意事项

尽量不要在重要的模块中使用解释器模式，否则维护是一个很大的问题。在项目中可以使用shell、JRuby、Groovy等脚本语言来代替解释器模式，弥补Java编译型语言的不足。（而且已有众多开源解释器，没必要自己写。）

6 扩展

暂无

7 范例

图1

很简单的一个类图，VarExpression用来解析运算元素，各个公式能运算元素的数量是不同的，但每个运算元素都对应一个VarExpression对象。SybmolExpression负责运算符号解析，由两个子类AddExpression（负责加法运算）和SubExpression（负责减法运算）来实现。解析的工作完成了，我们还需要把安排运行的先后顺序（加减法是不用考虑，但是乘除法呢？注意扩展性），并且还要返回结果，因此我们需要增加一个封装类来进行封装处理，由于我们只做运算，暂时还不与业务有关联，定义为Calculator类，分析到这里，思路就比较清晰了，优化后加减法类图如图27-2所示。

图2

优化后加减法类图

图27-3 完整加减法类图

源代码如下：

/**
 * @author cbf4Life cbf4life@126.com I'm glad to share my knowledge with you
 *         all. 抽象表达式
 */
public abstract class Expression {
	// 解析公式和数值,其中var中的key值是是公式中的参数，value值是具体的数字
	public abstract int interpreter(HashMap<String, Integer> var);
}

public class VarExpression extends Expression {
	private String key;

	public VarExpression(String _key) {
		this.key = _key;
	}

	// 从map中取之
	public int interpreter(HashMap<String, Integer> var) {
		return var.get(this.key);
	}
}

public abstract class SymbolExpression extends Expression {
	protected Expression left;
	protected Expression right;

	// 所有的解析公式都应只关心自己左右两个表达式的结果
	public SymbolExpression(Expression _left, Expression _right) {
		this.left = _left;
		this.right = _right;
	}
}

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);
	}
}

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);
	}
}

public class Calculator {
	// 定义的表达式
	private Expression expression;

	// 构造函数传参,并解析
	public Calculator(String expStr) {
		// 定义一个堆栈，安排运算的先后顺序
		Stack<Expression> stack = new Stack<Expression>();
		// 表达式拆分为字符数组
		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])));
			}
		}
		// 把运算结果抛出来
		this.expression = stack.pop();
	}

	// 开始运算
	public int run(HashMap<String, Integer> var) {
		return this.expression.interpreter(var);
	}
}

public class Client {
	// 运行四则运算
	public static void main(String[] args) throws IOException {
		String expStr = getExpStr();
		// 赋值
		HashMap<String, Integer> var = getValue(expStr);
		Calculator cal = new Calculator(expStr);
		System.out.println("运算结果为：" + expStr + "=" + cal.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 exprStr)
			throws IOException {
		HashMap<String, Integer> map = new HashMap<String, Integer>();
		// 解析有几个参数要传递
		for (char ch : exprStr.toCharArray()) {
			if (ch != '+' && ch != '-') {
				if (!map.containsKey(String.valueOf(ch))) { // 解决重复参数的问题
					System.out.print("请输入" + ch + "的值:");
					String in = (new BufferedReader(new InputStreamReader(
							System.in))).readLine();
					map.put(String.valueOf(ch), Integer.valueOf(in));
				}
			}
		}
		return map;
	}
}