设计模式-17-解析器模式 Interpreter -[行为模式]

1.解析器模式简介

给定一门语言，定义它的文法的一种表示，并定义一个解释器，该解释器使用该表示来解释语言中句子。【属于行为类模式】

“文法” ： 指语言的语法规则 ； 解析器模式在现在项目中还是使用比较少的；

2.解析器模式的角色

1. Expression——抽象解释器：具体的解释任务由各个实现类完成，具体的解释器分别由TerminalExpression和NonterminalExpression完成。
2. TerminalExpression——终结符表达式：实现与文法中的元素相关联的解释操作，通常一个解释器模式中只有一个终结符表达式，担忧多个实例，对应不同的终结符。
3. NonterminalExpression——非终结符表达式：文法中每条规则对应于一个非终结表达式。非终结符表达式根据逻辑的复杂程度而增加，原则上每个文法规则都对应一个非终结符表达式。
4. Context——环境角色：例如采用HashMap。

3.解析器模式的简单应用

   我们就拿加减法运算的例子来看看何谓解释器模式（四则比较麻烦，例子只写加减操作）：

抽象解释器

/**
 * 抽象解释器
 */
public abstract class A1_Expression {

    /**
     * 解析公式和数值，其中var中的key是公式的参数，value值是具体的数字 如：{"a",108}
     * 负责对传递进来的参数和值进行解析和匹配，其中[key是表达式 a+b+c 中的a、b、c] [value是运算时取得的值]
     */
    // 如果是[终结符]表达式，那么此方法将[获取参数的值]
    // 如果是[非终结符]表达式，那么此方法将[进行运算] - 比如加减
    public abstract int interpreter(HashMap<String, Integer> var);
}

终结符表达式 - 变量解析器

/**
 * 变量解析器
 * [终结符表达式]
 */
public class B1_VarExpression extends A1_Expression {

    private String key;

    public B1_VarExpression(String key){
        this.key = key;
    }

    /**
     * [终结符]表达式，那么此方法将[获取参数的值]
     */
    @Override
    public int interpreter(HashMap<String, Integer> var) {
        return var.get(key);
    }
}

非终结符表达式-抽象类

/**
 * [抽象]运算符解析器
 * [非终结符表达式]
 */
public abstract class C1_SymbolExpression extends A1_Expression {

    // 每个运算符都有左右两个参数进行运算，因此抽象到父类中
    protected A1_Expression left;
    protected A1_Expression right;

    public C1_SymbolExpression(A1_Expression left,A1_Expression right){
        this.left = left;
        this.right = right;
    }
}

[非终结符表达式] 加法解析器

/**
 * [非终结符表达式] 加法解析器
 * interpreter方法处理加法运算
 */
public class C2_AddExpression extends C1_SymbolExpression{

    public C2_AddExpression(A1_Expression left, A1_Expression right) {
        super(left, right);
    }

    /**
     * 进行加法运算
     */
    @Override
    public int interpreter(HashMap<String, Integer> var) {
        return left.interpreter(var) + right.interpreter(var);
    }
}

[非终结符表达式] 减法解析器

/**
 * [非终结符表达式] 减法解析器
 * interpreter方法处理减法运算
 */
public class C3_SubExpression extends C1_SymbolExpression{

    public C3_SubExpression(A1_Expression left, A1_Expression right) {
        super(left, right);
    }

    /**
     * 进行减法运算
     */
    @Override
    public int interpreter(HashMap<String, Integer> var) {
        return left.interpreter(var) - right.interpreter(var);
    }
}

Context——环境角色

/**
 * Context——环境角色 对输入的表达式进行解析，并计算
 */
public class D1_Context {

    // 定义表达式，最后拿到是一个运算解析器，比如X+Y格式的，其中X可能又是由A+B的运算解析器组成
    // 只有最底层的解析器才是变量解析器，也就是终结符表达式
    // 此参数最终得到的肯定是非终结表达式
    private A1_Expression expression;

    /**
     * 分析用户输入的表达式
     */
    public void analyse(String expStr) {
        // 定义一个栈，安排运算的先后顺序
        Stack<A1_Expression> stack = new Stack<A1_Expression>();

        char[] charArray = expStr.toCharArray();

        A1_Expression left = null;
        A1_Expression right = null;
        for(int i=0; i<charArray.length; i++) {
            switch(charArray[i]) {
                case '+':
                    // 将加法运算加入到栈中
                    left = stack.pop();
                    right = new B1_VarExpression(String.valueOf(charArray[++i]));
                    stack.push(new C2_AddExpression(left, right));
                    break;
                case '-':
                    // 将减法运算加入到栈中
                    left = stack.pop();
                    right = new B1_VarExpression(String.valueOf(charArray[++i]));
                    stack.push(new C3_SubExpression(left, right));
                    break;
                default:
                    // 如果不是运算符，那么就是终结表达式
                    stack.push(new B1_VarExpression(String.valueOf(charArray[i])));
            }
        }
        // 把最终栈的顶层抛出，它即是最后封装的非终结表达式
        this.expression = stack.pop();
    }

    // 将键值对输入给表达式运算
    public int run(HashMap<String, Integer> var) {
        return expression.interpreter(var);
    }
}

客户端调用

/**
 * 客户端调用
 */
public class E1_Client {

    public static void main(String[] args) {
        String expStr = "a+b-c+d";
        HashMap<String, Integer> var = new HashMap<String, Integer>();
        var.put("a", 1);
        var.put("b", 2);
        var.put("c", 2);
        var.put("d", 4);

        D1_Context context = new D1_Context();
        // 先解析运算表达式
        context.analyse(expStr);
        // 进行运算
        System.out.println(expStr+"="+context.run(var));
    }
}

客户端运行结果： a+b-c+d=5

4.解析器模式的优点

1. 扩展性好。由于在解释器模式中使用类来表示语言的文法规则，因此可以通过继承等机制来改变或扩展文法。
2. 容易实现。在语法树中的每个表达式节点类都是相似的，所以实现其文法较为容易。

5.解析器模式的缺点

1. 执行效率较低。解释器模式中通常使用大量的循环和递归调用，当要解释的句子较复杂时，其运行速度很慢，且代码的调试过程也比较麻烦。
2. 会引起类膨胀。解释器模式中的每条规则至少需要定义一个类，当包含的文法规则很多时，类的个数将急剧增加，导致系统难以管理与维护。
3. 可应用的场景比较少。在软件开发中，需要定义语言文法的应用实例非常少，所以这种模式很少被使用到。

6.解析器模式的使用场景

1. 当语言的文法较为简单，且执行效率不是关键问题时。
2. 当问题重复出现，且可以用一种简单的语言来进行表达时。
3. 当一个语言需要解释执行，并且语言中的句子可以表示为一个抽象语法树的时候，如 XML 文档解释。

7.解析器模式注意事项

        尽量不要在重要模块中使用解释器模式，否则维护会是一个很大的问题。在项目中可以使用shell、JRuby、Groovy等脚本语言来代替解释器模式、弥补Java编译型语言的不足。

        解析器模式在实际的系统开发中使用的非常少，因为它会引起效率、性能以及维护等问题，一般在大中型的框架型项目中能找到它的身影，如一些数据分析工具、报表设计工具、科学计算工具等，如果你确实遇到“一种特定类型的问题发生的频率足够高”的情况，准备使用解释器模式时，可以考虑一下Expression4J、MESP、Jep 等开源的解析工具包，功能都非常强大，而且非常容易使用，效率也不错，实现大多数的数学运算完全没有问题，自己没有必要重头开始编写解释器。