设计模式：行为型-解释器模式

￡神魔★判官ぃ 2022-11-18 01:44 146阅读 0赞

### 目录 ###

*  第一章 解释器模式介绍
 *  第二章 解释器模式实现
 *   *  2.1、抽象表达式
     *  2.2、终结符表达式
     *  2.3、非终结符表达式
     *  2.4、环境类
     *  2.5、测试类
 *  第三章 解释器模式应用

--------------------

> 项目地址：https://gitee.com/caochenlei/design-pattern

# 第一章 解释器模式介绍 #

解释器模式的介绍：

在软件开发中，会遇到有些问题多次重复出现，而且有一定的相似性和规律性。如果将它们归纳成一种简单的语言，那么这些问题实例将是该语言的一些句子，这样就可以用“编译原理”中的解释器模式来实现了。

在“编译原理”中，一个算术表达式通过词法分析器形成词法单元，而后这些词法单元再通过语法分析器构建语法分析树，最终形成一颗抽象的语法分析树，这里的词法分析器和语法分析器都可以看做是解释器。

解释器模式（Interpreter Pattern）提供了评估语言的语法或表达式的方式，它属于行为型模式。这种模式实现了一个表达式接口，该接口解释一个特定的上下文。这种模式被用在 SQL 解析、符号处理引擎等。

解释器模式常用于对简单语言的编译或分析实例中，为了掌握好它的结构与实现，必须先了解编译原理中的“文法、句子、语法树”等相关概念。

**文法**

文法是用于描述语言的语法结构的形式规则。没有规矩不成方圆，语言也一样，不管它是机器语言还是自然语言，都有它自己的文法规则。例如，中文中的“句子”的文法如下。这里的符号“::=”表示“定义为”的意思，用“〈”和“〉”括住的是非终结符，没有括住的是终结符。

〈句子〉::=〈主语〉〈谓语〉〈宾语〉
    〈主语〉::=〈代词〉|〈名词〉
    〈谓语〉::=〈动词〉
    〈宾语〉::=〈代词〉|〈名词〉
    〈代词〉::=你|我|他
    〈名词〉::=大学生|高中生|初中生
    〈动词〉::=是|学习|工作

**句子**

句子是语言的基本单位，是语言集中的一个元素，它由终结符构成，能由“文法”推导出。例如，上述文法可以推出“我是大学生”，所以它是句子。

**语法树**

语法树是句子结构的一种树型表示，它代表了句子的推导结果，它有利于理解句子语法结构的层次。下图是“我是大学生”的语法树。

![aee09fd9c15939dbdd101eb3fa914ae5.gif][]

有了以上基础知识，现在来介绍解释器模式的结构就简单了。解释器模式的结构与组合模式相似，不过其包含的组成元素比组合模式多，而且组合模式是对象结构型模式，而解释器模式是类行为型模式。

解释器模式的优点：

*  扩展性好。由于在解释器模式中使用类来表示语言的文法规则，因此可以通过继承等机制来改变或扩展文法。
 *  容易实现。在语法树中的每个表达式节点类都是相似的，所以实现其文法较为容易。

解释器模式的缺点：

*  执行效率较低。解释器模式中通常使用大量的循环和递归调用，当要解释的句子较复杂时，其运行速度很慢，且代码的调试过程也比较麻烦。
 *  会引起类膨胀。解释器模式中的每条规则至少需要定义一个类，当包含的文法规则很多时，类的个数将急剧增加，导致系统难以管理与维护。
 *  可应用的场景比较少。在软件开发中，需要定义语言文法的应用实例非常少，所以这种模式很少被使用到。

解释器模式的场景：

*  当语言的文法较为简单，且执行效率不是关键问题时。
 *  当问题重复出现，且可以用一种简单的语言来进行表达时。
 *  当一个语言需要解释执行，并且语言中的句子可以表示为一个抽象语法树的时候，如 XML 文档解释。

解释器模式的角色：

*  抽象表达式（Abstract Expression）角色：定义解释器的接口，约定解释器的解释操作，主要包含解释方法 interpret()。
 *  终结符表达式（Terminal Expression）角色：是抽象表达式的子类，用来实现文法中与终结符相关的操作，文法中的每一个终结符都有一个具体终结表达式与之相对应。
 *  非终结符表达式（Nonterminal Expression）角色：也是抽象表达式的子类，用来实现文法中与非终结符相关的操作，文法中的每条规则都对应于一个非终结符表达式。
 *  环境（Context）角色：通常包含各个解释器需要的数据或是公共的功能，一般用来传递被所有解释器共享的数据，后面的解释器可以从这里获取这些值。
 *  客户端（Client）：主要任务是将需要分析的句子或表达式转换成使用解释器对象描述的抽象语法树，然后调用解释器的解释方法，当然也可以通过环境角色间接访问解释器的解释方法。

![3caed7d87eb378e57fe43b7daa54c48e.gif][]

# 第二章 解释器模式实现 #

## 2.1、抽象表达式 ##

Expression

public abstract class Expression { 
        public abstract int interpreter(HashMap<String, Integer> var);
    }

## 2.2、终结符表达式 ##

VarExpression

public class VarExpression extends Expression { 
        private String key;
    
        public VarExpression(String key) { 
            this.key = key;
        }
    
        @Override
        public int interpreter(HashMap<String, Integer> var) { 
            return var.get(this.key);
        }
    }

## 2.3、非终结符表达式 ##

SymbolExpression

public class SymbolExpression extends Expression { 
        protected Expression left;
        protected Expression right;
    
        public SymbolExpression(Expression left, Expression right) { 
            this.left = left;
            this.right = right;
        }
    
        @Override
        public int interpreter(HashMap<String, Integer> var) { 
            return 0;
        }
    }

## 2.4、环境类 ##

Calculator

public class Calculator { 
        private Expression expression;
        private Expression left;
        private Expression right;
    
        public Calculator(String expStr) { 
            Stack<Expression> stack = new Stack<>();
            char[] charArray = expStr.toCharArray();
            for (int i = 0; i < charArray.length; i++) { 
                switch (charArray[i]) { 
                    case '+':
                        left = stack.pop();
                        right = new VarExpression(String.valueOf(charArray[++i]));
                        stack.push(new AddExpression(left, right));
                        break;
                    case '-':
                        left = stack.pop();
                        right = new VarExpression(String.valueOf(charArray[++i]));
                        stack.push(new SubExpression(left, right));
                        break;
                    default:
                        stack.push(new VarExpression(String.valueOf(charArray[i])));
                        break;
                }
            }
            this.expression = stack.pop();
        }
    
        public int run(HashMap<String, Integer> var) { 
            return this.expression.interpreter(var);
        }
    }

## 2.5、测试类 ##

Client

public class Client { 
        public static void main(String[] args) throws IOException { 
            String expStr = getExpStr();
            HashMap<String, Integer> expVal = getValue(expStr);
            System.out.println("最终运算结果：" + expStr + "=" + new Calculator(expStr).run(expVal));
        }
    
        public static String getExpStr() throws IOException { 
            System.out.print("请输入表达式：");
            return (new BufferedReader(new InputStreamReader(System.in))).readLine();
        }
    
        public static HashMap<String, Integer> getValue(String expStr) throws IOException { 
            HashMap<String, Integer> map = new HashMap<>();
            for (char ch : expStr.toCharArray()) { 
                if (ch != '+' && ch != '-') { 
                    if (!map.containsKey(String.valueOf(ch))) { 
                        System.out.print("请输入" + String.valueOf(ch) + "的值：");
                        String value = (new BufferedReader(new InputStreamReader(System.in))).readLine();
                        map.put(String.valueOf(ch), Integer.valueOf(value));
                    }
                }
            }
            return map;
        }
    }

请输入表达式：a+b+c-d
    请输入a的值：5
    请输入b的值：4
    请输入c的值：3
    请输入d的值：2
    最终运算结果：a+b+c-d=10

# 第三章 解释器模式应用 #

由于 JDK、Spring、Mybatis 中很少有备忘录模式，所以该设计模式不做典型应用源码分析。

[aee09fd9c15939dbdd101eb3fa914ae5.gif]: /images/20221022/7aff2ab5129043d1919649d009658f71.png
[3caed7d87eb378e57fe43b7daa54c48e.gif]: /images/20221022/acaacfc31c9544458149b4e619664def.png