设计模式(23)>解释器模式 小强斋

解释器模式

 

一、定义：

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

二、结构

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)

抽象解释器

public abstract class AbstractExpression
{
    public abstract int interpreter(Context context);
}

终结符表达式

public class TerminalExpression extends AbstractExpression
{
    private final int i;

    public TerminalExpression(final int i)
    {
        this.i = i;
    }

    @Override
    public int interpreter(final Context context)
    {
        return this.i;
    }

}

环境角色

import java.util.HashMap;
import java.util.Map;

public class Context {
	private final Map<String, Integer> valueMap = new HashMap<String, Integer>();

	public void addValue(final String key, final int value) {
		valueMap.put(key, Integer.valueOf(value));
	}

	public int getValue(final String key) {
		return valueMap.get(key).intValue();
	}
}

非终结符表达式  加

public class AddNonterminalExpression extends AbstractExpression
{
    private final AbstractExpression left;
    private final AbstractExpression right;

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

    @Override
    public int interpreter(final Context context)
    {
        return this.left.interpreter(context) + this.right.interpreter(context);
    }

}

非终结符表达式  减

public class SubtractNonterminalExpression extends AbstractExpression
{
    private final AbstractExpression left;
    private final AbstractExpression right;

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

    @Override
    public int interpreter(final Context context)
    {
        return this.left.interpreter(context) - this.right.interpreter(context);
    }
}

非终结符表达式  乘

public class MultiplyNonterminalExpression extends AbstractExpression
{
    private final AbstractExpression left;
    private final AbstractExpression right;

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

    @Override
    public int interpreter(final Context context)
    {
        return this.left.interpreter(context) * this.right.interpreter(context);
    }

}

非终结符表达式  除

public class DivisionNonterminalExpression extends AbstractExpression
{
    private final AbstractExpression left;
    private final AbstractExpression right;

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

    @Override
    public int interpreter(final Context context)
    {
        final int value = this.right.interpreter(context);
        if (value != 0)
        {
            return this.left.interpreter(context) / value;
        }
        return -1111;
    }

}

Client

public class Client {
	//(a*b)/(a-b+2)
	public static void main(final String[] args) {
		final Context context = new Context();
		context.addValue("a", 7);
		context.addValue("b", 8);
		context.addValue("c", 2);

		final MultiplyNonterminalExpression multiplyValue = new MultiplyNonterminalExpression(
				new TerminalExpression(context.getValue("a")),
				new TerminalExpression(context.getValue("b")));

		final SubtractNonterminalExpression subtractValue = new SubtractNonterminalExpression(
				new TerminalExpression(context.getValue("a")),
				new TerminalExpression(context.getValue("b")));

		final AddNonterminalExpression addValue = new AddNonterminalExpression(
				subtractValue, new TerminalExpression(context.getValue("c")));

		final DivisionNonterminalExpression divisionValue = new DivisionNonterminalExpression(
				multiplyValue, addValue);

		System.out.println(divisionValue.interpreter(context));
	}
}

结果56 

四、解释器模式的优缺点

4.1、优点：

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

4.2、缺点：

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

五、适用场景

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

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

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

 

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