设计模式之解释器模式

什么是设计模式
设计模式是经常使用、大多数人知道，有特定目录的代码设计经验。设计模式可以提高代码可维护性，可提升代码运行效率，也能提高系统可靠性。设计模式可以分为三类，分别是创建型、结构型和行为型。以下就解释器模式简要概述。

什么是解释器模式
解释器模式就是评估语法或表达式的方式。这种模式实现一个表达式接口，该接口负责解析上下文，也是属于行为型模式。

应用场景
1、SQL解析
2、表达式解析验证，比如正则表达式
3、需要灵活解析验证的其他场景

优势与劣势
优点：可扩展性好，业务灵活
缺点：复杂的业务逻辑不好维护

小试牛刀
比如我们业务需要写一个验证上下文字符是否包含某一个字符串，这个时候我们可以用解释器模式设计一个表达式。
首先我们可以定义一个表达式接口Expression,提供解释方法interpreter；然后我们分别实现上下文字段分别包含某字符类CheckExpression,多个上下文是否同时包含字符串类AndExpression,多个上下文是否任意一个包含字符串类OrExpression。最后，我们定义好具体的表达式传入需要验证的字符串即可。
类的依赖关系为：

1、创建验证表达式接口并提供解释方法

/**
 * 表达式接口
 * @author senfel
 * @version 1.0
 * @date 2022/8/30 10:43
 */
public interface Expression {

    /**
     * 解释方法
     * @param str 字段
     */
    Boolean interpreter(String str);

}

2、定义单一验证字符串表达式类并实现验证接口

/**
 * 验证表达式
 * 验证上下文是否包含字段
 * @author senfel
 * @version 1.0
 * @date 2022/8/30 10:59
 */
public class CheckExperssion implements Expression{

    /**
     * 目标上下文
     */
    private String context;

    public CheckExperssion(String context) {
        this.context = context;
    }


    /**
     * 验证上下文是否包含字段
     * @param str
     * @author senfel
     * @date 2022/8/30 11:04
     * @return java.lang.Boolean
     */
    @Override
    public Boolean interpreter(String str) {
        if(context.contains(str)){
            return true;
        }
        return false;
    }
}

3、定义复杂的验证类，同时满足多个表达式、任意满足一个表达式的验证类并实现验证接口

/**
 * AND表达式
 * @author senfel
 * @version 1.0
 * @date 2022/8/30 11:01
 */
public class AndExperssion implements Expression{

    /**
     * 表达式1
     */
    private CheckExperssion checkExperssion1;
    /**
     * 表达式2
     */
    private CheckExperssion checkExperssion2;

    public AndExperssion(CheckExperssion checkExperssion1, CheckExperssion checkExperssion2) {
        this.checkExperssion1 = checkExperssion1;
        this.checkExperssion2 = checkExperssion2;
    }


    /**
     * 验证两个两个表达式是否都同时包含字段
     * @param str
     * @author senfel
     * @date 2022/8/30 11:05
     * @return java.lang.Boolean
     */
    @Override
    public Boolean interpreter(String str) {
        return checkExperssion1.interpreter(str) && checkExperssion2.interpreter(str);
    }
}

/**
 * OR表达式
 * @author senfel
 * @version 1.0
 * @date 2022/8/30 11:03
 */
public class OrExpression implements Expression{
    /**
     * 表达式1
     */
    private CheckExperssion checkExperssion1;
    /**
     * 表达式2
     */
    private CheckExperssion checkExperssion2;

    public OrExpression(CheckExperssion checkExperssion1, CheckExperssion checkExperssion2) {
        this.checkExperssion1 = checkExperssion1;
        this.checkExperssion2 = checkExperssion2;
    }


    /**
     * 验证两个两个表达式是否任意一个包含字段
     * @param str
     * @author senfel
     * @date 2022/8/30 11:05
     * @return java.lang.Boolean
     */
    @Override
    public Boolean interpreter(String str) {
        return checkExperssion1.interpreter(str) || checkExperssion2.interpreter(str);
    }
}

4、解释器模式测试

/**
 * 解释器模式测试
 * @author senfel
 * @version 1.0
 * @date 2022/8/30 11:06
 */
@SpringBootTest
public class TestInterpreterPattern {


    /**
     * 验证表达式中是否包含字段
     * 同时验证两个表达式是否都包含字段
     * 同时验证两个表达式任意一个包含字段
     */
    @Test
    public void test(){
        //定义验证表达式
        String context = "interpreter pattern test";
        CheckExperssion checkExperssion = new CheckExperssion(context);
        //验证单个表达式
        String str = "interpreter";
        if(checkExperssion.interpreter(str)){
            System.err.println("测试解释器模式成功,上下文："+context+" 包含字符串："+str);
        }else{
            System.err.println("测试解释器模式成功,上下文："+context+" 不包含字符串："+str);
        }
        //验证两个表达式是否都包含
        String context2 = "pattern test";
        CheckExperssion checkExperssion2 = new CheckExperssion(context2);
        AndExperssion andExperssion = new AndExperssion(checkExperssion, checkExperssion2);
        if(!andExperssion.interpreter(str)){
            System.err.println("测试解释器模式成功,上下文："+context+"/"+context2+" 没有同时包含字符串："+str);
        }else{
            System.err.println("测试解释器模式成功,上下文："+context+"/"+context2+" 同时包含字符串："+str);
        }

        //验证两个表达式任意一个包含
        OrExpression orExpression = new OrExpression(checkExperssion, checkExperssion2);
        if(orExpression.interpreter(str)){
            System.err.println("测试解释器模式成功,上下文："+context+"/"+context2+" 任意一个包含字符串："+str);
        }else{
            System.err.println("测试解释器模式成功,上下文："+context+"/"+context2+" 都不包含字符串："+str);
        }

    }
}

验证结果：

测试解释器模式成功,上下文：interpreter pattern test 包含字符串：interpreter
测试解释器模式成功,上下文：interpreter pattern test/pattern test 同时包含字符串：interpreter
测试解释器模式成功,上下文：interpreter pattern test/pattern test 任意一个包含字符串：interpreter