设计模式 | 解释器模式及典型应用

设计模式 前端之家
前端之家收集整理的这篇文章主要介绍了设计模式 | 解释器模式及典型应用，前端之家小编觉得挺不错的，现在分享给大家，也给大家做个参考。

微信原文：
博客原文：

本文主要介绍解释器模式，在日常开发中，解释器模式的使用频率比较低

解释器模式(Interpreter Pattern)：定义一个语言的文法，并且建立一个解释器来解释该语言中的句子，这里的 "语言" 是指使用规定格式和语法的代码。解释器模式是一种类行为型模式。

AbstractExpression（抽象表达式）：在抽象表达式中声明了抽象的解释操作，它是所有终结符表达式和非终结符表达式的公共父类。

TerminalExpression（终结符表达式）：终结符表达式是抽象表达式的子类，它实现了与文法中的终结符相关联的解释操作，在句子中的每一个终结符都是该类的一个实例。通常在一个解释器模式中只有少数几个终结符表达式类，它们的实例可以通过非终结符表达式组成较为复杂的句子。

NonterminalExpression（非终结符表达式）：非终结符表达式也是抽象表达式的子类，它实现了文法中非终结符的解释操作，由于在非终结符表达式中可以包含终结符表达式，也可以继续包含非终结符表达式，因此其解释操作一般通过递归的方式来完成。

Context（环境类）：环境类又称为上下文类，它用于存储解释器之外的一些全局信息，通常它临时存储了需要解释的语句。

解释器模式结构图

使用解释器模式实现一个简单的后缀表达式解释器，仅支持对整数的加法和乘法即可

定义抽象表达式接口

public interface Interpreter {
    int interpret();
}

非终结符表达式，对整数进行解释

public class NumberInterpreter implements Interpreter {
    private int number;

public NumberInterpreter(int number) {
    this.number = number;
}

public NumberInterpreter(String number) {
    this.number = Integer.parseInt(number);
}

@Override
public int interpret() {
    return this.number;
}


}

终结符表达式，对加法和乘法进行解释

// 加法
public class AddInterpreter implements Interpreter {
    private Interpreter firstExpression,secondExpression;
    public AddInterpreter(Interpreter firstExpression,Interpreter secondExpression) {
        this.firstExpression = firstExpression;
        this.secondExpression = secondExpression;
    }
    @Override
    public int interpret() {    
        return this.firstExpression.interpret() + this.secondExpression.interpret();
    }
    @Override
    public String toString() {
        return "+";
    }
}

// 乘法

public class MultiInterpreter implements Interpreter {

private Interpreter firstExpression,secondExpression;


public MultiInterpreter(Interpreter firstExpression,Interpreter secondExpression) {
    this.firstExpression = firstExpression;
    this.secondExpression = secondExpression;
}
@Override
public int interpret() {
    return this.firstExpression.interpret() * this.secondExpression.interpret();
}
@Override
public String toString() {
    return "*";
}


}

工具类

public class OperatorUtil {
    public static boolean isOperator(String symbol) {
        return (symbol.equals("+") || symbol.equals("*"));

}
public static Interpreter getExpressionObject(Interpreter firstExpression,Interpreter secondExpression,String symbol) {
    if ("+".equals(symbol)) {  // 加法
        return new AddInterpreter(firstExpression,secondExpression);
    } else if ("*".equals(symbol)) {    // 乘法
        return new MultiInterpreter(firstExpression,secondExpression);
    } else {
        throw new RuntimeException("<a href="https://www.jb51.cc/tag/buzhichi/" target="_blank" class="keywords">不支持</a>的操作符：" + symbol);
    }
}


}

测试，对后缀表达式 6 100 11 + * 进行求值

public class Test {
    public static void main(String[] args) {
        String inputStr = "6 100 11 + *";
        MyExpressionParser expressionParser = new MyExpressionParser();
        int result = expressionParser.parse(inputStr);
        System.out.println("解释器计算结果: " + result);
    }
}

运行结果

入栈: 6
入栈: 100
入栈: 11
出栈: 11 和 100
应用运算符: +
阶段结果入栈: 111
出栈: 111 和 6
应用运算符: *
阶段结果入栈: 666
解释器计算结果: 666

示例.类图

解释器模式为自定义语言的设计和实现提供了一种解决方案，它用于定义一组文法规则并通过这组文法规则来解释语言中的句子。虽然解释器模式的使用频率不是特别高，但是它在正则表达式、XML文档解释等领域还是得到了广泛使用。

  • 易于改变和扩展文法。由于在解释器模式中使用类来表示语言的文法规则，因此可以通过继承等机制来改变或扩展文法。
  • 每一条文法规则都可以表示为一个类，因此可以方便地实现一个简单的语言。
  • 实现文法较为容易。在抽象语法树中每一个表达式节点类的实现方式都是相似的，这些类的代码编写都不会特别复杂，还可以通过一些工具自动生成节点类代码。
  • 增加新的解释表达式较为方便。如果用户需要增加新的解释表达式只需要对应增加一个新的终结符表达式或非终结符表达式类，原有表达式类代码无须修改，符合 "开闭原则"。

  • 对于复杂文法难以维护。在解释器模式中，每一条规则至少需要定义一个类，因此如果一个语言包含太多文法规则，类的个数将会急剧增加，导致系统难以管理和维护，此时可以考虑使用语法分析程序等方式来取代解释器模式。
  • 执行效率较低。由于在解释器模式中使用了大量的循环和递归调用，因此在解释较为复杂的句子时其速度很慢，而且代码的调试过程也比较麻烦。

  • 可以将一个需要解释执行的语言中的句子表示为一个抽象语法树。
  • 一些重复出现的问题可以用一种简单的语言来进行表达。
  • 一个语言的文法较为简单。
  • 对执行效率要求不高。

Spring EL表达式相关的类在 org.springframework.expression 包下，类图如下

org.springframework.expression 包的类图

涉及的类非常多，这里仅对此时我们最关心的几个类做介绍：

SpelExpression，表示一个 EL 表达式，表达式在内部通过一个 AST抽象语法树 表示，EL表达式求值是通过 this.ast.getValue(expressionState); 求值

public class SpelExpression implements Expression {
    private final String expression;
    private final SpelNodeImpl ast;
    private final SpelParserConfiguration configuration;

@Override
@Nullable
public Object getValue() throws EvaluationException {
    if (this.compiledAst != null) {
        try {
            EvaluationContext context = getEvaluationContext();
            return this.compiledAst.getValue(context.getRootObject().getValue(),context);
        }
        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);
    Object result = this.ast.getValue(expressionState);
    checkCompile(expressionState);
    return result;
}
//...省略...


}

SpelNodeImpl：已解析的Spring表达式所代表的ast语法树的节点的通用父类型，语法树的节点在解释器模式中扮演的角色是终结符和非终结符。从类图中可以看到，SpelNodeImpl 的子类主要有 Literal，Operator，Indexer等，其中 Literal 是各种类型的值的父类，Operator 则是各种操作的父类

public abstract class SpelNodeImpl implements SpelNode,Opcodes {
    protected int pos;  // start = top 16bits,end = bottom 16bits
    protected SpelNodeImpl[] children = SpelNodeImpl.NO_CHILDREN;
    @Nullable
    private SpelNodeImpl parent;

public final Object getValue(ExpressionState expressionState) throws EvaluationException {
    return getValueInternal(expressionState).getValue();
}
// 抽象<a href="https://www.jb51.cc/tag/fangfa/" target="_blank" class="keywords">方法</a>，由子类实现，<a href="https://www.jb51.cc/tag/huoqu/" target="_blank" class="keywords">获取</a>对象的值
public abstract TypedValue getValueInternal(ExpressionState expressionState) throws EvaluationException;
//...省略...


}

IntLiteral 表示整型文字的表达式语言的ast结点

public class IntLiteral extends Literal {
    private final TypedValue value;
    public IntLiteral(String payload,int pos,int value) {
        super(payload,pos);
        this.value = new TypedValue(value); // 
        this.exitTypeDescriptor = "I";
    }
    @Override
    public TypedValue getLiteralValue() {
        return this.value;
    }
    // ...
}

OpPlus 表示加法的ast结点，在 getValueInternal 方法中对操作符两边进行相加操作

public class OpPlus extends Operator {
    public OpPlus(int pos,SpelNodeImpl... operands) {
        super("+",pos,operands);
        Assert.notEmpty(operands,"Operands must not be empty");
    }
    @Override
    public TypedValue getValueInternal(ExpressionState state) throws EvaluationException {
        SpelNodeImpl leftOp = getLeftOperand();

    if (this.children.length < 2) {  // if only one operand,then this is unary plus
        Object operandOne = leftOp.getValueInternal(state).getValue();
        if (operandOne instanceof Number) {
            if (operandOne instanceof Double) {
                this.exitTypeDescriptor = "D";
            }
            else if (operandOne instanceof Float) {
                this.exitTypeDescriptor = "F";
            }
            else if (operandOne instanceof Long) {
                this.exitTypeDescriptor = "J";
            }
            else if (operandOne instanceof Integer) {
                this.exitTypeDescriptor = "I";
            }
            return new TypedValue(operandOne);
        }
        return state.operate(Operation.ADD,operandOne,null);
    }
    // 递归调用leftOp的 getValueInternal(state) ，获取操作符左边的值
    TypedValue operandOneValue = leftOp.getValueInternal(state);
    Object leftOperand = operandOneValue.getValue();
    // 递归调用children[1]的 getValueInternal(state) ，获取操作符右边的值
    TypedValue operandTwoValue = getRightOperand().getValueInternal(state);
    Object rightOperand = operandTwoValue.getValue();

    // 如果操作符左右都是数值类型，则将它们相加
    if (leftOperand instanceof Number &amp;&amp; rightOperand instanceof Number) {
        Number leftNumber = (Number) leftOperand;
        Number rightNumber = (Number) rightOperand;

        if (leftNumber instanceof BigDecimal || rightNumber instanceof BigDecimal) {
            BigDecimal leftBigDecimal = NumberUtils.convertNumberToTargetClass(leftNumber,BigDecimal.class);
            BigDecimal rightBigDecimal = NumberUtils.convertNumberToTargetClass(rightNumber,BigDecimal.class);
            return new TypedValue(leftBigDecimal.add(rightBigDecimal));
        }
        else if (leftNumber instanceof Double || rightNumber instanceof Double) {
            this.exitTypeDescriptor = "D";  
            return new TypedValue(leftNumber.doubleValue() + rightNumber.doubleValue());
        }
        //...省略 Float->F,BigInteger->add,Long->J,Integer->I
        else {
            // Unknown Number subtypes -> best guess is double addition
            return new TypedValue(leftNumber.doubleValue() + rightNumber.doubleValue());
        }
    }
    //...
    return state.operate(Operation.ADD,leftOperand,rightOperand);
}
//...


}

通过一个示例，调试查看程序中间经历的步骤

public class SpringELTest {
    public static void main(String[] args) {
        // 1. 构建解析器
        org.springframework.expression.ExpressionParser parser = new SpelExpressionParser();
        // 2. 解析表达式
        Expression expression = parser.parseExpression("100 * 2 + 400 * 1 + 66");
        // 3. 获取结果
        int result = (Integer) expression.getValue();
        System.out.println(result); // 结果：666
    }
}

EL表达式解析后得到表达式 (((100 * 2) + (400 * 1)) + 66)

EL表达式解析后得到的表达式

如果用图形把其这棵AST抽象语法树简单地画出来，大概是这样

示例.AST抽象语法树

调用 expression.getValue() 求值，此时的 ast 是语法树的头结点，也就是 + OpPlus，所以通过 this.ast.getValue(expressionState) 进入了 OpPlus 的 getValue 方法（是父类中的方法），接着进入 getValueInternal 方法，然后递归计算操作符左边的值，递归计算操作符右边的值，最后相加返回

示例.spring EL调试

参考：

Java设计模式精讲

欢迎评论、转发、分享

更多内容可访问我的个人博客：http://laijianfeng.org

关注【小旋锋】微信公众号，及时接收博文推送

关注_小旋锋_微信公众号

原文链接：https://www.f2er.com/javaschema/238289.html

猜你在找的设计模式相关文章

适配器模式-让不兼容的接口得以适配
适配器模式将一个类的接口转换成客户期望的另一个接口，使得原本接口不兼容的类可以相互合...
策略模式-定义一个算法族
策略模式定义了一系列算法族，并封装在类中，它们之间可以互相替换，此模式让算法的变化独...
设计模式之高质量代码
设计模式讲的是如何编写可扩展、可维护、可读的高质量代码，它是针对软件开发中经常遇到的...
模板方法模式-封装一套算法流程
模板方法模式在一个方法中定义一个算法的骨架，而将一些步骤延迟到子类中，使得子类可以在...
迭代器模式-统一集合的遍历方式
迭代器模式提供了一种方法，用于遍历集合对象中的元素，而又不暴露其内部的细节。
单例模式的五种实现方式及优缺点
单例模式（Singleton Design Pattern）保证一个类只能有一个实例，并提供一个全局访问点。
组合模式-统一的处理个别对象与组合对象
组合模式可以将对象组合成树形结构来表示“整体-部分”的层次结构，使得客户可以用一致的方...
装饰者模式-动态的包装原有对象的行为
装饰者模式能够更灵活的，动态的给对象添加其它功能，而不需要修改任何现有的底层代码。
观察者模式-将消息通知给观察者
观察者模式（Observer Design Pattern）定义了对象之间的一对多依赖，当对象状态改变的时候...
代理模式-访问对象的代理而非其本身
代理模式为对象提供一个代理，来控制对该对象的访问。代理模式在不改变原始类代码的情况下...
算法设计模式多媒体技术正则表达式ElasticsearchFlinkHadoopIDE
受约束摘*day25Java常用类库置信lamda留存持续录入年后正则表达式303.17regularexpre匹多模适20130322基础理论pathmunge涵义reectok需要转义的特资源分享validationex简明魔法里弄形如源码实现完备actionscript