设计模式系列-解释器模式-Interpreter

解释器模式介绍

现实生活中，我们经常碰到需要解释手语的情况，当你看到一个手语时，它代表着一个具体的意思，但是根据不同的文化背景，我们的解释可以不同的意义。
类似情况，在编程世界里，应用从不同的来源接收用户的输入信息，比如浏览器、程序界面、命令行、或者手机等。用户输入可以用不同的格式来表示，例如数学计算表达式可以用中缀、前缀、后缀表达法，还有，当一个新的表达法被引入时，我们不需要更改客户端代码，用解释器模式可以自动和灵活的处理用户输入的表达式。
解释器模式的目的是处理用户输入的表达式和根据表达式构建抽象语法树，一般称为 AST 。AST 是组合模式的的一个实例，你需要一个解释器来解析AST 然后生成结果。
我们用后缀表达式来表示数学计算的表达式， 比如用户输入 2 1 5 + * , 通过解释生成表达式 (5+1)*2 ，计算结果是 12。
上面的数学计算表达式会被解释器分解为如下表达式：

• 终端：抽象语法树的叶子节点，他们不包含其他的表达式，上面数学表达中，2,1,5 属于终端表达式
• 非终端：抽象语法树的非叶子节点，他们包含其他表达式，+ 和 * 属于非终端表达式

2 1 5 + * 后缀表达式的抽象语法树如下图：

解释器模式的参与者

我们将应用此模式通过后缀表达法来解释一个数学计算表达式，为了实现，我们先创建一个 Expression 接口和子类 NumberExpression 代表数字（终端表达式），对于非终端表达式，我们为每个操作符创建一个类，分别为 AdditionExpression、SubtractExpression、MultiplicationExpression，用类 ExpressionParser 来解析抽象语法树。
来总结下解释器模式的参与者：

• AbstractExpression( Expression) : 声明一个方法 interpret() 操作AST 中的所有节点
• TerminalExpression( NumberExpression): 实现终端表达式的方法 interpret()
• NonterminalExpression( AdditionExpression, SubtractExpression,MultiplicationExpression): 实现非终端表达式方法 interpret()
• Context(String) : 包含解释器所需解释的所有信息，如例子中一个后缀表示的数学计算表达式
• Client(ExpressionParser) : 从 TerminalExpression 和 NonterminalExpression 中组装 AST ，然后调用方法 interpret()

参与者的关系图：

解释器模式代码实现

public interface Expression {

    int interpret();

}

public class NumberExpression implements Expression {

    private int number;

    public NumberExpression(int number) {
        this.number = number;
    }

    public NumberExpression(String number) {
        this.number = Integer.parseInt(number);
    }

    @Override
    public int interpret() {
        return this.number;
    }
}

public class AdditionExpression implements Expression {

    private final Expression firstExpression;
    private final Expression secondExpression;

    public AdditionExpression(Expression firstExpression, Expression secondExpression) {
        this.firstExpression = firstExpression;
        this.secondExpression = secondExpression;
    }
    
    @Override
    public int interpret() {
        return this.firstExpression.interpret() + this.secondExpression.interpret();
    }

    @Override
    public String toString() {
        return "+";
    }
}

public class MultiplicationExpression implements Expression {

    private final Expression firstExpression;
    private final Expression secondExpression;

    public MultiplicationExpression(Expression firstExpression, Expression secondExpression) {
        this.firstExpression = firstExpression;
        this.secondExpression = secondExpression;
    }

    @Override
    public int interpret() {
        return this.firstExpression.interpret() * this.secondExpression.interpret();
    }

    @Override
    public String toString() {
        return "*";
    }
}

public class ParserUtil {

    public static boolean isOperator(String symbol) {
        return (symbol.equals("+") || symbol.equals("*"));
    }

    public static Expression getExpressionObject(Expression firstExpression, Expression secondExpression, String symbol) {
        if (symbol.equals("+"))
            return new AdditionExpression(firstExpression, secondExpression);
        else
            return new MultiplicationExpression(firstExpression, secondExpression);
    }
}

public class ExpressionParser {

    Stack<Expression> stack = new Stack<>();

    public int parser(String str) {
        String[] tokenList = str.split(" ");
        for (String tokenStr : tokenList) {
            if (!ParserUtil.isOperator(tokenStr)) {
                Expression numberExpression = new NumberExpression(tokenStr);
                stack.push(numberExpression);
            } else {
                int result = ParserUtil.getExpressionObject(stack.pop(), stack.pop(), tokenStr).interpret();
                stack.push(new NumberExpression(result));
            }
        }
        return stack.pop().interpret();
    }

    public static void main(String[] args) {
        String str = "2 1 5 + *";
        ExpressionParser parser = new ExpressionParser();
        int result = parser.parser(str);
        System.out.println(result);
    }
}

简言之，解释器模式允许我们创建一个mini 语言来实现简单的场下逻辑，比如，正则表达式，在jdk 中也有默认实现 java.util.Pattern ，java.text.Format 的子类也使用了解释器模式。如果你使用Spring的话，Spring EL 也使用了解释器模式。