設計模式（二十一）——解釋器模式(Spring 框架中SpelExpressionParser源碼分析）

1 四則運算問題

通過解釋器模式來實現四則運算，如計算 a+b-c 的值，具體要求

1) 先輸入表達式的形式，比如 a+b+c-d+e,  要求表達式的字母不能重復

2) 在分別輸入 a ,b, c, d, e 的值

3) 最后求出結果：如圖

2 傳統方案解決四則運算問題分析

1) 編寫一個方法，接收表達式的形式，然后根據用戶輸入的數值進行解析，得到結果

2) 問題分析：如果加入新的運算符，比如 * / ( 等等，不利於擴展，另外讓一個方法來解析會造成程序結構混亂， 不夠清晰.

3) 解決方案：可以考慮使用解釋器模式，  即：  表達式  -> 解釋器(可以有多種) -> 結果

3 解釋器模式基本介紹

基本介紹

1) 在編譯原理中，一個算術表達式通過詞法分析器形成詞法單元，而后這些詞法單元再通過語法分析器構建語法分析樹，最終形成一顆抽象的語法分析樹。這里的詞法分析器和語法分析器都可以看做是解釋器

2) 解釋器模式（Interpreter Pattern）：是指給定一個語言(表達式)，定義它的文法的一種表示，並定義一個解釋器， 使用該解釋器來解釋語言中的句子(表達式)

3) 應用場景

• 應用可以將一個需要解釋執行的語言中的句子表示為一個抽象語法樹
• 一些重復出現的問題可以用一種簡單的語言來表達

• 一個簡單語法需要解釋的場景

4) 這樣的例子還有，比如編譯器、運算表達式計算、正則表達式、機器人等

4 解釋器模式的原理類圖

 

• 對原理類圖的說明-即(解釋器模式的角色及職責)

1) Context: 是環境角色,含有解釋器之外的全局信息.

2) AbstractExpression: 抽象表達式， 聲明一個抽象的解釋操作,這個方法為抽象語法樹中所有的節點所共享

3) TerminalExpression: 為終結符表達式, 實現與文法中的終結符相關的解釋操作

4) NonTermialExpression: 為非終結符表達式，為文法中的非終結符實現解釋操作.

5) 說明： 輸入 Context he TerminalExpression  信息通過 Client 輸入即可

5 解釋器模式來實現四則

1) 應用實例要求

通過解釋器模式來實現四則運算， 如計算 a+b-c 的值

2) 思路分析和圖解(類圖)

3)代碼實現

 

 

 

package com.lin.interpret;

import java.util.HashMap;

    /**
     * 抽象類表達式，通過 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);
    
}

 

package com.lin.interpret;

import java.util.HashMap;

    /**
     * 抽象運算符號解析器 這里，每個運算符號，都只和自己左右兩個數字有關系， 但左右兩個數字有可能也是一個解析的結果，無論何種類型，都是 Expression
     * 類的實現類
     *
     * @author Administrator
     *
     */
public 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;
    }
}

 

package com.lin.interpret;

import java.util.HashMap;

public class SubExpression extends SymbolExpression {

    public SubExpression(Expression left, Expression right) {

        super(left, right);
    }

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

 

package com.lin.interpret;

import java.util.HashMap;

    /**
     * 變量的解釋器
     * 
     * @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);
    }
}

 

package com.lin.interpret;

import java.util.HashMap;
import java.util.Stack;

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

 

package com.lin.interpret;

import java.util.HashMap;

    /**
     * 加法解釋器
     * 
     * @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) {
        //super.left.interpreter(var) ： 返回 left 表達式對應的值 a = 10
        //super.right.interpreter(var): 返回 right 表達式對應值 b = 20
        return super.left.interpreter(var) + super.right.interpreter(var);
    }
}

 

package com.lin.interpret;

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.util.HashMap;

public class Client {

    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 框架應用的源碼剖析

1) Spring 框架中 SpelExpressionParser 就使用到解釋器模式

2) 代碼分析

 

 

 3)說明

7 解釋器模式的注意事項和細節

1) 當有一個語言需要解釋執行，可將該語言中的句子表示為一個抽象語法樹，就可以考慮使用解釋器模式，讓程序具有良好的擴展性

2) 應用場景：編譯器、運算表達式計算、正則表達式、機器人等

3) 使用解釋器可能帶來的問題：解釋器模式會引起類膨脹、解釋器模式采用遞歸調用方法，將會導致調試非常復雜、效率可能降低.

 

僅供參考，有錯誤還請指出！

有什么想法，評論區留言，互相指教指教。

覺得不錯的可以點一下右邊的推薦喲！