设计模式学习笔记 - 设计模式与范式 -行为型：16.解释器模式：如何设计实现一个自定义接口告警规则功能？

概述

上篇文章，我们学习了命令模式。本章，我们来学习解释器模式，它用来描述如何构建一个简单的 "语言" 解释器。比如命令模式，解释器模式更加小众，只在一些特定的领域内会被用到，比如编译器、规则引擎、正则表达式。所以，解释器模式，只要稍微了解即可。

解释器模式的原理和实现

解释器模式的英文翻译是 Interpreter Design Pattern。在 GoF 的《设计模式》中，是这样定义的：

Interpreter pattern is used to defines a grammatical representation for a language and provides an Interpreter to deal with this grammar.

翻译成中文：解释器模式为某个语言定义它的语法（或者叫文法）表示，并定义一个解释器来处理这个语法。

看了定义，你估计会一头雾水，因为这里面有很多我们平时开发中很少接触的概念，比如 "语言" "解释器"。实际上，这里的 "语言" 不仅仅指我们平时说的中、英、法等各种语言。从广义上来讲，只要是能承载信息的载体，我们都可以称之为 "语言"，比如，古代的结绳记事、盲文、哑语、摩斯密码等。

要想来了解 "语言" 表达的意思，就必须定义相应的语法规则。这样，书写者就可以根据语法规则来书写 "句子" （专业点的叫法应该是 "表达式"），阅读者根据语法规则来阅读 "句子"，这样才能做到信息的正确传递。而我们要讲的解释器模式，其实就是用来实现语法规则解读 "句子" 的解释器。

我们来举一个比较贴近生活的例子。比如中英文翻译。我们知道，把英文翻译成中文是有一定的规则的。这个规则就是定义种的 "语法"。我们开发一个类似 Google Translate 这样的翻译器，这个翻译器能够根据语法规则，将输入的中文翻译成英文。这里的翻译器就是解释器模式定义种的 "解释器"。

现在，我们再来举一个更加贴近编程的例子。

假设我们定义了一个新的加减乘除计算 "语言"，语法规则如下：

运算符质保函加、减、乘、除，并且没有优先级概念
表达式（也就是前面的句子）中，先书写数字，后书写运算符，空格隔开。
按照先后顺序，取出两个数字和一个运算符计算结果，结果重新放入数字的最头部位置，循环上述过程，直到剩下一个数字，这个数字就是表达式最终的计算结果。

比如，" 8 3 2 4 - + * " 这样一个表达式，按照上面的语法规则来处理：

取出数字 8 3 和 - 运算符，计算得到 5，于是表达式就变成了 5 2 4 + *。
然后，我们再取出 5 2 和 +，计算得到7，表达式就变成了 7 4 * 。
最后取出 7 4 和 * 运算符，最终得到的结果是 28。

看懂了上面的语法规则，下面的具体的代码实现。代码非常简单，用户按照上面的规则书写表达式，传递给 interpret() 函数，就可以得到最终的计算结果。

java 复制代码

public class ExpressionInterpreter {
    private Deque<Long> numbers = new LinkedList<>();
    
    public long interpret(String expression) {
        String[] elements = expression.split(" ");
        int length = elements.length;
        for (int i = 0; i < (length+1)/2; i++) {
            numbers.addLast(Long.parseLong(elements[i]));
        }
        for (int i = (length+1)/2; i < length; i++) {
            String operator = elements[i];
            boolean isValid = "+".equals(operator) || "-".equals(operator)
                    || "*".equals(operator) || "/".equals(operator);
            if (isValid) {
                throw new RuntimeException("Invalid expression: " + expression);
            }
            long number1 = numbers.pollFirst();
            long number2 = numbers.pollFirst();
            long result = 0;
            if ("+".equals(operator)) {
                result = number1 + number2;
            } else if ("-".equals(operator)) {
                result = number1 - number2;
            } else if ("*".equals(operator)) {
                result = number1 * number2;
            } else if ("/".equals(operator)) {
                result = number1 / number2;
            }
            numbers.addFirst(result);
        }
        if (numbers.size() != 1) {
            throw new RuntimeException("Invalid expression: " + expression);
        }
        return numbers.pop();
    }
}

上面的代码实现中，语法规则的解析逻辑都集中在一个函数，对于简单的语法规则解析，这样的设计足够了。但是，对于复杂的语法规则的解析，逻辑复杂，代码量多，所有的解析都耦合在一个函数中，这样显然是不合适的。这个时候，我们就要考虑拆分代码，将解析逻辑拆分到独立的小类中。

该怎么拆分？这个时候就需要解释器模式了。

解释器模式的代码实现比较灵活，没有固定的模板。前面我们说过，应用设计模式主要是应对代码的复杂性，实际上，解释器模式也不例外。它的代码实现的核心思想，就是将语法解析的工作拆分到各个小类中，以此来避免大而全的解析类。一般的做法是，将语法规则拆分成一些小的独立的单元，然后对每个单元进行解析，最终合并为对整个语法规则的解析。

前面定义的语法规则有两类表达式，一类是数字，一类是运算符，运算符包括加减乘除。利用解释器模式，我们把解析的工作拆分为 NumberExpression、AdditionExpression、SubstractionExpression、MultiplicationExpression、DivisionExpression 这样五个解析类中。

按照这个思路，我们对代码进行重构，重构之后的代码如下所示。当然，因为加减乘除比较简单，利用解释器模式的设计思路，看起来有点过度设计。不过呢，这里我主要是为了解释原理，你明白意思就好，不用过度细究这个例子。

java 复制代码

public interface Expression {
    long interpret();
}

public class NumberExpression implements Expression {
    private long number;

    public NumberExpression(long number) {
        this.number = number;
    }

    public NumberExpression(String number) {
        this.number = Long.parseLong(number);
    }

    @Override
    public long interpret() {
        return this.number;
    }
}

public class SubstractionExpression implements Expression {
    private Expression exp1;
    private Expression exp2;

    public SubstractionExpression(Expression exp1, Expression exp2) {
        this.exp1 = exp1;
        this.exp2 = exp2;
    }

    @Override
    public long interpret() {
        return exp1.interpret() - exp2.interpret();
    }
}

public class MultiplicationExpression implements Expression {
    private Expression exp1;
    private Expression exp2;

    public MultiplicationExpression(Expression exp1, Expression exp2) {
        this.exp1 = exp1;
        this.exp2 = exp2;
    }

    @Override
    public long interpret() {
        return exp1.interpret() * exp2.interpret();
    }
}

public class DivisionExpression implements Expression {
    private Expression exp1;
    private Expression exp2;

    public DivisionExpression(Expression exp1, Expression exp2) {
        this.exp1 = exp1;
        this.exp2 = exp2;
    }

    @Override
    public long interpret() {
        return exp1.interpret() / exp2.interpret();
    }
}

public class ExpressionInterpreter {
    private Deque<Expression> numbers = new LinkedList<>();

    public long interpret(String expression) {
        String[] elements = expression.split(" ");
        int length = elements.length;
        for (int i = 0; i < (length+1)/2; i++) {
            numbers.addLast(new NumberExpression(elements[i]));
        }
        for (int i = (length+1)/2; i < length; i++) {
            String operator = elements[i];
            boolean isValid = "+".equals(operator) || "-".equals(operator)
                    || "*".equals(operator) || "/".equals(operator);
            if (isValid) {
                throw new RuntimeException("Invalid expression: " + expression);
            }
            Expression exp1 = numbers.pollFirst();
            Expression exp2 = numbers.pollFirst();
            Expression combineExp = null;
            if ("+".equals(operator)) {
                combineExp = new AdditionExpression(exp1, exp2);
            } else if ("-".equals(operator)) {
                combineExp = new SubstractionExpression(exp1, exp2);
            } else if ("*".equals(operator)) {
                combineExp = new MultiplicationExpression(exp1, exp2);
            } else if ("/".equals(operator)) {
                combineExp = new DivisionExpression(exp1, exp2);
            }
            long result = combineExp.interpret();
            numbers.addFirst(new NumberExpression(result));
        }
        if (numbers.size() != 1) {
            throw new RuntimeException("Invalid expression: " + expression);
        }
        return numbers.pop().interpret();
    }
}

解释器模式实战举例

接下来，再来看一个更加贴近实战的例子：如何实现一个自定义接口告警规则功能？

在我们平时的开发中，监控系统非常重要，它可以时刻监控业务系统的运行情况，及时将异常报告给开发者。比如，如果接口每分钟出错数超过 100，监控系统就通过短信、微信、邮件等方式发送告警给开发者。

一般来讲，监控系统支持开发者自定义告警规则，比如我们可以用下面这样一个表达式，来表示一个告警规则，它表达的意思是：每分钟 API 总出错数超过 100 或者每分钟 API 总调用数超过 10000 就出发告警。

bash 复制代码

api_error_per_minute > 100 || api_count_per_minute > 10000

在监控系统重，告警模块只负责统计数据和告警规则，判断是否出发告警。至于每分钟 API 接口出错数、每分钟接口调用总数等统计数据的计算，是由其他模块来负责的。其他模块将统计数据放到一个 Map 中（数据的格式如下所示），发送给告警模块。接下来，我们只关注告警模块。

java 复制代码

Map<String, Long> apiStat = new HashMap<>();
apiStat.put("api_error_per_minute", 103L);
apiStat.put("api_count_per_minute", 987L);

为了简化讲解和代码实现，我们假设自定义的告警规则只包含 ||、&&、>、<、== 这五个运算符：

其中，>、<、== 运算符的优先级高于 ||、&& 运算符，
&& 优先级高于 ||。
在表达式中，任意元素之间需要通过空格来分隔。
此外，用户要可以自定义要监控的 key，比如前面的 api_error_per_minute、api_count_per_minute。

那如何实现上面的需求呢？下面写了一个骨架代码，其中的核心思想我没有给出，你可以自己试着补全一下。

java 复制代码

public class AlertRuleInterpreter {
    // key1 > 100 && key2 < 1000 || key3 == 200
    public AlertRuleInterpreter(String ruleExpression) {
        // 由你来完善
    }

    //<String, Long> apiStat = new HashMap<>();
    //apiStat.put("key1", 103);
    //apiStat.put("key2", 987);
    public boolean interpret(Map<String, Long> stats) {
        boolean result = false;
        // 由你来完善
        return result;
    }
}

public class DemoTest {
    public static void main(String[] args) {
        String rule = "key1 > 100 && key2 < 30 || key3 < 100 || key4 == 88";
        AlertRuleInterpreter interpreter = new AlertRuleInterpreter(rule);
        Map<String, Long> stats = new HashMap<>();
        stats.put("key1", 101L);
        stats.put("key3", 121L);
        stats.put("key4", 88L);
        boolean alert = interpreter.interpret(stats);
        System.out.println(alert);
    }
}

实际上，我们可以把自定义的告警规则，看作一种特殊 "语言" 的语法规则。我们实现一个解释器，能够根据规则，针对用户输入的数据，判断是否出发告警。利用解释器模式，我们把解析表达式的逻辑拆分到各个小类中，避免大而复杂的大量出现。按照这个实现思路，我把刚刚的代码补全，如下所示。

java 复制代码

public interface Expression {
    boolean interpret(Map<String, Long> stats);
}

public class GreaterExpression implements Expression {
    private String key;
    private long value;

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

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

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

public class LessExpression implements Expression {
    private String key;
    private long value;

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

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

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

public class EqualsExpression implements Expression {
    private String key;
    private long value;

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

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

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

public class AndExpression implements Expression {
    private List<Expression> expressions = new ArrayList<>();

    public AndExpression(String strAndExpression) {
        String[] strExpressions = strAndExpression.split("&&");
        for (String strExpr : strExpressions) {
            if (strExpr.contains(">")) {
                expressions.add(new GreaterExpression(strExpr));
            } else if (strExpr.contains("<")) {
                expressions.add(new LessExpression(strExpr));
            } else if (strExpr.contains("==")) {
                expressions.add(new EqualsExpression(strExpr));
            } else {
                throw new RuntimeException("Invalid expression: " + strAndExpression);
            }
        }
    }

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

public class OrExpression implements Expression {
    private List<Expression> expressions = new ArrayList<>();

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

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

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 DemoTest {
    public static void main(String[] args) {
        String rule = "key1 > 100 && key2 < 30 || key3 < 100 || key4 == 88";
        AlertRuleInterpreter interpreter = new AlertRuleInterpreter(rule);
        Map<String, Long> stats = new HashMap<>();
        stats.put("key1", 101L);
        stats.put("key3", 121L);
        stats.put("key4", 88L);
        boolean alert = interpreter.interpret(stats);
        System.out.println(alert);
    }
}

总结

解释器模式，为某个语言定义它的语法表示，并定义一个解释器用来处理这个语法。实际上，这里的 "语言" 不仅仅指我们平时说的中、英、法等各种语言。从广义上讲，只要是能承载信息的载体，都可以称之为 "语言"，比如，古代的结绳记事、盲文、哑语、摩斯密码等。

要想了解 "语言" 要表达的信息，就必须定义相应的语法规则。这样，书写者就可以根据语法规则来书写 "句子"，阅读者根据语法规则来阅读 "句子"，这样才能做到信息的正确传递。而我们要讲解的解释器模式，其实就是用来实现根据语法规则解读 "句子" 的解释器。

解释器模式的代码实现比较灵活，没有固定的模版。前面讲过，应用设计模式主要是应对代码的复杂性，解释器模式也不例外。它的代码实现的核心思想，就是讲语法解析的工作拆分到各个小类中，以此来避免大而全的解析类。一般的做法是，将语法规则拆分成一些小的独立的单元，然后对每个单元进行解析，最终合并为对整个语法规则的解析。

扩展

在上面的告警规则解析的例子中，如果我们还要在表达式中支持括号 "()"，那如何对代码进行重构呢？你可以自行练习下。