设计模式之解释器模式

解释器模式

解释器模式更加小众，只在一些特定的领域会被用到，比如编译器、规则引擎、正则表达式。它的代码实现的核心思想，就是将语法解析的工作拆分到各个小类中，以此来避免大而全的解析类。一般的做法是，将语法规则拆分成一些小的独立的单元，然后对每个单元进行解析，最终合并为对整个语法规则的解析。

定义

解释器模式为某个语言定义它的语法（或者叫文法）表示，并定义一个解释器用来处理这个语法。

实现

基于解析器模式的自定义告警规则功能。

1. 定义表达式接口

/**
 * 定义表达式解析模板
 */
public interface Expression {
    /**
     * 对状态进行判断
     * @param stats
     * @return
     */
    boolean interpret(Map<String, Long> stats);
}

2.定义表达式实现类

&&

/**
 * 解析 &&
 * AND的话，需要里面的每个表达式都要满足最后才输出true
 */
public class AndExpression implements Expression {
    private List<Expression> expressions = new ArrayList<>();

    public AndExpression(String strAndExpression) {
        String[] elements = strAndExpression.split("&&");
        for (String element : elements) {
            if (element.contains(">")) {
                expressions.add(new GreaterExpression(element));
            } else if (element.contains("<")) {
                expressions.add(new LessExpression(element));
            } else if (element.contains("==")) {
                expressions.add(new EqualsExpression(element));
            } else {
                throw new RuntimeException("Expression is invalid: " + strAndExpression);
            }
        }
    }

    public AndExpression(List<Expression> expressions) {
        this.expressions.addAll(expressions);
    }

    @Override
    public boolean interpret(Map<String, Long> stats) {
        for (Expression expression : expressions) {
            if (!expression.interpret(stats)) {
                return false;
            }
        }
        return true;
    }
}

||

public class OrExpression implements Expression{
    private List<Expression> expressions = new ArrayList<>();
    public OrExpression(String strOrExpression) {
        String[] andExpressions = strOrExpression.split("\\|\\|");
        for (String andExpression : andExpressions) {
            expressions.add(new AndExpression(andExpression));
        }
    }

    public OrExpression(List<Expression> expressions) {
        this.expressions.addAll(expressions);
    }

    @Override
    public boolean interpret(Map<String, Long> stats) {
        for (Expression expr : expressions) {
            if (expr.interpret(stats)) {
                return true;
            }
        }
        return false;
    }
}

>

/**
 * 解析 >
 */
public class GreaterExpression implements Expression{
    private String key;
    private long value;

    public GreaterExpression(String strExpression) {
        String[] elements = strExpression.trim().split("\\s+");
        if (elements.length != 3 || !elements[1].trim().equals(">")) {
            throw new RuntimeException("Expression is invalid: " + strExpression);
        }
        this.key = elements[0].trim();
        this.value = Long.parseLong(elements[2].trim());
    }

    public GreaterExpression(String key, long value) {
        this.key = key;
        this.value = value;
    }

    @Override
    public boolean interpret(Map<String, Long> stats) {
        if (!stats.containsKey(key)) {
            return false;
        }
        long statValue = stats.get(key);
        return statValue > value;
    }
}

<

/**
 * 解析 <
 */
public class LessExpression implements Expression{
    private String key;
    private long value;

    public LessExpression(String strExpression) {
        String[] elements = strExpression.trim().split("\\s+");
        if (elements.length != 3 || !elements[1].trim().equals("<")) {
            throw new RuntimeException("Expression is invalid: " + strExpression);
        }
        this.key = elements[0].trim();
        this.value = Long.parseLong(elements[2].trim());
    }

    public LessExpression(String key, long value) {
        this.key = key;
        this.value = value;
    }

    @Override
    public boolean interpret(Map<String, Long> stats) {
        if (!stats.containsKey(key)) {
            return false;
        }
        long statValue = stats.get(key);
        return statValue < value;
    }
}

==

/**
 * 解析 ==
 * 单一职责: 只判断key和stats里面的状态是否相等即可
 */
public class EqualsExpression implements Expression{
    private String key;
    private long value;

    public EqualsExpression(String strExpression) {
        String[] elements = strExpression.trim().split("\\s+");
        if (elements.length != 3 || !elements[1].trim().equals("==")) {
            throw new RuntimeException("Expression is invalid: " + strExpression);
        }
        this.key = elements[0].trim();
        this.value = Long.parseLong(elements[2].trim());
    }

    public EqualsExpression(String key, long value) {
        this.key = key;
        this.value = value;
    }

    @Override
    public boolean interpret(Map<String, Long> stats) {
        if (!stats.containsKey(key)) {
            return false;
        }
        long statValue = stats.get(key);
        return statValue == value;
    }
}

3. Main

public class AlertRuleInterpreter {
    private Expression expression;

    public AlertRuleInterpreter(String ruleExpression) {
        this.expression = new OrExpression(ruleExpression);
    }

    public boolean interpret(Map<String, Long> stats) {
        return expression.interpret(stats);
    }
}

/**
 * 解释器模式的代码比较灵活，没有固定的模板。核心思想是将语法解析的工作拆分到各个小类中，从而避免大而全的解析类。
 * 一般做法是，将语法规则拆分一些小的独立单元，然后对每个单元进行解析，最终合并为对整个语法规则的解析
 */
public class M {
    public static void main(String[] args) {
        String rule = "key1 > 100 && key2 < 30 || key4 == 88";
        AlertRuleInterpreter interpreter = new AlertRuleInterpreter(rule);
        HashMap<String, Long> stats = new HashMap<>(6);
        stats.put("key1", 101L);
        stats.put("key3", 121L);
        stats.put("key4", 88L);

        boolean interpret = interpreter.interpret(stats);
        System.out.println("是否产生预警: " + (interpret ? "产生预警": "未能产生预警"));
    }
}

总结

1. 解释器模式为某个语言定义它的语法（或者叫文法）表示，并定义一个解释器用来处理这个语法。
2. 解释器模式的代码实现比较灵活，没有固定的模板。核心思想是将语法解析的工作拆分到各个小类中，从而避免大而全的解析类。
3. 一般做法是，将语法规则拆分一些小的独立单元，然后对每个单元进行解析，最终合并为对整个语法规则的解析