折騰Java設計模式之直譯器模式

大萌小路發表於2019-01-13

Java設計模式

直譯器模式

直譯器模式是類的行為模式。給定一個語言之後，直譯器模式可以定義出其文法的一種表示，並同時提供一個直譯器。客戶端可以使用這個直譯器來解釋這個語言中的句子。

意圖給定一個語言，定義它的文法表示，並定義一個直譯器，這個直譯器使用該標識來解釋語言中的句子。

主要解決 對於一些固定文法構建一個解釋句子的直譯器。

何時使用 如果一種特定型別的問題發生的頻率足夠高，那麼可能就值得將該問題的各個例項表述為一個簡單語言中的句子。這樣就可以構建一個直譯器，該直譯器通過解釋這些句子來解決該問題。

如何解決 構件語法樹，定義終結符與非終結符。

關鍵程式碼 構件環境類，包含直譯器之外的一些全域性資訊，一般是 HashMap。

直譯器模式相關UML圖

類圖

可以看出右側的協作圖(object collaboration diagram)展現出執行時的直譯器模式。Client向右側抽象語法樹傳送解釋請求，請求被轉發並向下到樹結構的所有物件。

直譯器模式的主要角色

抽象直譯器(AbstractExpression/Expression)：宣告一個所有具體表示式都要實現的抽象介面（或者抽象類），介面中主要是一個interpret()方法，稱為解釋操作。具體解釋任務由它的各個實現類來完成，具體的直譯器分別由終結符直譯器TerminalExpression和非終結符直譯器NonterminalExpression完成。

終結符表示式(TerminalExpression)：實現與文法中的元素相關聯的解釋操作，通常一個直譯器模式中只有一個終結符表示式，但有多個例項，對應不同的終結符。終結符一半是文法中的運算單元，比如有一個簡單的公式R=R1+R2，在裡面R1和R2就是終結符，對應的解析R1和R2的直譯器就是終結符表示式。

非終結符表示式(NonterminalExpression)：文法中的每條規則對應於一個非終結符表示式，非終結符表示式一般是文法中的運算子或者其他關鍵字，比如公式R=R1+R2中，+就是非終結符，解析+的直譯器就是一個非終結符表示式。非終結符表示式根據邏輯的複雜程度而增加，原則上每個文法規則都對應一個非終結符表示式。

環境角色(Context)：這個角色的任務一般是用來存放文法中各個終結符所對應的具體值，比如R=R1+R2，我們給R1賦值100，給R2賦值200。這些資訊需要存放到環境角色中，很多情況下我們使用Map來充當環境角色就足夠了。

乾貨程式碼

跳轉到原始碼地址

簡單的一個直譯器計算加減乘除演算法，環境上下文沒有用好，其實計算規則更多的是人為設定的了。

本次的抽象接收器用的是抽象類，用介面代替也可以。

//抽象直譯器
public abstract class AbstractExpression {

    public abstract int interpreter(Context context);
}

//非終結表示式：加法
@Data
@AllArgsConstructor
public class Add extends AbstractExpression {

    private final AbstractExpression left;

    private final AbstractExpression right;

    @Override
    public int interpreter(Context context) {
        return left.interpreter(context) + right.interpreter(context);
    }
}

//非終結表示式：減法
@Data
@AllArgsConstructor
public class Subtract extends AbstractExpression {

    private final AbstractExpression left;

    private final AbstractExpression right;

    @Override
    public int interpreter(Context context) {
        return left.interpreter(context) - right.interpreter(context);
    }
}

//非終結表示式：乘法
@Data
@AllArgsConstructor
public class Multiply extends AbstractExpression {

    private final AbstractExpression left;

    private final AbstractExpression right;

    @Override
    public int interpreter(Context context) {
        return left.interpreter(context) * right.interpreter(context);
    }
}

//非終結表示式：除法
@Data
@AllArgsConstructor
public class Division extends AbstractExpression {

    private final AbstractExpression left;

    private final AbstractExpression right;

    @Override
    public int interpreter(Context context) {
        int right = this.right.interpreter(context);
        if (right != 0) {
            return left.interpreter(context) / right;
        }

        return -1;
    }
}

//終結表示式：變數
@Data
@AllArgsConstructor
public class Variable extends AbstractExpression {

    private final String key;

    @Override
    public int interpreter(Context context) {
        return context.getValue(key);
    }
}

//環境上下文
@Getter
public class Context {

    private final Map<String, Integer> valueMap = Maps.newHashMap();

    public void addValue(final String key, final int value) {
        valueMap.put(key, Integer.valueOf(value));
    }

    public int getValue(final String key) {
        return valueMap.get(key).intValue();
    }
}


//
public class Application {

    public static void main(String[] args) {
        Context context = new Context();
        context.addValue("a", 6);
        context.addValue("b", 9);
        context.addValue("c", 1);

        Variable a = new Variable("a");
        Variable b = new Variable("b");
        Variable c = new Variable("c");

        AbstractExpression multiplyValue = new Multiply(a, b);
        AbstractExpression subtractValue = new Subtract(a, b);
        AbstractExpression addValue = new Add(subtractValue, c);
        AbstractExpression divisionValue = new Division(multiplyValue, addValue);

        log.info("{}", context.getValueMap());
        log.info("(a*b)/(a-b+c) = {}", divisionValue.interpreter(context));
    }
}
複製程式碼