设计模式学习笔记（二十二）解释器模式及其实现

归斯君的博客 2023-03-28 原文

解释器模式（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 = 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;
    }
}

告警规则解释器

负责解释并实现告警规则

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

及其笔记 code String public 设计模式

有关设计模式学习笔记（二十二）解释器模式及其实现的更多相关文章

ruby-on-rails - Rails - 子类化模型的设计模式是什么？ - 2
我有一个模型:classItem项目有一个属性“商店”基于存储的值，我希望Item对象对特定方法具有不同的行为。Rails中是否有针对此的通用设计模式？如果方法中没有大的if-else语句，这是如何干净利落地完成的？最佳答案通常通过Single-TableInheritance. 关于ruby-on-rails-Rails-子类化模型的设计模式是什么？，我们在StackOverflow上找到一个类似的问题： https://stackoverflow.co
ruby - 解析 RDFa、微数据等的最佳方式是什么，使用统一的模式/词汇(例如 schema.org)存储和显示信息 - 2
我主要使用Ruby来执行此操作，但到目前为止我的攻击计划如下:使用gemsrdf、rdf-rdfa和rdf-microdata或mida来解析给定任何URI的数据。我认为最好映射到像schema.org这样的统一模式，例如使用这个yaml文件，它试图描述数据词汇表和opengraph到schema.org之间的转换:#SchemaXtoschema.orgconversion#data-vocabularyDV:name:namestreet-address:streetAddressregion:addressRegionlocality:addressLocalityphoto:i
ruby - 如何在续集中重新加载表模式？ - 2
鉴于我有以下迁移:Sequel.migrationdoupdoalter_table:usersdoadd_column:is_admin,:default=>falseend#SequelrunsaDESCRIBEtablestatement,whenthemodelisloaded.#Atthispoint,itdoesnotknowthatusershaveais_adminflag.#Soitfails.@user=User.find(:email=>"admin@fancy-startup.example")@user.is_admin=true@user.save!ende
ruby-on-rails - 使用 rails 4 设计而不更新用户 - 2
我将应用程序升级到Rails4，一切正常。我可以登录并转到我的编辑页面。也更新了观点。使用标准View时，用户会更新。但是当我添加例如字段:name时，它不会在表单中更新。使用devise3.1.1和gem'protected_attributes'我需要在设备或数据库上运行某种更新命令吗？我也搜索过这个地方，找到了许多不同的解决方案，但没有一个会更新我的用户字段。我没有添加任何自定义字段。最佳答案如果您想允许额外的参数，您可以在ApplicationController中使用beforefilter，因为Rails4将参数
ruby - 如何根据特征实现 FactoryGirl 的条件行为 - 2
我有一个用户工厂。我希望默认情况下确认用户。但是鉴于unconfirmed特征，我不希望它们被确认。虽然我有一个基于实现细节而不是抽象的工作实现，但我想知道如何正确地做到这一点。factory:userdoafter(:create)do|user,evaluator|#unwantedimplementationdetailshereunlessFactoryGirl.factories[:user].defined_traits.map(&:name).include?(:unconfirmed)user.confirm!endendtrait:unconfirmeddoenden
ruby - 是否有用于序列化和反序列化各种格式的对象层次结构的模式？ - 2
给定一个复杂的对象层次结构，幸运的是它不包含循环引用，我如何实现支持各种格式的序列化？我不是来讨论实际实现的。相反，我正在寻找可能会派上用场的设计模式提示。更准确地说:我正在使用Ruby，我想解析XML和JSON数据以构建复杂的对象层次结构。此外，应该可以将该层次结构序列化为JSON、XML和可能的HTML。我可以为此使用Builder模式吗？在任何提到的情况下，我都有某种结构化数据-无论是在内存中还是文本中-我想用它来构建其他东西。我认为将序列化逻辑与实际业务逻辑分开会很好，这样我以后就可以轻松支持多种XML格式。最佳答案我最
华为OD机试用Python实现 -【明明的随机数】 2023Q1A - 2
华为OD机试题本篇题目：明明的随机数题目输入描述输出描述：示例1输入输出说明代码编写思路最近更新的博客华为od2023|什么是华为od，od薪资待遇，od机试题清单华为OD机试真题大全，用Python解华为机试题|机试宝典【华为OD机试】全流程解析+经验分享,题型分享,防作弊指南华为o
基于C#实现简易绘图工具【100010177】 - 2
C#实现简易绘图工具一.引言实验目的:通过制作窗体应用程序(C#画图软件),熟悉基本的窗体设计过程以及控件设计,事件处理等,熟悉使用C#的winform窗体进行绘图的基本步骤,对于面向对象编程有更加深刻的体会.Tutorial任务设计一个具有基本功能的画图软件**·包括简单的新建文件,保存,重新绘图等功能**·实现一些基本图形的绘制,包括铅笔和基本形状等,学习橡皮工具的创建**·设计一个合理舒适的UI界面**注明:你可能需要先了解一些关于winform窗体应用程序绘图的基本知识,以及关于GDI+类和结构的知识二.实验环境Windows系统下的visualstudio2017C#窗体应用程序三.
LC滤波器设计学习笔记（一）滤波电路入门 - 2
目录前言滤波电路科普主要分类实际情况单位的概念常用评价参数函数型滤波器简单分析滤波电路构成低通滤波器RC低通滤波器RL低通滤波器高通滤波器RC高通滤波器RL高通滤波器部分摘自《LC滤波器设计与制作》，侵权删。前言最近需要学习放大电路和滤波电路，但是由于只在之前做音乐频谱分析仪的时候简单了解过一点点运放，所以也是相当从零开始学习了。滤波电路科普主要分类滤波器：主要是从不同频率的成分中提取出特定频率的信号。有源滤波器：由RC元件与运算放大器组成的滤波器。可滤除某一次或多次谐波，最普通易于采用的无源滤波器结构是将电感与电容串联，可对主要次谐波（3、5、7）构成低阻抗旁路。无源滤波器：无源滤波器，又称
CAN协议的学习与理解 - 2
最近在学习CAN，记录一下，也供大家参考交流。推荐几个我觉得很好的CAN学习，本文也是在看了他们的好文之后做的笔记首先是瑞萨的CAN入门，真的通透；秀！靠这篇我竟然2天理解了CAN协议！实战STM32F4CAN！原文链接：https://blog.csdn.net/XiaoXiaoPengBo/article/details/116206252CAN详解（小白教程）原文链接：https://blog.csdn.net/xwwwj/article/details/105372234一篇易懂的CAN通讯协议指南1一篇易懂的CAN通讯协议指南1-知乎(zhihu.com)视频推荐CAN总线个人知识总