我们直接从一个业务来看解释器模式
业务需求：输入一个模型公式（加减运算）， 然后输入模型中的参数，晕算出结果
设计要求：
· 公式可以运行时编辑，并且符合正确算术书写方式，例如a+b-c
· 高拓展性，未来增加指数、开方、极限、求导等运算符号时较少改动
· 效率暂时不用考虑，晚间批量运算
需求不复杂，如果仅仅是对数字采用四则运算，每个人都可以写出来。但是增加了增加模型公式就复杂了。首先解释一下为什么需要公式，而不采用直接计算的方法，例如有如下三个公式：
· 业务种类1的公式：a+b+c-d
· 业务种类2的公式：a+b+e-d
· 业务种类3的公式：a-f
其中，a b c d e f参数的值都可以取得，如果使用直接计算参数的方法需要为每个品种写一个算法，目前仅仅是3个业务种类，那上百个品种呢?
建立公式，然后通过公式计算才是王道。
我们以实现加减算法的公式为例，讲解如何解析一个固定语法逻辑。
想想公式中有什么？仅有两类元素：运算元素和运算符号。运算元素就是a b c等符号，需要具体赋值的对象，也叫做终结符号。
两类元素的共同点：
· 都要被解析
两类元素的不同点：
- 所有的运算元素具有相同的功能，可以用一个类表示，而运算符号则是需要分别进行解释，加法需要加法解释器，减法需要减法解释器。
下面用解释器模式来解决这个业务，先看类图设计
具体代码如下：
/** *抽象表达式类 */ public abstract class Expression { //解析公式和数值，其中var中的key值是公式中的参数，value是具体的数字 public abstract int interpreter(HashMap<String, Integer> var); } public class AddExpression extends SymbolExpression { public AddExpression(Expression _left, Expression _right) { super(_left, _right); } @Override 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); } @Override public int interpreter(HashMap<String, Integer> var) { return super.left.interpreter(var) - super.right.interpreter(var); } } 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, Integer> var) { return 0; } } 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); } } 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]))); } } 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<>(); 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; } } /**Output 请输入表达式:a+b-c 100 20 10 结果为：a+b-c=110 */ |
解释器模式的定义：给定一门语言，按照它的文法的一种表示，并定义一个解释器，该解释器使用该表示来解释语言中的句子。
解释器模式使用较少，但是像写编译器这种肯定是要用到。普适性不是很高。
解释器模式的优点：
· 解释器模式是一个简单的语法分析工具，最显著的优点就是拓展性，修改语法规则只要修改对应的非终结符表达式就可以了，若拓展语法，则只要增加非终结符类就可以了
解释器模式的缺点：
· 解释器模式会引起类的膨胀
· 采用递归调用，不好差错
· 效率问题【使用了大量的循环和递归】
解释器模式的使用场景：
· 重复发生的问题可以使用解释器模式
-例如，多个应用服务器，每天产生大量的日志，需要对日志文件进行分析处理，由于各个服务器的日志格式不同，但是数据要素相同，按照解释器的说法就是非终结表达式都是相同的，但是非终结符表达式就需要制定了。
· 一个简单语法需要解释的场景
解释器模式的注意事项：
不要在重要模块使用这个模式，否则维护是一个很大的问题。在项目中可以使用shell、JRuby、Groovy等脚本语言来代替解释器模式。
最佳实践：
解释器模式在实际的系统开发中使用变得非常少，因为它会引起效率、性能以及维护等问题。一般在大中型的框架型项目能够找到它的身影，如一些数据分析工具、报表设计工具。
