JAVA设计模式——解析器模式

解析器模式是一种行为型设计模式。其思想是：给定一个语言, 定义它的文法的一种表示，并定义一个解释器，该解释器使用该表示来解释语言中的句子。

解析器模式涉及4个角色：

• 抽象表达式（Expression）：声明一个所有的具体表达式的抽象接口，包含一个interpret()方法，称做解释操作。
• 终结符表达式（Terminal Expression）： 实现与文法中的元素相关联的解释操作。通常一个解释器模式中只有一个终结符表达式，但有多个实例，对应不同的终结符。例如表达式a+b中，+就是一个终结符。
• 非终结符表达式（Nonterminal Expression）：文法中的每一条规则都需要一个具体的非终结符表达式，非终结符表达式一般是文法中的运算符或者其他关键字。例如表达式a+b中，a和b就是非终结符。
• 环境（Context）：用来存放文法中各个终结符所对应的具体值，很多情况下我们使用Map来充当环境角色。

结构图：

（图片来源于网络）

下面提供一个简单例子。一个简易的控制台计算器，要求用户输入一个表达式，如a+b-c，然后要求用户输入每个变量的具体值，如a=1，b=2，c=3，最后屏幕显示计算结果。篇幅所限，这里只演示加法和减法运算，有兴趣的读者可以自行扩展。

抽象表达式：

public interface Expression {
    double interpreter(HashMap<String, Double> var); // 声明一个解析操作
}

非终结符表达式：

public class VarExp implements Expression {
    private String value;

    public VarExp(String value) {
        this.value = value;
    }

    @Override
    public double interpreter(HashMap<String, Double> var) {
        return var.get(this.value); // 返回表达式所对应的值
    }
}

终结符表达式：

public abstract class SymbolExp implements Expression {
    protected Expression left;  // 运算符左侧的表达式
    protected Expression right; // 运算符右侧的表达式

    public SymbolExp(Expression left, Expression right) {
        this.left = left;
        this.right = right;
    }
}

// 加法
public class Add extends SymbolExp {
    public Add(Expression left, Expression right) {
        super(left, right);
    }

    @Override
    public double interpreter(HashMap<String, Double> var) {
        return left.interpreter(var) + right.interpreter(var); // 返回左右两个表达式之和
    }
}

// 减法
public class Minus extends  SymbolExp {
    public Minus(Expression left, Expression right) {
        super(left, right);
    }

    @Override
    public double interpreter(HashMap<String, Double> var) {
        return left.interpreter(var) - right.interpreter(var); // 返回左右两个表达式之差
    }
}

计算器：

public class Calculator {
    private Expression expression;

    public Calculator(String exp) {
        Expression left;
        Expression right;
        Stack<Expression> stack = new Stack<>();
        char[] chars = exp.toCharArray();
        for (int i = 0, len = chars.length; i < len; i++) {
            switch (chars[i]) {
                case '+':
                    left = stack.pop();                             // 从栈中取回上一个压入的元素作为左侧表达式
                    right = new VarExp(String.valueOf(chars[++i])); // 指针后移一位得到右侧表达式
                    stack.push(new Add(left, right));               // 将计算结果压回栈中
                    break;
                case '-':
                    left = stack.pop();
                    right = new VarExp(String.valueOf(chars[++i]));
                    stack.push(new Minus(left, right));
                    break;
                default:
                    // 如果是非运算符，则生成一个非终结表达式，然后压和栈中
                    stack.push(new VarExp(String.valueOf(chars[i]))); 
                    break;
            }
        }
        this.expression = stack.pop(); // 遍历完成后取回栈中的元素
    }

    // 实际上，计算已经在构造器里完成了，这里只是取回结果的值
    public double cal(HashMap<String, Double> var) {
        return this.expression.interpreter(var);
    }
}

客户：

public class Client {
    // 运行程序
    public void run() {
        String exp = getExp();
        HashMap<String, Double> var = getValues(exp);
        Calculator calculator = new Calculator(exp);
        System.out.printf("%s = %f", exp, calculator.cal(var));
    }

    // 要求用户输入表达式
    private String getExp() {
        Scanner sc = new Scanner(System.in);
        System.out.println("please defined an expression:");
        return sc.nextLine();
    }

    // 要求用户输入每个变量的值
    private HashMap<String, Double> getValues(String exp) {
        HashMap<String, Double> map = new HashMap<>();
        Scanner sc = new Scanner(System.in);
        char[] chars = exp.toCharArray();
        for (char c : chars) {
            String str = String.valueOf(c);
            if (!"+-".contains(str) && !map.containsKey(str)) {
                System.out.printf("%s = ", str);
                map.put(str, sc.nextDouble());
            }
        }
        return map;
    }
}

// 测试
class Test {
    public static void main(String[] args) {
        Client client = new Client();
        client.run();
    }
}

运行结果：

please defined an expression:
a+b-c+b
a = 3
b = 2
c = 1
a+b-c+b = 6.000000

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

但是，解释器模式由于使用了大量的循环和递归，效率是个不容忽视的问题，特别是用于解析复杂、冗长的语法时，效率是难以忍受的，排错也非常困难。

解释器模式在实际的系统开发中使用的非常少，因为它会引起效率、性能以及维护等问题，一般在大中型的框架型项目能够找到它的身影，比如一些数据分析工具、报表设计工具、科学计算工具等等。当确实需要使用解释器模式时，可以考虑使用Expression4J、MESP（Math Expression String Parser）、Jep等开源的解析工具包。