第 23 章 解释器模式

已于 2022-08-17 18:34:42 修改
阅读量313 收藏 1
点赞数
分类专栏： 老韩设计模式 文章标签： java 设计模式
于 2020-10-07 16:15:59 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/oneby1314/article/details/108952069
版权

第 23 章 解释器模式

1、四则运算问题

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

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

image-20200830191729763

2、传统方案解决四则运算问题分析

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

3、解释器模式基本介绍

解释器模式

  1. 在编译原理中， 一个算术表达式通过词法分析器形成词法单元，而后这些词法单元再通过语法分析器构建语法分析树，最终形成一颗抽象的语法分析树。这里的词法分析器和语法分析器都可以看做是解释器
  2. 解释器模式(Interpreter Pattern)：是指给定一个语言(表达式)， 我们编程人员需要定义语句的文法的一种表示，并定义一个解释器， 使用该解释器来解释语言中的句子(表达式)

应用场景

  1. 应用可以将一个需要解释执行的语言中的句子表示为一个抽象语法树
  2. 一些重复出现的问题可以用一种简单的语言来表达
  3. 一个简单语法需要解释的场景
  4. 这样的例子还有，比如编译器、 运算表达式计算、正则表达式、 机器人等

4、解释器模式的原理类图

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

image-20200830193406951

5、解释器模式来实现四则运算

应用实例要求

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

类图

image-20200830211124396

代码实现

  1. Expression：表达式解释器的抽象父类

    /**
 * 抽象类表达式，通过HashMap 键值对, 可以获取到变量的值
 * 
 * @author Administrator
 *
 */
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);
}

  2. VarExpression：变量的解释器，重写了 interpreter() 方法，该方法通过变量的名称获取变量的值

    /**
 * 变量的解释器
 * 
 * @author Administrator
 *
 */
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);
	}
}

  3. SymbolExpression：抽象运算符的解释器，由于运算符有多中类型，所以在 interpreter() 无法完成具体的运算操作，具体操作交由子类实现

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

	protected Expression left;
	protected Expression right;

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

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

  4. AddExpression：加法运算符的解释器，递归调用：表达式的值 = 左边表达式的值 + 右边表达式的值

    /**
 * 加法解释器
 * 
 * @author Administrator
 *
 */
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) {
		// left.interpreter(var) ： 返回 left 表达式对应的值 a = 10
		// right.interpreter(var): 返回right 表达式对应值 b = 20
		return left.interpreter(var) + right.interpreter(var);
	}
}

  5. SubExpression：减法运算符的解释器，递归调用：表达式的值 = 左边表达式的值 + 右边表达式的值

    /**
 * 减法解释器
 * 
 * @author Administrator
 *
 */
public class SubExpression extends SymbolExpression {

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

	// 求出left 和 right 表达式相减后的结果
	public int interpreter(HashMap<String, Integer> var) {
		return left.interpreter(var) - right.interpreter(var);
	}
}

  6. Calculator：计算器类，通过 Expression 的实现类完成具体的解释运算

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

  7. ClientTest：测试代码

    public class ClientTest {

	public static void main(String[] args) throws IOException {
		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、Spring SpelExpressionParser

测试代码

public class Interpreter {

	public static void main(String[] args) {
		// 创建一个 Parser 对象
		ExpressionParser 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);
	}

}

源码追踪

  1. ExpressionParser 是个接口，定义了获取 Express 表达式对象的行为规范，其继承关系如下

    image-20200830214436826

    public interface ExpressionParser {

	Expression parseExpression(String expressionString) throws ParseException;

	Expression parseExpression(String expressionString, ParserContext context) throws ParseException;

}

  2. TemplateAwareExpressionParser 实现了 ExpressionParser 接口，其中有个重要的方法为 parseExpression()，该方法根据表达式的值，获取 Express 对象；在 TemplateAwareExpressionParser 中实现了获取 CompositeStringExpression 表达式对象的方法

    public abstract class TemplateAwareExpressionParser implements ExpressionParser {
    
    // ...
    
    @Override
	public Expression parseExpression(String expressionString) throws ParseException {
		return parseExpression(expressionString, NON_TEMPLATE_PARSER_CONTEXT);
	}

	@Override
	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 对象
		}
	}
    
    
    // ...
    
    private Expression parseTemplate(String expressionString, ParserContext context)
        	throws ParseException {
		if (expressionString.length() == 0) {
			return new LiteralExpression("");
		}
		Expression[] expressions = parseExpressions(expressionString, context);
		if (expressions.length == 1) {
			return expressions[0];
		}
		else {
			return new CompositeStringExpression(expressionString, expressions);
		}
	}
    
    protected abstract Expression doParseExpression(String expressionString,
		ParserContext context) throws ParseException;

    // ...

  3. SpelExpressionParser 类继承自 TemplateAwareExpressionParser 类，实现了 doParseExpression() 抽象方法

    public class SpelExpressionParser extends TemplateAwareExpressionParser {
    
    // ...
    
    @Override
	protected SpelExpression doParseExpression(String expressionString, ParserContext context) throws ParseException {
		return new InternalSpelExpressionParser(this.configuration).doParseExpression(expressionString, context);
	}
    
    // ...

  4. Expression 是个接口，定义了表达式解释器的业务规范，里面有超多的 getValue() 方法，用于获取表达式的值，其继承关系如下

    image-20200830215014476

    public interface Expression {

	Object getValue() throws EvaluationException;

	Object getValue(Object rootObject) throws EvaluationException;

	<T> T getValue(Class<T> desiredResultType) throws EvaluationException;

	<T> T getValue(Object rootObject, Class<T> desiredResultType) throws EvaluationException;
    
    // ...

  5. SpelExpression 实现了 Expression 接口，重写了超多的 getValue() 方法，主要是通过调用 SpelNodeImpl 类中的方法来实现 Expresssion 中的 getValue() 方法

    public class SpelExpression implements Expression {

	private final String expression;

	private final SpelNodeImpl ast;

	private final SpelParserConfiguration configuration;

	// the default context is used if no override is supplied by the user
	private EvaluationContext defaultContext;


	/**
	 * Construct an expression, only used by the parser.
	 */
	public SpelExpression(String expression, SpelNodeImpl ast, SpelParserConfiguration configuration) {
		this.expression = expression;
		this.ast = ast;
		this.configuration = configuration;
	}


	// implementing Expression

	@Override
	public Object getValue() throws EvaluationException {
		ExpressionState expressionState = new ExpressionState(getEvaluationContext(), this.configuration);
		return this.ast.getValue(expressionState);
	}

	@Override
	public Object getValue(Object rootObject) throws EvaluationException {
		ExpressionState expressionState = new ExpressionState(getEvaluationContext(), toTypedValue(rootObject), this.configuration);
		return this.ast.getValue(expressionState);
	}

	@Override
	public <T> T getValue(Class<T> expectedResultType) throws EvaluationException {
		ExpressionState expressionState = new ExpressionState(getEvaluationContext(), this.configuration);
		TypedValue typedResultValue = this.ast.getTypedValue(expressionState);
		return ExpressionUtils.convertTypedValue(expressionState.getEvaluationContext(), typedResultValue, expectedResultType);
	}

	@Override
	public <T> T getValue(Object rootObject, Class<T> expectedResultType) throws EvaluationException {
		ExpressionState expressionState = new ExpressionState(getEvaluationContext(), toTypedValue(rootObject), this.configuration);
		TypedValue typedResultValue = this.ast.getTypedValue(expressionState);
		return ExpressionUtils.convertTypedValue(expressionState.getEvaluationContext(), typedResultValue, expectedResultType);
	}

	@Override
	public Object getValue(EvaluationContext context) throws EvaluationException {
		Assert.notNull(context, "The EvaluationContext is required");
		return this.ast.getValue(new ExpressionState(context, this.configuration));
	}
    
    // ...

总结

Expression 接口有不同的实现类，比如 SpelExpression，使用的时候，根据我们创建的 ExpressionParser 对象不同，就返回不同的 Expression 对象

7、解释器模式的注意事项和细节

  1. 当有一个语言需要解释执行， 可将该语言中的句子表示为一个抽象语法树， 就可以考虑使用解释器模式， 让程序具有良好的扩展性
  2. 应用场景： 编译器、 运算表达式计算、 正则表达式、 机器人等
  3. 使用解释器可能带来的问题： 解释器模式会引起类膨胀、 解释器模式采用递归调用方法， 将会导致调试非常复杂、 效率可能降低
OnebyWang
关注
专栏目录
大话设计模式之爱你一万年：第二十三章 行为模式：解释器模式：在也不用担心工资计算错误了：2.解释器模式之简单计算器
悟纤学院
12-22 1万+
我们有有这么简单的表达式： String statement = "1 - 2 + 3 - 4 + 5"; 这个表达式结果是多少呢？这里我们就可以使用到解释器进行处理。 一、常规之计算器1.0 我们先来个简单的，就是两位数的加减法，比如：1 + 2。 1.1 分析 比如我们有一个表达式： String statement = "1 + 2 "; 这里+号之间有一个很大的空格，这里主要是为了之后编码方便，进行分割而已。 ...
Interpreter模式实现简单计算器
05-19
运用Interpreter模式实现简单算术运算的C++源码
四则混合运算解释器
01-14
四则混合运算解释成表达树，然后执行运算，输出结果，本代码有bug，请谨慎使用
23种设计模式（14）：解释器模式
java开发指南博客 【转载】
06-15 461
定义：给定一种语言，定义他的文法的一种表示，并定义一个解释器，该解释器使用该表示来解释语言中句子。 类型：行为类模式 类图： 解释器模式是一个比较少用的模式，本人之前也没有用过这个模式。下面我们就来一起看一下解释器模式。 解释器模式的结构 抽象解释器：声明一个所有具体表达式都要实现的抽象接口（或者抽象类），接口中主要是一个interpret()方法，称为解释操作。具体解释任务...
go-设计模式-解释器模式
lzx2766478的博客
10-23 151
go 设计模式 解释器模式 package main import ( "fmt" "regexp" "strconv" ) type Address struct { City string } type User struct { Id int Name string Age int } func main() { var users = []*User{ {Id: 102, Name: "shenyi", Age: 20}, {Id: 103, Name: "sh
Go设计模式(27)-解释器模式
09-01 261
解释器模式可以描述如何构建一个简单的“语言”解释器。这个模式只在一些特定的领域才有可能用到，如编译器、规则引擎、正则表达式等。好在解释器模式比较简单，大家可以了解一下。
《golang设计模式》第三部分·行为型模式-03-解释器模式（Interpreter）
最新发布
运维玄德公
10-31 436
解释器模式（Interpreter）是用于表达语言语法树和封装语句解释（或运算）行为的对象。
第19章_解释器模式.ppt
03-30
如果在系统中某一特定类型的问题发生的频率很高，此时可以考虑将这些问题的实例表述为一个语言中的句子，因此可以构建一...解释器模式描述了如何构成一个简单的语言解释器，主要应用在使用面向对象语言开发的编译器中。
《模式分类》答案第二章
06-10
第二章通常会涵盖数据预处理、概率论基础以及统计模式识别的初步概念。 在这一章中，读者可以期待学习到以下几个核心知识点： 1. **数据预处理**：数据预处理是机器学习流程中的关键步骤，包括数据清洗、归一化、...
设计模式课程每章ppt(共27章).zip
03-29
├── 第19章_解释器模式.ppt ├── 第20章_迭代器模式.ppt ├── 第21章_中介者模式.ppt ├── 第22章_备忘录模式.ppt ├── 第23章_观察者模式.ppt ├── 第24章_状态模式.ppt ├── 第25章_策略模式.ppt ...
【Interpreter】构建简单的解释器（第2部分—Go语言实现）
问题不大
01-02 3692
文章目录【Interpreter】构建简单的解释器（第1部分—练习—Go语言实现）一、练习题目二、代码三、运行结果 【Interpreter】构建简单的解释器（第1部分—练习—Go语言实现） 一、练习题目 修改代码，允许输入多位数整数，例如 “12+3” 添加一个忽略空白字符的方法，让计算器可以处理带有空白字符的输入，如 “12 + 3” 修改代码，使用 ‘-’ 代替 ‘+’ 来处理像 “7-...
设计模式 行为型模式 实例 -- 解释器模式实例：实现四则运算的计算器
天行健 君子以自强不息，地势坤 君子以厚德载物。
11-23 1261
1. 解释器模式实例 1.1 需求 请用解释器模式实现一个四则混合运算的表达式解析并结算出表达式的值 例如：5+3-2*6 1.2 类图分析: 1.3 代码实现： 1.3.1 Node：抽象表达式类 package ex08.interpreter; /** * ClassName: Node * Description: 抽象表达式类 * * @author Tianjiao * @date 2021/11/22 21:29 */ public abstract class No
【Java设计模式】简单学解释器模式——加减乘除
winrh的博客
07-29 2086
目录 说明 实现方式 应用场景 其他链接 说明 行为型模式之一，其他还有命令模式、模板方法模式、访问者模式、观察者模式、中介者模式、备忘录模式、迭代器模式（Interpreter模式）、状态模式、策略模式、职责链模式(责任链模式) 解释器模式（Interpreter Pattern）：给定一个语言(表达式)，定义它的文法的一种表示，并定义一个解释器，使用该解释器来解释语言中的句子(表达式) 使用解释器可能带来的问题：解释器模式会引起类膨胀、解释器模式采用递归调用方法，将会导致调.
【算法】解释器模式解决字符串四则运算问题
Crick19931221的博客
05-10 1199
 public class MyInterpreter    {        //{"(","1","+","2",")","*","3.5"}        public MyInterpreter(string[] tokens)        {            this.Tokens = tokens;            this.Finger =
解释器模式
lw8014的博客
03-15 531
概述解释器模式是类的行为模式。给定一个语言之后，解释器模式可以定义出其文法的一种表示，并同时提供一个解释器。客户端可以使用这个解释器来解释这个语言中的句子。核心概念： 定义一个语言的文法，并且建立一个解释器来解释该语言中的句子，这里的“语言”是指使用规定格式和语法的代码。解释器模式是一种类行为型模式。解释器模式结构重要核心模块：抽象表达式(Expression)声明一个所有的具体表达式角色都需要实...
理解Java设计模式：第19章 解释器模式
【资源摘要信息】: "Java 23种设计模式19解释器模式.pdf" 解释器模式是设计模式中的一种，主要用于构建一个简单的语言解释器，它定义了语言的文法，并提供了解释器来解析该语言中的句子。这种模式常用于实现小型的...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值