Java 设计模式(19) —— 解释器模式

一、解释器模式

定义一个语法, 定义一个解释器，该解释器处理该语法句子。将某些复杂问题，表达为某种语法规则，然后构建解释器来解释处理这类句子。

解释器模式

二、示例

数据分析项目：现在有大量的数据需要进行分析统计，统计过程中不同的需求则要根据不同的运算方法所得，按照传统的方法则需要每有一种分析需求，就制定一套解析方法，较繁琐不利于维护

则引用解释器模式，外部直接输入数据集合和加减乘除的运算方式，解释器进行自动解析即可

• 计算模型按正常算术方式书写，解释器处理语法逻辑
• 计算模型里有两种表达式：变量数据和计算符
• 用逆波兰算法分析算式语法
• 用解释器模式处理数据

1.计算表达式的抽象类，用HashMap存储所有要计算的变量

/**
 * 解释器模式，抽象表达式，HashMap存储运算的具体数据
 */
public abstract class AbstractExpresstion {
    public abstract Float interpreter(HashMap var);
}

2.定义变量表达式代表运算中的所有变量

/**
 * 解释器模式，变量表达式，代表所有操作的数字
 */
public class VarExpresstion extends AbstractExpresstion {
    private String key;

    public VarExpresstion(String _key) {
        this.key = _key;

    }

    @Override
    public Float interpreter(HashMap var) {
        return var.get(this.key);
    }

}

3.定义运算符表达式的超类，并定义加减乘除各项表达式的解释器模型

/**
 * 解释器模式，运算符相关的表达式，每种运算符操作都是两个数据
 */
public abstract class SymbolExpresstion extends AbstractExpresstion {
    protected AbstractExpresstion left;
    protected AbstractExpresstion right;

    public SymbolExpresstion(AbstractExpresstion _left,
                             AbstractExpresstion _right) {
        this.left = _left;

        this.right = _right;
    }

}

/**
 * 解释器模式，相加的表达式
 */
public class AddExpresstion extends SymbolExpresstion {

    public AddExpresstion(AbstractExpresstion _left, AbstractExpresstion _right) {
        super(_left, _right);
    }

    @Override
    public Float interpreter(HashMap var) {
        return super.left.interpreter(var) + super.right.interpreter(var);
    }

}

/**
 * 解释器模式，相减的表达式
 */
public class SubExpresstion extends SymbolExpresstion {

    public SubExpresstion(AbstractExpresstion _left, AbstractExpresstion _right) {
        super(_left, _right);
    }

    @Override
    public Float interpreter(HashMap var) {
        return super.left.interpreter(var) - super.right.interpreter(var);
    }

}

/**
 * 解释器模式，相乘的表达式
 */
public class MultiExpresstion extends SymbolExpresstion {

    public MultiExpresstion(AbstractExpresstion _left,
                            AbstractExpresstion _right) {
        super(_left, _right);
    }

    @Override
    public Float interpreter(HashMap var) {
        return super.left.interpreter(var) * super.right.interpreter(var);
    }

}

/**
 * 解释器模式，相除的表达式
 */
public class DivExpresstion extends SymbolExpresstion {

    public DivExpresstion(AbstractExpresstion _left, AbstractExpresstion _right) {
        super(_left, _right);
    }

    @Override
    public Float interpreter(HashMap var) {
        return super.left.interpreter(var) / super.right.interpreter(var);
    }

}

4.设计计算方法，用HashMap引入需要计算的数据，让用户自定义输入运算方法

/**
 * 解释器模式，计算器方法，对数据进行加减乘除的运算
 */
public class Calculator {

    public Calculator() {


        // 随机生成需要运算3组数据，每组6个
        float[][] dataSource = new float[3][6];
        System.out.println("data source:");
        for (int i = 0; i < 3; i++) {
            for (int j = 0; j < 6; j++) {
                dataSource[i][j] = (float) (Math.random() * 100);
                System.out.print(dataSource[i][j] + ",");
            }
            System.out.println(";");
        }

        try {


            // 让用户自定义输入各数据运算的规则
            System.out.println("Input a expression:");
            BufferedReader is = new BufferedReader(new InputStreamReader(
                    System.in));
            for (; ; ) {
                String input = new String();
                input = is.readLine().trim();
                if (input.equals("q"))
                    break;
                else {
                    RPN boya = new RPN(input);
                    HashMap var;

                    // 用abcdef代表存储在HashMap中数据的key
                    for (int i = 0; i < 3; i++) {
                        var = new HashMap();
                        var.put("a", dataSource[i][0]);
                        var.put("b", dataSource[i][1]);
                        var.put("c", dataSource[i][2]);
                        var.put("d", dataSource[i][3]);
                        var.put("e", dataSource[i][4]);
                        var.put("f", dataSource[i][5]);

                        boya.getResult(var);

                    }

                }
                System.out.println("Input another expression or input 'q' to quit:");
            }
            is.close();
        } catch (IOException e) {
            System.out.println("Wrong input!!!");
        }

    }

}

5.运行结果

计算数据解析

以上则根据解释器模式将模型分成了变量表达式和运算表达式两种，并对各表达式进行了解释器模型的定义，用递归的原理实现了数据的循环运算。则可以实现用户自定义数据的运算方式得出统计结果

三、总结

• 优点：

  • 容易修改，修改语法规则只要修改相应非终结符即可
  • 扩展方便，扩展语法，只要增加非终结符类即可

• 缺点：

  • 对于复杂语法的表示会产生复杂的类层次结构，不便管理和维护
  • 解释器采用递归方式，效率会受影响

• 注意事项：

  • 尽量不要在重要的模块中使用解释器模式
  • 解释器模式在实际的系统开发中使用的非常少
  • 可以考虑一下Expression4J、MESP、Jep等开源的解析工具包

• 适用场合：

  • 当你有一个简单语法，而且效率不是问题的时候
  • 一些数据分析工具、报表设计工具、科学计算工具等

Java设计模式所有示例代码，持续更新中