設計模式學習筆記（二十二）直譯器模式及其實現

歸斯君發表於2022-04-12
設計模式筆記

直譯器模式（Interpreter Design Pattern）指給定一個“語言”，定義它的文法的一種表示，並定義一個直譯器，這個直譯器使用該表示來解釋語言中的句子。這裡所指的“語言”是指使用規定格式和語法的程式碼。

比如說在計算器中，我們輸入一個加法/減法表示式（中綴表示式）“1+6-5”字串，就能在計算器中輸出結果2。而我們知道，一般的程式語言像C++、Java和Python無法直接解釋這個字串，那麼就必須定義規定格式和語法的直譯器，來對這個字串表示式進行解釋成程式語言能計算的方式（字尾表示式），最後再進行輸出。也就是中綴表示式轉換成字尾表示式。

image-20220412102618569

那麼在著這個轉換中就需要滿足這樣的語法：

首先 依次 遍歷中綴表示式，

如果是數字 直接輸出

如果是符號： 

​		左括號， 直接進棧

​		運算子， 與棧頂元素 進行比較如果  棧頂元素 優先順序較低， 直接入棧即可。

​						如果棧頂元素 優先順序較高，將棧頂元素 彈出 並輸出。 之後進棧即可。

​		右括號， 將棧中的元素依次彈出 直到遇到左括號。

遍歷結束後，如果棧中還有元素依次彈出並輸出 即可。

一、直譯器模式介紹

在介紹直譯器模式的結構前，先來了解兩個概念文法規則和抽象語法樹

1.1 文法和抽象語法樹

1.1.1 文法

文法也就是用於描述語言的語法結構，比如對於上面提到的表示式“1+6-5”，可以使用一下文法規則來定義：

# 表示式的組成方式，value和operation是兩個語言構造成分或語言單位
expression :: = value | operation
# 非終結表示式，操作符的種類這裡定義兩種’+‘和’-‘
operation :: = expression '+' expression | expression '-' expression
# 終結表示式，組成元素是最基本的語言單位，這裡指像1、6等的整數值
value :: = an integer
  • 符號expression是表示式的組成方式，其中value和operation是後面兩個語言單位的定義
  • 符號::=是定義為的意思
  • 語言單位分為終結符表示式和非終結表示式，value是終結符表示式不可再分，operation是非終結符表示式，可以再分

1.1.2 抽象語法樹

除了使用文法規則來定義語言外，在直譯器模式中還可以通過抽象語法樹（Abstract Syntax Tree, AST）圖形的方式來直觀地表示語言構成，比如“1+6-5”可以用語法樹表達為：

image-20220412111705957

1.2 直譯器模式的結構

從上面的文法規則可以知道，表示式可分為終結符表示式和非終結符表示式，因此直譯器模式的結構與組合模式的結構類似，它的結構類圖如下所示：

image-20220412122703139

  • AbstractExpression：抽象表示式，宣告抽象的解釋操作，終結符表示式和非終結符表示式的公共介面
  • TerminalExpression：終結符表示式，實現抽象表示式以及相關的解釋操作
  • NonterminalExpression：非終結符表示式，實現抽象表示式的相關解釋操作。其中既可以包含終結符表示式，也可以包含非終結符表示式
  • Context：上下文類，用於儲存直譯器外的一些全域性資訊
  • Client：客戶端

1.3 直譯器模式的實現

根據上面的類圖，首先來看一下終結符表示式和非終結符表示式的公共介面抽象表示式

public interface AbstractExpression {
    
	void interpret(Context ctx);
}

接下來是終結符表示式和非終結符表示式類

public class TerminalExpression implements AbstractExpression{

    @Override
    public void interpret(Context context) {
        System.out.println("對終結符表示式進行處理");
    }
}
public class NonterminalExpression implements AbstractExpression{

    private AbstractExpression left;
    private AbstractExpression right;

    public NonterminalExpression(AbstractExpression left, AbstractExpression right) {
        this.left = left;
        this.right = right;
    }

    @Override
    public void interpret(Context context) {
        System.out.println("非終結符表示式進行處理中~");
        //遞迴呼叫每一個組成部分的 interpret()方法

    }
}

最後是上下文類（Context）:

public class Context {
    private Map<String, String> contextMap = new HashMap<String, String>();

    public void assign(String key, String value) {
        //向上下文Map中設定值
        contextMap.put(key, value);
    }

    public String lookup(String key) {
        return contextMap.get(key);
    }

}

二、直譯器模式應用場景

在下列的情況可以考慮使用直譯器模式：

  1. 可以將一個需要解釋執行的語言中的句子表示為一顆抽象語法樹
  2. 一些重複出現的問題可以用一種簡單的語言進行表達
  3. 一個語言的文法較為簡單，對於負責的文法，直譯器模式中的文法類層次結構將變得很龐大而無法管理，此時最好的方式是使用語法分析程式生成器

三、直譯器模式實戰

本案例中模擬監控業務系統的執行情況，及時將異常報告傳送給開發者，比如，如果每分鐘介面出錯數超過100，監控系統就通過簡訊、微信、郵件等方式傳送告警給開發者。（案例來源於《設計模式之美》）

首先設定一個告警規則：每分鐘API總錯數超過100或者每分鐘API總呼叫數超過10000就觸發告警

api_error_per_minute > 100 || api_count_per_minute > 10000

我們定義告警的判斷規則有五種：||、&&、<、>、==，其中<、>、==運算子的優先順序高於||和&&。

image-20220412162955921

程式碼的結構如下：

src
  ├─main
  │  ├─java
  │    │  AlertRuleInterpreter.java
  │    │
  │    └─expression
  │        │  Expression.java
  │        │
  │        └─impl
  │            	AndExpression.java
  │            	EqualExpression.java
  │            	GreaterExpression.java
  │            	LesserExpression.java
  │            	OrExpression.java
  │  
  └─test
      └─java
           ApiTest.java

具體程式碼

  1. 抽象告警規則介面
public interface Expression {

    boolean interpret(Map<String, Long> stats);
}
  1. 具體告警規則實現

分別有||、&&、<、>、==五種運算子判斷規則

public class OrExpression implements Expression {

    private List<Expression> expressions = new ArrayList<>();

    public OrExpression(List<Expression> expressions) {
        this.expressions.addAll(expressions);
    }

    public OrExpression(String strOrExpression) {
        String[] andExpressions = strOrExpression.split("\\|\\|");
        for (String andExpression : andExpressions) {
            expressions.add(new AndExpression(andExpression));
        }
    }

    @Override
    public boolean interpret(Map<String, Long> stats) {
        for (Expression expression : expressions) {
            if (expression.interpret(stats)) {
                return true;
            }
        }
        return false;
    }
}
public class AndExpression implements Expression {

    private List<Expression> expressions = new ArrayList<>();

    public AndExpression(List<Expression> expressions) {
        this.expressions.addAll(expressions);
    }

    public AndExpression(String strAndExpression) {
        String[] strExpressions = strAndExpression.split("&&");
        for (String strExpression : strExpressions) {
            if (strExpression.contains(">")) {
                expressions.add(new GreaterExpression(strExpression));
            } else if (strExpression.contains("<")) {
                expressions.add(new LesserExpression(strExpression));
            } else if (strAndExpression.contains("==")) {
                expressions.add(new EqualExpression(strExpression));
            } else {
                throw new RuntimeException("Expression is invalid: " + strAndExpression);
            }
        }
    }

    @Override
    public boolean interpret(Map<String, Long> stats) {
        for (Expression expression : expressions) {
            if (!expression.interpret(stats)) {
                return false;
            }
        }
        return true;
    }
}
public class EqualExpression implements Expression {

    private String key;
    private Long value;

    public EqualExpression(String key, Long value) {
        this.key = key;
        this.value = value;
    }

    public EqualExpression(String strExpression) {
        String[] elements = strExpression.trim().split("\\s+");
        if (elements.length != 3 || !elements[1].trim().equals("==")) {
            throw new RuntimeException("Expression is invalid: " + strExpression);
        }
        this.key = elements[0].trim();
        this.value = Long.parseLong(elements[2].trim());
    }

    @Override
    public boolean interpret(Map<String, Long> stats) {
        if (!stats.containsKey(key)) {
            return false;
        }
        Long statsValue = stats.get(key);
        return statsValue == value;
    }
}
public class GreaterExpression implements Expression {

    private String key;
    private long value;

    public GreaterExpression(String key, long value) {
        this.key = key;
        this.value = value;
    }

    public GreaterExpression(String strExpression) {
        String[] elements = strExpression.trim().split("\\s+");
        if (elements.length != 3 || !elements[1].trim().equals(">")) {
            throw new RuntimeException("Expression is invalid: " + strExpression);
        }
        this.key = elements[0].trim();
        this.value = Long.parseLong(elements[2].trim());
    }

    @Override
    public boolean interpret(Map<String, Long> stats) {
        if (!stats.containsKey(key)) {
            return false;
        }
        Long statValue = stats.get(key);
        return statValue > value;
    }
}
public class LesserExpression implements Expression {

    private String key;
    private long value;

    public LesserExpression(String key, long value) {
        this.key = key;
        this.value = value;
    }

    public LesserExpression(String strExpression) {
        String[] elements = strExpression.trim().split("\\s+");
        if (elements.length != 3 || !elements[1].trim().equals("<")) {
            throw new RuntimeException("Expression is invalid: " + strExpression);
        }
        this.key = elements[0].trim();
        this.value = Long.parseLong(elements[2].trim());
    }

    @Override
    public boolean interpret(Map<String, Long> stats) {
        if (!stats.containsKey(key)) {
            return false;
        }
        Long statsValue = stats.get(key);
        return statsValue < value;
    }
}
  1. 告警規則直譯器

負責解釋並實現告警規則

public class AlertRuleInterpreter {

    private Expression expression;

    public AlertRuleInterpreter(String ruleExpression) {
        this.expression = new OrExpression(ruleExpression);
    }

    public boolean interpret(Map<String, Long> stats) {
        return expression.interpret(stats);
    }
}
  1. 測試類及結果
public class ApiTest {

    private Logger logger = LoggerFactory.getLogger(ApiTest.class);

    @Test
    public void test() {
        String rule = "api_error_per_minute > 100 || api_count_per_minute > 10000";
        AlertRuleInterpreter alertRuleInterpreter = new AlertRuleInterpreter(rule);
        HashMap<String, Long> statsMap = new HashMap<>();
        statsMap.put("api_error_per_minute", 99l);
        statsMap.put("api_count_per_minute", 121l);
        boolean alertInterpret = alertRuleInterpreter.interpret(statsMap);
        String alert = alertInterpret == true ? "超過閾值，危險！！" : "目前執行良好";
        logger.info("預警結果為：alert:{}", alert);

    }
}

最後的測試結果為：

16:18:14.525 [main] INFO  ApiTest - 預警結果為：alert:目前執行良好

參考資料

《設計模式之美》

《Java設計模式》

《設計模式》

http://c.biancheng.net/view/1402.html

相關文章