設計模式 | 解釋器模式及典型應用

時間  2019-11-07
標籤 設計 模式 解釋器 典型 應用 简体版
原文   原文鏈接

微信原文：設計模式 | 解釋器模式及典型應用
博客原文：設計模式 | 解釋器模式及典型應用java

本文主要介紹解釋器模式，在平常開發中，解釋器模式的使用頻率比較低正則表達式

解釋器模式

解釋器模式(Interpreter Pattern)：定義一個語言的文法，而且創建一個解釋器來解釋該語言中的句子，這裏的 "語言" 是指使用規定格式和語法的代碼。解釋器模式是一種類行爲型模式。spring

角色

AbstractExpression（抽象表達式）：在抽象表達式中聲明瞭抽象的解釋操做，它是全部終結符表達式和非終結符表達式的公共父類。express

TerminalExpression（終結符表達式）：終結符表達式是抽象表達式的子類，它實現了與文法中的終結符相關聯的解釋操做，在句子中的每個終結符都是該類的一個實例。一般在一個解釋器模式中只有少數幾個終結符表達式類，它們的實例能夠經過非終結符表達式組成較爲複雜的句子。設計模式

NonterminalExpression（非終結符表達式）：非終結符表達式也是抽象表達式的子類，它實現了文法中非終結符的解釋操做，因爲在非終結符表達式中能夠包含終結符表達式，也能夠繼續包含非終結符表達式，所以其解釋操做通常經過遞歸的方式來完成。bash

Context（環境類）：環境類又稱爲上下文類，它用於存儲解釋器以外的一些全局信息，一般它臨時存儲了須要解釋的語句。微信

解釋器模式結構圖

示例

使用解釋器模式實現一個簡單的後綴表達式解釋器，僅支持對整數的加法和乘法便可ide

定義抽象表達式接口工具

public interface Interpreter {
    int interpret();
}
複製代碼

非終結符表達式，對整數進行解釋測試

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;
    }
}
複製代碼

終結符表達式，對加法和乘法進行解釋

// 加法
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);
        }
    }
}
複製代碼

測試，對後綴表達式 6 100 11 + * 進行求值

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("解釋器計算結果: " + result);
    }
}
複製代碼

運行結果

入棧: 6
入棧: 100
入棧: 11
出棧: 11 和 100
應用運算符: +
階段結果入棧: 111
出棧: 111 和 6
應用運算符: *
階段結果入棧: 666
解釋器計算結果: 666
複製代碼

示例.類圖

解釋器模式總結

解釋器模式爲自定義語言的設計和實現提供了一種解決方案，它用於定義一組文法規則並經過這組文法規則來解釋語言中的句子。雖然解釋器模式的使用頻率不是特別高，可是它在正則表達式、XML文檔解釋等領域仍是獲得了普遍使用。

主要優勢

  • 易於改變和擴展文法。因爲在解釋器模式中使用類來表示語言的文法規則，所以能夠經過繼承等機制來改變或擴展文法。
  • 每一條文法規則均可以表示爲一個類，所以能夠方便地實現一個簡單的語言。
  • 實現文法較爲容易。在抽象語法樹中每個表達式節點類的實現方式都是類似的，這些類的代碼編寫都不會特別複雜，還能夠經過一些工具自動生成節點類代碼。
  • 增長新的解釋表達式較爲方便。若是用戶須要增長新的解釋表達式只須要對應增長一個新的終結符表達式或非終結符表達式類，原有表達式類代碼無須修改，符合 "開閉原則"。

主要缺點

  • 對於複雜文法難以維護。在解釋器模式中，每一條規則至少須要定義一個類，所以若是一個語言包含太多文法規則，類的個數將會急劇增長，致使系統難以管理和維護，此時能夠考慮使用語法分析程序等方式來取代解釋器模式。
  • 執行效率較低。因爲在解釋器模式中使用了大量的循環和遞歸調用，所以在解釋較爲複雜的句子時其速度很慢，並且代碼的調試過程也比較麻煩。

適用場景

  • 能夠將一個須要解釋執行的語言中的句子表示爲一個抽象語法樹。
  • 一些重複出現的問題能夠用一種簡單的語言來進行表達。
  • 一個語言的文法較爲簡單。
  • 對執行效率要求不高。

解釋器模式的典型應用

Spring EL表達式中的解釋器模式

Spring EL表達式相關的類在 org.springframework.expression 包下，類圖以下

org.springframework.expression 包的類圖

涉及的類很是多，這裏僅對此時咱們最關心的幾個類作介紹：

SpelExpression，表示一個 EL 表達式，表達式在內部經過一個 AST抽象語法樹 表示，EL表達式求值是經過 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表達式所表明的ast語法樹的節點的通用父類型，語法樹的節點在解釋器模式中扮演的角色是終結符和非終結符。從類圖中能夠看到，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();
	}
    // 抽象方法，由子類實現，獲取對象的值
	public abstract TypedValue getValueInternal(ExpressionState expressionState) throws EvaluationException;
	//...省略...
}
複製代碼

IntLiteral 表示整型文字的表達式語言的ast結點

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結點，在 getValueInternal 方法中對操做符兩邊進行相加操做

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);
		}
        // 遞歸調用leftOp的 getValueInternal(state) ，獲取操做符左邊的值
		TypedValue operandOneValue = leftOp.getValueInternal(state);
		Object leftOperand = operandOneValue.getValue();
		// 遞歸調用children[1]的 getValueInternal(state) ，獲取操做符右邊的值
		TypedValue operandTwoValue = 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) {
				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);
	}
    //...
}
複製代碼

經過一個示例，調試查看程序中間經歷的步驟

public class SpringELTest {
    public static void main(String[] args) {
        // 1. 構建解析器
        org.springframework.expression.ExpressionParser parser = new SpelExpressionParser();
        // 2. 解析表達式
        Expression expression = parser.parseExpression("100 * 2 + 400 * 1 + 66");
        // 3. 獲取結果
        int result = (Integer) expression.getValue();
        System.out.println(result); // 結果：666
    }
}
複製代碼

EL表達式解析後獲得表達式 (((100 * 2) + (400 * 1)) + 66)

EL表達式解析後獲得的表達式

若是用圖形把其這棵AST抽象語法樹簡單地畫出來，大概是這樣

示例.AST抽象語法樹

調用 expression.getValue() 求值，此時的 ast 是語法樹的頭結點，也就是 + OpPlus，因此經過 this.ast.getValue(expressionState) 進入了 OpPlus 的 getValue 方法（是父類中的方法），接着進入 getValueInternal 方法，而後遞歸計算操做符左邊的值，遞歸計算操做符右邊的值，最後相加返回

示例.spring EL調試

參考：
劉偉.Java設計模式
Java設計模式精講

後記

歡迎評論、轉發、分享

更多內容可訪問個人我的博客：laijianfeng.org

關注【小旋鋒】微信公衆號，及時接收博文推送

關注_小旋鋒_微信公衆號
相關文章
相關標籤/搜索
每日一句
    每一个你不满意的现在，都有一个你没有努力的曾经。
本站公眾號
   歡迎關注本站公眾號,獲取更多信息
聯繫我們 最近搜索 最新文章 沪ICP备13005482号-10 MyBatis教程 SQL 教程 MySQL教程 Java 教程 Thymeleaf 教程 Hibernate教程 Spring教程 Redis教程