* 24种设计模式——解释器模式

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

一、加减运算

1.抽象表达式类

public abstract class Expression {
	//解析公式和数值，其中var中的key值是公式中的参数，value值是具体的数字
	public abstract int interpreter(Map<String,Integer> var);
}

2. 变量解析器

public class VarExpression extends Expression{
	private String key;
	public VarExpression(String key) {
		this.key = key;
	}
	//从map中取之
	public int interpreter(Map<String, Integer> var) {
		return var.get(this.key);
	}
}

3. 抽象运算符号解析器

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

4. 加法解析器

public class AddExpression extends SymbolExpression{
	public AddExpression(Expression left, Expression right) {
		super(left, right);
	}
	//把左右两个表达式运算的结果加起来
	public int interpreter(Map<String, Integer> var) {
		return super.left.interpreter(var)+super.right.interpreter(var);
	}
}

5. 减法解析器

public class SubExpression extends SymbolExpression{
	public SubExpression(Expression left, Expression right) {
		super(left, right);
	}
	//左右两个表达式相减
	public int interpreter(Map<String, Integer> var) {
		return super.left.interpreter(var)-super.right.interpreter(var);
	}
}

6. 解析器封装类

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

7. 场景类

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.println("请输入表达式：");
		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))){
					String in = (new BufferedReader(new InputStreamReader(System.in))).readLine();
					map.put(String.valueOf(ch), Integer.valueOf(in));
				}
			}
		}
		return map;
	}
}

二、解释器模式的定义

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

1. 抽象表达式

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

2. 终结符表达式

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

3. 非终结符表达式

public class NonterminalExpression extends Expression{
	//每个非终结符表达式都会对其他表达式产生依赖
	public NonterminalExpression(Expression...expression){
		
	}
	public Object interpreter(Context ctx) {
		//进行方法处理
		return null;
	}
}

4. 场景类

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

三、解释器模式的应用

1. 优点：扩展性好，修改语法：规则只要修改相应的非终结符表达式就可以了，扩展语法：则只要增加非终结符类就可以了。

2. 缺点：采用递归调用方法，当解析冗长的语法时，效率很低。

3. 使用场景:

1）重复发生的问题可以使用解释器模式

例如，多个应用服务器，每天产生大量的日志，需要对日志文件进行分析处理，由于各个服务器的日志格式不同，但是数据要素是相同的，按照解释器的说法是终结符表达式都是相同的，但是非终结符表达式就需要制定了。在这种情况下，可以通过程序来一劳永逸的解决该问题。

2）一个简单语法需要解释的场景

例如，非终结表达式不多的情况

四、最佳实践

解释器模式在开发中应用很少，它会引起效率、性能以及维护等问题，可以考虑用Expression4J、MESP、Jep等开源解析工具包，实现大多数数学运算完全没有问题。