Mybatis SqlNode

已于 2022-12-01 15:09:03 修改
阅读量336 收藏
点赞数
分类专栏： Mybatis 文章标签： java spring boot 开发语言
于 2022-05-13 08:30:00 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/lijinxiong520/article/details/124742069
版权

我们在以前的文章中曾经介绍过 OGNL 强大的表达式引擎

我们知道在 BaseExecutor#query 中

@Override
public <E> List<E> query(MappedStatement ms, Object parameter, RowBounds rowBounds, ResultHandler resultHandler) throws SQLException {
  BoundSql boundSql = ms.getBoundSql(parameter);
  CacheKey key = createCacheKey(ms, parameter, rowBounds, boundSql);
  return query(ms, parameter, rowBounds, resultHandler, key, boundSql);
}

我们会通过 MappedStatement 获取解释之后的 Sql

public BoundSql getBoundSql(Object parameterObject) {
  BoundSql boundSql = sqlSource.getBoundSql(parameterObject);
  List<ParameterMapping> parameterMappings = boundSql.getParameterMappings();
  if (parameterMappings == null || parameterMappings.isEmpty()) {
    boundSql = new BoundSql(configuration, boundSql.getSql(), parameterMap.getParameterMappings(), parameterObject);
  }

  // check for nested result maps in parameter mappings (issue #30)
  for (ParameterMapping pm : boundSql.getParameterMappings()) {
    String rmId = pm.getResultMapId();
    if (rmId != null) {
      ResultMap rm = configuration.getResultMap(rmId);
      if (rm != null) {
        hasNestedResultMaps |= rm.hasNestedResultMaps();
      }
    }
  }
  return boundSql;
}

Mybatis 中存在两种 SqlSource

public SqlSource parseScriptNode() {
  MixedSqlNode rootSqlNode = parseDynamicTags(context);
  SqlSource sqlSource;
  if (isDynamic) {
    sqlSource = new DynamicSqlSource(configuration, rootSqlNode);
  } else {
    sqlSource = new RawSqlSource(configuration, rootSqlNode, parameterType);
  }
  return sqlSource;
}

一种是动态 Sql 一种是静态 Sql

对于静态 Sql、不需要解释和处理

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

动态 Sql

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

DynamicContext

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;
  private final StringJoiner sqlBuilder = new StringJoiner(" ");
  private int uniqueNumber = 0;
  ......

主要存在两个成员变量 sqlBuilder 的类型为 StringJoiner 、JDK 类不再介绍

主要看看 bindings

static class ContextMap extends HashMap<String, Object> {
  private static final long serialVersionUID = 2977601501966151582L;
  private final MetaObject parameterMetaObject;
  private final boolean fallbackParameterObject;

  public ContextMap(MetaObject parameterMetaObject, boolean fallbackParameterObject) {
    this.parameterMetaObject = parameterMetaObject;
    this.fallbackParameterObject = fallbackParameterObject;
  }

  @Override
  public Object get(Object key) {
    String strKey = (String) key;
    if (super.containsKey(strKey)) {
      return super.get(strKey);
    }

    if (parameterMetaObject == null) {
      return null;
    }

    if (fallbackParameterObject && !parameterMetaObject.hasGetter(strKey)) {
      return parameterMetaObject.getOriginalObject();
    } else {
      // issue #61 do not modify the context when reading
      return parameterMetaObject.getValue(strKey);
    }
  }
}

是 HashMap 、重写了 get 方法。

  • 首先，尝试按照 Map 的规则查找 Key，如果查找成功直接返回；
  • 如果 parameterMetaObject 为 null 直接返回 null
  • 如果 parameterMetaObject 不为 null 、并且 fallbackParameterObject 为 false 或者 parameterMetaObject 有这个属性的 get 方法、那么就调用 getValue 尝试获取值
  • 如果 parameterMetaObject 不为 null、并且 fallbackParameterObject 为 true (其实就是查询的参数的类型存在类型转换器)、并且不存在 get 方法、那么就直接返回这个查询参数

创建 ContextMap 在 DynamicContext 构造函数中

public DynamicContext(Configuration configuration, Object parameterObject) {
  if (parameterObject != null && !(parameterObject instanceof Map)) {
    MetaObject metaObject = configuration.newMetaObject(parameterObject);
    boolean existsTypeHandler = configuration.getTypeHandlerRegistry().hasTypeHandler(parameterObject.getClass());
    bindings = new ContextMap(metaObject, existsTypeHandler);
  } else {
    bindings = new ContextMap(null, false);
  }
  // 这里实参对应的Key是_parameter
  bindings.put(PARAMETER_OBJECT_KEY, parameterObject);
  bindings.put(DATABASE_ID_KEY, configuration.getDatabaseId());
}
  • 对于非Map类型的实参，会创建对应的MetaObject对象，并封装成ContextMap对象
  • 对于Map类型的实参，这里会创建一个空的ContextMap对象

SqlNode

创建玩 DynamicContext 之后、就会调用 SqlNode 的 apply 方法

  rootSqlNode.apply(context);

微信公众号:CoderLi

public interface SqlNode {
  boolean apply(DynamicContext context);
}

apply 方法会根据用户传入的参数、解析 SqlNode 所表示的动态 SQL 内容并将解释之后的 Sql 片段追加到 Dynamic 中的 StringJoiner 类型的变量上、当 SQL 中全部动态片段都解释完成之后、就可以从 DynamicContext 中 StringJoiner 中获取到一条完整的 SQL

StaticTextSqlNode

用于表示非动态的 SQL 片段、啥都不用干、直接将对应的 Sql 字符串拼接到 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;
  }
}

MixedSqlNode

在整个 SqlNode 中充当了树枝节点、主要作用就是组织聚合其他 SqlNode。

public class MixedSqlNode implements SqlNode {
  private final List<SqlNode> contents;

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

  @Override
  public boolean apply(DynamicContext context) {
    contents.forEach(node -> node.apply(context));
    return true;
  }
}

apply 方法直接遍历集合中的 SqlNode 的 apply 方法。

TextSqlNode

包含了 ${} 占位符的动态 SQL 片段、在 apply 方法中集合用户给定的参数解释 ${} 占位符

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

使用 GenericTokenParser 识别 ${} 占位符、在识别到占位符之后、会通过 BindingTokenParser 将占位符替换为用户传入的参数。

private GenericTokenParser createParser(TokenHandler handler) {
  return new GenericTokenParser("${", "}", handler);
}

public String parse(String text) {
  if (text == null || text.isEmpty()) {
    return "";
  }
  // search open token
  int start = text.indexOf(openToken);
  if (start == -1) {
    return text;
  }
  char[] src = text.toCharArray();
  int offset = 0;
  final StringBuilder builder = new StringBuilder();
  StringBuilder expression = null;
  do {
    if (start > 0 && src[start - 1] == '\\') {
      // this open token is escaped. remove the backslash and continue.
      builder.append(src, offset, start - offset - 1).append(openToken);
      offset = start + openToken.length();
    } else {
      // found open token. let's search close token.
      if (expression == null) {
        expression = new StringBuilder();
      } else {
        expression.setLength(0);
      }
      builder.append(src, offset, start - offset);
      offset = start + openToken.length();
      int end = text.indexOf(closeToken, offset);
      while (end > -1) {
        if (end > offset && src[end - 1] == '\\') {
          // this close token is escaped. remove the backslash and continue.
          expression.append(src, offset, end - offset - 1).append(closeToken);
          offset = end + closeToken.length();
          end = text.indexOf(closeToken, offset);
        } else {
          expression.append(src, offset, end - offset);
          break;
        }
      }
      if (end == -1) {
        // close token was not found.
        builder.append(src, start, src.length - start);
        offset = src.length;
      } else {
        builder.append(handler.handleToken(expression.toString()));
        offset = end + closeToken.length();
      }
    }
    start = text.indexOf(openToken, offset);
  } while (start > -1);
  if (offset < src.length) {
    builder.append(src, offset, src.length - offset);
  }
  return builder.toString();
}

parse 方法会调用 handleToken 方法

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

IfSqlNode

对应的是 <if> 标签、在 Mybatis 中、使用 <if> 标签可以通过 test 属性置顶一个表达式、当表达式成立时、<if> 标签内的 SQL 片段才会出现在完整的 SQL 语句中

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

在 IfSqlNode 中的 apply 方法实现中、会依赖 ExpressionEvaluator 工具类解释 test 表达式、只有 test 表达式为 true 、才会调用子 SqlNode 的 apply 方法。ExpressionEvaluator 底层也是依赖 OGNL 实现 test 表达式解释的。

TrimSqlNode

在使用 <trim> 标签的时候、我们可以指定 prefix 和 suffix 属性添加前缀和后缀、也可以指定 prefixesToOverride 和 suffixesToOverride 属性来删除多个前缀和后缀(使用|来分割不同字符串)

public class TrimSqlNode implements SqlNode {

  private final SqlNode contents;
  private final String prefix;
  private final String suffix;
  private final List<String> prefixesToOverride;
  private final List<String> 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<String> prefixesToOverride, String suffix, List<String> 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);
    // 首先执行子SqlNode对象的apply()方法完成对应动态SQL片段的解析
    boolean result = contents.apply(filteredDynamicContext);
    // 使用FilteredDynamicContext.applyAll()方法完成前后缀的处理操作
    filteredDynamicContext.applyAll();
    return result;
  }

  private static List<String> parseOverrides(String overrides) {
    if (overrides != null) {
      final StringTokenizer parser = new StringTokenizer(overrides, "|", false);
      final List<String> list = new ArrayList<>(parser.countTokens());
      while (parser.hasMoreTokens()) {
        list.add(parser.nextToken().toUpperCase(Locale.ENGLISH));
      }
      return list;
    }
    return Collections.emptyList();
  }
  .......

FilteredDynamicContext 可以看作是 DynamicContext 的装饰器、额外添加了处理前缀和后缀的功能

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

private void applyPrefix(StringBuilder sql, String trimmedUppercaseSql) {
  if (!prefixApplied) {
    prefixApplied = true;
    if (prefixesToOverride != null) {
      for (String toRemove : prefixesToOverride) {
        if (trimmedUppercaseSql.startsWith(toRemove)) {
          sql.delete(0, toRemove.trim().length());
          break;
        }
      }
    }
    if (prefix != null) {
      sql.insert(0, " ");
      sql.insert(0, prefix);
    }
  }
}

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

  • applyPrefix() 方法在处理前缀的时候，首先会遍历 prefixesToOverride 集合，从 SQL 片段的头部逐个尝试进行删除，之后在 SQL 片段的头部插入一个空格以及 prefix 字段指定的前缀字符串。

  • applySuffix() 方法在处理后缀的时候，首先会遍历 suffixesToOverride 集合，从 SQL 片段的尾部逐个尝试进行删除，之后在 SQL 片段的尾部插入一个空格以及 suffix 字段指定的后缀字符串。

WhereSqlNode

public class WhereSqlNode extends TrimSqlNode {

  private static List<String> 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);
  }

}

作为 TrimSqlNode 的子类、在 WhereSqlNode 中将 prefix 设置为“WHERE”字符串，prefixesToOverride 集合包含 “OR”“AND”“OR\n”“AND\n”“OR\r”“AND\r” 等字符串，这样就实现了删除 SQL 片段开头多余的 “AND”“OR” 关键字，并添加“WHERE”关键字的效果。

SetSqlNode

public class SetSqlNode extends TrimSqlNode {

  private static final List<String> COMMA = Collections.singletonList(",");

  public SetSqlNode(Configuration configuration,SqlNode contents) {
    super(configuration, contents, "SET", COMMA, null, COMMA);
  }

}

在 SetSqlNode 中将 prefix 设置为“SET”关键字，prefixesToOverride 集合和 suffixesToOverride 集合只包含“，”（逗号）字符串，这样就实现了删除 SQL 片段开头和结尾多余的逗号，并添加“SET”关键字的效果。

ForEachSqlNode

在动态 SQL 语句中、我们可以使用 标签对一个集合进行迭代。我们可以通过 index 属性指定元素的下标索引(迭代 Map 集合的话、就是 key 值)、使用 item 属性置顶变量作为集合元素(迭代 Map 集合的话、就是 Value 值)。另外我们还可以通过 open 和 close 属性在迭代开始前和结束后添加相应的字符串、也允许使用 separator 属性自定义分隔符。

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

ChooseSqlNode

在有的业务场景中，可能会碰到非常多的分支判断，在 Java 中，我们可以通过 switch…case…default 的方式来编写这段代码；在 MyBatis 的动态 SQL 语句中，我们可以使用 、 和 三个标签来实现类似的效果。

标签会被 MyBatis 解析成 ChooseSqlNode 对象， 标签会被解析成 IfSqlNode 对象， 标签会被解析成 MixedSqlNode 对象。

public class ChooseSqlNode implements SqlNode {
  private final SqlNode defaultSqlNode;
  private final List<SqlNode> ifSqlNodes;

  public ChooseSqlNode(List<SqlNode> ifSqlNodes, SqlNode defaultSqlNode) {
    this.ifSqlNodes = ifSqlNodes;
    this.defaultSqlNode = defaultSqlNode;
  }

  @Override
  public boolean apply(DynamicContext context) {
    for (SqlNode sqlNode : ifSqlNodes) {
      if (sqlNode.apply(context)) {
        return true;
      }
    }
    if (defaultSqlNode != null) {
      defaultSqlNode.apply(context);
      return true;
    }
    return false;
  }
}

VarDeclSqlNode

这个不太常用、

VarDeclSqlNode 抽象了 标签，其核心功能是将一个 OGNL 表达式的值绑定到一个指定的变量名上，并记录到 DynamicContext 上下文中。

VarDeclSqlNode 中的 name 字段维护了 标签中 name 属性的值，expression 字段记录了 标签中 value 属性的值（一般是一个 OGNL 表达式）。

在 apply() 方法中，VarDeclSqlNode 首先会通过 OGNL 工具类解析 expression 这个表达式的值，然后将解析结果与 name 字段的值一起绑定到 DynamicContext 上下文中，这样后面就可以通过 name 字段值获取这个表达式的值了。

public class VarDeclSqlNode implements SqlNode {

  private final String name;
  private final String expression;

  public VarDeclSqlNode(String var, String exp) {
    name = var;
    expression = exp;
  }

  @Override
  public boolean apply(DynamicContext context) {
    final Object value = OgnlCache.getValue(expression, context.getBindings());
    context.bind(name, value);
    return true;
  }

}
CoderLi_
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Mybatis-SqlNode.png
01-08
MyBaits解析mapper映射文件，获取都sqlNode，最终解析封装给SqlSource。SqlSource通过getBoundSql可以获取到Sql信息。
解析Mybatis判断表达式源码分析
08-26
2. 然后，Mybatis 将 DynamicContext 对象传递给 SqlNode 对象，以便将 SQL 语句节点应用于 DynamicContext 对象中。 3. SqlNode 对象将 apply 方法实现，以便将 SQL 语句节点拼接起来。 4. 最后，Mybatis 将拼接好...
在ognl的PropertyAccessor实现类中如何判断当前Node是否最后一个
amyson的专栏
03-05 1945
 我们在使用ognl时，一般情况下ognl已经考虑的非常完善了。但是特定的情况下，我们仍然需要注册自己的PropertyAccessor，以便ognl能够正确的遍历特殊的对象。注册特定PropertyAccessor的方式：OgnlRuntime.setPropertyAccessor（clz,PropertyAccessor）;其中clz是Class对象，它可以是目标对象的具体Class
MyBatis（技术NeiMu）：核心处理层（SqlNode和SqlSource）
GDUT_Trim的博客
12-12 747
回顾SqlNode与SqlSourceSqlSource组合模式OGNL表达式OgnlCacheDynamicContextContextMapSqlNodeMixedSqlNodeStaticSqlNodeTextSqlNodeSqlSourceBuilderParameterMappingTokenHandlerParameterMappingBoundSqlDynamicSqlSource总结一下动态SQL的解析拓展：${}和#{}的区别RawSqlSource 回顾 前面我们已经看了整个MyBat.
Mybatis之SqlNode&SqlSource
最新发布
好记性不如烂笔头
04-18 1064
apply()是SqlNode 接口中定义的唯一方法，该方法会根据用户传入的实参， 参数解析该SqlNode所记录的动态SQL节点，并调用DynamicContext.appendSql()方法将解析后的SQL片段追加到DynamicContext.sqlBuilder中保存。SqlNode的解析流程，主要是由XMLScriptBuilder这个类来完成的，其构造方法会调用initNodeHandlerMap这个方法，这个方法会注册很多handler，即不同的标签将会由不同的handler处理。
Struts的OGNL
stujike123456的博客
12-04 157
import java.util.ArrayList; import java.util.Arrays; import java.util.Date; import java.util.HashMap; import java.util.List; import java.util.Map; import ognl.Ognl; import ognl.OgnlException; import...
struts2对Ognl的封装--PropertyAccessor
java12345678
03-21 519
Ognl 中PropertyAccessor 用于从类实例中获取或设置属性值 Ognl中已有的PropertyAccessor ：因为不同的类的获取属性值和赋值方式不同，如Map、List、javabean，因此有多个子类，第一个子类对应一种类型。   Struts 对PropertyAccessor  的扩展：    Struts 加载扩展的PropertyAccessor  ：...
腊月一十八，聊聊 MyBatis 中的设计模式.docx
11-19
例如 SqlNode 和各个子类 ChooseSqlNode 等就是组合模式的应用。组合模式的定义是“将对象组合成树形结构以表示部分以及整体关系”。 6. 模板方法模式 模板方法模式是 MyBatis 中使用的第六个设计模式。例如 ...
MyBatis 添加元数据自定义元素标签的实现代码
08-18
public void handleNode(XNode nodeToHandle, List<SqlNode> targetContents) { final String test = nodeToHandle.getStringAttribute("test"); final String type = nodeToHandle.getStringAttribute("type"); ...
mybatis3.x源码深度解析与最佳实践.pdf
09-12
SqlNode 是 MyBatis 中的另一个核心对象，该对象负责将 SQL 语句解析成可执行的语句。 3.3 BaseBuilder BaseBuilder 是 MyBatis 中的基础建造器，该对象负责将 SQL 语句解析成可执行的语句。 3.4 ...
node-mybatis-generator:用 nodejs 编写 mybatis 的生成器
06-10
节点-mybatis-生成器
33、SQL解析基础
等风的帆
06-27 832
BoundSqlBoundSql只是一个简单的java对象，有两个属性比较重要 - sql:从解析时可以看出这个sql不是配置文件中的sql,这个sql已经经过了处理(如:占用位符的处理、动态语句的解析if、foreach等待) - parameterObject:客户端执行sql时传入的参数 - parameterMappings: sql中的参数映射对应#{id,jdbcType=INTE
mybatis -- sqlnode
hc1428090104的博客
05-26 164
sqlNode
Mybatis中SqlNode的组合模式
weixin_34240657的博客
04-10 892
2019独角兽企业重金招聘Python工程师标准>>> ...
Mybatis解析动态sql原理分析
多看多听多总结
08-11 5736
前言 废话不多说，直接进入文章。 我们在使用mybatis的时候，会在xml中编写sql语句。 比如这段动态sql代码： "update" parameterType="org.format.dynamicproxy.mybatis.bean.User"> UPDATE users "SET" prefixOverrides=","> if test="
mybatis源码分析—sql动态解析
wp120453的博客
06-26 479
一、相关类 DynamicContext：动态上下文，持有方法的参数对象，以及解析替换后的sql XMLScriptBuilder：从XNode中解析并构建SqlNode，构建过程中会通过TextSqlNode#isDynamic()检查原始sql中是否含有${}判断是否为动态sql，有则是 XNode：其中的字符类型的body保存解析后的sql，用于构造SqlNode SqlNode：sql节点...
dubbo源码深度解析_mybatis 3.x源码深度解析（五）
weixin_39876002的博客
11-28 94
3 关键对象总结与回顾3.1 SqlSourceSqlSource是XML文件或者注解方法中映射语句的实现时表示，通过SqlSourceBuilder.parse()方法创建，SqlSourceBuilder中符号解析器将mybatis中的查询参数#{}转换为?，并记录了参数的顺序。它只有一个方法getBoundSql用于获取映射语句对象的各个组成部分，它的定义如下：/** * Represen...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值