Mybatis源码阅读（二）：动态节点解析2.1 —— SqlSource和SqlNode

最新推荐文章于 2023-08-19 15:48:45 发布
最新推荐文章于 2023-08-19 15:48:45 发布
阅读量159 收藏
点赞数
分类专栏： 随手笔记 文章标签： java mybatis dom android math.h
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_41530937/article/details/111048643
版权

*************************************优雅的分割线 **********************************

分享一波:程序员赚外快-必看的巅峰干货

如果以上内容对你觉得有用,并想获取更多的赚钱方式和免费的技术教程

请关注微信公众号:HB荷包
在这里插入图片描述
一个能让你学习技术和赚钱方法的公众号,持续更新

前言

前面的文章介绍了mybatis核心配置文件和mapper文件的解析，之后因为加班比较重，加上个人也比较懒，一拖就是将近半个月，今天抽空开始第二部分的阅读。

由前面的文章可知，mapper文件中定义的Sql节点会被解析成MappedStatement，其中的SQL语句会被解析成SqlSource。而Sql语句中定义的动态sql节点（如if节点、foreach节点）会被解析成SqlNode。SqlNode节点的解析中会使用到Ognl表达式（没错就是是struts2用的那玩意。本以为随着struts2和jsp淡出开发环境，这种动态标签也会随之过时，没想到mybatis里依然沿用了ognl），这个内容介绍起来有点麻烦，因此感兴趣的读者请自行了解一下。
SqlSource

Sql节点中的Sql语句会被解析成SqlSource，SqlSource接口中只定义了一个方法 getBoundSql 。该方法用于表示解析后的Sql语句（带问号）。

/**

  • 该接口用于标识映射文件或者注解中定义的sql语句

  • 这里的sql可能带有#{}等标志

  • @author Clinton Begin
    */
    public interface SqlSource {

    /**

    • 可执行的sql
    • @param parameterObject
    • @return
      */
      BoundSql getBoundSql(Object parameterObject);
      }

[点击并拖拽以移动]

SqlSource的继承关系如下图所示。每个实现类都比较简单，下面只做简单的说明。

DynamicSqlSource用于处理动态语句（带有动态sql标签），RawSqlSource用于处理静态语句（没有动态sql标签），二者最终会解析成StaticSqlSource。StaticSqlSource可能会带有问号。这里暂时只将代码简单的贴出来，部分内容需要结合后面才可以加注释（如SqlNode）

/**

  • 处理静态sql语句

  • @since 3.2.0

  • @author Eduardo Macarron
    */
    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<>());
    }

    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);
    }
    }

/**

  • 负责解析动态sql语句

  • 包含#{}占位符

  • @author Clinton Begin
    */
    public class DynamicSqlSource implements SqlSource {

    private final Configuration configuration;
    private final SqlNode rootSqlNode;

    public DynamicSqlSource(Configuration configuration, SqlNode rootSqlNode) {
    this.configuration = configuration;
    this.rootSqlNode = rootSqlNode;
    }

    @Override
    public BoundSql getBoundSql(Object parameterObject) {
    DynamicContext context = new DynamicContext(configuration, parameterObject);
    rootSqlNode.apply(context);
    SqlSourceBuilder sqlSourceParser = new SqlSourceBuilder(configuration);
    Class<?> parameterType = parameterObject == null ? Object.class : parameterObject.getClass();
    SqlSource sqlSource = sqlSourceParser.parse(context.getSql(), parameterType, context.getBindings());
    BoundSql boundSql = sqlSource.getBoundSql(parameterObject);
    context.getBindings().forEach(boundSql::setAdditionalParameter);
    return boundSql;
    }

}

/**

  • 经过DynamicSqlSource和RawSqlSource处理后

  • 这里存放的sql可能含有？占位符

  • @author Clinton Begin
    */
    public class StaticSqlSource implements SqlSource {

    private final String sql;
    private final List parameterMappings;
    private final Configuration configuration;

    public StaticSqlSource(Configuration configuration, String sql) {
    this(configuration, sql, null);
    }

    public StaticSqlSource(Configuration configuration, String sql, List parameterMappings) {
    this.sql = sql;
    this.parameterMappings = parameterMappings;
    this.configuration = configuration;
    }

    @Override
    public BoundSql getBoundSql(Object parameterObject) {
    return new BoundSql(configuration, sql, parameterMappings, parameterObject);
    }

}

ProviderSqlSource暂时不贴出来（还没读到这里）
DynamicContext

DynamicContext用于记录解析动态Sql时产生的Sql片段。这里也先将主要代码放出来。

/**

  • 用于记录解析动态SQL语句之后产生的SQL语句片段

  • 可以认为它是一个用于记录动态SQL语句解析生产的容器

  • @author Clinton Begin
    */
    public class DynamicContext {

    public static final String PARAMETER_OBJECT_KEY = “_parameter”;
    public static final String DATABASE_ID_KEY = “_databaseId”;

    static {
    OgnlRuntime.setPropertyAccessor(ContextMap.class, new ContextAccessor());
    }

    /**

    • 参数上下文
      /
      private final ContextMap bindings;
      /      *
    • 在SQL弄得解析动态SQL时，会将解析后的SQL语句片段添加到该属性总保存
    • 最终拼凑出一条完整的SQL
      */
      private final StringJoiner sqlBuilder = new StringJoiner(" ");
      private int uniqueNumber = 0;

    /**

    • 构造中初始化bindings集合
    • @param configuration
    • @param parameterObject 运行时用户传入的参数。
      */
      public DynamicContext(Configuration configuration, Object parameterObject) {
      if (parameterObject != null && !(parameterObject instanceof Map)) {
      // 非Map就去找对应的类型处理器
      MetaObject metaObject = configuration.newMetaObject(parameterObject);
      boolean existsTypeHandler = configuration.getTypeHandlerRegistry().hasTypeHandler(parameterObject.getClass());
      bindings = new ContextMap(metaObject, existsTypeHandler);
      } else {
      bindings = new ContextMap(null, false);
      }
      bindings.put(PARAMETER_OBJECT_KEY, parameterObject);
      bindings.put(DATABASE_ID_KEY, configuration.getDatabaseId());
      }

    public Map<String, Object> getBindings() {
    return bindings;
    }

    public void bind(String name, Object value) {
    bindings.put(name, value);
    }

    /**

    • 追加SQL片段
    • @param sql
      */
      public void appendSql(String sql) {
      sqlBuilder.add(sql);
      }

    /**

    • 获取解析后的SQL语句
    • @return
      */
      public String getSql() {
      return sqlBuilder.toString().trim();
      }

    public int getUniqueNumber() {
    return uniqueNumber++;
    }

}

SqlNode

SqlNode表示Sql节点中的动态Sql。该类（接口）只有一个apply方法，用于解析动态Sql节点，并调用DynamicContext的appendSql方法去拼接sql语句。

/**

  • @author Clinton Begin
    */
    public interface SqlNode {

    /**

    • 根据用户传入的实参去解析动态SQL节点
    • 并调用DynamicContext.appendSql将解析后的SQL片段
    • 追加到DynamicContext.sqlBuilder保存
    • @param context
    • @return
      */
      boolean apply(DynamicContext context);
      }

SqlNode实现类很多，如图所示。光看实现类的名称，想必大家都可以猜出这些实现类的作用了。下面将对这些实现类一一解释

StaticTextSqlNode使用text字段记录非动态Sql节点，apply方法直接将text字段追加到DynamicContext.sqlBuilder；MixedSqlNode中使用contents字段存放子节点的动态sql，apply方法则是遍历contents去调用每个SqlNode的apply方法，代码都比较简单就不贴出来了。
TextSqlNode

TextSqlNode表示包含 的 s q l 节 点 ， i s D y n a m i c 方 法 用 于 检 测 s q l 中 是 否 包 含 {}的sql节点，isDynamic方法用于检测sql中是否包含 的sql节点，isDynamic方法用于检测sql中是否包含{}占位符。该类的apply方法会使用GenericTokenParser将 占 位 符 解 析 成 实 际 意 义 的 参 数 值 ， 因 此 {}占位符解析成实际意义的参数值，因此 占位符解析成实际意义的参数值，因此{}在mybatis中会有注入风险，应当慎用，尽量用于非前端传递的参数。这里比较特殊的场景就是order by。order by后面只能使用${}占位符，因此前端操作排序列时，务必要做防注入处理。

/**

  • 包含${}的sql

  • @author Clinton Begin
    */
    public class TextSqlNode implements SqlNode {
    private final String text;
    private final Pattern injectionFilter;

    public TextSqlNode(String text) {
    this(text, null);
    }

    public TextSqlNode(String text, Pattern injectionFilter) {
    this.text = text;
    this.injectionFilter = injectionFilter;
    }

    public boolean isDynamic() {
    DynamicCheckerTokenParser checker = new DynamicCheckerTokenParser();
    GenericTokenParser parser = createParser(checker);
    parser.parse(text);
    return checker.isDynamic();
    }

    @Override
    public boolean apply(DynamicContext context) {
    GenericTokenParser parser = createParser(new BindingTokenParser(context, injectionFilter));
    context.appendSql(parser.parse(text));
    return true;
    }

    private GenericTokenParser createParser(TokenHandler handler) {
    // 这里标识解析的是 占 位 符 r e t u r n n e w G e n e r i c T o k e n P a r s e r ( " {}占位符 return new GenericTokenParser(" 占位符returnnewGenericTokenParser("{", “}”, handler);
    }

    private static class BindingTokenParser implements TokenHandler {

     private DynamicContext context;
 private Pattern injectionFilter;

 public BindingTokenParser(DynamicContext context, Pattern injectionFilter) {
     this.context = context;
     this.injectionFilter = injectionFilter;
 }

 @Override
 public String handleToken(String content) {
     // 获取用户提供的实参
     Object parameter = context.getBindings().get("_parameter");
     if (parameter == null) {
         context.getBindings().put("value", null);
     } else if (SimpleTypeRegistry.isSimpleType(parameter.getClass())) {
         context.getBindings().put("value", parameter);
     }
     // 通过ognl解析content的值
     Object value = OgnlCache.getValue(content, context.getBindings());
     String srtValue = value == null ? "" : String.valueOf(value); // issue #274 return "" instead of "null"
     checkInjection(srtValue);
     return srtValue;
 }

 private void checkInjection(String value) {
     if (injectionFilter != null && !injectionFilter.matcher(value).matches()) {
         throw new ScriptingException("Invalid input. Please conform to regex" + injectionFilter.pattern());
     }
 }

    }

    private static class DynamicCheckerTokenParser implements TokenHandler {

     private boolean isDynamic;

 public DynamicCheckerTokenParser() {
     // Prevent Synthetic Access
 }

 public boolean isDynamic() {
     return isDynamic;
 }

 @Override
 public String handleToken(String content) {
     this.isDynamic = true;
     return null;
 }

    }

}

IfSqlNode

该类表示mybatis中的if标签。if标签中使用的其实就是Ognl语句，因此可以有一些很花哨的写法，如调用参数的equals方法等，这里不对Ognl表达式做过多的介绍。

/**

  • if节点

  • @author Clinton Begin
    /
    public class IfSqlNode implements SqlNode {
    /    *

    • if节点的test表达式值
      /
      private final ExpressionEvaluator evaluator;
      /      *
    • if节点的test表达式
      /
      private final String test;
      /      *
    • if节点的子节点
      */
      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) {
    // 检测表达式是否为true，来决定是否执行apply方法
    if (evaluator.evaluateBoolean(test, context.getBindings())) {
    contents.apply(context);
    return true;
    }
    return false;
    }

}

TrimSqlNode

trimSqlNode用于根据解析结果添加或删除后缀活前缀。

/**

  • 根据解析结果添加或删除后缀或前缀

  • @author Clinton Begin
    */
    public class TrimSqlNode implements SqlNode {

    /**

    • trim节点的子节点
      /
      private final SqlNode contents;
      /      *
    • 前缀
      /
      private final String prefix;
      /      *
    • 后缀
      /
      private final String suffix;
      /      *
    • 如果trim节点包裹的SQL是空语句，删除指定的前缀，如where
      /
      private final List prefixesToOverride;
      /      *
    • 如果trim节点包裹的SQL是空语句，删除指定的后缀，如逗号
      */
      private final List suffixesToOverride;
      private final Configuration configuration;

    public TrimSqlNode(Configuration configuration, SqlNode contents, String prefix, String prefixesToOverride, String suffix, String suffixesToOverride) {
    this(configuration, contents, prefix, parseOverrides(prefixesToOverride), suffix, parseOverrides(suffixesToOverride));
    }

    protected TrimSqlNode(Configuration configuration, SqlNode contents, String prefix, List prefixesToOverride, String suffix, List suffixesToOverride) {
    this.contents = contents;
    this.prefix = prefix;
    this.prefixesToOverride = prefixesToOverride;
    this.suffix = suffix;
    this.suffixesToOverride = suffixesToOverride;
    this.configuration = configuration;
    }

    @Override
    public boolean apply(DynamicContext context) {
    FilteredDynamicContext filteredDynamicContext = new FilteredDynamicContext(context);
    boolean result = contents.apply(filteredDynamicContext);
    // 处理前缀和后缀
    filteredDynamicContext.applyAll();
    return result;
    }

    /**

    • 对prefixOverrides和suffixOverride属性解析
    • 并初始化两个Override集合
    • @param overrides
    • @return
      */
      private static List parseOverrides(String overrides) {
      if (overrides != null) {
      // 使用|分隔
      final StringTokenizer parser = new StringTokenizer(overrides, “|”, false);
      final List list = new ArrayList<>(parser.countTokens());
      while (parser.hasMoreTokens()) {
      list.add(parser.nextToken().toUpperCase(Locale.ENGLISH));
      }
      return list;
      }
      return Collections.emptyList();
      }

    private class FilteredDynamicContext extends DynamicContext {
    /**
    * 上下文对象
    /
    private DynamicContext delegate;
    /    *
    * 标识已经处理过的前缀和后缀
    /
    private boolean prefixApplied;
    private boolean suffixApplied;
    /    *
    * 记录子节点解析后的结果
    */
    private StringBuilder sqlBuffer;

     public FilteredDynamicContext(DynamicContext delegate) {
     super(configuration, null);
     this.delegate = delegate;
     this.prefixApplied = false;
     this.suffixApplied = false;
     this.sqlBuffer = new StringBuilder();
 }

 public void applyAll() {
     sqlBuffer = new StringBuilder(sqlBuffer.toString().trim());
     String trimmedUppercaseSql = sqlBuffer.toString().toUpperCase(Locale.ENGLISH);
     if (trimmedUppercaseSql.length() > 0) {
         applyPrefix(sqlBuffer, trimmedUppercaseSql);
         applySuffix(sqlBuffer, trimmedUppercaseSql);
     }
     delegate.appendSql(sqlBuffer.toString());
 }

 @Override
 public Map<String, Object> getBindings() {
     return delegate.getBindings();
 }

 @Override
 public void bind(String name, Object value) {
     delegate.bind(name, value);
 }

 @Override
 public int getUniqueNumber() {
     return delegate.getUniqueNumber();
 }

 @Override
 public void appendSql(String sql) {
     sqlBuffer.append(sql);
 }

 @Override
 public String getSql() {
     return delegate.getSql();
 }

 /**
  * 处理前缀
  *
  * @param sql sql
  * @param trimmedUppercaseSql 小写sql
  */
 private void applyPrefix(StringBuilder sql, String trimmedUppercaseSql) {
     if (!prefixApplied) {
         prefixApplied = true;
         if (prefixesToOverride != null) {
             for (String toRemove : prefixesToOverride) {
                 // 遍历prefixesToOverride，如果以其中的某项开头就从SQL语句开头剔除
                 if (trimmedUppercaseSql.startsWith(toRemove)) {
                     sql.delete(0, toRemove.trim().length());
                     break;
                 }
             }
         }
         if (prefix != null) {
             sql.insert(0, " ");
             sql.insert(0, prefix);
         }
     }
 }

 /**
  * 处理后缀。
  * @param sql
  * @param trimmedUppercaseSql
  */
 private void applySuffix(StringBuilder sql, String trimmedUppercaseSql) {
     if (!suffixApplied) {
         suffixApplied = true;
         if (suffixesToOverride != null) {
             for (String toRemove : suffixesToOverride) {
                 if (trimmedUppercaseSql.endsWith(toRemove) || trimmedUppercaseSql.endsWith(toRemove.trim())) {
                     int start = sql.length() - toRemove.trim().length();
                     int end = sql.length();
                     sql.delete(start, end);
                     break;
                 }
             }
         }
         if (suffix != null) {
             sql.append(" ");
             sql.append(suffix);
         }
     }
 }

    }

}

WhereSqlNode&SetSqlNode

WhereSqlNode和SetSqlNode分别表示where节点和set节点。这两个类继承了TrimSqlNode，因此自带处理前后缀的功能。

WhereSqlNode将and、or两个关键字作为需要删除的前缀。当where的第一个条件以这两个开头时，会将and或者or删除。而SetSqlNode则会删除前缀或者后缀的嘤文逗号。这里只贴出WhereSqlNode代码。

/**

  • where节点。继承了TrimSqlNode

  • 因此where节点自带处理前缀后缀功能

  • @author Clinton Begin
    */
    public class WhereSqlNode extends TrimSqlNode {

    /**

    • 设置前缀是OR和AND，因此解析后的SQL如果以这俩开头就会删掉前缀
      */
      private static List prefixList = Arrays.asList("AND ", "OR ", “AND\n”, “OR\n”, “AND\r”, “OR\r”, “AND\t”, “OR\t”);

    public WhereSqlNode(Configuration configuration, SqlNode contents) {
    super(configuration, contents, “WHERE”, prefixList, null, null);
    }

}

ForeachSqlNode

在动态Sql语句中构建in条件时，往往需要遍历一个集合，因此使用foreach标签。这里需要着重介绍一下FilteredDynamicContext这个内部类。该类继承了DynamicContext，用来处理foreach中的#{}占位符。这里是对其不完全的处理。如#{item}会被处理乘#{__frch_item_index值}这种格式，用来表示遍历中的每一项。

/**

  • forEach节点

  • @author Clinton Begin
    */
    public class ForEachSqlNode implements SqlNode {
    public static final String ITEM_PREFIX = “_frch”;

    /**

    • 判断循环终止的条件
      /
      private final ExpressionEvaluator evaluator;
      /      *
    • 迭代的集合表达式
      /
      private final String collectionExpression;
      /      *
    • 该节点下的节点
      /
      private final SqlNode contents;
      /      *
    • 循环前以什么开头
      /
      private final String open;
      /      *
    • 循环后以什么结束
      /
      private final String close;
      /      *
    • 循环过程中的分隔符
      /
      private final String separator;
      /      *
    • 每次循环的变量名
      /
      private final String item;
      /      *
    • 当前迭代次数
      */
      private final String index;
      private final Configuration configuration;

    public ForEachSqlNode(Configuration configuration, SqlNode contents, String collectionExpression, String index, String item, String open, String close, String separator) {
    this.evaluator = new ExpressionEvaluator();
    this.collectionExpression = collectionExpression;
    this.contents = contents;
    this.open = open;
    this.close = close;
    this.separator = separator;
    this.index = index;
    this.item = item;
    this.configuration = configuration;
    }

    @Override
    public boolean apply(DynamicContext context) {
    Map<String, Object> bindings = context.getBindings();
    final Iterable<?> iterable = evaluator.evaluateIterable(collectionExpression, bindings);
    if (!iterable.iterator().hasNext()) {
    return true;
    }
    boolean first = true;
    // 循环之前添加open指定的字符串
    applyOpen(context);
    int i = 0;
    for (Object o : iterable) {
    DynamicContext oldContext = context;
    if (first || separator == null) {
    // 是第一个循环，并且没有间隔符
    context = new PrefixedContext(context, “”);
    } else {
    context = new PrefixedContext(context, separator);
    }
    int uniqueNumber = context.getUniqueNumber();
    // 将index和item添加到DynamicContext.bindings集合
    if (o instanceof Map.Entry) {
    @SuppressWarnings(“unchecked”)
    Map.Entry<Object, Object> mapEntry = (Map.Entry<Object, Object>) o;
    applyIndex(context, mapEntry.getKey(), uniqueNumber);
    applyItem(context, mapEntry.getValue(), uniqueNumber);
    } else {
    applyIndex(context, i, uniqueNumber);
    applyItem(context, o, uniqueNumber);
    }
    // 调用子节点的apply急需处理
    contents.apply(new FilteredDynamicContext(configuration, context, index, item, uniqueNumber));
    if (first) {
    first = !((PrefixedContext) context).isPrefixApplied();
    }
    context = oldContext;
    i++;
    }
    // 拼接close
    applyClose(context);
    context.getBindings().remove(item);
    context.getBindings().remove(index);
    return true;
    }

    private void applyIndex(DynamicContext context, Object o, int i) {
    if (index != null) {
    context.bind(index, o);
    context.bind(itemizeItem(index, i), o);
    }
    }

    private void applyItem(DynamicContext context, Object o, int i) {
    if (item != null) {
    context.bind(item, o);
    context.bind(itemizeItem(item, i), o);
    }
    }

    private void applyOpen(DynamicContext context) {
    if (open != null) {
    context.appendSql(open);
    }
    }

    private void applyClose(DynamicContext context) {
    if (close != null) {
    context.appendSql(close);
    }
    }

    private static String itemizeItem(String item, int i) {
    return ITEM_PREFIX + item + “_” + i;
    }

    /**

    • 处理#{}(不完全处理)
      */
      private static class FilteredDynamicContext extends DynamicContext {
      private final DynamicContext delegate;
      private final int index;
      private final String itemIndex;
      private final String item;

      public FilteredDynamicContext(Configuration configuration, DynamicContext delegate, String itemIndex, String item, int i) {
      super(configuration, null);
      this.delegate = delegate;
      this.index = i;
      this.itemIndex = itemIndex;
      this.item = item;
      }

      @Override
      public Map<String, Object> getBindings() {
      return delegate.getBindings();
      }

      @Override
      public void bind(String name, Object value) {
      delegate.bind(name, value);
      }

      @Override
      public String getSql() {
      return delegate.getSql();
      }

      /**

      • 这里会将#{item}占位符解析成#{__frch_item_index值}

      • @param sql
        /
        @Override
        public void appendSql(String sql) {
        GenericTokenParser parser = new GenericTokenParser("#{", “}”, content -> {
        String newContent = content.replaceFirst("^\s        " + item + “(?![^.,:\s])”, itemizeItem(item, index));
        if (itemIndex != null && newContent.equals(content)) {
        newContent = content.replaceFirst("^\s*" + itemIndex + “(?![^.,:\s])”, itemizeItem(itemIndex, index));
        }
        return “#{” + newContent + “}”;
        });

        delegate.appendSql(parser.parse(sql));
        }

      @Override
      public int getUniqueNumber() {
      return delegate.getUniqueNumber();
      }

    }

    private class PrefixedContext extends DynamicContext {
    private final DynamicContext delegate;
    private final String prefix;
    private boolean prefixApplied;

     public PrefixedContext(DynamicContext delegate, String prefix) {
     super(configuration, null);
     this.delegate = delegate;
     this.prefix = prefix;
     this.prefixApplied = false;
 }

 public boolean isPrefixApplied() {
     return prefixApplied;
 }

 @Override
 public Map<String, Object> getBindings() {
     return delegate.getBindings();
 }

 @Override
 public void bind(String name, Object value) {
     delegate.bind(name, value);
 }

 @Override
 public void appendSql(String sql) {
     if (!prefixApplied && sql != null && sql.trim().length() > 0) {
         delegate.appendSql(prefix);
         prefixApplied = true;
     }
     delegate.appendSql(sql);
 }

 @Override
 public String getSql() {
     return delegate.getSql();
 }

 @Override
 public int getUniqueNumber() {
     return delegate.getUniqueNumber();
 }

    }

}

剩余的如ChooseSqlNode请读者自行阅读，代码也都比较容易理解。
结语

本次文章只是介绍一下动态sql解析时常用的类和接口，之后的文章对动态sql进行介绍时将不再对这些类进行赘述。

最后说一些闲话。

其实坚持写博客是一件很难的事情。七月份入职以来，便开始考虑写博客的事，起初不知道从哪写起，博客质量并不高。后来慢慢爱上了阅读源码这件事。其实mybatis源码我已经参照某本书读完了，但是阅读完之后我并没有觉得有何收获和见解，对源码的理解也比较浅显，因此便想着通过撰写博客的方式去加深对源码的认知。Mybatis插件机制是很重要的特性，而想编写一个好的插件就需要对源码有深刻的理解，因此源码不得不读，对于一个java程序员来说这也是必修课。在这几篇博客的撰写下，我慢慢养成了写博客的习惯，也知道什么该写，什么不该写。博客中大部分的内容其实都在代码注释上，因此显得博客内容不多，需要阅读者仔细阅读代码注释（但愿我的博客有人看吧。）。养成一个习惯不容易，这段时间划水的过程中对撰写博客这件事也有所懈怠（说实话差点都忘了我还开了这么大一个坑。）

*************************************优雅的分割线 **********************************

分享一波:程序员赚外快-必看的巅峰干货

如果以上内容对你觉得有用,并想获取更多的赚钱方式和免费的技术教程

请关注微信公众号:HB荷包
在这里插入图片描述
一个能让你学习技术和赚钱方法的公众号,持续更新

HB荷包
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Mybatis源码阅读（三）：结果集映射3.3 —— 主键生成策略
12-14
在前面两篇博客中，我们介绍了对于select语句的简单映射和嵌套映射。mybatis中使用ResultHandler等一系列的类，将查询结果封装到实体类中，可以说是mybatis中最复杂的过程，而剩下的insert、update、delete语句的...
mybatis之SQLNode&SqlSource
a1047003619的博客
05-18 640
SqlNode&SqlSource 1.DynamicContext DynamicContext主要用于记录解析动态SQL语句之后产生的SQL语句片段，可以认为它是一个用于记录动态SQL语句解析结果的容器。DynamicContext中核心字段 含义如下： // 参数上下文 private final ContextMap bindings; // 在SqlNode解析动态SQL时，会将解析后的SQL片段添加到该属性中保存，最终拼凑出一条完成的SQL语句 private final
Mybatis的SqlSource & SqlNode & BoundSql
最新发布
pscool的博客
08-19 727
Mybatis的SqlSource&SqlNode - processon。
mybatis源码学习------动态sql的解析(SqlNode)
我是兴锅的博客
11-04 2013
123
MyBatis 基石之 SqlNode
qq_42419406的博客
07-20 997
平时我们基于 MyBaits 框架进行编写的 Mapper.xml 中每一个 `insert/update/delete/select` 标签里面的每一行 SQL（包括 include 标签被替换成 SQL ） 文本被抽象为 SqlNode。
MyBatisCN:《通用通用阅读指导书——MyBatis源码详解》配套注释版
03-23
《通用源码阅读指导书——MyBatis源码详解》以MyBatis源码中的包为单位，详细和透彻地介绍每个类的源码，包括其背景知识，组织方式，逻辑结构，实现细节。在本书的在阅读MyBatis源码的过程中，本书使用了运行初探，...
MyBatis源码分析.pdf
05-23
MyBatis会将节点解析到Properties对象中，然后将其设置到Configuration对象中。 2.1.2 解析节点 节点用于定义MyBatis的全局设置，包括日志记录、缓存设置等。MyBatis会将节点解析到Settings对象中，然后将其设置到...
MyBatis 源码解析：通过源码深入理解 SQL 的执行过程 - GitChat
05-13
MyBatis 源码解析：通过源码深入理解 SQL 的执行过程 抓下来打包成了HTML文件, 方便离线观看
mybatis解析动态xml sql
12-09
项目需要springboot 可以绕过mybatis xml加载直接解析带标签的sql 演示代码，给需要的码农
MyBatis（技术NeiMu）：核心处理层（SqlNode和SqlSource）
GDUT_Trim的博客
12-12 891
回顾SqlNode与SqlSourceSqlSource组合模式OGNL表达式OgnlCacheDynamicContextContextMapSqlNodeMixedSqlNodeStaticSqlNodeTextSqlNodeSqlSourceBuilderParameterMappingTokenHandlerParameterMappingBoundSqlDynamicSqlSource总结一下动态SQL的解析拓展：${}和#{}的区别RawSqlSource 回顾 前面我们已经看了整个MyBat.
mybatis 如何获取sql并设置值
cgj296645438的博客
02-11 2320
目录 初始化阶段 构造MixedSqlNode 解析标签 构造SqlNode 例子 阶段总结1 构造SqlSource 阶段总结2 在JDBC用PreparedStatement编程访问数据库时，都需要先用带有占位符(如果存在参数的话)sql创建PreparedStatement，然后在根据数据库类型设置值。这块在mybatis是如何实现的呢。 初始化阶段 构造MixedSqlNode 解析标签 具体的sql解析是在解析mapper.xml的四种标签select|insert|up
mybatis 动态sql 源码解析
master_boy的博客
04-29 1113
mybatis 动态sql 测试例子 java程序 xml文件 调试 直接进入到解析select语句的地方 进入 解析xml 进入buildStatementFromContext,依然是交给XMLStatementBuilder解析 核心部分创建SqlSource 交给XMLLanguageDriver后再转到XMLScriptBuilder 先读取xm...
Mybatis如何获取SQL语句
qq_45621336的博客
05-11 5164
Mybatis如何获取SQL语句 一、获取映射文件xml 在我们的mybatis-config.xml文件里面，有这么一个标签 <mappers> <mapper resource="mybatis/UserMapper.xml"/> </mappers> 众所周知，这个绑定的是写SQL语句的文件，所以说，谁去解析的上面的这个xml文件，谁就能拿到SQL语句 那这个文件将会被哪个标签或者哪个类加载呢？我们知道UserMapper.xml文
【Mybatis源码分析】动态标签的底层原理，DynamicSqlSource源码分析
qq_63691275的博客
04-29 1988
DynamicSqlSource 是用 DynamicContext 对象中的 sqlBuilder 对象进行动态Sql片段拼接的，它是一个StringJoiner对象，以空格分隔开片段。 解析映射xml中的动态sql标签是封装在SqlNode对象中，其中是通过 MixedSqlNode 混合 SqlNode 进行遍历，然后通过递归的一种形式进行处理的。 SqlSourceBuilder.parse 进行了sql 最后的处理，处理了#{}，并对参数进行了封装。
《Mybatis源码》第13章 SqlSource
迦南学院
11-25 487
总结 SqlSource 负责执行静态编译 / 动态编译 SqlNode 负责处理解析各种动态SQL BoudnSql 负责保存解析SQL后的最终结果 将 #{} 替换成 ？ 是在SqlSourceBuilder中，并且创建ParameterMapping 将 ${}解析成对应的值，会在TextSqNode中完成 一、BoundSql BoundSql 主要为SQL解析之后的实体类，包含 sql 和 参数映射 public class BoundSql { // SQL语句 private f
MyBatis核心处理层：MyBatis初始化流程补充(动态sql解析)
自恃无情的博客
01-19 349
1：概述        在写完MyBaits核心处理层时，总感觉对于动态sql语句的解析没有写清楚，所以对于SqlNode，SqlSource这两个类相关的东西再写一篇博客，也算是对MyBatis源码的相关知识点的一次回顾，童鞋在看完这篇的时候，可以再回顾一下MyBatis初始化流程下，可能对sql语句解析的章节理解起来更容易。其实SqlNode和SqlSo...
MyBatis源码的学习（14）---SqlSource和SqlNode
itw_zhangzx02的博客
12-29 671
sqlSource接口中最底层的，最基础的是： StaticSqlSource，里面sql字段用于存放解析好的sql，比如将'#{}'替换为“?”占位符 BoundSql getBoundSql(Object parameterObject); RawSqlSource--.>StaticSqlSource-- >sql 常规的解析Mapper.xml的时候，我们创建S...
mybaits源码分析（七） SqlSource及动态sql解析详细分析
shuixiou1的博客
02-06 608
SqlSource及动态sql解析 mybaits可以通过#{}的方式插值，也可以${}方式拼接，另外一个最强大的功能就是可以动态的解析sql语句,而不管动态解析还是静态解析，sql都是通过不同的SqlSource实现进包装的，本文将深入讲解动态sql解析。 一、sql解析加载的分析 1、主干解析方法XMLScriptBuilder的parseScriptNode。 a) 解析<select>语句标签的Node节点 public SqlSource par...
Mybatis入门进阶教程：动态SQL与缓存解析
"这是一份针对Java开发者的Mybatis基础入门学习笔记，旨在帮助新手理解并掌握Mybatis的核心概念，特别是第三天的进阶内容，包括动态Sql、Sql片段、缓存机制等知识点。" 在Mybatis的学习过程中，动态Sql是一个重要的...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值