设计模式(22)——解释器模式

解释器模式

 

一、定义：

给定一种语言，定义他的文法的一种表示，并定义一个解释器，该解释器使用该表示来解释语言中句子。

二、结构

2.1、类图

2.2、角色组成

·抽象解释器：声明一个所有具体表达式都要实现的抽象接口（或者抽象类），接口中主要是一个interpret()方法，称为解释操作。具体解释任务由它的各个实现类来完成，具体的解释器分别由终结符解释器TerminalExpression和非终结符解释器NonterminalExpression完成。

·终结符表达式：实现与文法中的元素相关联的解释操作，通常一个解释器模式中只有一个终结符表达式，但有多个实例，对应不同的终结符。终结符一半是文法中的运算单元，比如有一个简单的公式R=R1+R2，在里面R1和R2就是终结符，对应的解析R1和R2的解释器就是终结符表达式。                                

·非终结符表达式：文法中的每条规则对应于一个非终结符表达式，非终结符表达式一般是文法中的运算符或者其他关键字，比如公式R=R1+R2中，+就是非终结符，解析+的解释器就是一个非终结符表达式。非终结符表达式根据逻辑的复杂程度而增加，原则上每个文法规则都对应一个非终结符表达式。

·环境角色：这个角色的任务一般是用来存放文法中各个终结符所对应的具体值，比如R=R1+R2，我们给R1赋值100，给R2赋值200。这些信息需要存放到环境角色中，很多情况下我们使用Map来充当环境角色就足够了。

三、例子

计算(a*b)/(a-b+2)

抽象解释器

[java]  view plain copy print ?

1. public abstract class AbstractExpression  
2. {  
3.     public abstract int interpreter(Context context);  
4. }  

终结符表达式

[java]  view plain copy print ?

1. public class TerminalExpression extends AbstractExpression  
2. {  
3.     private final int i;  
4.   
5.     public TerminalExpression(final int i)  
6.     {  
7.         this.i = i;  
8.     }  
9.   
10.     @Override  
11.     public int interpreter(final Context context)  
12.     {  
13.         return this.i;  
14.     }  
15.   
16. }  

环境角色

[java]  view plain copy print ?

1. import java.util.HashMap;  
2. import java.util.Map;  
3.   
4. public class Context {  
5.     private final Map<String, Integer> valueMap = new HashMap<String, Integer>();  
6.   
7.     public void addValue(final String key, final int value) {  
8.         valueMap.put(key, Integer.valueOf(value));  
9.     }  
10.   
11.     public int getValue(final String key) {  
12.         return valueMap.get(key).intValue();  
13.     }  
14. }  

非终结符表达式  加

[java]  view plain copy print ?

1. public class AddNonterminalExpression extends AbstractExpression  
2. {  
3.     private final AbstractExpression left;  
4.     private final AbstractExpression right;  
5.   
6.     public AddNonterminalExpression(final AbstractExpression left, final AbstractExpression right)  
7.     {  
8.         this.left = left;  
9.         this.right = right;  
10.     }  
11.   
12.     @Override  
13.     public int interpreter(final Context context)  
14.     {  
15.         return this.left.interpreter(context) + this.right.interpreter(context);  
16.     }  
17.   
18. }  

非终结符表达式  减

[java]  view plain copy print ?

1. public class SubtractNonterminalExpression extends AbstractExpression  
2. {  
3.     private final AbstractExpression left;  
4.     private final AbstractExpression right;  
5.   
6.     public SubtractNonterminalExpression(final AbstractExpression left, final AbstractExpression right)  
7.     {  
8.         this.left = left;  
9.         this.right = right;  
10.     }  
11.   
12.     @Override  
13.     public int interpreter(final Context context)  
14.     {  
15.         return this.left.interpreter(context) - this.right.interpreter(context);  
16.     }  
17. }  

非终结符表达式  乘

[java]  view plain copy print ?

1. public class MultiplyNonterminalExpression extends AbstractExpression  
2. {  
3.     private final AbstractExpression left;  
4.     private final AbstractExpression right;  
5.   
6.     public MultiplyNonterminalExpression(final AbstractExpression left, final AbstractExpression right)  
7.     {  
8.         this.left = left;  
9.         this.right = right;  
10.     }  
11.   
12.     @Override  
13.     public int interpreter(final Context context)  
14.     {  
15.         return this.left.interpreter(context) * this.right.interpreter(context);  
16.     }  
17.   
18. }  

非终结符表达式  除

[java]  view plain copy print ?

1. public class DivisionNonterminalExpression extends AbstractExpression  
2. {  
3.     private final AbstractExpression left;  
4.     private final AbstractExpression right;  
5.   
6.     public DivisionNonterminalExpression(final AbstractExpression left, final AbstractExpression right)  
7.     {  
8.         this.left = left;  
9.         this.right = right;  
10.     }  
11.   
12.     @Override  
13.     public int interpreter(final Context context)  
14.     {  
15.         final int value = this.right.interpreter(context);  
16.         if (value != 0)  
17.         {  
18.             return this.left.interpreter(context) / value;  
19.         }  
20.         return -1111;  
21.     }  
22.   
23. }  

Client

[java]  view plain copy print ?

1. public class Client {  
2.     //(a*b)/(a-b+2)  
3.     public static void main(final String[] args) {  
4.         final Context context = new Context();  
5.         context.addValue("a", 7);  
6.         context.addValue("b", 8);  
7.         context.addValue("c", 2);  
8.   
9.         final MultiplyNonterminalExpression multiplyValue = new MultiplyNonterminalExpression(  
10.                 new TerminalExpression(context.getValue("a")),  
11.                 new TerminalExpression(context.getValue("b")));  
12.   
13.         final SubtractNonterminalExpression subtractValue = new SubtractNonterminalExpression(  
14.                 new TerminalExpression(context.getValue("a")),  
15.                 new TerminalExpression(context.getValue("b")));  
16.   
17.         final AddNonterminalExpression addValue = new AddNonterminalExpression(  
18.                 subtractValue, new TerminalExpression(context.getValue("c")));  
19.   
20.         final DivisionNonterminalExpression divisionValue = new DivisionNonterminalExpression(  
21.                 multiplyValue, addValue);  
22.   
23.         System.out.println(divisionValue.interpreter(context));  
24.     }  
25. }  

结果56 

四、解释器模式的优缺点

4.1、优点：

解释器是一个简单语法分析工具，它最显著的优点就是扩展性，修改语法规则只要修改相应的非终结符表达式就可以了，若扩展语法，则只要增加非终结符类就可以了。

4.2、缺点：

• 解释器模式会引起类膨胀，每个语法都要产生一个非终结符表达式，语法规则比较复杂时，可能产生大量的类文件，难以维护。
• 解释器模式采用递归调用方法，它导致调试非常复杂。
• 解释器由于使用了大量的循环和递归，所以当用于解析复杂、冗长的语法时，效率是难以忍受的 

五、适用场景

        在以下情况下可以使用解释器模式：

·有一个简单的语法规则，比如一个sql语句，如果我们需要根据sql语句进行rm转换，就可以使用解释器模式来对语句进行解释。

·一些重复发生的问题，比如加减乘除四则运算，但是公式每次都不同，有时是a+b-c*d，有时是a*b+c-d，等等等等个，公式千变万化，但是都是由加减乘除四个非终结符来连接的，这时我们就可以使用解释器模式。

 

       解释器模式真的是一个比较少用的模式，因为对它的维护实在是太麻烦了，想象一下，一坨一坨的非终结符解释器，假如不是事先对文法的规则了如指掌，或者是文法特别简单，则很难读懂它的逻辑。解释器模式在实际的系统开发中使用的很少，因为他会引起效率、性能以及维护等问题。在项目中，可以使用shell,JRuby,Groovy等脚本语言来代替解释器模式。