解释器模式的一个应用
需求
做产品的时候，有一个需求：对于一个字符串要在提交之前做校验，但是校验标准需要可配置。最合理的方案就是使用正则表达式+表达式组合。
基础数据结构
配置的数据结构如下
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个类了，而且每个类都非常简单
- 过多的对象，每次运行都会产生大量中间变量，固然是很不好的。可以使用对象池+工厂解决。