设计模式-解释器模式

解释器模式

1.定义与类型

定义：给定一个语言，定义它的文法的一种表示，并定义一个解释器，这个解释器使用该表示来解释语言中的句子
为了解释一种语言，而为语言创建的解释器
类型：行为型

2.适用场景

某个特定类型问题发生频率足够高

3.优点

语法由很多类表示,容易改变及扩展此语言

4.缺点

当语法规则数目太多，增加了系统复杂度

5.相关设计模式

解释器模式和适配器模式

6.Coding

创建解释器顶级接口

public interface Interpreter {
    int interpreter();
}

解释器的相关实现类

public class AddInterpreter implements Interpreter{
    private Interpreter firstExpression,secondExpression;

    public AddInterpreter(Interpreter firstExpression,Interpreter secondExpression){
        this.firstExpression = firstExpression;
        this.secondExpression = secondExpression;
    }
    @Override
    public int interpreter() {
        return this.firstExpression.interpreter() + this.secondExpression.interpreter();
    }

    @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 interpreter() {
        return this.firstExpression.interpreter() * this.secondExpression.interpreter();
    }

    @Override
    public String toString() {
        return "*";
    }
}

创建数字解释器，用于处理入参

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 interpreter() {
        return this.number;
    }
}

简单实现一个工具类

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

    public static Interpreter getExpressionObjects(Interpreter firstInterpreter, Interpreter secondInterpreter, String symbol) {
        if ("+".equals(symbol)) {
            return new AddInterpreter(firstInterpreter, secondInterpreter);
        } else if ("*".equals(symbol)) {
            return new MultiInterpreter(firstInterpreter, secondInterpreter);
        }
        return null;
    }
}

自定义一个解释器语法

public class QchExpressionParser {
    private Stack<Interpreter> stack = new Stack<>();

    public int parse(String str) {
        String[] strArray = str.split(" ");
        for (String item : strArray) {
            if (!OperatorUtil.isOperator(item)) {
                NumberInterpreter numberInterpreter = new NumberInterpreter(item);
                stack.push(numberInterpreter);
                System.out.println(String.format("入栈：%d", numberInterpreter.interpreter()));
            } else {
                Interpreter firstInterpreter = stack.pop();
                Interpreter secondInterpreter = stack.pop();
                System.out.println(String.format("出栈:%d 和 %d", firstInterpreter.interpreter(), secondInterpreter.interpreter()));
                Interpreter expressionObjects = OperatorUtil.getExpressionObjects(firstInterpreter, secondInterpreter, item);
                System.out.println(String.format("应用运算符: %s", expressionObjects.interpreter()));
                int result = expressionObjects.interpreter();
                NumberInterpreter numberInterpreter = new NumberInterpreter(result);
                stack.push(numberInterpreter);
                System.out.println(String.format("阶段结果入栈:%d", result));
            }
        }
        int result = stack.pop().interpreter();
        return result;
    }
}

Test测试类

public class Test {
    public static void main(String[] args) {
        String geelyInputStr = "6 100 11 + *";
        QchExpressionParser expressionParser = new QchExpressionParser();
        int parse = expressionParser.parse(geelyInputStr);
        System.out.println("解释器执行结果为:"+parse);
    }
}

控制台打印

7.源码

Spring框架中的使用

public class TestForSpring {
  
    public static void main(String[] args) {
      
        ExpressionParser parser = new SpelExpressionParser();
      
        Expression expression = parser.parseExpression("100 + 11 * 6");
      
        int result = (int)expression.getValue();
      
        System.out.println(result);
    }

}