设计模式-解释器模式

概述

解释器模式是一种使用频率相对较低但学习难度较大的设计模式，它用于描述如何使用面向对象语言构成一个简单的语言解释器。在某些情况下，为了更好地描述某一些特定类型的问题，我们可以创建一种新的语言，这种语言拥有自己的表达式和结构，即文法规则，这些问题的实例将对应为该语言中的句子。此时，可以使用解释器模式来设计这种新的语言。对解释器模式的学习能够加深我们对面向对象思想的理解，并且掌握编程语言中文法规则的解释过程。

定义

解释器模式(Interpreter Pattern)：定义一个语言的文法，并且建立一个解释器来解释该语言中的句子，这里的“语言”是指使用规定格式和语法的代码。解释器模式是一种类行为型模式。

解释器结构图

由于表达式可分为终结符表达式和非终结符表达式，因此解释器模式的结构与组合模式的结构有些类似，但在解释器模式中包含更多的组成元素，它的结构如图18-3所示：

在解释器模式结构图中包含如下几个角色：
● AbstractExpression（抽象表达式）：在抽象表达式中声明了抽象的解释操作，它是所有终结符表达式和非终结符表达式的公共父类。
● TerminalExpression（终结符表达式）：终结符表达式是抽象表达式的子类，它实现了与文法中的终结符相关联的解释操作，在句子中的每一个终结符都是该类的一个实例。通常在一个解释器模式中只有少数几个终结符表达式类，它们的实例可以通过非终结符表达式组成较为复杂的句子。
● NonterminalExpression（非终结符表达式）：非终结符表达式也是抽象表达式的子类，它实现了文法中非终结符的解释操作，由于在非终结符表达式中可以包含终结符表达式，也可以继续包含非终结符表达式，因此其解释操作一般通过递归的方式来完成。
● Context（环境类）：环境类又称为上下文类，它用于存储解释器之外的一些全局信息，通常它临时存储了需要解释的语句。
在解释器模式中，每一种终结符和非终结符都有一个具体类与之对应，正因为使用类来表示每一条文法规则，所以系统将具有较好的灵活性和可扩展性。对于所有的终结符和非终结符，我们首先需要抽象出一个公共父类，即抽象表达式类，其典型代码如下所示：

abstract class AbstractExpression {
public  abstract void interpret(Context ctx);
}

终结符表达式和非终结符表达式类都是抽象表达式类的子类，对于终结符表达式，其代码很简单，主要是对终结符元素的处理，其典型代码如下所示：

class TerminalExpression extends AbstractExpression {
public  void interpret(Context ctx) {
//终结符表达式的解释操作
       }
}

对于非终结符表达式，其代码相对比较复杂，因为可以通过非终结符将表达式组合成更加复杂的结构，对于包含两个操作元素的非终结符表达式类，其典型代码如下：

class NonterminalExpression extends AbstractExpression {
private  AbstractExpression left;
private  AbstractExpression right;

public  NonterminalExpression(AbstractExpression left,AbstractExpression right) {
this.left=left;
this.right=right;
       }

public void interpret(Context ctx) {
//递归调用每一个组成部分的interpret()方法
//在递归调用时指定组成部分的连接方式，即非终结符的功能
       }     
}

除了上述用于表示表达式的类以外，通常在解释器模式中还提供了一个环境类Context，用于存储一些全局信息，通常在Context中包含了一个HashMap或ArrayList等类型的集合对象（也可以直接由HashMap等集合类充当环境类），存储一系列公共信息，如变量名与值的映射关系（key/value）等，用于在进行具体的解释操作时从中获取相关信息。其典型代码片段如下：

class Context {
private HashMap map = new HashMap();
public void assign(String key, String value) {
//往环境类中设值
     }
public String  lookup(String key) {
//获取存储在环境类中的值
     }
}

当系统无须提供全局公共信息时可以省略环境类，可根据实际情况决定是否需要环境类。

Context的作用

在解释器模式中，环境类Context用于存储解释器之外的一些全局信息，它通常作为参数被传递到所有表达式的解释方法interpret()中，可以在Context对象中存储和访问表达式解释器的状态，向表达式解释器提供一些全局的、公共的数据，此外还可以在Context中增加一些所有表达式解释器都共有的功能，减轻解释器的职责。

下面再过一个简单实例来说明环境类的用途：
软件公司开发了一套简单的基于字符界面的格式化指令，可以根据输入的指令在字符界面中输出一些格式化内容，例如输入“LOOP 2 PRINT杨过 SPACE SPACE PRINT 小龙女 BREAK END PRINT郭靖 SPACE SPACE PRINT 黄蓉”，将输出如下结果：
杨过 小龙女
杨过 小龙女
郭靖 黄蓉
其中关键词LOOP表示“循环”，后面的数字表示循环次数；PRINT表示“打印”，后面的字符串表示打印的内容；SPACE表示“空格”；BREAK表示“换行”；END表示“循环结束”。每一个关键词对应一条命令，计算机程序将根据关键词执行相应的处理操作。

现使用解释器模式设计并实现该格式化指令的解释，对指令进行分析并调用相应的操作执行指令中每一条命令。

软件公司开发人员通过分析，根据该格式化指令中句子的组成，定义了如下文法规则：

expression ::= command* //表达式，一个表达式包含多条命令
command ::= loop | primitive //语句命令
loop ::= 'loopnumber' expression  'end' //循环命令，其中number为自然数
primitive ::= 'printstring'  | 'space' | 'break' //基本命令，其中string为字符串

根据以上文法规则，通过进一步分析，绘制如图18-6所示结构图：

在图18-6中，Context充当环境角色，Node充当抽象表达式角色，ExpressionNode、CommandNode和LoopCommandNode充当非终结符表达式角色，PrimitiveCommandNode充当终结符表达式角色。完整代码如下所示：

import java.util.*;  

//环境类：用于存储和操作需要解释的语句，在本实例中每一个需要解释的单词可以称为一个动作标记(Action Token)或命令 
class Context {  
private StringTokenizer tokenizer; //StringTokenizer类，用于将字符串分解为更小的字符串标记(Token)，默认情况下以空格作为分隔符 
private String currentToken; //当前字符串标记 

public Context(String text) {  
        tokenizer = new StringTokenizer(text); //通过传入的指令字符串创建StringTokenizer对象 
        nextToken();  
    }  

//返回下一个标记 
public String nextToken() {  
if (tokenizer.hasMoreTokens()) {  
            currentToken = tokenizer.nextToken();  
        }  
else {  
            currentToken = null;  
        }  
return currentToken;  
    }  

//返回当前的标记 
public String currentToken() {  
return currentToken;  
    }  

//跳过一个标记 
public void skipToken(String token) {  
if (!token.equals(currentToken)) {  
            System.err.println("错误提示：" + currentToken + "解释错误！");  
            }  
        nextToken();  
    }  

//如果当前的标记是一个数字，则返回对应的数值 
public int currentNumber() {  
int number = 0;  
try{  
            number = Integer.parseInt(currentToken); //将字符串转换为整数 
        }  
catch(NumberFormatException e) {  
            System.err.println("错误提示：" + e);  
        }  
return number;  
    }  
}  

//抽象节点类：抽象表达式 
abstract class Node {  
public abstract void interpret(Context text); //声明一个方法用于解释语句 
public abstract void execute(); //声明一个方法用于执行标记对应的命令 
}  

//表达式节点类：非终结符表达式 
class ExpressionNode extends Node {  
private ArrayList<Node> list = new ArrayList<Node>(); //定义一个集合用于存储多条命令 

public void interpret(Context context) {  
//循环处理Context中的标记 
while (true){  
//如果已经没有任何标记，则退出解释 
if (context.currentToken() == null) {  
break;  
            }  
//如果标记为END，则不解释END并结束本次解释过程，可以继续之后的解释 
else if (context.currentToken().equals("END")) {  
                context.skipToken("END");  
break;  
            }  
//如果为其他标记，则解释标记并将其加入命令集合 
else {  
                Node commandNode = new CommandNode();  
                commandNode.interpret(context);  
                list.add(commandNode);  
            }  
        }  
    }  

//循环执行命令集合中的每一条命令 
public void execute() {  
        Iterator iterator = list.iterator();  
while (iterator.hasNext()){  
            ((Node)iterator.next()).execute();  
        }  
    }  
}  

//语句命令节点类：非终结符表达式 
class CommandNode extends Node {  
private Node node;  

public void interpret(Context context) {  
//处理LOOP循环命令 
if (context.currentToken().equals("LOOP")) {  
            node = new LoopCommandNode();  
            node.interpret(context);  
        }  
//处理其他基本命令 
else {  
            node = new PrimitiveCommandNode();  
            node.interpret(context);  
        }  
    }  

public void execute() {  
        node.execute();  
    }  
}  

//循环命令节点类：非终结符表达式 
class LoopCommandNode extends Node {  
private int number; //循环次数 
private Node commandNode; //循环语句中的表达式 

//解释循环命令 
public void interpret(Context context) {  
        context.skipToken("LOOP");  
        number = context.currentNumber();  
        context.nextToken();  
        commandNode = new ExpressionNode(); //循环语句中的表达式 
        commandNode.interpret(context);  
    }  

public void execute() {  
for (int i=0;i<number;i++)  
            commandNode.execute();  
    }  
}  

//基本命令节点类：终结符表达式 
class PrimitiveCommandNode extends Node {  
private String name;  
private String text;  

//解释基本命令 
public void interpret(Context context) {  
        name = context.currentToken();  
        context.skipToken(name);  
if (!name.equals("PRINT") && !name.equals("BREAK") && !name.equals ("SPACE")){  
            System.err.println("非法命令！");  
        }  
if (name.equals("PRINT")){  
            text = context.currentToken();  
            context.nextToken();  
        }  
    }  

public void execute(){  
if (name.equals("PRINT"))  
            System.out.print(text);  
else if (name.equals("SPACE"))  
            System.out.print(" ");  
else if (name.equals("BREAK"))  
            System.out.println();  
    }  
}  

在本实例代码中，环境类Context类似一个工具类，它提供了用于处理指令的方法，如nextToken()、currentToken()、skipToken()等，同时它存储了需要解释的指令并记录了每一次解释的当前标记(Token)，而具体的解释过程交给表达式解释器类来处理。我们还可以将各种解释器类包含的公共方法移至环境类中，更好地实现这些方法的重用和扩展。

针对本实例代码，我们编写如下客户端测试代码：

class Client{  
public static void main(String[] args){  
        String text = "LOOP 2 PRINT 杨过 SPACE SPACE PRINT 小龙女 BREAK END PRINT 郭靖 SPACE SPACE PRINT 黄蓉";  
        Context context = new Context(text);  

        Node node = new ExpressionNode();  
        node.interpret(context);  
        node.execute();  
    }  
}  

编译并运行程序，输出结果如下：
杨过 小龙女
杨过 小龙女
郭靖 黄蓉

解释器模式总结

解释器模式为自定义语言的设计和实现提供了一种解决方案，它用于定义一组文法规则并通过这组文法规则来解释语言中的句子。虽然解释器模式的使用频率不是特别高，但是它在正则表达式、XML文档解释等领域还是得到了广泛使用。与解释器模式类似，目前还诞生了很多基于抽象语法树的源代码处理工具，例如Eclipse中的Eclipse AST，它可以用于表示Java语言的语法结构，用户可以通过扩展其功能，创建自己的文法规则。

解释器模式优点

解释器模式的主要优点如下：
(1) 易于改变和扩展文法。由于在解释器模式中使用类来表示语言的文法规则，因此可以通过继承等机制来改变或扩展文法。
(2) 每一条文法规则都可以表示为一个类，因此可以方便地实现一个简单的语言。
(3) 实现文法较为容易。在抽象语法树中每一个表达式节点类的实现方式都是相似的，这些类的代码编写都不会特别复杂，还可以通过一些工具自动生成节点类代码。
(4) 增加新的解释表达式较为方便。如果用户需要增加新的解释表达式只需要对应增加一个新的终结符表达式或非终结符表达式类，原有表达式类代码无须修改，符合“开闭原则”。

解释器模式的缺点

解释器模式的主要缺点如下：
(1) 对于复杂文法难以维护。在解释器模式中，每一条规则至少需要定义一个类，因此如果一个语言包含太多文法规则，类的个数将会急剧增加，导致系统难以管理和维护，此时可以考虑使用语法分析程序等方式来取代解释器模式。
(2) 执行效率较低。由于在解释器模式中使用了大量的循环和递归调用，因此在解释较为复杂的句子时其速度很慢，而且代码的调试过程也比较麻烦。

适用场景

在以下情况下可以考虑使用解释器模式：
(1) 可以将一个需要解释执行的语言中的句子表示为一个抽象语法树。
(2) 一些重复出现的问题可以用一种简单的语言来进行表达。
(3) 一个语言的文法较为简单。
(4) 执行效率不是关键问题。【注：高效的解释器通常不是通过直接解释抽象语法树来实现的，而是需要将它们转换成其他形式，使用解释器模式的执行效率并不高。】