Day58-设计模式-解释器模式

---

title: Day58-设计模式-解释器模式
date: 2021-03-29 15:46:26
author: Liu_zimo

---

设计模式

• 设计模式分为三种类型，共23种
  1. 创建型模式：单例模式、抽象工厂模式、原型模式、建造者模式、工厂模式。
  2. 结构型模式：适配器模式、桥接模式、装饰模式、组合模式、外观模式、享元模式、代理模式。
  3. 行为型模式：模版方法模式、命令模式、访问者模式、迭代器模式、观察者模式、中介者模式、备忘录模式、解释器模式(Interpreter模式)、状态模式、策略模式、职责链模式(责任链模式)。

解释器模式

• 四则运算问题

  通过解释器模式来实现四则运算，如计算a + b - c的值，具体要求

  1. 先输入表达式的形式，比如 a + b + c - d + e，要求表达式的字母不能重复
  2. 再分别输入a，b，c，d，e的值

  请输入表达式：a + b + c - d + e
  请输入a的值：10
  请输入b的值：11
  请输入c的值：1
  请输入d的值：2
  请输入e的值：3
  运算的结果：a + b + c - d + e = 23
  

• 传统方式解决问题

  1. 编写一个方法，接收表达式的形式，然后根据用户输入的数值进行解析，得到结果
  2. 问题分析：如果加入新的运算符，比如*/(等等，不利于扩展，另外让一个方法来解析会造成程序结构混乱，不够清晰
  3. 解决方案：可以考虑使用解释器模式，即：表达式 → 解释器(可以有多种) → 结果

基本介绍

1. 在编译原理中，一个算术表达式通过词法分析器形成词法单元，而后这些词法单元再通过语法分析器构建语法分析树，最终形成一颗抽象的语法分析树。这里的词法分析器和语法分析器都可以看做是解释器
2. 解释器模式(Interpreter Pattern)：是指给定一个语言(表达式)，定义它的文法的一种表示，并定义一个解释器，使用该解释器来解释语言中的句子(表达式)
3. 应用场景
   • 应用可以将一个需要解释执行的语言中的句子表示为一个抽象语法树
   • 一些重复出现的问题可以用一种简单的语言来表达
   • 一个简单语法需要解释的场景
4. 这样的例子还有，比如编译器、运算表达式计算、正则表达式、机器人等

• 类图说明：
  • Context：是环境角色，含有解释器之外的全局信息
  • AbstractExpression：抽象表达式，声明一个抽象的解释操作，这个方法为抽象语法树中所有的节点所共享
  • TerminalExpressian：为终结符表达式，实现与文法中的终结符相关的解释操作
  • NonTermialExpressin：为非终结符表达式，为文法中的非终结符实现解释操作
  • 说明：输入Context和TerminalExression信息通过Client输入即可
• 实例类图说明：

package com.zimo.设计模式.行为型模式.解释器模式;
import java.util.HashMap;
/**
 * 设计模式 - 解释器模式：四则运算问题
 *      抽象类表达式 - 通过HashMap键值对,可以获取到变量的值
 * @author Liu_zimo
 * @version v0.1 by 2021/3/29 16:22
 */
public abstract class Expression {
    public abstract int interpreter(HashMap<String, Integer> var); // key:变量名 value：变量值
}
--------------------------------------------------------------------------
package com.zimo.设计模式.行为型模式.解释器模式;
import java.util.HashMap;
/**
 * 设计模式 - 解释器模式：四则运算问题
 *      变量解释器
 * @author Liu_zimo
 * @version v0.1 by 2021/3/29 16:24
 */
public class VarExpression extends Expression{
    private String key;     // 存储变量名
    public VarExpression(String key) {
        this.key = key;
    }
    @Override
    public int interpreter(HashMap<String, Integer> var) {
        return var.get(this.key);   // 获取变量值
    }
}
--------------------------------------------------------------------------
package com.zimo.设计模式.行为型模式.解释器模式;
import java.util.HashMap;
/**
 * 设计模式 - 解释器模式：四则运算问题
 *      抽象符号解释器
 * @author Liu_zimo
 * @version v0.1 by 2021/3/29 16:26
 */
public class SymbolExpression extends Expression{
    // 每个运算符号,都只和自己左右两个数字有关系
    // 左右两个数字有可能也是一个解析的结果，无论何种类型，都是Expression类的实现类
    protected Expression left;
    protected Expression right;
    public SymbolExpression(Expression left, Expression right) {
        this.left = left;
        this.right = right;
    }
    @Override
    public int interpreter(HashMap<String, Integer> var) {
        return 0;   // 默认实现
    }
}
--------------------------------------------------------------------------
package com.zimo.设计模式.行为型模式.解释器模式;
import java.util.HashMap;
/**
 * 设计模式 - 解释器模式：四则运算问题
 *      加法解释器
 * @author Liu_zimo
 * @version v0.1 by 2021/3/29 16:31
 */
public class AddExpression extends SymbolExpression{
    public AddExpression(Expression left, Expression right) { super(left, right); }
    @Override
    public int interpreter(HashMap<String, Integer> var) { return super.left.interpreter(var) + super.right.interpreter(var); }
}
--------------------------------------------------------------------------
package com.zimo.设计模式.行为型模式.解释器模式;
import java.util.HashMap;
/**
 * 设计模式 - 解释器模式：四则运算问题
 *      减法解释器
 * @author Liu_zimo
 * @version v0.1 by 2021/3/29 16:28
 */
public class SubExpression extends SymbolExpression{
    public SubExpression(Expression left, Expression right) { super(left, right); }
    public int interpreter(HashMap<String, Integer> var) { return super.left.interpreter(var) - super.right.interpreter(var); }
}
--------------------------------------------------------------------------
package com.zimo.设计模式.行为型模式.解释器模式;
import java.util.HashMap;
import java.util.Stack;
/**
 * 描述
 * @author Liu_zimo
 * @version v0.1 by 2021/3/29 16:36
 */
public class Calculator {
    private Expression expression;
    public Calculator(String expStr) {
        Stack<Expression> stack = new Stack<>();    // 安排运算先后顺序
        char[] charArray = expStr.toCharArray();    // 表达式拆分成字符数组  [a, +, b]
        Expression left = null;
        Expression right = null;
        //遍历字符数组，即遍历[a, +, b]，不同情况处理
        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:
                    //如果是一个 Var 就创建要给 VarExpression 对象，并push到 stack
                    stack.push(new VarExpression(String.valueOf(charArray[i])));
                    break;
            }
        }
        //当遍历完整个 charArray 数组后，stack 就得到最后Expression
        this.expression = stack.pop();
    }
    public int run(HashMap<String, Integer> var) {
        //最后将表达式a+b和 var = {a=10,b=20}
        //然后传递给expression的interpreter进行解释执行
        return this.expression.interpreter(var);
    }
}
--------------------------------------------------------------------------
package com.zimo.设计模式.行为型模式.解释器模式;
import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.util.HashMap;
/**
 * 模拟客户端
 * @author Liu_zimo
 * @version v0.1 by 2021/3/29 16:37
 */
public class Client {
    public static void main(String[] args) throws IOException {
        // TODO Auto-generated method stub
        String expStr = getExpStr(); // a+b
        HashMap<String, Integer> var = getValue(expStr);// var {a=10, b=20}
        Calculator calculator = new Calculator(expStr);
        System.out.println("运算结果：" + expStr + "=" + calculator.run(var));
    }

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

    // 获得值映射
    public static HashMap<String, Integer> getValue(String expStr) throws IOException {
        HashMap<String, Integer> map = new HashMap<>();
        for (char ch : expStr.toCharArray()) {
            if (ch != '+' && ch != '-') {
                if (!map.containsKey(String.valueOf(ch))) {
                    System.out.print("请输入" + String.valueOf(ch) + "的值：");
                    String in = (new BufferedReader(new InputStreamReader(System.in))).readLine();
                    map.put(String.valueOf(ch), Integer.valueOf(in));
                }
            }
        }
        return map;
    }
}

Spring框架中应用

• Spring框架中 SpelExpressionParser就使用到解释器模式
• 说明：
  • Expression接口表达式接口
  • 下面有不同的实现类，比如SpelExpression，或者CompositeStringExpression
  • 使用时候，根据你创建的不同的Parser对象，返回不同的 Expression对象
  • 使用得当Expression对象:调用getvalue解释执行表达式，最后得到结果

注意事项和细节

1. 当有一个语言需要解释执行，可将该语言中的句子表示为一个抽象语法树就可以考虑使用解释器模式，让程序具有良好的扩展性
2. 应用场景：编译器、运算表达式计算、正则表达式、机器人等
3. 使用解释器可能带来的问题：解释器模式会引起类膨胀、解释器模式采用递归调用方法，将会导致调试非常复杂、效率可能降低