设计模式之解释器模式

作用

给定一个语言，定义他的文法的一个表示，并定义一个解释器，这个解释器使用该表示来解释语言中的句子。

原理

Context：环境角色，包含解释器之外的全局信息。

AbstractExpression：声明一个抽象的解释操作，这个方法为抽象语法树中所有的节点所共享。

TerminalExpression：终结符表达式，实现与文法中的终结符相关的解释操作。

NonTermialExpression：非终结符表达式，为文法中的非终结符实现解释操作。

案例

Context

public class Calculator {

    private Expression expression;

    public Calculator(String expStr) {
        Stack<Expression> stack = new Stack<>();
        char[] charArray = expStr.toCharArray();
        Expression left;
        Expression right;
        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])));
                    break;
            }
        }
        this.expression = stack.pop();
    }

    public int run(Set<Integer> var) {
        return this.expression.interpreter(var);
    }
}

AbstractExpression

public interface Expression {

    int interpreter(Set<Integer> var);

}

TerminalExpression

public class VarExpression implements Expression {
    private String key;

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

    @Override
    public int interpreter(Set<Integer> var) {
        return var.contains(Integer.valueOf(this.key)) ? Integer.valueOf(this.key) : -1;
    }
}

NonTermialExpression

public class SymbolExpression implements Expression {

    protected Expression left;
    protected Expression right;

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

    @Override
    public int interpreter(Set<Integer> var) {
        return 0;
    }
}

public class AddExpression extends SymbolExpression {

    public AddExpression(Expression left, Expression right) {
        super(left, right);
    }

    @Override
    public int interpreter(Set<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(Set<Integer> var) {
        return super.left.interpreter(var) - super.right.interpreter(var);
    }
}

源码

org.springframework.expression.spel.standard.SpelExpressionParser

org.springframework.expression.ExpressionParser

org.springframework.expression.Expression