設計模式學習筆記（二十二）解釋器模式及其實作-有解無憂

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

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

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

首先 依次 遍歷中綴運算式，

如果是數字 直接輸出

如果是符號： 

?		左括號， 直接進堆疊

?		運算子， 與堆疊頂元素 進行比較如果  堆疊頂元素 優先級較低， 直接入堆疊即可，

?						如果堆疊頂元素 優先級較高，將堆疊頂元素 彈出 并輸出， 之后進堆疊即可，

?		右括號， 將堆疊中的元素依次彈出 直到遇到左括號，

遍歷結束后，如果堆疊中還有元素依次彈出并輸出 即可，

一、解釋器模式介紹

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

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”可以用語法樹表達為：

1.2 解釋器模式的結構

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

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

}

二、解釋器模式應用場景

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

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

三、解釋器模式實戰

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

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

api_error_per_minute > 100 || api_count_per_minute > 10000

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

代碼的結構如下：

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

具體代碼

抽象告警規則介面

public interface Expression {

    boolean interpret(Map<String, Long> stats);
}

具體告警規則實作

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

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 = https://www.cnblogs.com/EthanWong/p/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 = https://www.cnblogs.com/EthanWong/p/Long.parseLong(elements[2].trim());
    }

    @Override
    public boolean interpret(Map 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 = https://www.cnblogs.com/EthanWong/p/Long.parseLong(elements[2].trim());
    }

    @Override
    public boolean interpret(Map 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 = https://www.cnblogs.com/EthanWong/p/Long.parseLong(elements[2].trim());
    }

    @Override
    public boolean interpret(Map stats) {
        if (!stats.containsKey(key)) {
            return false;
        }
        Long statsValue = stats.get(key);
        return statsValue < value;
    }
}

告警規則解釋器

負責解釋并實作告警規則

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

測驗類及結果

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

轉載請註明出處，本文鏈接：https://www.uj5u.com/ruanti/458078.html

標籤：設計模式

上一篇：行為型：一. 觀察者模式

下一篇：約定編程與Sping AOP