设计模式之解释器模式

Given a language,define a representation for its grammar along with an interpreter that uses the representation to interpret sentences in the language.（给定一门语言，定义它的语法的一种表示，并定义一个解释器，该解释器使用该解释来解释语言中的句子。）

解释器模式是指给定一个语言（表达式），定义它的文法的一种表示，并定义一个解释器，使用该解释器来解释语言中的句子（表达式）。  
    在编译原理中，一个算术表达式通过词法分析器形成词法单元，而后这些词法单元再通过语法解析器构建语法分析树，最终形成一颗抽象的语法分析树。这里的词法分析器和语法分析器可以看作是解释器。

//抽象解释器
public abstract class Expression {
    //解析任务
    public abstract Object interpreter(Context ctx);
}

//终结符表达式
public class TerminalExpression extends Expression {
    @Override
    public Object interpreter(Context ctx) {
        return null;
    }
}

public class NonterminalExpression extends Expression {
    //每个非终结符表达式都会对其它表达式产生依赖
    public NonterminalExpression(Expression... expressions){
    }
    @Override
    public Object interpreter(Context ctx) {
        //进行文法处理
        return null;
    }
}

每个非终结表达式都代表了一个文法规则，并且每个文法规则都只关心自己周边的文法规则的结果，因此这就产生了每个非终结符表达式调用自己周边的非终结符表达式，最终，最小的文法规则就是终结符表达式。

public class Client {
    public static void main(String[] args){
        Context ctx=new Context();
        //定义一个语法容器，容纳一个具体的表达式；
        Stack<Expression> stack=null;
        for (;;){
            //进行语法分析，并产生递归调用
        }
        //产生一个完整的语法树，由各个具体的语法分析进行解析
        Expression exp=stack.pop();
        //j具体元素进入场景
        exp.interpreter(ctx);
    }
}

在下面的类图中，Expression是一个接口，相当于我们解释器模式中的非终结符表达式，而ExpressionParser相当于终结符表达式。根据不同的Parser对象，返回不同的Expression对象。

//抽象的非终结符表达式
public interface Expression {
  Object getValue() throws EvaluationException;
  Object getValue(Object rootObject) throws EvaluationException;
}

//具体的非终结符表达式
public class SpelExpression implements Expression {
  @Override
  public Object getValue() throws EvaluationException {
    Object result;
    if (this.compiledAst != null) {
      try {
        TypedValue contextRoot = evaluationContext == null ? null : evaluationContext.getRootObject();
        return this.compiledAst.getValue(contextRoot == null ? null : contextRoot.getValue(), evaluationContext);
      }
      catch (Throwable ex) {
        // If running in mixed mode, revert to interpreted
        if (this.configuration.getCompilerMode() == SpelCompilerMode.MIXED) {
          this.interpretedCount = 0;
          this.compiledAst = null;
        }
        else {
          // Running in SpelCompilerMode.immediate mode - propagate exception to caller
          throw new SpelEvaluationException(ex, SpelMessage.EXCEPTION_RUNNING_COMPILED_EXPRESSION);
        }
      }
    }
    ExpressionState expressionState = new ExpressionState(getEvaluationContext(), this.configuration);
    result = this.ast.getValue(expressionState);
    checkCompile(expressionState);
    return result;
  }
}

//具体的非终结符表达式
public class CompositeStringExpression implements Expression {
  @Override
  public String getValue() throws EvaluationException {
    StringBuilder sb = new StringBuilder();
    for (Expression expression : this.expressions) {
      String value = expression.getValue(String.class);
      if (value != null) {
        sb.append(value);
      }
    }
    return sb.toString();
  }
}

public interface ExpressionParser {
  //解析表达式
  Expression parseExpression(String expressionString) throws ParseException;
  Expression parseExpression(String expressionString, ParserContext context) throws ParseException;
}

public abstract class TemplateAwareExpressionParser implements ExpressionParser {
  @Override
  public Expression parseExpression(String expressionString) throws ParseException {
    return parseExpression(expressionString, NON_TEMPLATE_PARSER_CONTEXT);
  }
  //根据不同的parser返回不同的Expression对象
  @Override
  public Expression parseExpression(String expressionString, ParserContext context)
      throws ParseException {
    if (context == null) {
      context = NON_TEMPLATE_PARSER_CONTEXT;
    }
    if (context.isTemplate()) {
      return parseTemplate(expressionString, context);
    }
    else {
      return doParseExpression(expressionString, context);
    }
  }
  private Expression parseTemplate(String expressionString, ParserContext context)
      throws ParseException {
    if (expressionString.length() == 0) {
      return new LiteralExpression("");
    }
    Expression[] expressions = parseExpressions(expressionString, context);
    if (expressions.length == 1) {
      return expressions[0];
    }
    else {
      return new CompositeStringExpression(expressionString, expressions);
    }
  }
  //抽象的，由子类去实现
  protected abstract Expression doParseExpression(String expressionString,
      ParserContext context) throws ParseException;
}

public class SpelExpressionParser extends TemplateAwareExpressionParser {
  @Override
  protected SpelExpression doParseExpression(String expressionString, ParserContext context) throws ParseException {
    //这里返回了一个InternalSpelExpressionParser，
    return new InternalSpelExpressionParser(this.configuration).doParseExpression(expressionString, context);
  }
}

class InternalSpelExpressionParser extends TemplateAwareExpressionParser {
  @Override
  protected SpelExpression doParseExpression(String expressionString, ParserContext context) throws ParseException {
    try {
      this.expressionString = expressionString;
      Tokenizer tokenizer = new Tokenizer(expressionString);
      tokenizer.process();
      this.tokenStream = tokenizer.getTokens();
      this.tokenStreamLength = this.tokenStream.size();
      this.tokenStreamPointer = 0;
      this.constructedNodes.clear();
      SpelNodeImpl ast = eatExpression();
      if (moreTokens()) {
        throw new SpelParseException(peekToken().startPos, SpelMessage.MORE_INPUT, toString(nextToken()));
      }
      Assert.isTrue(this.constructedNodes.isEmpty());
      return new SpelExpression(expressionString, ast, this.configuration);
    }
    catch (InternalParseException ex) {
      throw ex.getCause();
    }
  }
}