Mybatis处理动态占位符实现

背景

最近做一个打招呼需求，打招呼的内容类似模板形式，但是模板中有动态占位符，比如：

老乡式打招呼 -> “你好，我也是 xxx 的，我们是老乡呀！”（老乡见老乡，少来这套，来了就是深圳人）

高学历牛逼式打招呼 -> “你好，我是 xxx 高材生，很高兴认识你！” （我心想，谁TM稀罕）

炫富式打招呼 -> “你好，我年薪 xxx，能和你交个朋友么？”（你是想做py交易吧）

模板就是这么简单，内容中的 xxx 是动态的，根据用户信息改变。看到这里的你是不是已经开始躁动了， String.replace()不就解决问题了么？是的，如果你是这么做的，那么恭喜你能快速完成任务！

我这人想的比较多，如果PM后面要把模板改成一个文案中有多个 xxx ，并且多个 xxx 位置顺序不确定的情况怎么办？想到这里我脑海中出现的就是占位符，然后把值存到Map中，key就是 xxx。占位符习惯性想到用 ${xxx}，当时想手撸一个解析${}工具类。由于我本人是比较懒的，绞尽脑汁想这种需求在业界应该很常见，有没有可用的工具类呢？想到工具类就肯定会想到apache的spring，spring加载xml文件中属性一般值会存放在properties文件中，这也是占位符的一种方式。还想到了mybatis中的sql动态替换不也是跟这需求差不多！

Spring动态占位符实现

影像中之前调试spring启动过程看到过对属性处理，后面再次调试是发现了 PropertyPlaceholderHelper，这个需求我就用的是这个工具类来实现的（当时没有撸过mybatis源码），具体代码如下：

public class PropertyPlaceHolderUtil {
    private static final String placeholderPrefix = "${";
    private static final String placeholderSuffix = "}";

    private static final PropertyPlaceholderHelper helper = new PropertyPlaceholderHelper(placeholderPrefix, placeholderSuffix);

    private PropertyPlaceHolderUtil() {
    }

    public static final String replace(String text, Properties props) {
        if (StringUtils.isBlank(text) || props == null || props.isEmpty()) {
            return text;
        }

        return helper.replacePlaceholders(text, props);
    }

}

懒人是不会想着去造轮子的，但必须知道轮子的原理和应用！这个类在 spring-core包中，用到spring框架的应该基本都有该类。

Mybatis动态占位符实现

最近在撸mybatis源码，撸到parsing包（解析器模块）时意外发现Mybatis处理动态占位符实现。主要实现在GenericTokenParser 和 PropertyParser 类中。

GenericTokenParser

public class GenericTokenParser {

  private final String openToken;
  private final String closeToken;
  private final TokenHandler handler;

  public GenericTokenParser(String openToken, String closeToken, TokenHandler handler) {
    this.openToken = openToken;
    this.closeToken = closeToken;
    this.handler = handler;
  }

  public String parse(String text) {
    if (text == null || text.isEmpty()) {
      return "";
    }
    // search open token
    // 寻找开始的 openToken 下标
    int start = text.indexOf(openToken, 0);
    // 如果没有包含 openToken 直接返回
    if (start == -1) {
      return text;
    }
    char[] src = text.toCharArray();
    int offset = 0;
    // 临时存放结果对象
    final StringBuilder builder = new StringBuilder();
    // 匹配到 openToken 和 closeToken 之间的表达式
    StringBuilder expression = null;
    // 循环匹配 ,text中有可能存在多个 ${} ${}
    while (start > -1) {
      // 转义字符
      if (start > 0 && src[start - 1] == '\\') {
        // this open token is escaped. remove the backslash and continue.
        // 因为 openToken 前面一个位置是 \ 转义字符，所以忽略 \
        // 添加 [offset, start - offset - 1] 和 openToken 的内容，添加到 builder 中, 即把 ${ 放到builder中
        builder.append(src, offset, start - offset - 1).append(openToken);
        // 重新修改 offset 值，offset 往后移动
        offset = start + openToken.length();
      } else { // 非转义字符
        // found open token. let's search close token.
        if (expression == null) {
          expression = new StringBuilder();
        } else {
          expression.setLength(0);
        }
        // 添加 offset 和 openToken 之间的内容，添加到 builder 中
        builder.append(src, offset, start - offset);
        // 修改起始下标 offset
        offset = start + openToken.length();
        // 从 下标 offset 往后查找 closeToken 并返回下标值
        int end = text.indexOf(closeToken, offset);
        while (end > -1) {
          // 判断找到的 closeToken 是否是被转义字符修饰的
          if (end > offset && src[end - 1] == '\\') {
            // this close token is escaped. remove the backslash and continue.
            // 被转义字符修饰的 closeToken，把 offset 到该closeToken下标的字符添加到expression中
            expression.append(src, offset, end - offset - 1).append(closeToken);
            // 查找开始下标继续后移
            offset = end + closeToken.length();
            // 下一个 closeToken 所在下标值
            end = text.indexOf(closeToken, offset);
          } else {
            // 添加 offset 到 end 之间的内容到 expression 中， 如 ${key} 把key存放到 expression中
            expression.append(src, offset, end - offset);
            // 查找开始下标继续后移
            offset = end + closeToken.length();
            break;
          }
        }
        if (end == -1) {
          // close token was not found.
          // 如果没有找到closeToken，把剩下的都追加到 builder 中
          builder.append(src, start, src.length - start);
          // 把offset设置成最大下标，跳出外层的 while 循环
          offset = src.length;
        } else {
          // 把匹配到的表达式交给 handler 处理，并把结果追加到 builder 中
          builder.append(handler.handleToken(expression.toString()));
          // 查找开始下标继续后移
          offset = end + closeToken.length();
        }
      }

      // 查询下一个开始的 openToken 下标
      start = text.indexOf(openToken, offset);
    }
    // 拼接剩下内容
    if (offset < src.length) {
      builder.append(src, offset, src.length - offset);
    }
    return builder.toString();
  }
}

该类就是分析 text 中 openToken 和 closeToken成双成对的中间关键字，然后交给 handler 处理。

PropertyParser

public class PropertyParser {

  private static final String KEY_PREFIX = "org.apache.ibatis.parsing.PropertyParser.";
  /**
   * 是否开启默认值，如 ${key:v1} 如果key没有值默认设置 v1
   * The special property key that indicate whether enable a default value on placeholder.
   * <p>
   *   The default value is {@code false} (indicate disable a default value on placeholder)
   *   If you specify the {@code true}, you can specify key and default value on placeholder (e.g. {@code ${db.username:postgres}}).
   * </p>
   * @since 3.4.2
   */
  public static final String KEY_ENABLE_DEFAULT_VALUE = KEY_PREFIX + "enable-default-value";

  /**
   * The special property key that specify a separator for key and default value on placeholder.
   * <p>
   *   The default separator is {@code ":"}.
   * </p>
   * @since 3.4.2
   */
  public static final String KEY_DEFAULT_VALUE_SEPARATOR = KEY_PREFIX + "default-value-separator";
  /**
   * 是否开启设置默认值功能 如 ${key:v1} 如果variables中没有key属性默认设置 v1
   */
  private static final String ENABLE_DEFAULT_VALUE = "false";
  private static final String DEFAULT_VALUE_SEPARATOR = ":";

  private PropertyParser() {
    // Prevent Instantiation
  }

  public static String parse(String string, Properties variables) {
    VariableTokenHandler handler = new VariableTokenHandler(variables);
    // 1. 写死了只处理${}占位符
    GenericTokenParser parser = new GenericTokenParser("${", "}", handler);
    return parser.parse(string);
  }

  private static class VariableTokenHandler implements TokenHandler {
    private final Properties variables;
    /**
     * 是否开启设置默认值功能 如 ${key:v1} 如果variables中没有key属性默认设置 v1
     */
    private final boolean enableDefaultValue;
    /**
     * 默认值分隔符号
     */
    private final String defaultValueSeparator;

    private VariableTokenHandler(Properties variables) {
      this.variables = variables;
      this.enableDefaultValue = Boolean.parseBoolean(getPropertyValue(KEY_ENABLE_DEFAULT_VALUE, ENABLE_DEFAULT_VALUE));
      this.defaultValueSeparator = getPropertyValue(KEY_DEFAULT_VALUE_SEPARATOR, DEFAULT_VALUE_SEPARATOR);
    }

    private String getPropertyValue(String key, String defaultValue) {
      return (variables == null) ? defaultValue : variables.getProperty(key, defaultValue);
    }

    @Override
    public String handleToken(String content) {
      if (variables != null) {
        String key = content;
        // 开启默认值
        if (enableDefaultValue) {
          // 分离key和默认值
          final int separatorIndex = content.indexOf(defaultValueSeparator);
          String defaultValue = null;
          if (separatorIndex >= 0) {
            key = content.substring(0, separatorIndex);
            defaultValue = content.substring(separatorIndex + defaultValueSeparator.length());
          }
          // variables存在key属性直接返回，否则返回默认值
          if (defaultValue != null) {
            return variables.getProperty(key, defaultValue);
          }
        }
        // 没有默认值，如果variables中存在返回该属性值
        if (variables.containsKey(key)) {
          return variables.getProperty(key);
        }
      }
      // 直接返回
      return "${" + content + "}";
    }
  }

}

该类构造函数是private的，注定了他是一个静态工具类。1处写死了只处理${}方式的占位符。

VariableTokenHandler 提供了实现默认值方式。

测试

看源码时最好是用源码提供的测试单元来debug，用GenericTokenParserTest来debug GenericTokenParser实现，用PropertyParserTest 来debug PropertyParser 实现。

总结

作为代码的搬运工，不要轻易的造轮子，因为自己造的轮子可能存在隐患的bug，用开源的工具会安全很多，毕竟那么多开发者帮他们测试过。但是用别人的东西最基本得知道怎么用！！！