解释器模式的一个应用

需求

做产品的时候，有一个需求：对于一个字符串要在提交之前做校验，但是校验标准需要可配置。最合理的方案就是使用正则表达式+表达式组合。

基础数据结构

配置的数据结构如下

package com.example.ayizty.myapplication.reg;import java.util.HashMap;public class Configure {    public HashMap<String, String> statements;//variant list    public String expression;//separate all operand by space    public HashMap<String, String> extras;}

解释器分为：
- 取非：读下一个值，并取非
- 合：对前后两值取和
- 或：对前后两值取或
- 左括号：计算后面所有值，直到遇到右括号
- 右括号：返回前一个值
- 正则表达式：计算值
- 值：布尔值，表示中间结果
expression是由！、&、|、括号和正则表达式组成的逻辑表达式，所有单词用空格分隔开。正则表达式由变量表示，对应放到statements里。（主要是懒得做词法分析）

逻辑

这是一个标准的解释器模式的应用场景，但是，因为面试题的余孽（逆波兰式，表达式解析什么的），用解释器的模式做解释器不太容易，百度最高的就是用堆栈处理表达式，然后调解释器，这就成了strategy，而不是解释器。
解释器模式的精髓在于使用函数调用的堆栈来遍历表达式树，每个解释器仅对其前后的解释器有感知，对于所有解释器都是调用interpret（为了省事，我这里特殊处理了值解释器）。

解释器基类

package com.example.ayizty.myapplication.reg;public abstract class AbsOperator {    public static AbsOperator getOperand(String rawOperand, Processor processor) {        switch (rawOperand.charAt(0)) {            case '!':                return new NegativeOperator();            case '&':                return new AndOperator();            case '(':                return new LeftParenthesisOperator();            case '|':                return new OrOperator();            case ')':                return new RightParenthesisOperator();            default:                return new RegOperand(rawOperand, processor);        }    }    public abstract ValueOperand interpret(String input, Processor processor, int index);}

解释器们

• 取非

package com.example.ayizty.myapplication.reg;public class NegativeOperand extends AbsOperand {    @Override    public ValueOperand interpret(String input, Processor processor, int index) {        processor.removeOperand(index);        AbsOperand next = processor.getOperand(index);        ValueOperand result = next.interpret(input, processor, index);        result.setValue(!result.getValue());        return result;    }    @Override    public String toString() {        return "!";    }}

• 合

package com.example.ayizty.myapplication.reg;public class AndOperator extends AbsOperator {    @Override    public ValueOperand interpret(String input, Processor processor, int index) {        ValueOperand left = (ValueOperand) processor.removeOperand(index - 1);        processor.removeOperand(index - 1);        AbsOperator next = processor.getOperand(index - 1);        return new ValueOperand(next.interpret(input, processor, index - 1).getValue() && left.getValue());    }    @Override    public String toString() {        return "&&";    }}

• 或

package com.example.ayizty.myapplication.reg;public class OrOperator extends AbsOperator {    @Override    public ValueOperand interpret(String input, Processor processor, int index) {        ValueOperand left = (ValueOperand) processor.removeOperand(index - 1);        processor.removeOperand(index - 1);        AbsOperator next = processor.getOperand(index - 1);        return new ValueOperand(next.interpret(input, processor, index - 1).getValue() || left.getValue());    }    @Override    public String toString() {        return "||";    }}

• 左括号

package com.example.ayizty.myapplication.reg;public class LeftParenthesisOperator extends AbsOperator {    @Override    public ValueOperand interpret(String input, Processor processor, int index) {        processor.removeOperand(index);        AbsOperator expected = null;        do {            AbsOperator next = processor.getOperand(index);            processor.putOperand(index, next.interpret(input, processor, index));            expected = processor.getOperand(index + 1);        } while (!(expected instanceof RightParenthesisOperator));        return expected.interpret(input, processor, index + 1);    }    @Override    public String toString() {        return "(";    }}

• 右括号

public class RightParenthesisOperator extends AbsOperator {    @Override    public ValueOperand interpret(String input, Processor processor, int index) {        ValueOperand operand = (ValueOperand) processor.removeOperand(index - 1);        processor.removeOperand(index - 1);        return operand;    }    @Override    public String toString() {        return ")";    }}

• 正则表达式

public class RegOperand extends AbsOperator {    private Pattern mPattern;    public RegOperand(String rawOperand, Processor processor) {        mPattern = Pattern.compile(processor.getRawStatement(rawOperand));    }    @Override    public ValueOperand interpret(String input, Processor processor, int index) {        processor.removeOperand(index);        Matcher matcher = mPattern.matcher(input);        ValueOperand result = new ValueOperand(matcher.find());        System.out.println(index + " " + this + " 3 " + result);        return result;    }    @Override    public String toString() {        return mPattern.toString();    }}

• 值

public class ValueOperand extends AbsOperator {    private boolean mValue;    public ValueOperand(boolean value) {        mValue = value;    }    @Override    public ValueOperand interpret(String input, Processor processor, int index) {        AbsOperator next = processor.getOperand(index + 1);        return next.interpret(input, processor, index + 1);    }    public void setValue(boolean value) {        mValue = value;    }    public boolean getValue() {        return mValue;    }    @Override    public String toString() {        return String.valueOf(mValue);    }}

值之所以有这个intercept是因为整体流程的需要。主要就是Processor的结构：

package com.example.ayizty.myapplication.reg;import java.util.ArrayList;public class Processor {    private Configure mConfigure;    private ArrayList<AbsOperator> mOperands;    public Processor(Configure configure) {        mConfigure = configure;        String expression = configure.expression;        String[] rawOperands = expression.split(" ");        final int length = rawOperands.length;        mOperands = new ArrayList<>();        for (int i = 0; i < length; ++i) {            mOperands.add(AbsOperator.getOperand(rawOperands[i], this));        }        System.out.println("init " + this);    }    public AbsOperator removeOperand(int index) {        return mOperands.remove(index);    }    public AbsOperator getOperand(int index) {        return mOperands.get(index);    }    public void putOperand(int i, AbsOperator operand) {        mOperands.add(i, operand);    }    public String getRawStatement(String name) {        return mConfigure.statements.get(name);    }    public boolean process(String input) {        while (1 != mOperands.size()) {            ValueOperand operand = mOperands.get(0).interpret(input, this, 0);            mOperands.add(0, operand);            System.out.println("processor " + this);        }        AbsOperator operand = mOperands.get(0);        if (operand instanceof ValueOperand) {            return ((ValueOperand) operand).getValue();        }        return false;    }    @Override    public String toString() {        StringBuilder stringBuilder = new StringBuilder();        final int length = mOperands.size();        for (int i = 0; i < length; ++i) {            stringBuilder.append(mOperands.get(i));        }        return stringBuilder.toString();    }}

这里就是解释器模式的整体调用逻辑，没有树、没有堆栈，简单到底的对第一个解释器进行解释。

PS

解释器模式确实让代码简单的令人发指，但是有一些问题：
- 类爆炸，简简单单的逻辑表达式已经10个类了，而且每个类都非常简单
- 过多的对象，每次运行都会产生大量中间变量，固然是很不好的。可以使用对象池+工厂解决。