设计模式【十一】-解释器模式

1. 作用

适用于判断逻辑比较多或者表达式比较复杂的业务情况

2. 代码

2.1 功能类

package com.hz.design.explain;

/**
 * @fileName: Expression
 * @version:
 * @description:
 * @author: pp_lan
 * @date: 2022/3/28
 */
public interface Expression {

    boolean explain(Object o);

}

package com.hz.design.explain;

/**
 * @fileName: ContainExpress
 * @version:
 * @description:
 * @author: pp_lan
 * @date: 2022/3/28
 */
public class ContainExpress implements Expression {

    /**
     * 是否包含的字符串
     */
    private final String data;

    public ContainExpress(String data) {
        this.data = data;
    }

    @Override
    public boolean explain(Object o) {
        if (o instanceof String) {
            String str = String.valueOf(o);
            return str.contains(data);
        }
        return false;
    }
}

package com.hz.design.explain;

/**
 * @fileName: NanjingExpress
 * @version:
 * @description:
 * @author: pp_lan
 * @date: 2022/3/29
 */
public class OtherCityExpress implements Expression {

    @Override
    public boolean explain(Object o) {

        if (o instanceof String) {
            String str = String.valueOf(o);
            return "其他".equals(str);
        }
        return false;
    }
}

package com.hz.design.explain;

import com.hz.model.CommonException;

/**
 * @fileName: OrExpression
 * @version:
 * @description:
 * @author: pp_lan
 * @date: 2022/3/28
 */
public class OrExpression implements Expression {

    private final Expression baseExpression;

    private final Expression[] expressions;

    /**
     * or语法构造器
     *
     * @param baseExpression
     * @param expressions 多个带取或的公式
     */
    public OrExpression(Expression baseExpression, Expression... expressions) {
        this.baseExpression = baseExpression;
        if (baseExpression == null || expressions == null || expressions.length < 1) {
            throw new CommonException("Or连接参数不能为空");
        }
        this.expressions = expressions;
    }


    @Override
    public boolean explain(Object o) {
        boolean success = baseExpression.explain(o);
        for (Expression expression : expressions) {
            success = success || expression.explain(o);
        }
        return success;
    }
}

2.2 测试类（调用）

package com.hz.design.explain;

/**
 * @fileName: ExplainTest
 * @version: 适用于判断逻辑比较多或者表达式比较复杂的业务情况
 * @description:
 * @author: pp_lan
 * @date: 2022/3/29
 */
public class ExplainTest {

    public static void main(String[] args) {

        // 直接判断，数量比较大还行，数量较多较复杂时候可以使用解释器
        String location = "建邺";
        boolean containCity = location.contains("太原") || location.contains("南京") || location.contains("合肥") || "其他".equals(location);
        System.out.format("直接判断包含结果：%s.\n", containCity);

        // 解释模式
        String expressLocation = "其他";
        ContainExpress containJudgeA = new ContainExpress("太原");
        ContainExpress containJudgeB = new ContainExpress("南京");
        ContainExpress containJudgeC = new ContainExpress("合肥");
        OtherCityExpress otherCityExpress = new OtherCityExpress();

        OrExpression orExpression = new OrExpression(containJudgeA, containJudgeB, containJudgeC, otherCityExpress);
        boolean contain = orExpression.explain(expressLocation);

        System.out.format("express判断包含太原结果：%s.", containJudgeA.explain(expressLocation));
        System.out.format("express判断包含结果：%s.\n", contain);
    }
}

3. 执行结果

Connected to the target VM, address: '127.0.0.1:58227', transport: 'socket'
直接判断包含结果：false.
express判断包含结果：true.
Disconnected from the target VM, address: '127.0.0.1:58227', transport: 'socket'

4. 说明

       可以在判断比较复杂，冗长，可读性不高的情况下使用解释器模式，通过对判断条件解耦，实现高高复用，自由组合的目的。同时解释器命名时候规范化可以使代码具有更好的可读性。