解释器模式

最新推荐文章于 2020-10-22 21:56:14 发布

未曾路过

最新推荐文章于 2020-10-22 21:56:14 发布

阅读量355

点赞数

分类专栏：设计模式文章标签：设计模式解释器模式

本文链接：https://blog.csdn.net/one_Jachen/article/details/102986916

版权

设计模式专栏收录该内容

32 篇文章 4 订阅

订阅专栏

一、解释器模式介绍

在编译原理中，一个算法表达式通过语法分析器形成词法单元，而后这些词法单元再通过语法分析器构建语法分析树，最终形成一颗抽象的语法分析树，这里的词法分析器和语法分析器都可以看做是解释器。

解释器模式是指给定一个语法（表达式），并定义它的文法的一种表示，再定义一个解释器，使用该解释器来解释语言中的句子（表达式）。

二、解释器模式原理图

说明：

1）Context：是环境角色，含有解释器之外的全局信息

2）AbstractExpression；抽象表达式，声明一个抽象的解释操作，这个方法被抽象语法树中所有的节点所共享

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

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

5）说明：输入Context和TerminalExpression信息通过Client输入即可

三、解释器模式例子

通过解释器模式来实现四则运算，如计算a+b-c的值，具体要求：1）先输入表达式的形式，比如a+b+c-d+e，要求表达式的字母不能重复；2）在分别输入a，b，c，d，e的值；3）最后求出结果

类图如下所示：

代码如下所示：

创建Expression抽象类及其子类：

//抽象类表达式，通过Map的键值对，可以获取到变量的值
public abstract class Expression{

    //解释公式和数值，key就是公式（表达式）参数[a,b,c]，value就是具体值
    //如{a = 10, b = 20}
    public abstract int interpreter(Map<String, Integer> map);
}

//变量的解析器
public class VarExpression extends Expression{

    private String key;

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

    public int interpreter(Map<String, Integer> map){
        return map.get(this.key)
    }
}

//抽象运算符解析器。每个运算符都只和自己左右两个数字有关系，
//但是左右两个数字有可能也是一个解析结果，无论何种类型，都是Expression类的实现类
public class SymbolExpression extends Expression{

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

    //因为SymbolExpression是让其子类来实现的，因此interpreter是一个默认实现
    public int interpreter(Map<String, Integer> map){
        return 0;
    }
}

创建AddExpression类和SubExpression类：

//加法解释器
public class AddExpression extends SymbolExpression{

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

    //处理相加
    public int interpreter(Map<String, Integer> map){
        //super.left.interperter(map)：返回left表达式对应的值
        //super.right.interpreter(map)：返回right表达式对应的值
        return super.left.interperter(map) + super.right.interpreter(map);
    }
}

//减法解释器
public class SubExpression extends SymbolExpression{

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

    //处理相减
    public int interpreter(Map<String, Integer> map){
        //super.left.interperter(map)：返回left表达式对应的值
        //super.right.interpreter(map)：返回right表达式对应的值
        return super.left.interperter(map) - super.right.interpreter(map);
    }
}

创建Calculator类：

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:
                    //如果是一个变量，就创建VarExpression对象，并push到stack中
                    stack.push(new VarExpression(String.valueof(charArray[i])));
                    break;
            }
        }
        //当遍历完整个数组后，栈中就得到最后Expression
        this.expression = stack.pop();
    }

    public int run(Map<String, Integer> map){
        return this.expression.interpreter(map);
    }
}

创建Client类：

public class Client{

    public static void main(String[] args){
        String expStr = getExpStr();
        Map<String, Integer> varMap = getValue(expStr);
        Calculator cal = new Calculator(expStr);
        System.out.println("运算结果：" + expStr + "=" + cal.run(varMap));
    }

    public static String getExpStr() throws IOException{
        System.out.print("请输入表达式:");
        return (new BufferedReader(new InputStreamReader(System.in))).readLine();
    }

    public static Map<String, Integer> getValue(String expStr) throws IOException{
        Map<String, Integer> map = new HashMap<>();

        for(char c : expStr.toCharArray()){
            if(ch != '+' && ch != '-'){
                if(!map.containsKey(String.valueof(ch))){
                    System.out.print("请输入" + String.valueof(ch) + "的值：");
                    String input = (new BufferedReader(new InputStreamReader(System.in))).readLine();
                    map.put(String.valueof(ch), input);
                }
            }
        }
        return map;
    }

}

四、解释器模式在spring框架中应用

1）Expression接口：表达式接口

2）下面有不同的实现类，比如SpelExpression，或者ComponsiteStringExpression

3）使用的时候，根据你创建不同的Parser对象，返回不同的Expression对象

public Expression parseExpression(String expressionString, ParserContext context) throws ParseException{
    if(context == null){
        context = NON_TEMPLATE_PARSER_CONTEXT;
    }
    if(context.isTemplate()){
        return parseTemplate(expressionString, context);//返回的就是CompositeStringExpression
    } else {
        return doParseExpression(expressionString, context);//返回的就是SpelExpression
    }
}

4）使用得到的Expression对象，调用getValue，解释执行表达式，最后得到结果