设计模式学习笔记 - 设计模式与范式 -行为型：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 - + * ” 这样一个表达式，按照上面的语法规则来处理：

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

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

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 这样五个解析类中。

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

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);}@Overridepublic 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;}@Overridepublic 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;}@Overridepublic 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;}@Overridepublic 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 就出发告警。

api_error_per_minute > 100 || api_count_per_minute > 10000

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

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。

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

public class AlertRuleInterpreter {// key1 > 100 && key2 < 1000 || key3 == 200public 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);}
}

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

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

总结

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

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

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

扩展

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

本文来自互联网用户投稿，该文观点仅代表作者本人，不代表本站立场。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如若转载，请注明出处：http://www.mzph.cn/news/814252.shtml

如若内容造成侵权/违法违规/事实不符，请联系多彩编程网进行投诉反馈email:809451989@qq.com，一经查实，立即删除！

相关文章

数字经济专家高泽龙担任工信部元宇宙标准化委员会委员

数字经济专家高泽龙担任工信部元宇宙标准化委员会委员

数字经济专家高泽龙受聘担任工信部元宇宙标准化委员会委员&#xff0c;出席工作组成立大会暨第一次全体委员会议。 第一届元宇宙国标、团标以及标委会工作组会议顺利召开&#xff01; 同时&#xff0c;正式成为工信部中国人工智能产业发展联盟科技伦理工作组成员&#xff01;
阅读更多...
jmeter使用之生成html测试报告

jmeter使用之生成html测试报告

测试的最终结果是需要给出一份报告&#xff0c;那么在用jmeter测试时怎么生成一份报告呢&#xff0c;以下针对jmeter如何生成html报告进行简单介绍 一、首先把测试脚本写好二、利用命令生成html报告 命令&#xff1a;jmeter -n -t 【Jmx脚本位置】-l 【结果文件result.jtl存放…
阅读更多...
区块链、web3.0、元宇宙的基本概念

区块链、web3.0、元宇宙的基本概念

目录 区块链 起源 发展现状 相关技术 智能合约 加密算法 共识算法 对等网络 web3.0 应用 DeFi 去中心化金融 NFT 非同质化代币 DAO 去中心化自治组织 底层技术 元宇宙 文章部分内容来自网络及AIGC，仅供学习 区块链 起源 区块链的起源可以追溯到21世纪初，当…
阅读更多...
C#, 查找同一个进程显示在任务栏上的多个窗口

C#, 查找同一个进程显示在任务栏上的多个窗口

有的程序可以打开多个窗口并显示在任务栏上。某些情况下&#xff0c;我们需要找到窗口做些事情时&#xff0c;可以参考下面的代码。 public static class Win32Api{[DllImport("user32.dll", SetLastError true)]public static extern bool EnumWindows(EnumWindows…
阅读更多...
HTML5媒体元素

HTML5媒体元素

video元素 视频元素&#xff0c;可以用来插入电影片段或其他视频流。 支持的视频格式是MP4&#xff0c;WebM&#xff0c;Ogg source元素 定义媒体的资源 src属性 规定媒体资源的URL type属性 规定媒体资源的MIME类型 <video controls><source src"../v…
阅读更多...
桥接模式：解耦抽象与实现的设计艺术

桥接模式：解耦抽象与实现的设计艺术

在软件设计中&#xff0c;桥接模式是一种结构型设计模式&#xff0c;旨在将抽象部分与其实现部分分离&#xff0c;使它们可以独立地变化。这种模式通过提供更加灵活的代码结构帮助软件开发人员处理不断变化的需求&#xff0c;特别是在涉及多平台应用开发时。本文将详细介绍桥接…
阅读更多...
kubeadm部署kubernetes1.29

kubeadm部署kubernetes1.29

一、kubernetes集群节点准备 1.1、服务器要求 两台或多台安装linux服务器&#xff0c;此处使用vmware安装虚拟服务器 硬件配置&#xff1a;2GB或更多RAM&#xff0c;2个CPU或更多CPU 需要拉取镜像&#xff0c;如果服务器不能上网&#xff0c;需要提前下载镜像并导入节点 1.2…
阅读更多...
爬虫开发教程

爬虫开发教程

一、爬虫概述 爬虫&#xff08;也称为网络爬虫或蜘蛛&#xff09;是一种自动化程序&#xff0c;能够模拟人类在互联网上浏览和抓取数据的行为。它通过发送HTTP请求&#xff0c;获取网页的HTML代码&#xff0c;然后解析这些代码以提取有用的数据。爬虫在数据分析、价格监测、竞…
阅读更多...
sql注入之宽字节注入

sql注入之宽字节注入

1.1 宽字节注入原理 宽字节注入&#xff0c;在 SQL 进行防注入的时候&#xff0c;一般会开启 gpc&#xff0c;过滤特殊字符。 一般情况下开启 gpc 是可以防御很多字符串型的注入&#xff0c;但是如果数据库编码不 对&#xff0c;也可以导致 SQL 防注入绕过&#xff0c;达到注入…
阅读更多...
【网站项目】农产品自主供销小程序

【网站项目】农产品自主供销小程序

&#x1f64a;作者简介&#xff1a;拥有多年开发工作经验&#xff0c;分享技术代码帮助学生学习&#xff0c;独立完成自己的项目或者毕业设计。 代码可以私聊博主获取。&#x1f339;赠送计算机毕业设计600个选题excel文件&#xff0c;帮助大学选题。赠送开题报告模板&#xff…
阅读更多...
英特尔、联想等服务器曝出难以修复的漏洞

英特尔、联想等服务器曝出难以修复的漏洞

文章目录 前言一、漏洞潜伏六年，服务器供应链安全堪忧二、漏洞广泛存在但难以修复前言 近日，英特尔、联想等多个厂商销售的服务器硬件曝出一个难以修复的远程可利用漏洞。该漏洞属于供应链漏洞，源自一个被多家服务器厂商整合到产品中的开源软件包——Lighttpd。 Lighttpd是…
阅读更多...
SpringMVC之响应

SpringMVC之响应

1.SpringMVC响应常用注解 注解名称注解类型位置作用RestController类注解SpringMVC控制器类上定义设置当前类为SpringMVC控制器类&#xff0c;且设置当前控制器类中所有方法的返回值为响应内容&#xff08;该注解包含ResponseBody注解&#xff09;ResponseBody方法注解SpringM…
阅读更多...
Vue3——html-doc-ja(html导出为word的js库)

Vue3——html-doc-ja(html导出为word的js库)

一、下载 官方地址 html-doc-js - npm npm install html-doc-js 二、使用方法 // 使用页面中引入 import exportWord from html-doc-js// 配置项以及实现下载方法 const wrap document.getElementById(test)const config {document:document, //默认当前文档的document…
阅读更多...
初识SpringMVC(SpringMVC学习笔记一)

初识SpringMVC(SpringMVC学习笔记一)

1 、还是熟悉的配方&#xff0c;先创建一个父Maven项目&#xff08;忘记怎么创建项目了就去前面翻笔记&#xff09;&#xff0c;导入通用的配置依赖 <project xmlns"http://maven.apache.org/POM/4.0.0" xmlns:xsi"http://www.w3.org/2001/XMLSchema-instan…
阅读更多...
Vitis HLS 学习笔记--ap_int.h / ap_fixed.h(1)

Vitis HLS 学习笔记--ap_int.h / ap_fixed.h(1)

目录 目录 1. 概述 2. 简要规则 3. 浮点运算的复杂性 2.1 对阶 3.2 尾数运算 3.3 规格化和舍入 3.4 特殊值的处理 4. 示例&#xff08;ap_fixed.h&#xff09; 5. 量化模式&#xff08;ap_fixed.h&#xff09; 5.1 AP_SAT* 模式会增加资源用量 1. 概述 ap_int.h 和…
阅读更多...
如何将三方库集成到hap包中——通过IDE集成cmak构建方式的C/C++三方库

如何将三方库集成到hap包中——通过IDE集成cmak构建方式的C/C++三方库

简介 cmake构建方式是开源三方库的主流构建方式。DevEco Studio目前以支持cmake的构建方式。本文将通过在IDE上适配cJSON三方库为例讲来解如何在IDE上集成cmake构建方式得三方库。 创建工程 在开发进行三方库适配以及napi接口开发前&#xff0c;我们需要创建一个三方库对应的…
阅读更多...
【opencv】示例-points_classifier.cpp 使用不同机器学习算法在二维空间中对点集进行分类...

【opencv】示例-points_classifier.cpp 使用不同机器学习算法在二维空间中对点集进行分类...

#include "opencv2/core.hpp" // 包含OpenCV核心功能的文件 #include "opencv2/imgproc.hpp" // 包含OpenCV图像处理功能的文件 #include "opencv2/ml.hpp" // 包含OpenCV机器学习模块的文件 #include "opencv2/highgui.hpp" // 包含O…
阅读更多...
【vue】slot 匿名插槽 / 具名插槽

【vue】slot 匿名插槽 / 具名插槽

slot父组件向子组件传递数据 匿名插槽–直接写 具名插槽–指定名称 父组件中 子组件中&#xff1a; 代码 App.vue <template><h2>App.vue</h2><!-- 匿名插槽 --><Header><a href"1234567890.com">1234567890</a>&…
阅读更多...
Vue2基础知识

Vue2基础知识

钩子函数created()和mount()区别 created()是在创建数据代理之后执行的&#xff0c;mount()是在将虚拟dom渲染成真实dom之后执行的 vue的数据代理和数据劫持 开发者工具里获取vue中data的一个数据时可以看到有一个{...},在我们点击之后才能获取到数据。 这是因为vue在初始化…
阅读更多...
常用的过滤网站扫描网站攻击的路径是那些，比如：/etc/passwd等

常用的过滤网站扫描网站攻击的路径是那些，比如：/etc/passwd等

网站攻击中经常被尝试的路径主要包括利用漏洞获取敏感文件、执行系统命令或者注入恶意代码的尝试。以下是一些常见的被攻击者尝试访问的路径和文件&#xff0c;这些通常在网络入侵检测系统&#xff08;IDS&#xff09;和网络防火墙的过滤规则中被特别关注&#xff1a; 系统文件…
阅读更多...
最新文章

Copyright @ 2022~2023