设计模式之解释器模式

约定不等于承诺〃 2024-04-07 10:18 75阅读 0赞

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

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

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

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

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

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

[3dee2efcc1d849aaa11ea36a3d7f3654.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/07/dfd78f2ff28c4d4d92d090efa084cfc1.png