微信原文：設(shè)計模式 | 解釋器模式及典型應(yīng)用
博客原文：設(shè)計模式 | 解釋器模式及典型應(yīng)用
本文主要介紹解釋器模式，在日常開發(fā)中，解釋器模式的使用頻率比較低
解釋器模式
解釋器模式(Interpreter Pattern)：定義一個語言的文法，并且建立一個解釋器來解釋該語言中的句子，這里的 "語言" 是指使用規(guī)定格式和語法的代碼。解釋器模式是一種類行為型模式。
角色
AbstractExpression（抽象表達(dá)式）：在抽象表達(dá)式中聲明了抽象的解釋操作，它是所有終結(jié)符表達(dá)式和非終結(jié)符表達(dá)式的公共父類。
TerminalExpression（終結(jié)符表達(dá)式）：終結(jié)符表達(dá)式是抽象表達(dá)式的子類，它實現(xiàn)了與文法中的終結(jié)符相關(guān)聯(lián)的解釋操作，在句子中的每一個終結(jié)符都是該類的一個實例。通常在一個解釋器模式中只有少數(shù)幾個終結(jié)符表達(dá)式類，它們的實例可以通過非終結(jié)符表達(dá)式組成較為復(fù)雜的句子。
NonterminalExpression（非終結(jié)符表達(dá)式）：非終結(jié)符表達(dá)式也是抽象表達(dá)式的子類，它實現(xiàn)了文法中非終結(jié)符的解釋操作，由于在非終結(jié)符表達(dá)式中可以包含終結(jié)符表達(dá)式，也可以繼續(xù)包含非終結(jié)符表達(dá)式，因此其解釋操作一般通過遞歸的方式來完成。
Context（環(huán)境類）：環(huán)境類又稱為上下文類，它用于存儲解釋器之外的一些全局信息，通常它臨時存儲了需要解釋的語句。
示例
使用解釋器模式實現(xiàn)一個簡單的后綴表達(dá)式解釋器，僅支持對整數(shù)的加法和乘法即可
定義抽象表達(dá)式接口
public interface Interpreter {
int interpret();
}
非終結(jié)符表達(dá)式，對整數(shù)進(jìn)行解釋
public class NumberInterpreter implements Interpreter {
private int number;
public NumberInterpreter(int number) {
this.number = number;
}
public NumberInterpreter(String number) {
this.number = Integer.parseInt(number);
}
@Override
public int interpret() {
return this.number;
}
}
終結(jié)符表達(dá)式，對加法和乘法進(jìn)行解釋
// 加法
public class AddInterpreter implements Interpreter {
private Interpreter firstExpression, secondExpression;
public AddInterpreter(Interpreter firstExpression, Interpreter secondExpression) {
this.firstExpression = firstExpression;
this.secondExpression = secondExpression;
}
@Override
public int interpret() {
return this.firstExpression.interpret() + this.secondExpression.interpret();
}
@Override
public String toString() {
return "+";
}
}
// 乘法
public class MultiInterpreter implements Interpreter {
private Interpreter firstExpression, secondExpression;
public MultiInterpreter(Interpreter firstExpression, Interpreter secondExpression) {
this.firstExpression = firstExpression;
this.secondExpression = secondExpression;
}
@Override
public int interpret() {
return this.firstExpression.interpret() * this.secondExpression.interpret();
}
@Override
public String toString() {
return "*";
}
}
工具類
public class OperatorUtil {
public static boolean isOperator(String symbol) {
return (symbol.equals("+") || symbol.equals("*"));
}
public static Interpreter getExpressionObject(Interpreter firstExpression, Interpreter secondExpression, String symbol) {
if ("+".equals(symbol)) { // 加法
return new AddInterpreter(firstExpression, secondExpression);
} else if ("*".equals(symbol)) { // 乘法
return new MultiInterpreter(firstExpression, secondExpression);
} else {
throw new RuntimeException("不支持的操作符：" + symbol);
}
}
}
測試，對后綴表達(dá)式 6 100 11 + * 進(jìn)行求值
public class Test {
public static void main(String[] args) {
String inputStr = "6 100 11 + *";
MyExpressionParser expressionParser = new MyExpressionParser();
int result = expressionParser.parse(inputStr);
System.out.println("解釋器計算結(jié)果: " + result);
}
}
運(yùn)行結(jié)果
入棧: 6
入棧: 100
入棧: 11
出棧: 11 和 100
應(yīng)用運(yùn)算符: +
階段結(jié)果入棧: 111
出棧: 111 和 6
應(yīng)用運(yùn)算符: *
階段結(jié)果入棧: 666
解釋器計算結(jié)果: 666
解釋器模式總結(jié)
解釋器模式為自定義語言的設(shè)計和實現(xiàn)提供了一種解決方案，它用于定義一組文法規(guī)則并通過這組文法規(guī)則來解釋語言中的句子。雖然解釋器模式的使用頻率不是特別高，但是它在正則表達(dá)式、XML文檔解釋等領(lǐng)域還是得到了廣泛使用。
主要優(yōu)點(diǎn)
- 易于改變和擴(kuò)展文法。由于在解釋器模式中使用類來表示語言的文法規(guī)則，因此可以通過繼承等機(jī)制來改變或擴(kuò)展文法。
- 每一條文法規(guī)則都可以表示為一個類，因此可以方便地實現(xiàn)一個簡單的語言。
- 實現(xiàn)文法較為容易。在抽象語法樹中每一個表達(dá)式節(jié)點(diǎn)類的實現(xiàn)方式都是相似的，這些類的代碼編寫都不會特別復(fù)雜，還可以通過一些工具自動生成節(jié)點(diǎn)類代碼。
- 增加新的解釋表達(dá)式較為方便。如果用戶需要增加新的解釋表達(dá)式只需要對應(yīng)增加一個新的終結(jié)符表達(dá)式或非終結(jié)符表達(dá)式類，原有表達(dá)式類代碼無須修改，符合 "開閉原則"。
主要缺點(diǎn)
- 對于復(fù)雜文法難以維護(hù)。在解釋器模式中，每一條規(guī)則至少需要定義一個類，因此如果一個語言包含太多文法規(guī)則，類的個數(shù)將會急劇增加，導(dǎo)致系統(tǒng)難以管理和維護(hù)，此時可以考慮使用語法分析程序等方式來取代解釋器模式。
- 執(zhí)行效率較低。由于在解釋器模式中使用了大量的循環(huán)和遞歸調(diào)用，因此在解釋較為復(fù)雜的句子時其速度很慢，而且代碼的調(diào)試過程也比較麻煩。
適用場景
- 可以將一個需要解釋執(zhí)行的語言中的句子表示為一個抽象語法樹。
- 一些重復(fù)出現(xiàn)的問題可以用一種簡單的語言來進(jìn)行表達(dá)。
- 一個語言的文法較為簡單。
- 對執(zhí)行效率要求不高。
解釋器模式的典型應(yīng)用
Spring EL表達(dá)式中的解釋器模式
Spring EL表達(dá)式相關(guān)的類在 org.springframework.expression 包下，類圖如下
涉及的類非常多，這里僅對此時我們最關(guān)心的幾個類做介紹：
SpelExpression，表示一個 EL 表達(dá)式，表達(dá)式在內(nèi)部通過一個 AST抽象語法樹 表示，EL表達(dá)式求值是通過 this.ast.getValue(expressionState); 求值
public class SpelExpression implements Expression {
private final String expression;
private final SpelNodeImpl ast;
private final SpelParserConfiguration configuration;
@Override
@Nullable
public Object getValue() throws EvaluationException {
if (this.compiledAst != null) {
try {
EvaluationContext context = getEvaluationContext();
return this.compiledAst.getValue(context.getRootObject().getValue(), context);
}
catch (Throwable ex) {
// If running in mixed mode, revert to interpreted
if (this.configuration.getCompilerMode() == SpelCompilerMode.MIXED) {
this.interpretedCount = 0;
this.compiledAst = null;
}
else {
// Running in SpelCompilerMode.immediate mode - propagate exception to caller
throw new SpelEvaluationException(ex, SpelMessage.EXCEPTION_RUNNING_COMPILED_EXPRESSION);
}
}
}
ExpressionState expressionState = new ExpressionState(getEvaluationContext(), this.configuration);
Object result = this.ast.getValue(expressionState);
checkCompile(expressionState);
return result;
}
//...省略...
}
SpelNodeImpl：已解析的Spring表達(dá)式所代表的ast語法樹的節(jié)點(diǎn)的通用父類型，語法樹的節(jié)點(diǎn)在解釋器模式中扮演的角色是終結(jié)符和非終結(jié)符。從類圖中可以看到，SpelNodeImpl 的子類主要有 Literal，Operator，Indexer等，其中 Literal 是各種類型的值的父類，Operator 則是各種操作的父類
public abstract class SpelNodeImpl implements SpelNode, Opcodes {
protected int pos; // start = top 16bits, end = bottom 16bits
protected SpelNodeImpl[] children = SpelNodeImpl.NO_CHILDREN;
@Nullable
private SpelNodeImpl parent;
public final Object getValue(ExpressionState expressionState) throws EvaluationException {
return getValueInternal(expressionState).getValue();
}
// 抽象方法，由子類實現(xiàn)，獲取對象的值
public abstract TypedValue getValueInternal(ExpressionState expressionState) throws EvaluationException;
//...省略...
}
IntLiteral 表示整型文字的表達(dá)式語言的ast結(jié)點(diǎn)
public class IntLiteral extends Literal {
private final TypedValue value;
public IntLiteral(String payload, int pos, int value) {
super(payload, pos);
this.value = new TypedValue(value); //
this.exitTypeDescriptor = "I";
}
@Override
public TypedValue getLiteralValue() {
return this.value;
}
// ...
}
OpPlus 表示加法的ast結(jié)點(diǎn)，在 getValueInternal 方法中對操作符兩邊進(jìn)行相加操作
public class OpPlus extends Operator {
public OpPlus(int pos, SpelNodeImpl... operands) {
super("+", pos, operands);
Assert.notEmpty(operands, "Operands must not be empty");
}
@Override
public TypedValue getValueInternal(ExpressionState state) throws EvaluationException {
SpelNodeImpl leftOp = getLeftOperand();
if (this.children.length < 2) { // if only one operand, then this is unary plus
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);
}
return state.operate(Operation.ADD, operandOne, null);
}
// 遞歸調(diào)用leftOp的 getValueInternal(state) ，獲取操作符左邊的值
TypedValue operandOneValue = leftOp.getValueInternal(state);
Object leftOperand = operandOneValue.getValue();
// 遞歸調(diào)用children[1]的 getValueInternal(state) ，獲取操作符右邊的值
TypedValue operandTwoValue = getRightOperand().getValueInternal(state);
Object rightOperand = operandTwoValue.getValue();
// 如果操作符左右都是數(shù)值類型，則將它們相加
if (leftOperand instanceof Number && rightOperand instanceof Number) {
Number leftNumber = (Number) leftOperand;
Number rightNumber = (Number) rightOperand;
if (leftNumber instanceof BigDecimal || rightNumber instanceof BigDecimal) {
BigDecimal leftBigDecimal = NumberUtils.convertNumberToTargetClass(leftNumber, BigDecimal.class);
BigDecimal rightBigDecimal = NumberUtils.convertNumberToTargetClass(rightNumber, BigDecimal.class);
return new TypedValue(leftBigDecimal.add(rightBigDecimal));
}
else if (leftNumber instanceof Double || rightNumber instanceof Double) {
this.exitTypeDescriptor = "D";
return new TypedValue(leftNumber.doubleValue() + rightNumber.doubleValue());
}
//...省略 Float->F, BigInteger->add, Long->J,Integer->I
else {
// Unknown Number subtypes -> best guess is double addition
return new TypedValue(leftNumber.doubleValue() + rightNumber.doubleValue());
}
}
//...
return state.operate(Operation.ADD, leftOperand, rightOperand);
}
//...
}
通過一個示例，調(diào)試查看程序中間經(jīng)歷的步驟
public class SpringELTest {
public static void main(String[] args) {
// 1. 構(gòu)建解析器
org.springframework.expression.ExpressionParser parser = new SpelExpressionParser();
// 2. 解析表達(dá)式
Expression expression = parser.parseExpression("100 * 2 + 400 * 1 + 66");
// 3. 獲取結(jié)果
int result = (Integer) expression.getValue();
System.out.println(result); // 結(jié)果：666
}
}
EL表達(dá)式解析后得到表達(dá)式 (((100 * 2) + (400 * 1)) + 66)
如果用圖形把其這棵AST抽象語法樹簡單地畫出來，大概是這樣
調(diào)用 expression.getValue() 求值，此時的 ast 是語法樹的頭結(jié)點(diǎn)，也就是 + OpPlus，所以通過 this.ast.getValue(expressionState) 進(jìn)入了 OpPlus 的 getValue 方法（是父類中的方法），接著進(jìn)入 getValueInternal 方法，然后遞歸計算操作符左邊的值，遞歸計算操作符右邊的值，最后相加返回
參考：
劉偉.Java設(shè)計模式
Java設(shè)計模式精講
后記
歡迎評論、轉(zhuǎn)發(fā)、分享
更多內(nèi)容可訪問我的個人博客：http://laijianfeng.org
關(guān)注【小旋鋒】微信公眾號，及時接收博文推送
