设计模式 | 行为型 | 解释器模式

// 新建一个模板文件：template.docx ，并且在里面添加内容：{{title}}
// poi-tl 的所有的标签都是以 {{ 开头，以 }} 结尾
{{title}}

XWPFTemplate template=XWPFTemplate.compile("template.docx").render(
    new HashMap<String, Object>(){{
        put("title","Hi, poi-tl Word模板引擎");
}});
template.writeAndClose(new FileOutputStream("output.docx")); 

// 输出的 output.docx 文件内容：
Hi,poi-tl Word模板引擎

public interface Expression {
    String interpret(String sourceStr, Map<String, String> data);
}

/**
 * 表达式实现：文本表达式
 */
public class ExpressionStr implements Expression {

    private static String prefix = "{{";
    private static String suffix = "}}";

    @Override
    public String interpret(String sourceStr, Map<String, String> data) {

        for (Map.Entry<String, String> entry : data.entrySet()) {
            String targerStr = prefix + entry.getKey() + suffix;
            sourceStr = StrUtil.replace(sourceStr, targerStr, entry.getValue());
        }
        return sourceStr;
    }
}

/**
 * 表达式实现：表达式实现：图片表达式
 */
public class ExpressionPic implements Expression {

    private static String prefix = "{{@";
    private static String suffix = "}}";

    @Override
    public String interpret(String sourceStr, Map<String, String> data) {

        for (Map.Entry<String, String> entry : data.entrySet()) {
            String targerStr = prefix + entry.getKey() + suffix;
            String imageStr = "![" + entry.getKey() + "](assets/" + entry.getValue() + "]";
            sourceStr = StrUtil.replace(sourceStr, targerStr, imageStr);
        }
        return sourceStr;
    }
}

public class Interpreter {

    // 源文本
    private String sourceStr;
    // 表达式
    private Map<Expression, Map<String, String>> expressions = new HashMap<>();

    public Interpreter(String sourceStr) {
        this.sourceStr = sourceStr;
    }

    /**
     * 添加表达式
     */
    public void addExpression(Expression expression, Map<String, String> data) {
        expressions.put(expression, data);
    }

    /**
     * 执行解释
     */
    public String interpreter() {

        expressions.forEach((expression, data) -> {
            sourceStr = expression.interpret(sourceStr, data);
        });

        return sourceStr;
    }
}

public class InterpreterTest {
    @Test
    public void test() {

        String content = "这是一篇文章，文章标题为{{title}}，内容主要是讲{{subject}}，" +
                "目前评分{{score}}分，附带题图{{@picture}}，内容图{{@picture2}}";

        Interpreter interpreter = new Interpreter(content);

        // 套用文字模板进行渲染
        ExpressionStr expressionStr = new ExpressionStr();
        interpreter.addExpression(expressionStr, new HashMap() {{
            put("title", "解释器模式");
            put("subject", "模仿poi-tl的渲染方式展示解释器模式");
            put("score", "3.7");
        }});

        // 套用图片模板进行渲染
        ExpressionPic expressionPic = new ExpressionPic();
        interpreter.addExpression(expressionPic, new HashMap() {{
            put("picture", "/picture/1.jpg");
            put("picture2", "/picture/2.jpg");
        }});

        // 进行解释
        String result = interpreter.interpreter();
        Assertions.assertEquals("这是一篇文章，文章标题为解释器模式，" +
                        "内容主要是讲模仿poi-tl的渲染方式展示解释器模式，" +
                        "目前评分3.7分，附带题图![picture](assets//picture/1.jpg]，" +
                        "内容图![picture2](assets//picture/2.jpg]"
                , result);
    }
}

public interface SqlNode {
    /**
     * 将解析出来的值应用到context中
     */
    boolean apply(DynamicContext context);
}

public class RawSqlSource implements SqlSource {

    private final SqlSource sqlSource;

    public RawSqlSource(Configuration configuration, SqlNode rootSqlNode, Class<?> parameterType) {
        this(configuration, getSql(configuration, rootSqlNode), parameterType);
    }

    public RawSqlSource(Configuration configuration, String sql, Class<?> parameterType) {
        SqlSourceBuilder sqlSourceParser = new SqlSourceBuilder(configuration);
        Class<?> clazz = parameterType == null ? Object.class : parameterType;
        sqlSource = sqlSourceParser.parse(sql, clazz, new HashMap<>());
    }

    /**
     * 通过遍历所有的SqlNode，获取sql
     */
    private static String getSql(Configuration configuration, SqlNode rootSqlNode) {
        DynamicContext context = new DynamicContext(configuration, null);
        rootSqlNode.apply(context);
        return context.getSql();
    }

    @Override
    public BoundSql getBoundSql(Object parameterObject) {
        return sqlSource.getBoundSql(parameterObject);
    }

}

/**
 * 保存一个 CRUD 节点下所含有的所有 SqlNode 集合，方便统一管理以及解析
 */
public class MixedSqlNode implements SqlNode {
    // 记录sql节点中的所有SQL片段
    private final List<SqlNode> contents;

    public MixedSqlNode(List<SqlNode> contents) {
        this.contents = contents;
    }

    @Override
    public boolean apply(DynamicContext context) {
        // 循环调用contents集合中的所有SqlNode对象的apply方法
        contents.forEach(node -> node.apply(context));
        return true;
    }
}

/**
 * 最简单的SqlNode，功能仅仅就是将自身记录的text拼接到context上下文中
 */
public class StaticTextSqlNode implements SqlNode {
    private final String text;

    public StaticTextSqlNode(String text) {
        this.text = text;
    }

    @Override
    public boolean apply(DynamicContext context) {
        context.appendSql(text);
        return true;
    }
}

/**
 * 最常用的 if 标签，满足条件则合并到 contents 中，不满足则抛弃
 */
public class IfSqlNode implements SqlNode {
    private final ExpressionEvaluator evaluator;
    private final String test;
    private final SqlNode contents;

    public IfSqlNode(SqlNode contents, String test) {
        this.test = test;
        this.contents = contents;
        this.evaluator = new ExpressionEvaluator();
    }

    @Override
    public boolean apply(DynamicContext context) {
        if (evaluator.evaluateBoolean(test, context.getBindings())) {
            contents.apply(context);
            return true;
        }
        return false;
    }
}

// ... 其他 SqlNode 的实现略