* 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等开源解析工具包，实现大多数数学运算完全没有问题。