浅谈设计模式-解释器模式-CSDN博客

本文链接：https://blog.csdn.net/weixin_54398380/article/details/125909598

系列文章目录

浅谈设计模式-装饰者模式

前言

初学设计模式，看的韩顺平老师的视频和大话设计模式，记录一下。

一、解释器模式的引入

问题分析

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

先输入表达式的形式，比如 a+b+c-d+e，要求表达式的字母不能重复
在分别输入a ,b, c, d,e 的值
最后求出结果:如图：

常规思路

编写一个方法，接收表达式的形式，然后根据用户输入的数值进行解析，得到结果。

存在问题

问题分析:如果加入新的运算符，比如*/(等等，不利于扩展，另外让一个方法来解析会造成程序结构混乱，不够清晰。由此，引入了解释器模式。

二、什么是解释器模式？

1.解释器模式定义

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

2.如何理解

先来看一张图：
在这里插入图片描述

说明：

Context:是环境角色,含有解释器之外的全局信息.
AbstractExpression:抽象表达式，声明一个抽象的解释操作,这个方法为抽象语法树中所有的节点所共享
TerminalExpression:为终结符表达式，实现与文法中的终结符相关的解释操作
NonTermialExpression:为非终结符表达式，为文法中的非终结符实现解释操作

理解：

首先解释一下终结符表达式和非终结符表达式的区别，比方说上面那个题目，加减运算就是非终结符，而字母就是终结符。在非终结符表达式类中聚合AbstractException父类是为了存放终结符表达式类（比方说a+b，非终结符表达式类要完成加法运算就需要知道a和b的值，所以就需要聚合两个终结符字段来存放a和b）。
从上面一点就可以知道抽象表达式就是抽象了终结符表达式和非终结符表达式，无具体意义。
Context类比较简单，就是存放了输入的表达式。

3.应用场景

应用可以将一个需要解释执行的语言中的句子表示为一个抽象语法树一些重复出现的问题可以用一种简单的语言来表达，比如编译器、运算表达式计算、正则表达式、机器人指令等

三、代码部分

这里的类图和解释器模式有略微差别，具体实现类图如下：
在这里插入图片描述

1.Calculator 代码：

public class Calculator {

	// 定义表达式
	private Expression expression;

	// 构造函数传参，并解析
	public Calculator(String expStr) { // expStr = a+b
		// 安排运算先后顺序
		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();// 从stack取出left => "a"
				right = new VarExpression(String.valueOf(charArray[++i]));// 取出右表达式 "b"
				stack.push(new AddExpression(left, right));// 然后根据得到left 和 right 构建 AddExpresson加入stack
				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);
	}
}

2.Expression 代码：

/**
 * 抽象类表达式，通过HashMap 键值对, 可以获取到变量的值
 */
public abstract class Expression {
	// a + b - c
	// 解释公式和数值, key 就是公式(表达式) 参数[a,b,c], value就是就是具体值
	// HashMap {a=10, b=20}
	public abstract int interpreter(HashMap<String, Integer> var);
}

3.VarExpression 代码：

VarExpression 就是终结符表达式类

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

	private String key; // key=a,key=b,key=c

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

	// var 就是{a=10, b=20}
	// interpreter 根据 变量名称，返回对应值
	@Override
	public int interpreter(HashMap<String, Integer> var) {
		return var.get(this.key);
	}
}

4.AddExpression 代码：

AddExpression 和 SubExpression 就是非终结符表达式

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

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

	//处理相加
	//var 仍然是 {a=10,b=20}..
	//一会我们debug 源码,就ok
	public int interpreter(HashMap<String, Integer> var) {
		//super.left.interpreter(var) ： 返回 left 表达式对应的值 a = 10
		//super.right.interpreter(var): 返回right 表达式对应值 b = 20
		return super.left.interpreter(var) + super.right.interpreter(var);
		//⭐这里是否重要,super.left.interpreter(var)如果调用的是VarExpression 中的
		//方法，则直接放回数值，如果调用的是AddExpression 或 SubExpression 则是递归！
		//很明显这里使用了多态，
	}
}

注：SubExpression类类似就不写出来了

5.测试类ClientTest 代码：

public class ClientTest {

	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;
	}
}

6.代码难点解析

代码整体逻辑就是借助栈来区分表达式中的终结符和非终结符。在Calculator 类会依次遍历输入的表达式：
① 如果是终结符（如：a、b等）封装成VarExpression 就压入栈；
② 如果是非终结符（如：+或-）就出栈上一次运算结果和遍历下一个终结符（上一次结果可能是 AddExpression 或 SubExpression ，这里体现了递归调用!!!）作为当前非终结符的两个字段进行封装。（注意看代码Calculator 和 AddExpression 中带⭐的注释）

五、解释器模式在Spring框架中的应用

1.UML类图

Spring框架中SpelExceptionParser类中就使用了解释器模式（可能在InternalSpelExpressionParser中也使用了），大致的画一下类图：
在这里插入图片描述
理解：抽象表达式是Expression，共有三种实现的表达式，类似于上面VarExpression；而ExpressionParser类似于Calculator，根据输入的表达式返回三种表达式之一。

2.代码

在这里插入图片描述

分析：从上面TemplateAwareExpressionParser类的方法看出，根据输入的文本context来返回不同的表达式。

public class Interpreter {

	public static void main(String[] args) {
		// TODO Auto-generated method stub
		//创建一个 Parser（解析器） 对象
		SpelExpressionParser parser = new SpelExpressionParser();

		//通过 Parser 对象 获取到一个Expression对象
		//会根据不同的  Parser 对象 ，返回不同的 Expression对象
		Expression expression = parser.parseExpression("10 * (2 + 1) * 1 + 66"); //96
		int result = (Integer) expression.getValue();
		System.out.println(result);

	}

}

分析：因为调用parseExpression方法后，返回的Expression对象是Expression类的三个子类之一，所以调用getValue方法就会根据expression是哪个子类来调用该方法（其实就是多态啦）。

总结

个人理解：

解释器模式从代码层面来看，一个抽象解释器类，可能还有一个分派抽象类根据表达式来创建表达式对象（比如上面的Calculator和ExpressionParser，ExpressionParser的真正分配对象是在TemplateAwareExpressionParser中实现），抽象解释器类的子类可理解为解释/定义表达式，而分派抽象类的子类可理解为处理表达式返回结果。
PS：目前初学，理解还不到位！