解锁Spring Boot中的设计模式—02.解释器模式：探索【解释器模式】的奥秘与应用实践！

解释器模式

1.简介

解释器模式（Interpreter Pattern）是一种行为设计模式，它用于定义语言的文法，并且解释语言中的表达式。在Java中，解释器模式可以用于构建解释器以解析特定的语言或表达式，如数学表达式、查询语言等。

优点：

灵活性： 解释器模式可以灵活地添加新的表达式和规则，因此适用于处理不断变化的语言或表达式。
易扩展性： 可以轻松地扩展文法，添加新的解释器，而不会影响现有的解释器。
简化语法分析： 将文法规则分解成一个个小的解释器，使得语法分析更加简单和清晰。
易于实现： 每个表达式都可以由一个简单的解释器实现，降低了系统的复杂度，易于实现和维护。

缺点：

复杂度高： 对于复杂的文法规则，需要创建大量的解释器对象，可能会导致类爆炸问题，增加系统的复杂度。
执行效率低： 解释器模式通常采用递归调用的方式进行解释，可能会导致解释过程比较耗时，执行效率低下。
维护困难： 随着文法的变化和解释器的增加，维护成本可能会增加，特别是在处理复杂语言时。

使用场景：

特定领域语言（DSL）解析： 适用于需要解析和执行特定领域语言的场景，如数学表达式、正则表达式、查询语言等。
规则引擎： 用于构建规则引擎，根据不同的规则执行相应的操作。
编译器和解释器设计： 可用于编写编译器和解释器，将源代码转换成目标代码或执行相应的操作。
配置文件解析： 适用于解析配置文件，将配置信息转换成相应的对象或操作。

2.案例-生成SQL建表语句

需求描述：

假设我们需要开发一个简单的数据库表生成工具，它可以根据用户提供的列信息生成相应的 SQL 建表语句。用户可以指定表名、列名、数据类型等信息，并且可以选择是否设置列为主键、非空等约束。

用户需求：

用户希望能够指定表名以及列的详细信息，包括列名、数据类型、长度等。
用户希望能够选择是否将某列设置为主键、非空等约束。
用户希望能够生成符合特定数据库类型的建表语句，例如 PostgreSQL、MySQL 等。

实现思路：

定义抽象表达式接口：
- 创建一个接口，定义解释方法 interpret()，该方法将返回解释后的结果。
创建终结符表达式类：
- 实现抽象表达式接口的类，用于表示文法中的最小单元。
- 包含需要解释的数据和解释方法的具体实现。
创建非终结符表达式类：
- 实现抽象表达式接口的类，用于表示文法中的复合结构。
- 包含其他表达式对象或者其他操作的组合，并实现解释方法。
创建环境类（Context）：
- 封装解释器需要的数据和方法。
- 提供执行解释器的方法，并返回结果。
- 解耦解释器与客户端代码： Context提供统一接口，客户端代码不需要直接操作解释器，降低了耦合度。
- 封装解释器的创建逻辑： Context封装解释器的创建逻辑，使客户端代码更简洁，只需调用Context方法即可执行解释器。
- 统一的异常处理机制： Context提供统一异常处理，捕获解释器执行过程中的异常，进行统一处理，如记录日志、返回错误信息。
- 支持扩展和替换解释器：可以通过修改Context中的创建逻辑来引入新的解释器实现或替换现有实现，提高系统的灵活性和可扩展性。
客户端代码：
- 创建具体的终结符和非终结符表达式对象。
- 创建环境对象，将表达式对象传递给环境对象。
- 调用环境对象的解释方法，获取解释结果。

2.1.实现

2.1.1.抽共享表达式接口

/*** 定义抽象表达式接口* @author 13723* @version 1.0* 2024/2/6 10:01*/
public interface Expression {/*** 解释方法* @return 解释结果*/String interpret();
}

2.1.2.终结符表达式类

import lombok.Getter;
import lombok.NoArgsConstructor;
import lombok.Setter;/*** 终结符实现类* 终结符（Terminal Symbol）：在文法中，终结符是指不能进一步被分解的符号或标记。* 在语法分析过程中，终结符是输入字符的最小单元。终结符是文法的基本元素，通常代表实际的词汇或标记。* 文法中的每一个终结符都有一个具体终结表达式与之相对应。*/
@Getter @Setter
@NoArgsConstructor
public class ColumnExpression implements Expression {/*** 列名*/private String name;/*** 列类型*/private String type;/*** 列长度*/private String length;/*** 注释*/private String comment;/*** 是否是主键*/private Boolean primaryKey = false;/*** 是否是非空*/private Boolean notNull = false;public ColumnExpression(String name, String type, String length) {this.name = name;this.type = type;this.length = length;}public ColumnExpression(String name, String type, String length, String comment) {this.name = name;this.type = type;this.length = length;this.comment = comment;}public ColumnExpression(String name, String type, String length, String comment, Boolean notNull) {this.name = name;this.type = type;this.length = length;this.comment = comment;this.notNull = notNull;}public ColumnExpression(String name, String type, String length, String comment, Boolean primaryKey, Boolean notNull) {this.name = name;this.type = type;this.length = length;this.primaryKey = primaryKey;this.notNull = notNull;this.comment = comment;}@Overridepublic String interpret() {StringBuilder sb = new StringBuilder();sb.append("\t").append("\"").append(name).append("\"").append("  ").append(type).append("(").append(length).append(")");// 如果设置了不为空，根据数据类型添加 NOT NULLif (notNull) {if ("VARCHAR".equals(type) || "CHAR".equals(type) || "TEXT".equals(type) || "BLOB".equals(type) || "CLOB".equals(type) || "NCLOB".equals(type)){sb.append("  COLLATE \"pg_catalog\".\"default\" NOT NULL" );}else {sb.append(" NOT NULL");}}return sb.toString();}
}

2.1.3.非终结符表达式类

package com.hrfan.java_se_base.pattern.Interpreter_pattern.se;import lombok.Getter;
import lombok.Setter;
import org.apache.commons.lang3.StringUtils;import java.util.ArrayList;
import java.util.List;
import java.util.Map;
import java.util.stream.Collectors;/*** 非终结符（Nonterminal Symbol）：非终结符是可以被进一步分解的符号或标记，在文法规则中用来描述语言的结构和组织。* 非终结符通常代表语法结构中的一类元素，可以是语法规则的左侧或右侧的一部分。* 文法中的每条规则都对应于一个非终结符表达式。*/
@Getter @Setter
public class TableExpression  implements Expression{private String tableName;private List<ColumnExpression> columns;public TableExpression(String tableName) {this.tableName = tableName;this.columns = new ArrayList<>();}// 添加列public void addColumn(ColumnExpression column) {columns.add(column);}// 获取设置主键的数据public List<String> getColumnPrimaryKey(){List<String> collect = columns.stream().filter(ColumnExpression::getPrimaryKey).map(ColumnExpression::getName).collect(Collectors.toList());return collect;}// 设置注释 和 字段名称public Map<String,String> getColumnComment(){Map<String, String> map = columns.stream().filter(it -> StringUtils.isNotBlank(it.getComment())).collect(Collectors.toMap(ColumnExpression::getName, ColumnExpression::getComment));return map;}@Overridepublic String interpret() {// 获取主键的列名List<String> columnPrimaryKey = getColumnPrimaryKey();StringBuilder sb = new StringBuilder("\nCREATE TABLE \"gwstd\".\"" + tableName + "\" " + "(" + "\n");for (int i = 0; i < columns.size(); i++) {// 执行非终结符解释逻辑sb.append(columns.get(i).interpret());if (i < columns.size() - 1 || columnPrimaryKey.size() > 0){sb.append(", \n");}}if (columnPrimaryKey.size() > 0){sb.append("\tCONSTRAINT ").append("\"").append(tableName).append("_pkey\"").append("PRIMARY KEY (");for (int i = 0; i < columnPrimaryKey.size(); i++) {sb.append("\"").append(columnPrimaryKey.get(i)).append("\"");if (i < columnPrimaryKey.size() - 1) {sb.append(",");}}sb.append(")\n");}sb.append(");");// 生成输入语句sb.append("\n");sb.append("ALTER TABLE \"gwstd\".").append("\"").append(tableName).append("\"").append(" OWNER TO \"postgres\"").append(";");// 生成注释Map<String, String> columnComment = getColumnComment();if (!columnComment.isEmpty()){for (Map.Entry<String, String> entry : columnComment.entrySet()) {sb.append("\n");// COMMENT ON COLUMN "gwstd"."t_dec_order_head"."sid" IS '主键Sid';sb.append("COMMENT ON COLUMN \"gwstd\".").append("\"").append(tableName).append("\"").append(".").append("\"").append(entry.getKey()).append("\"").append(" IS '").append(entry.getValue()).append("';");}}return sb.toString();}
}

2.1.4.创建Context(承上启下)

import org.slf4j.Logger;
import org.slf4j.LoggerFactory;import java.lang.invoke.MethodHandles;/*** @author 13723* @version 1.0* 2024/2/6 10:17*/
public class Context {private static final Logger logger = LoggerFactory.getLogger(MethodHandles.lookup().lookupClass());/*** 建表语句表达式*/private Expression expression;public Context(){}/*** 解释方法*/public Context(Expression expression){this.expression = expression;}/*** 执行解释方法* @return 解释结果*/public String interpret(){return expression.interpret();}
}

2.1.5.测试类

import org.junit.jupiter.api.DisplayName;
import org.junit.jupiter.api.Test;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;import java.lang.invoke.MethodHandles;/*** @author 13723* @version 1.0* 2024/2/6 10:20*/
public class ExpressCreateTest {private static final Logger logger = LoggerFactory.getLogger(MethodHandles.lookup().lookupClass());@Test@DisplayName("测试建表语句解释器")public void test(){// 创建表对象(使用建造者模式构建表对象)TableExpressionBuilder builder = new TableExpressionBuilder("t_dec_erp_test_students");// 非终结符解释器 中 添加 终结符解释器// 字段名称，字段类型，字段长度，字段注释，是否为主键，是否为空builder.addColumn(new ColumnExpression("sid",  "VARCHAR", "11","主键sid",true,true)).addColumn(new ColumnExpression("name", "VARCHAR", "255","姓名")).addColumn(new ColumnExpression("age",   "NUMERIC", "3","年龄",true)).addColumn(new ColumnExpression("email", "VARCHAR", "255","邮箱",true)).addColumn(new ColumnExpression("address", "VARCHAR", "255","联系地址")).addColumn(new ColumnExpression("telephone", "VARCHAR", "255","联系电话"));// 构建表达式TableExpression expression = builder.build();// 通过Context执行解释方法,获取解释结果.String interpret = new Context(expression).interpret();logger.error("最终生成sql:\n{}",interpret);}
}

在这里插入图片描述

CREATE TABLE "gwstd"."t_dec_erp_test_students" ("sid"  VARCHAR(11)  COLLATE "pg_catalog"."default" NOT NULL, "name"  VARCHAR(255), "age"  NUMERIC(3) NOT NULL, "email"  VARCHAR(255)  COLLATE "pg_catalog"."default" NOT NULL, "address"  VARCHAR(255), "telephone"  VARCHAR(255), CONSTRAINT "t_dec_erp_test_students_pkey"PRIMARY KEY ("sid")
);
ALTER TABLE "gwstd"."t_dec_erp_test_students" OWNER TO "postgres";
COMMENT ON COLUMN "gwstd"."t_dec_erp_test_students"."address" IS '联系地址';
COMMENT ON COLUMN "gwstd"."t_dec_erp_test_students"."name" IS '姓名';
COMMENT ON COLUMN "gwstd"."t_dec_erp_test_students"."telephone" IS '联系电话';
COMMENT ON COLUMN "gwstd"."t_dec_erp_test_students"."email" IS '邮箱';
COMMENT ON COLUMN "gwstd"."t_dec_erp_test_students"."age" IS '年龄';
COMMENT ON COLUMN "gwstd"."t_dec_erp_test_students"."sid" IS '主键sid';

在这里插入图片描述

2.2.Spring使用场景

2.2.1.Spring-SpEL

Spring表达式语言（SpEL）允许在运行时动态计算值，它可以用于配置文件、注解等多种场景中。在SpEL的背后，实际上就是使用了解释器模式。

Spring框架中，与Spring EL（表达式语言）相关的类位于org.springframework.expression包下。以下是几个与Spring EL密切相关的类的简要介绍：

SpelExpression： 代表一个EL表达式，它在内部通过抽象语法树（AST）来表示表达式。EL表达式的求值是通过调用this.ast.getValue(expressionState);来实现的。
ExpressionParser： 表达式解析器接口，定义了解析EL表达式的方法。Spring提供了SpelExpressionParser作为默认的表达式解析器实现。
StandardEvaluationContext： 标准的评估上下文，用于在表达式求值期间存储变量和函数。它提供了用于设置变量和函数的方法，这些变量和函数可以在EL表达式中使用。
EvaluationContext： 评估上下文接口，用于在表达式求值期间提供变量和函数的访问。StandardEvaluationContext是EvaluationContext接口的实现之一。
SpelNode： SpEL语法树的节点，代表了EL表达式的各个部分。每个节点都有自己的类型和操作，用于实现EL表达式的解析和求值。

2.2.1.1.案例代码

@Test
@DisplayName("测试@Value")
public void test2(){// 1. 构建解析器ExpressionParser parser = new SpelExpressionParser();// 2. 解析表达式Expression expression = parser.parseExpression("100 * 2 + 200 * 1 + 100000");// 3. 获取结果int result = (Integer) expression.getValue();// 4. 打印结果logger.error("result:{}",result);
}

在这里插入图片描述

语法树

抽象语法树（Abstract Syntax Tree，AST）是一种用于表示编程语言代码结构的树形数据结构。

在编译器和解释器中，AST是一种常见的数据结构，用于表示程序代码的语法结构和语义信息。

在Java中，AST抽象语法树是指代表Java源代码结构的树形数据结构。它由多个节点组成，每个节点代表源代码中的一个语法元素，例如表达式、语句、方法调用等。AST的根节点表示整个程序的起始点，而子节点则代表程序中的具体语法结构。

# 语法树        +/   \*     +/  \   /  \100  2  *  100000/ \200  1

2.2.1.2.SpelExpression

SpelExpression 是 Spring 表达式语言（SpEL）中的一个组成部分，用于表达特定的表达式。它内部采用抽象语法树（AST）来表示表达式的结构。计算表达式的值是通过调用 this.ast.getValue(expressionState); 实现的。在这个过程中，AST被用来解释和执行表达式，最终得到表达式的计算结果。

public class SpelExpression implements Expression {@Nullablepublic Object getValue() throws EvaluationException {CompiledExpression compiledAst = this.compiledAst;if (compiledAst != null) {try {EvaluationContext context = this.getEvaluationContext();return compiledAst.getValue(context.getRootObject().getValue(), context);} catch (Throwable var4) {if (this.configuration.getCompilerMode() != SpelCompilerMode.MIXED) {throw new SpelEvaluationException(var4, SpelMessage.EXCEPTION_RUNNING_COMPILED_EXPRESSION, new Object[0]);}}this.compiledAst = null;this.interpretedCount.set(0);}ExpressionState expressionState = new ExpressionState(this.getEvaluationContext(), this.configuration);Object result = this.ast.getValue(expressionState);this.checkCompile(expressionState);return result;}
}

2.2.1.2.SpelNodeImpl

SpelNodeImpl 是 Spring 表达式语言（SpEL）中的关键类，用于表示已解析的表达式在抽象语法树（AST）中的节点。

在解释器模式中，AST 的节点充当了终结符和非终结符的角色，帮助构建表达式的结构。

SpelNodeImpl 的子类包括以下几种类型：

Literal: 代表各种类型值的父类。
Operator: 代表各种操作符的父类。
Indexer 等：代表其他类型的节点。

public abstract class SpelNodeImpl implements SpelNode, Opcodes {private static final SpelNodeImpl[] NO_CHILDREN = new SpelNodeImpl[0];protected SpelNodeImpl[] children;@Nullableprivate SpelNodeImpl parent;@Nullableprotected final <T> T getValue(ExpressionState state, Class<T> desiredReturnType) throws EvaluationException {return ExpressionUtils.convertTypedValue(state.getEvaluationContext(), this.getValueInternal(state), desiredReturnType);}// 抽象方法子类实现，获取对象值public abstract TypedValue getValueInternal(ExpressionState expressionState) throws EvaluationException;}

2.2.1.3.IntLiteral

IntLiteral 表示整型文字的表达式语言的ast结点

public class IntLiteral extends Literal {private final TypedValue value;public IntLiteral(String payload, int startPos, int endPos, int value) {super(payload, startPos, endPos);this.value = new TypedValue(value);this.exitTypeDescriptor = "I";}public TypedValue getLiteralValue() {return this.value;}// 
}

2.2.1.4.OpPlus

OpPlus 表示加法的ast结点，在 getValueInternal 方法中对操作符两边进行相加操作

public class OpPlus extends Operator {private static final int MAX_CONCATENATED_STRING_LENGTH = 100000;public OpPlus(int startPos, int endPos, SpelNodeImpl... operands) {super("+", startPos, endPos, operands);Assert.notEmpty(operands, "Operands must not be empty");}public TypedValue getValueInternal(ExpressionState state) throws EvaluationException {SpelNodeImpl leftOp = this.getLeftOperand();if (this.children.length < 2) {Object operandOne = leftOp.getValueInternal(state).getValue();if (operandOne instanceof Number) {if (operandOne instanceof Double) {this.exitTypeDescriptor = "D";} else if (operandOne instanceof Float) {this.exitTypeDescriptor = "F";} else if (operandOne instanceof Long) {this.exitTypeDescriptor = "J";} else if (operandOne instanceof Integer) {this.exitTypeDescriptor = "I";}return new TypedValue(operandOne);} else {return state.operate(Operation.ADD, operandOne, (Object)null);}} else {// 递归调用leftOp的 getValueInternal(state) ，获取操作符左边的值TypedValue operandOneValue = leftOp.getValueInternal(state);Object leftOperand = operandOneValue.getValue();// 递归调用children[1]的 getValueInternal(state) ，获取操作符右边的值TypedValue operandTwoValue = this.getRightOperand().getValueInternal(state);Object rightOperand = operandTwoValue.getValue();// 如果操作符左右都是数值类型，则将它们相加if (leftOperand instanceof Number && rightOperand instanceof Number) {Number leftNumber = (Number)leftOperand;Number rightNumber = (Number)rightOperand;if (!(leftNumber instanceof BigDecimal) && !(rightNumber instanceof BigDecimal)) {if (!(leftNumber instanceof Double) && !(rightNumber instanceof Double)) {if (!(leftNumber instanceof Float) && !(rightNumber instanceof Float)) {if (!(leftNumber instanceof BigInteger) && !(rightNumber instanceof BigInteger)) {if (!(leftNumber instanceof Long) && !(rightNumber instanceof Long)) {if (!CodeFlow.isIntegerForNumericOp(leftNumber) && !CodeFlow.isIntegerForNumericOp(rightNumber)) {return new TypedValue(leftNumber.doubleValue() + rightNumber.doubleValue());} else {this.exitTypeDescriptor = "I";return new TypedValue(leftNumber.intValue() + rightNumber.intValue());}} else {this.exitTypeDescriptor = "J";return new TypedValue(leftNumber.longValue() + rightNumber.longValue());}} else {BigInteger leftBigInteger = (BigInteger)NumberUtils.convertNumberToTargetClass(leftNumber, BigInteger.class);BigInteger rightBigInteger = (BigInteger)NumberUtils.convertNumberToTargetClass(rightNumber, BigInteger.class);return new TypedValue(leftBigInteger.add(rightBigInteger));}} else {this.exitTypeDescriptor = "F";return new TypedValue(leftNumber.floatValue() + rightNumber.floatValue());}} else {this.exitTypeDescriptor = "D";return new TypedValue(leftNumber.doubleValue() + rightNumber.doubleValue());}} else {BigDecimal leftBigDecimal = (BigDecimal)NumberUtils.convertNumberToTargetClass(leftNumber, BigDecimal.class);BigDecimal rightBigDecimal = (BigDecimal)NumberUtils.convertNumberToTargetClass(rightNumber, BigDecimal.class);return new TypedValue(leftBigDecimal.add(rightBigDecimal));}} else {String rightString;String leftString;if (leftOperand instanceof String && rightOperand instanceof String) {this.exitTypeDescriptor = "Ljava/lang/String";rightString = (String)leftOperand;leftString = (String)rightOperand;this.checkStringLength(rightString);this.checkStringLength(leftString);return this.concatenate(rightString, leftString);} else if (leftOperand instanceof String) {rightString = (String)leftOperand;this.checkStringLength(rightString);leftString = rightOperand == null ? "null" : convertTypedValueToString(operandTwoValue, state);this.checkStringLength(leftString);return this.concatenate(rightString, leftString);} else if (rightOperand instanceof String) {rightString = (String)rightOperand;this.checkStringLength(rightString);leftString = leftOperand == null ? "null" : convertTypedValueToString(operandOneValue, state);this.checkStringLength(leftString);return this.concatenate(leftString, rightString);} else {return state.operate(Operation.ADD, leftOperand, rightOperand);}}}}
}

解释器模式相对于其他设计模式确实在实际应用中使用较少，这主要是由于以下几个原因：

复杂性和性能开销： 解释器模式的实现可能会引入较高的复杂性和性能开销。解释器需要对输入进行解析、分析和执行，这可能导致性能上的损失，并且随着解释器规则的增多，代码的复杂度也会增加。
不易理解和维护： 解释器模式的实现通常较为复杂，需要设计者对语法和语义有深入的理解，同时需要维护大量的解释器规则。这使得解释器模式在代码的可读性和可维护性方面存在挑战。
有限的适用场景： 解释器模式通常适用于特定领域的问题，例如编译器、正则表达式引擎等。在许多常见的软件开发场景中，并不经常需要使用解释器模式来解决问题。
其他替代方案： 对于一些需要解释和执行逻辑的问题，通常有更简单、更高效的替代方案，例如使用编译器、脚本引擎、规则引擎等。这些替代方案能够更直接地执行逻辑，而不需要通过解释器的中间层。

尽管解释器模式在一些特定的领域和场景下仍然有其价值，但在许多常见的软件开发任务中，它并不是第一选择。因此，虽然解释器模式是一种重要的设计模式，但其应用相对较少。