解锁Spring Boot中的设计模式—02.解释器模式:探索【解释器模式】的奥秘与应用实践!

解释器模式

1.简介

解释器模式(Interpreter Pattern)是一种行为设计模式,它用于定义语言的文法,并且解释语言中的表达式。在Java中,解释器模式可以用于构建解释器以解析特定的语言或表达式,如数学表达式、查询语言等。

优点:

  1. 灵活性: 解释器模式可以灵活地添加新的表达式和规则,因此适用于处理不断变化的语言或表达式。
  2. 易扩展性: 可以轻松地扩展文法,添加新的解释器,而不会影响现有的解释器。
  3. 简化语法分析: 将文法规则分解成一个个小的解释器,使得语法分析更加简单和清晰。
  4. 易于实现: 每个表达式都可以由一个简单的解释器实现,降低了系统的复杂度易于实现和维护

缺点:

  1. 复杂度高: 对于复杂的文法规则,需要创建大量的解释器对象,可能会导致类爆炸问题,增加系统的复杂度。
  2. 执行效率低: 解释器模式通常采用递归调用的方式进行解释,可能会导致解释过程比较耗时,执行效率低下。
  3. 维护困难: 随着文法的变化和解释器的增加,维护成本可能会增加,特别是在处理复杂语言时。

使用场景:

  1. 特定领域语言(DSL)解析: 适用于需要解析和执行特定领域语言的场景,如数学表达式正则表达式查询语言等。
  2. 规则引擎: 用于构建规则引擎,根据不同的规则执行相应的操作。
  3. 编译器和解释器设计: 可用于编写编译器和解释器,将源代码转换成目标代码或执行相应的操作。
  4. 配置文件解析: 适用于解析配置文件,将配置信息转换成相应的对象或操作

2.案例-生成SQL建表语句

需求描述:

假设我们需要开发一个简单的数据库表生成工具,它可以根据用户提供的列信息生成相应的 SQL 建表语句。用户可以指定表名、列名、数据类型等信息,并且可以选择是否设置列为主键、非空等约束。

用户需求:

  1. 用户希望能够指定表名以及列的详细信息,包括列名、数据类型、长度等。
  2. 用户希望能够选择是否将某列设置为主键、非空等约束。
  3. 用户希望能够生成符合特定数据库类型的建表语句,例如 PostgreSQL、MySQL 等。

实现思路:

  1. 定义抽象表达式接口
    • 创建一个接口,定义解释方法 interpret(),该方法将返回解释后的结果。
  2. 创建终结符表达式类
    • 实现抽象表达式接口的类,用于表示文法中的最小单元。
    • 包含需要解释的数据和解释方法的具体实现。
  3. 创建非终结符表达式类
    • 实现抽象表达式接口的类,用于表示文法中的复合结构。
    • 包含其他表达式对象或者其他操作的组合,并实现解释方法。
  4. 创建环境类(Context)
    • 封装解释器需要的数据和方法。
    • 提供执行解释器的方法,并返回结果。
    • 解耦解释器与客户端代码: Context提供统一接口,客户端代码不需要直接操作解释器,降低了耦合度。
    • 封装解释器的创建逻辑: Context封装解释器的创建逻辑,使客户端代码更简洁,只需调用Context方法即可执行解释器。
    • 统一的异常处理机制: Context提供统一异常处理,捕获解释器执行过程中的异常,进行统一处理,如记录日志、返回错误信息。
    • 支持扩展和替换解释器: 可以通过修改Context中的创建逻辑来引入新的解释器实现或替换现有实现,提高系统的灵活性和可扩展性。
  5. 客户端代码
    • 创建具体的终结符和非终结符表达式对象。
    • 创建环境对象,将表达式对象传递给环境对象。
    • 调用环境对象的解释方法,获取解释结果。

2.1.实现

2.1.1.抽共享表达式接口
/*** 定义抽象表达式接口* @author 13723* @version 1.0* 2024/2/6 10:01*/
public interface Expression {/*** 解释方法* @return 解释结果*/String interpret();
}
2.1.2.终结符表达式类
import lombok.Getter;
import lombok.NoArgsConstructor;
import lombok.Setter;/*** 终结符实现类* 终结符(Terminal Symbol):在文法中,终结符是指不能进一步被分解的符号或标记。* 在语法分析过程中,终结符是输入字符的最小单元。终结符是文法的基本元素,通常代表实际的词汇或标记。* 文法中的每一个终结符都有一个具体终结表达式与之相对应。*/
@Getter @Setter
@NoArgsConstructor
public class ColumnExpression implements Expression {/*** 列名*/private String name;/*** 列类型*/private String type;/*** 列长度*/private String length;/*** 注释*/private String comment;/*** 是否是主键*/private Boolean primaryKey = false;/*** 是否是非空*/private Boolean notNull = false;public ColumnExpression(String name, String type, String length) {this.name = name;this.type = type;this.length = length;}public ColumnExpression(String name, String type, String length, String comment) {this.name = name;this.type = type;this.length = length;this.comment = comment;}public ColumnExpression(String name, String type, String length, String comment, Boolean notNull) {this.name = name;this.type = type;this.length = length;this.comment = comment;this.notNull = notNull;}public ColumnExpression(String name, String type, String length, String comment, Boolean primaryKey, Boolean notNull) {this.name = name;this.type = type;this.length = length;this.primaryKey = primaryKey;this.notNull = notNull;this.comment = comment;}@Overridepublic String interpret() {StringBuilder sb = new StringBuilder();sb.append("\t").append("\"").append(name).append("\"").append("  ").append(type).append("(").append(length).append(")");// 如果设置了不为空,根据数据类型添加 NOT NULLif (notNull) {if ("VARCHAR".equals(type) || "CHAR".equals(type) || "TEXT".equals(type) || "BLOB".equals(type) || "CLOB".equals(type) || "NCLOB".equals(type)){sb.append("  COLLATE \"pg_catalog\".\"default\" NOT NULL" );}else {sb.append(" NOT NULL");}}return sb.toString();}
}
2.1.3.非终结符表达式类
package com.hrfan.java_se_base.pattern.Interpreter_pattern.se;import lombok.Getter;
import lombok.Setter;
import org.apache.commons.lang3.StringUtils;import java.util.ArrayList;
import java.util.List;
import java.util.Map;
import java.util.stream.Collectors;/*** 非终结符(Nonterminal Symbol):非终结符是可以被进一步分解的符号或标记,在文法规则中用来描述语言的结构和组织。* 非终结符通常代表语法结构中的一类元素,可以是语法规则的左侧或右侧的一部分。* 文法中的每条规则都对应于一个非终结符表达式。*/
@Getter @Setter
public class TableExpression  implements Expression{private String tableName;private List<ColumnExpression> columns;public TableExpression(String tableName) {this.tableName = tableName;this.columns = new ArrayList<>();}// 添加列public void addColumn(ColumnExpression column) {columns.add(column);}// 获取设置主键的数据public List<String> getColumnPrimaryKey(){List<String> collect = columns.stream().filter(ColumnExpression::getPrimaryKey).map(ColumnExpression::getName).collect(Collectors.toList());return collect;}// 设置注释 和 字段名称public Map<String,String> getColumnComment(){Map<String, String> map = columns.stream().filter(it -> StringUtils.isNotBlank(it.getComment())).collect(Collectors.toMap(ColumnExpression::getName, ColumnExpression::getComment));return map;}@Overridepublic String interpret() {// 获取主键的列名List<String> columnPrimaryKey = getColumnPrimaryKey();StringBuilder sb = new StringBuilder("\nCREATE TABLE \"gwstd\".\"" + tableName + "\" " + "(" + "\n");for (int i = 0; i < columns.size(); i++) {// 执行非终结符解释逻辑sb.append(columns.get(i).interpret());if (i < columns.size() - 1 || columnPrimaryKey.size() > 0){sb.append(", \n");}}if (columnPrimaryKey.size() > 0){sb.append("\tCONSTRAINT ").append("\"").append(tableName).append("_pkey\"").append("PRIMARY KEY (");for (int i = 0; i < columnPrimaryKey.size(); i++) {sb.append("\"").append(columnPrimaryKey.get(i)).append("\"");if (i < columnPrimaryKey.size() - 1) {sb.append(",");}}sb.append(")\n");}sb.append(");");// 生成输入语句sb.append("\n");sb.append("ALTER TABLE \"gwstd\".").append("\"").append(tableName).append("\"").append(" OWNER TO \"postgres\"").append(";");// 生成注释Map<String, String> columnComment = getColumnComment();if (!columnComment.isEmpty()){for (Map.Entry<String, String> entry : columnComment.entrySet()) {sb.append("\n");// COMMENT ON COLUMN "gwstd"."t_dec_order_head"."sid" IS '主键Sid';sb.append("COMMENT ON COLUMN \"gwstd\".").append("\"").append(tableName).append("\"").append(".").append("\"").append(entry.getKey()).append("\"").append(" IS '").append(entry.getValue()).append("';");}}return sb.toString();}
}
2.1.4.创建Context(承上启下)
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;import java.lang.invoke.MethodHandles;/*** @author 13723* @version 1.0* 2024/2/6 10:17*/
public class Context {private static final Logger logger = LoggerFactory.getLogger(MethodHandles.lookup().lookupClass());/*** 建表语句表达式*/private Expression expression;public Context(){}/*** 解释方法*/public Context(Expression expression){this.expression = expression;}/*** 执行解释方法* @return 解释结果*/public String interpret(){return expression.interpret();}
}
2.1.5.测试类
import org.junit.jupiter.api.DisplayName;
import org.junit.jupiter.api.Test;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;import java.lang.invoke.MethodHandles;/*** @author 13723* @version 1.0* 2024/2/6 10:20*/
public class ExpressCreateTest {private static final Logger logger = LoggerFactory.getLogger(MethodHandles.lookup().lookupClass());@Test@DisplayName("测试建表语句解释器")public void test(){// 创建表对象(使用建造者模式构建表对象)TableExpressionBuilder builder = new TableExpressionBuilder("t_dec_erp_test_students");// 非终结符解释器 中 添加 终结符解释器// 字段名称,字段类型,字段长度,字段注释,是否为主键,是否为空builder.addColumn(new ColumnExpression("sid",  "VARCHAR", "11","主键sid",true,true)).addColumn(new ColumnExpression("name", "VARCHAR", "255","姓名")).addColumn(new ColumnExpression("age",   "NUMERIC", "3","年龄",true)).addColumn(new ColumnExpression("email", "VARCHAR", "255","邮箱",true)).addColumn(new ColumnExpression("address", "VARCHAR", "255","联系地址")).addColumn(new ColumnExpression("telephone", "VARCHAR", "255","联系电话"));// 构建表达式TableExpression expression = builder.build();// 通过Context执行解释方法,获取解释结果.String interpret = new Context(expression).interpret();logger.error("最终生成sql:\n{}",interpret);}
}

在这里插入图片描述

CREATE TABLE "gwstd"."t_dec_erp_test_students" ("sid"  VARCHAR(11)  COLLATE "pg_catalog"."default" NOT NULL, "name"  VARCHAR(255), "age"  NUMERIC(3) NOT NULL, "email"  VARCHAR(255)  COLLATE "pg_catalog"."default" NOT NULL, "address"  VARCHAR(255), "telephone"  VARCHAR(255), CONSTRAINT "t_dec_erp_test_students_pkey"PRIMARY KEY ("sid")
);
ALTER TABLE "gwstd"."t_dec_erp_test_students" OWNER TO "postgres";
COMMENT ON COLUMN "gwstd"."t_dec_erp_test_students"."address" IS '联系地址';
COMMENT ON COLUMN "gwstd"."t_dec_erp_test_students"."name" IS '姓名';
COMMENT ON COLUMN "gwstd"."t_dec_erp_test_students"."telephone" IS '联系电话';
COMMENT ON COLUMN "gwstd"."t_dec_erp_test_students"."email" IS '邮箱';
COMMENT ON COLUMN "gwstd"."t_dec_erp_test_students"."age" IS '年龄';
COMMENT ON COLUMN "gwstd"."t_dec_erp_test_students"."sid" IS '主键sid';

在这里插入图片描述

在这里插入图片描述

2.2.Spring使用场景

2.2.1.Spring-SpEL

Spring表达式语言(SpEL)允许在运行时动态计算值,它可以用于配置文件、注解等多种场景中。在SpEL的背后,实际上就是使用了解释器模式。

Spring框架中,与Spring EL(表达式语言)相关的类位于org.springframework.expression包下。以下是几个与Spring EL密切相关的类的简要介绍:

  1. SpelExpression: 代表一个EL表达式,它在内部通过抽象语法树(AST)来表示表达式。EL表达式的求值是通过调用this.ast.getValue(expressionState);来实现的。
  2. ExpressionParser: 表达式解析器接口,定义了解析EL表达式的方法。Spring提供了SpelExpressionParser作为默认的表达式解析器实现。
  3. StandardEvaluationContext: 标准的评估上下文,用于在表达式求值期间存储变量和函数。它提供了用于设置变量和函数的方法,这些变量和函数可以在EL表达式中使用。
  4. EvaluationContext: 评估上下文接口,用于在表达式求值期间提供变量和函数的访问。StandardEvaluationContextEvaluationContext接口的实现之一。
  5. SpelNode: SpEL语法树的节点,代表了EL表达式的各个部分。每个节点都有自己的类型和操作,用于实现EL表达式的解析和求值。
2.2.1.1.案例代码
@Test
@DisplayName("测试@Value")
public void test2(){// 1. 构建解析器ExpressionParser parser = new SpelExpressionParser();// 2. 解析表达式Expression expression = parser.parseExpression("100 * 2 + 200 * 1 + 100000");// 3. 获取结果int result = (Integer) expression.getValue();// 4. 打印结果logger.error("result:{}",result);
}

在这里插入图片描述

语法树

抽象语法树(Abstract Syntax Tree,AST)是一种用于表示编程语言代码结构的树形数据结构

在编译器和解释器中,AST是一种常见的数据结构,用于表示程序代码的语法结构和语义信息

在Java中,AST抽象语法树是指代表Java源代码结构的树形数据结构。它由多个节点组成,每个节点代表源代码中的一个语法元素,例如表达式、语句、方法调用等。AST的根节点表示整个程序的起始点,而子节点则代表程序中的具体语法结构。

# 语法树        +/   \*     +/  \   /  \100  2  *  100000/ \200  1
2.2.1.2.SpelExpression

SpelExpression 是 Spring 表达式语言(SpEL)中的一个组成部分,用于表达特定的表达式。它内部采用抽象语法树(AST)来表示表达式的结构。计算表达式的值是通过调用 this.ast.getValue(expressionState); 实现的。在这个过程中,AST被用来解释和执行表达式,最终得到表达式的计算结果。

public class SpelExpression implements Expression {@Nullablepublic Object getValue() throws EvaluationException {CompiledExpression compiledAst = this.compiledAst;if (compiledAst != null) {try {EvaluationContext context = this.getEvaluationContext();return compiledAst.getValue(context.getRootObject().getValue(), context);} catch (Throwable var4) {if (this.configuration.getCompilerMode() != SpelCompilerMode.MIXED) {throw new SpelEvaluationException(var4, SpelMessage.EXCEPTION_RUNNING_COMPILED_EXPRESSION, new Object[0]);}}this.compiledAst = null;this.interpretedCount.set(0);}ExpressionState expressionState = new ExpressionState(this.getEvaluationContext(), this.configuration);Object result = this.ast.getValue(expressionState);this.checkCompile(expressionState);return result;}
}
2.2.1.2.SpelNodeImpl

SpelNodeImpl 是 Spring 表达式语言(SpEL)中的关键类,用于表示已解析的表达式在抽象语法树(AST)中的节点。

在解释器模式中,AST 的节点充当了终结符和非终结符的角色,帮助构建表达式的结构。

SpelNodeImpl 的子类包括以下几种类型:

  • Literal: 代表各种类型值的父类。
  • Operator: 代表各种操作符的父类。
  • Indexer 等:代表其他类型的节点。
public abstract class SpelNodeImpl implements SpelNode, Opcodes {private static final SpelNodeImpl[] NO_CHILDREN = new SpelNodeImpl[0];protected SpelNodeImpl[] children;@Nullableprivate SpelNodeImpl parent;@Nullableprotected final <T> T getValue(ExpressionState state, Class<T> desiredReturnType) throws EvaluationException {return ExpressionUtils.convertTypedValue(state.getEvaluationContext(), this.getValueInternal(state), desiredReturnType);}// 抽象方法子类实现,获取对象值public abstract TypedValue getValueInternal(ExpressionState expressionState) throws EvaluationException;}
2.2.1.3.IntLiteral

IntLiteral 表示整型文字的表达式语言的ast结点

public class IntLiteral extends Literal {private final TypedValue value;public IntLiteral(String payload, int startPos, int endPos, int value) {super(payload, startPos, endPos);this.value = new TypedValue(value);this.exitTypeDescriptor = "I";}public TypedValue getLiteralValue() {return this.value;}// 
}
2.2.1.4.OpPlus

OpPlus 表示加法的ast结点,在 getValueInternal 方法中对操作符两边进行相加操作

public class OpPlus extends Operator {private static final int MAX_CONCATENATED_STRING_LENGTH = 100000;public OpPlus(int startPos, int endPos, SpelNodeImpl... operands) {super("+", startPos, endPos, operands);Assert.notEmpty(operands, "Operands must not be empty");}public TypedValue getValueInternal(ExpressionState state) throws EvaluationException {SpelNodeImpl leftOp = this.getLeftOperand();if (this.children.length < 2) {Object operandOne = leftOp.getValueInternal(state).getValue();if (operandOne instanceof Number) {if (operandOne instanceof Double) {this.exitTypeDescriptor = "D";} else if (operandOne instanceof Float) {this.exitTypeDescriptor = "F";} else if (operandOne instanceof Long) {this.exitTypeDescriptor = "J";} else if (operandOne instanceof Integer) {this.exitTypeDescriptor = "I";}return new TypedValue(operandOne);} else {return state.operate(Operation.ADD, operandOne, (Object)null);}} else {// 递归调用leftOp的 getValueInternal(state) ,获取操作符左边的值TypedValue operandOneValue = leftOp.getValueInternal(state);Object leftOperand = operandOneValue.getValue();// 递归调用children[1]的 getValueInternal(state) ,获取操作符右边的值TypedValue operandTwoValue = this.getRightOperand().getValueInternal(state);Object rightOperand = operandTwoValue.getValue();// 如果操作符左右都是数值类型,则将它们相加if (leftOperand instanceof Number && rightOperand instanceof Number) {Number leftNumber = (Number)leftOperand;Number rightNumber = (Number)rightOperand;if (!(leftNumber instanceof BigDecimal) && !(rightNumber instanceof BigDecimal)) {if (!(leftNumber instanceof Double) && !(rightNumber instanceof Double)) {if (!(leftNumber instanceof Float) && !(rightNumber instanceof Float)) {if (!(leftNumber instanceof BigInteger) && !(rightNumber instanceof BigInteger)) {if (!(leftNumber instanceof Long) && !(rightNumber instanceof Long)) {if (!CodeFlow.isIntegerForNumericOp(leftNumber) && !CodeFlow.isIntegerForNumericOp(rightNumber)) {return new TypedValue(leftNumber.doubleValue() + rightNumber.doubleValue());} else {this.exitTypeDescriptor = "I";return new TypedValue(leftNumber.intValue() + rightNumber.intValue());}} else {this.exitTypeDescriptor = "J";return new TypedValue(leftNumber.longValue() + rightNumber.longValue());}} else {BigInteger leftBigInteger = (BigInteger)NumberUtils.convertNumberToTargetClass(leftNumber, BigInteger.class);BigInteger rightBigInteger = (BigInteger)NumberUtils.convertNumberToTargetClass(rightNumber, BigInteger.class);return new TypedValue(leftBigInteger.add(rightBigInteger));}} else {this.exitTypeDescriptor = "F";return new TypedValue(leftNumber.floatValue() + rightNumber.floatValue());}} else {this.exitTypeDescriptor = "D";return new TypedValue(leftNumber.doubleValue() + rightNumber.doubleValue());}} else {BigDecimal leftBigDecimal = (BigDecimal)NumberUtils.convertNumberToTargetClass(leftNumber, BigDecimal.class);BigDecimal rightBigDecimal = (BigDecimal)NumberUtils.convertNumberToTargetClass(rightNumber, BigDecimal.class);return new TypedValue(leftBigDecimal.add(rightBigDecimal));}} else {String rightString;String leftString;if (leftOperand instanceof String && rightOperand instanceof String) {this.exitTypeDescriptor = "Ljava/lang/String";rightString = (String)leftOperand;leftString = (String)rightOperand;this.checkStringLength(rightString);this.checkStringLength(leftString);return this.concatenate(rightString, leftString);} else if (leftOperand instanceof String) {rightString = (String)leftOperand;this.checkStringLength(rightString);leftString = rightOperand == null ? "null" : convertTypedValueToString(operandTwoValue, state);this.checkStringLength(leftString);return this.concatenate(rightString, leftString);} else if (rightOperand instanceof String) {rightString = (String)rightOperand;this.checkStringLength(rightString);leftString = leftOperand == null ? "null" : convertTypedValueToString(operandOneValue, state);this.checkStringLength(leftString);return this.concatenate(leftString, rightString);} else {return state.operate(Operation.ADD, leftOperand, rightOperand);}}}}
}

解释器模式相对于其他设计模式确实在实际应用中使用较少,这主要是由于以下几个原因:

  1. 复杂性和性能开销: 解释器模式的实现可能会引入较高的复杂性和性能开销。解释器需要对输入进行解析、分析和执行,这可能导致性能上的损失,并且随着解释器规则的增多,代码的复杂度也会增加。
  2. 不易理解和维护: 解释器模式的实现通常较为复杂,需要设计者对语法和语义有深入的理解,同时需要维护大量的解释器规则。这使得解释器模式在代码的可读性和可维护性方面存在挑战。
  3. 有限的适用场景: 解释器模式通常适用于特定领域的问题,例如编译器、正则表达式引擎等。在许多常见的软件开发场景中,并不经常需要使用解释器模式来解决问题。
  4. 其他替代方案: 对于一些需要解释和执行逻辑的问题,通常有更简单、更高效的替代方案,例如使用编译器、脚本引擎、规则引擎等。这些替代方案能够更直接地执行逻辑,而不需要通过解释器的中间层。

尽管解释器模式在一些特定的领域和场景下仍然有其价值,但在许多常见的软件开发任务中,它并不是第一选择。因此,虽然解释器模式是一种重要的设计模式,但其应用相对较少。

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

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

相关文章

C++面试宝典第28题:寻找丢失的数字

题目 给定一个包含n个整数的数组nums,其中nums[i]在区间[1, n]内。请找出所有在[1, n]范围内,但没有出现在nums中的数字,并以数组的形式返回结果。 示例1: 输入:nums = [4, 3, 2, 7, 8, 2, 3, 1] 输出:[5, 6] 示例2: 输入:nums = [1, 1] 输出:[2] 解析 初看这道题,…

【lesson57】信号量和生产者消费者模型(环形队列版)

文章目录 信号量概念信号量接口初始化销毁等待发布 基于环形队列的生产者消费者模型编码Common.hLockGuard.hppTask.hppsem.hppRingQueue.hppConProd.cc 信号量概念 POSIX信号量和SystemV信号量作用相同&#xff0c;都是用于同步操作&#xff0c;达到无冲突的访问共享资源目的…

【测试】JUnit

目 录 一.注解二.断言三.用例的执行顺序四.参数化五.测试套件 自动化就是 selenium 脚本来实现的 junit 是 java 的单亓测试工具&#xff0c;只不过我们在实现自动化的时候需要借用一下下 junit 库里面提供的一些方法 引入依赖 Junit 5 <!-- https://mvnrepository.com/a…

自然语言编程系列(二):自然语言处理(NLP)、编程语言处理(PPL)和GitHub Copilot X

编程语言处理的核心是计算机如何理解和执行预定义的人工语言&#xff08;编程语言&#xff09;&#xff0c;而自然语言处理则是研究如何使计算机理解并生成非正式、多样化的自然语言。GPT-4.0作为自然语言处理技术的最新迭代&#xff0c;其编程语言处理能力相较于前代模型有了显…

电子元器件基础5---二极管

除了电阻、电容和电感等线性元器件之外,还有二极管、三极管这些常用的非线性器件广泛应用于日常生活中。那么今天我们来介绍以下二极管这一常用的电子元器件。 一、二极管概念 二极管是用半导体材料(硅、硒、锗等)制成的一种电子器件 。二极管有两个电极,正极,又叫阳极;负…

django报错:Cannot use ImageField because Pillow is not installed

1、问题概述 ERRORS: accounts.User.avatar: (fields.E210) Cannot use ImageField because Pillow is not installed. HINT: Get Pillow at https://pypi.org/project/Pillow/ or run command "python -m pip install Pillow". System check identified 1 …

JDK1.8安装教程

目录 下载安装环境配置打开系统高级设置环境配置 验证安装是否成功 下载 https://www.oracle.com/java/technologies/downloads/#java8-windows 安装 打开安装包&#xff0c;点击下一步。 选择好自己熟悉的目的安装目录&#xff0c;点击下一步。 等待安装 选择好jre的安装目…

ubuntu22.04@laptop OpenCV Get Started: 013_contour_detection

ubuntu22.04laptop OpenCV Get Started: 013_contour_detection 1. 源由2. 应用Demo2.1 C应用Demo2.2 Python应用Demo 3. contour_approx应用3.1 读取图像并将其转换为灰度格式3.2 应用二进制阈值过滤算法3.3 查找对象轮廓3.4 绘制对象轮廓3.5 效果3.6 CHAIN_APPROX_SIMPLE v.s…

java中的枚举

枚举 枚举类型的概述 关键字&#xff1a;enum 你可以把枚举类型理解成是一个自定义的常量的序列 枚举的语法结构 定义的枚举类型文件 package com.it.xiaosi.demo01;/*** Classname : direction* Description : TODO 枚举* Author : lin_refuelqq.com*/ public enum direct…

springboot第56集:微服务框架,物联网IOT,SQL数据库MySQL底层,AOP收集业务操作日志架构周刊...

单点登录 1.配置代理信息 /*请求登陆的方法*/ "/modelLogin": {//本地服务接口地址&#xff0c;这是测试环境&#xff0c;正式环境需要更改下地址target: "http://127.0.0.1:6776/xxx-auth/",changeOrigin: true,pathRewrite: {"^/modelLogin": …

在ubuntu中制作ubuntu的U盘启动盘

概要&#xff1a; 本篇演示在ubuntu22.04中制作ubuntu22.04的U盘启动盘 一、下载ubuntu22.04的iso文件 访问ubuntu官网https://ubuntu.com自行下载ubuntu官网 二、制作U盘启动盘 打开系统自带软件Startup Disk Creator 软件会自动检测iso文件和U盘 点击Make Startup Disk…

【Java EE初阶十二】网络原理(二)

2. 传输层 2.2 TCP协议 2.2.2 关于可靠传输 4.滑动窗口 前面的三个机制&#xff0c;都是在保证 tcp 的可靠性&#xff1b; TCP 的可靠传输,是会影响传输的效率的.(多出了一些等待 ack 的时间,单位时间内能传输的数据就少了)&#xff1b; 滑动窗口,就让可靠传输对性能的影响,更…

MySQL数据库⑪_C/C++连接MySQL_发送请求

目录 1. 下载库文件 2. 使用库 3. 链接MySQL函数 4. C/C链接示例 5. 发送SQL请求 6. 获取查询结果 本篇完。 1. 下载库文件 要使用C/C连接MySQL&#xff0c;需要使用MySQL官网提供的库。 进入MySQL官网选择适合自己平台的mysql connect库&#xff0c;然后点击下载就行…

Day-02-02

Httpclient测试 安装HTTP Client插件 使用IDEA自带的http接口测试工具——HTTP Client Open in HTTP Client 生成测试用例 点击绿色箭头可以运行测试用例&#xff0c;控制台会输出结果。 保存和修改测试用例 在模块下新建一个api-test包用来存放测试用例&#xff0c;将生…

Packet content transfer stopped (received 8 bytes)

esp32烧录程序时报错&#xff1a;A fatal error occurred: Packet content transfer stopped (received 8 bytes) 解决方法&#xff1a; 降低上传速度&#xff0c;使用115200&#xff1b;更换flash模式&#xff0c;使用DIO方式重试如果还不行&#xff0c;检查flash连接情况&am…

failing dimm dimm location (uncorrectable memory component found)

开机界面出现这个 failing dimm dimm location (uncorrectable memory component found)“DIMM DIMM location. Uncorrectable memory component found” 是一条硬件故障信息&#xff0c;表明在服务器的某个特定双列直插式内存模块&#xff08;Dual In-line Memory Module, DI…

【漏洞复现】蓝网科技临床浏览系统信息泄露漏洞

Nx01 产品简介 蓝网科技临床浏览系统是一个专门用于医疗行业的软件系统&#xff0c;主要用于医生、护士和其他医疗专业人员在临床工作中进行信息浏览、查询和管理。 Nx02 漏洞描述 蓝网科技临床浏览系统存在信息泄露漏洞&#xff0c;攻击者可以利用该漏洞获取敏感信息。 Nx03…

深度学习基础之《TensorFlow框架(4)—Operation》

一、常见的OP 1、举例 类型实例标量运算add&#xff0c;sub&#xff0c;mul&#xff0c;div&#xff0c;exp&#xff0c;log&#xff0c;greater&#xff0c;less&#xff0c;equal向量运算concat&#xff0c;slice&#xff0c;splot&#xff0c;canstant&#xff0c;rank&am…

力扣72. 编辑距离(动态规划)

Problem: 72. 编辑距离 文章目录 题目描述思路复杂度Code 题目描述 思路 由于易得将字符串word1向word2转换和word2向word1转换是等效的&#xff0c;则我们假定统一为word1向word2转换&#xff01;&#xff01;&#xff01; 1.确定状态&#xff1a;我们假设现在有下标i&#x…

Python算法题集_随机链表的复制

Python算法题集_随机链表的复制 题138&#xff1a;随机链表的复制1. 示例说明2. 题目解析- 题意分解- 优化思路- 测量工具 3. 代码展开1) 标准求解【双层循环】2) 改进版一【字典哈希】3) 改进版二【单层哈希】4) 改进版三【递归大法】 4. 最优算法 本文为Python算法题集之一的…