MyBatis-plus 转化处理 SQL 语句的源码分析

最新推荐文章于 2024-05-29 16:16:20 发布
最新推荐文章于 2024-05-29 16:16:20 发布
阅读量6.7k 收藏 14
点赞数 9
分类专栏： MyBatis 文章标签： sql 数据库 java 1024程序员节
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_45505313/article/details/120551879
版权

文章目录

前言

在 MyBatis-plus 自定义通用方法及其实现原理 中笔者介绍了 MyBatis-plus 添加通用方法的实现方式，但是其中还有一些细节需要澄清，下文笔者将详细分析

  1. MyBatis-plus 对 SQL 语句脚本的构建，以及将其嵌入MappedStatement 的过程
  2. MyBatis 使用 SqlSource 构建可执行的 SQL 语句

在这里插入图片描述

1. MyBatis-plus 对 SQL 语句脚本的处理

我们都知道 MyBatis-plus 干掉了繁琐的 XML 文件，使 MyBatis 框架的易用度、好用度大幅上升。在MyBatis-plus 源码解析 中笔者提到过，MyBatis-plus 实际是将 Mapper 方法映射为了对应的 SQL 语句脚本，这个步骤的核心就是 AbstractMethod#injectMappedStatement() 的子类实现，本文以 SelectOne#injectMappedStatement() 为例进行分析，其主要处理分为两个部分：

  1. SQL 语句脚本的构建
  2. 解析 SQL 语句脚本，将其转化为 SqlSource 封装到 MappedStatement 中

1.1 SQL 语句脚本的构建

  1. SelectOne#injectMappedStatement() 方法如下，SQL 语句脚本的构建实际在一个以 SqlMethod.SELECT_ONE 为主体的 String#format() 拼接操作中，重要调用的如下：

    1. 通过 sqlMethod.getSql() 调用 SqlMethod.SELECT_ONE#getSql() 方法获得 SQL 脚本主体字符串
    2. 调用 AbstractMethod#sqlFirst() 构建 SQL 脚本在正式 SQL 语句之前的部分，这里会使用字符串替换 ${ew.sqlFirst}
    3. 调用 AbstractMethod#sqlSelectColumns() 构建 SQL 语句 SELECT 查询的字段相关的脚本部分，此处会使用字符串替换 ${ew.sqlSelect}
    4. 调用 TableInfo#getTableName() 获取实际的要查询的表名
    5. 调用 AbstractMethod#sqlWhereEntityWrapper() 构建 SQL 语句 WHERE 条件相关的脚本部分，此处会使用字符串替换 ${ew.sqlSegment}
    6. 调用 AbstractMethod#sqlComment() 构建 SQL 语句尾部注释相关的脚本部分，此处会使用字符串替换 ${ew.sqlComment}
    @Override
 public MappedStatement injectMappedStatement(Class<?> mapperClass, Class<?> modelClass, TableInfo tableInfo) {
     SqlMethod sqlMethod = SqlMethod.SELECT_ONE;
     SqlSource sqlSource = languageDriver.createSqlSource(configuration, String.format(sqlMethod.getSql(),
         sqlFirst(), sqlSelectColumns(tableInfo, true), tableInfo.getTableName(),
         sqlWhereEntityWrapper(true, tableInfo), sqlComment()), modelClass);
     return this.addSelectMappedStatementForTable(mapperClass, getMethod(sqlMethod), sqlSource, tableInfo);
 }

  2. SqlMethod.SELECT_ONE#getSql() 方法实际只是个获取操作，只要看下这个枚举的定义就知道这里拿到的是个使用 %s 占位的脚本字符串

    public enum SqlMethod {
 
 ......

 SELECT_ONE("selectOne", "查询满足条件一条数据", "<script>%s SELECT %s FROM %s %s %s\n</script>"),

 private final String method;
 private final String desc;
 private final String sql;

 SqlMethod(String method, String desc, String sql) {
     this.method = method;
     this.desc = desc;
     this.sql = sql;
 }

 public String getMethod() {
     return method;
 }

 public String getDesc() {
     return desc;
 }

 public String getSql() {
     return sql;
 }
}

  3. AbstractMethod#sqlFirst() 的实现很简单，可以看到这里实际就是使用 SqlScriptUtils#convertChoose() 工具类拼接 SQL 语句脚本 标签的过程，经过处理这里可以得到的脚本片段如下

    <choose>
     <when test="ew != null and ew.sqlFirst != null">
         ${ew.sqlFirst}
     </when>
     <otherwise></otherwise>
 </choose>

      protected String sqlFirst() {
     return SqlScriptUtils.convertChoose(String.format("%s != null and %s != null", WRAPPER, Q_WRAPPER_SQL_FIRST),
         SqlScriptUtils.unSafeParam(Q_WRAPPER_SQL_FIRST), EMPTY);
 }

  4. SqlScriptUtils#convertChoose() 方法如下，显然就是标签字符串的构造，没有特别操作

      public static String convertChoose(final String whenTest, final String whenSqlScript, final String otherwise) {
     return "<choose>" + NEWLINE
         + "<when test=\"" + whenTest + QUOTE + RIGHT_CHEV + NEWLINE
         + whenSqlScript + NEWLINE + "</when>" + NEWLINE
         + "<otherwise>" + otherwise + "</otherwise>" + NEWLINE
         + "</choose>";
 }

  5. AbstractMethod#sqlSelectColumns() 的处理大同小异，其实就是指定查询表的字段，此处可以得到如下脚本片段

    <choose>
  <when test="ew != null and ew.sqlSelect != null">
      ${ew.sqlSelect}
  </when>
  <otherwise>id,name,type</otherwise>
</choose>

    protected String sqlSelectColumns(TableInfo table, boolean queryWrapper) {
     /* 假设存在 resultMap 映射返回 */
     String selectColumns = ASTERISK;
     if (table.getResultMap() == null || (table.getResultMap() != null && table.isInitResultMap())) {
         /* 普通查询 */
         selectColumns = table.getAllSqlSelect();
     }
     if (!queryWrapper) {
         return selectColumns;
     }
     return SqlScriptUtils.convertChoose(String.format("%s != null and %s != null", WRAPPER, Q_WRAPPER_SQL_SELECT),
         SqlScriptUtils.unSafeParam(Q_WRAPPER_SQL_SELECT), selectColumns);
 }

  6. AbstractMethod#sqlWhereEntityWrapper() 的处理稍显复杂，不过原理和以上方法是一样的，此处可以获得如下脚本片段

       <if test="ew != null">
    <where>
        <if test="ew.entity != null">
            <if test="ew.entity.id != null">id=#{ew.entity.id}</if>
            <if test="ew.entity['name'] != null">AND name=#{ew.entity.name}</if>
            <if test="ew.entity['type'] != null">AND type=#{ew.entity.type}</if>
        </if>
        <if test="ew.sqlSegment != null and ew.sqlSegment != '' and ew.nonEmptyOfWhere">
            <if test="ew.nonEmptyOfEntity and ew.nonEmptyOfNormal">AND</if>
            ${ew.sqlSegment}
        </if>
    </where>
    <if test="ew.sqlSegment != null and ew.sqlSegment != '' and ew.emptyOfWhere">
        ${ew.sqlSegment}
    </if>
</if>

    protected String sqlWhereEntityWrapper(boolean newLine, TableInfo table) {
     if (table.isLogicDelete()) {
         String sqlScript = table.getAllSqlWhere(true, true, WRAPPER_ENTITY_DOT);
         sqlScript = SqlScriptUtils.convertIf(sqlScript, String.format("%s != null", WRAPPER_ENTITY),
             true);
         sqlScript += (NEWLINE + table.getLogicDeleteSql(true, true) + NEWLINE);
         String normalSqlScript = SqlScriptUtils.convertIf(String.format("AND ${%s}", WRAPPER_SQLSEGMENT),
             String.format("%s != null and %s != '' and %s", WRAPPER_SQLSEGMENT, WRAPPER_SQLSEGMENT,
                 WRAPPER_NONEMPTYOFNORMAL), true);
         normalSqlScript += NEWLINE;
         normalSqlScript += SqlScriptUtils.convertIf(String.format(" ${%s}", WRAPPER_SQLSEGMENT),
             String.format("%s != null and %s != '' and %s", WRAPPER_SQLSEGMENT, WRAPPER_SQLSEGMENT,
                 WRAPPER_EMPTYOFNORMAL), true);
         sqlScript += normalSqlScript;
         sqlScript = SqlScriptUtils.convertChoose(String.format("%s != null", WRAPPER), sqlScript,
             table.getLogicDeleteSql(false, true));
         sqlScript = SqlScriptUtils.convertWhere(sqlScript);
         return newLine ? NEWLINE + sqlScript : sqlScript;
     } else {
         String sqlScript = table.getAllSqlWhere(false, true, WRAPPER_ENTITY_DOT);
         sqlScript = SqlScriptUtils.convertIf(sqlScript, String.format("%s != null", WRAPPER_ENTITY), true);
         sqlScript += NEWLINE;
         sqlScript += SqlScriptUtils.convertIf(String.format(SqlScriptUtils.convertIf(" AND", String.format("%s and %s", WRAPPER_NONEMPTYOFENTITY, WRAPPER_NONEMPTYOFNORMAL), false) + " ${%s}", WRAPPER_SQLSEGMENT),
             String.format("%s != null and %s != '' and %s", WRAPPER_SQLSEGMENT, WRAPPER_SQLSEGMENT,
                 WRAPPER_NONEMPTYOFWHERE), true);
         sqlScript = SqlScriptUtils.convertWhere(sqlScript) + NEWLINE;
         sqlScript += SqlScriptUtils.convertIf(String.format(" ${%s}", WRAPPER_SQLSEGMENT),
             String.format("%s != null and %s != '' and %s", WRAPPER_SQLSEGMENT, WRAPPER_SQLSEGMENT,
                 WRAPPER_EMPTYOFWHERE), true);
         sqlScript = SqlScriptUtils.convertIf(sqlScript, String.format("%s != null", WRAPPER), true);
         return newLine ? NEWLINE + sqlScript : sqlScript;
     }
 }

  7. AbstractMethod#sqlComment() 拿到的脚本片段如下，不做更多解释

    <choose>
     <when test="ew != null and ew.sqlComment != null">
         ${ew.sqlComment}
     </when>
     <otherwise></otherwise>
 </choose>

     protected String sqlComment() {
     return SqlScriptUtils.convertChoose(String.format("%s != null and %s != null", WRAPPER, Q_WRAPPER_SQL_COMMENT),
         SqlScriptUtils.unSafeParam(Q_WRAPPER_SQL_COMMENT), EMPTY);
 }

经过以上步骤，SQL 语句脚本各个关键的片段都已经构建完毕，最终得到的脚本如下所示。接下来的处理就是解析这个脚本，通过 LanguageDriver#createSqlSource() 方法将脚本转化为 SqlSource 对象，这个对象是决定最终执行的 SQL 语句的重中之重

<script>
    <choose>
        <when test="ew != null and ew.sqlFirst != null">
            ${ew.sqlFirst}
        </when>
        <otherwise></otherwise>
    </choose>
    SELECT
    <choose>
        <when test="ew != null and ew.sqlSelect != null">
            ${ew.sqlSelect}
        </when>
        <otherwise>id,name,type</otherwise>
    </choose>
    FROM node
    <if test="ew != null">
        <where>
            <if test="ew.entity != null">
                <if test="ew.entity.id != null">id=#{ew.entity.id}</if>
                <if test="ew.entity['name'] != null">AND name=#{ew.entity.name}</if>
                <if test="ew.entity['type'] != null">AND type=#{ew.entity.type}</if>
            </if>
            <if test="ew.sqlSegment != null and ew.sqlSegment != '' and ew.nonEmptyOfWhere">
                <if test="ew.nonEmptyOfEntity and ew.nonEmptyOfNormal">AND</if>
                ${ew.sqlSegment}
            </if>
        </where>
        <if test="ew.sqlSegment != null and ew.sqlSegment != '' and ew.emptyOfWhere">
            ${ew.sqlSegment}
        </if>
    </if>
    <choose>
        <when test="ew != null and ew.sqlComment != null">
            ${ew.sqlComment}
        </when>
        <otherwise></otherwise>
    </choose>
</script>

1.2 SqlSource 的转化

  1. LanguageDriver#createSqlSource() 是接口方法，MyBatis 使用 XML 来定义 SQL 语句配置的，实际调用到 XMLLanguageDriver#createSqlSource()，可以看到这里最终调用 XMLScriptBuilder#parseScriptNode() 开始解析 XML 脚本

     public SqlSource createSqlSource(Configuration configuration, String script, Class<?> parameterType) {
 // issue #3
 if (script.startsWith("<script>")) {
   XPathParser parser = new XPathParser(script, false, configuration.getVariables(), new XMLMapperEntityResolver());
   return createSqlSource(configuration, parser.evalNode("/script"), parameterType);
 } else {
   // issue #127
   script = PropertyParser.parse(script, configuration.getVariables());
   TextSqlNode textSqlNode = new TextSqlNode(script);
   if (textSqlNode.isDynamic()) {
     return new DynamicSqlSource(configuration, textSqlNode);
   } else {
     return new RawSqlSource(configuration, script, parameterType);
   }
 }
}

@Override
public SqlSource createSqlSource(Configuration configuration, XNode script, Class<?> parameterType) {
 XMLScriptBuilder builder = new XMLScriptBuilder(configuration, script, parameterType);
 return builder.parseScriptNode();
}

  2. XMLScriptBuilder#parseScriptNode() 方法如下，可以看到核心是调用 XMLScriptBuilder#parseDynamicTags() 解析 XML 脚本中的各个节点，最终返回一个 SqlSource 对象

    此处注意，解析脚本时会判断 TextSqlNode 保存的文本内容，只要含有字符串拼接符 ${} 就需要进行动态拼接处理，因此返回一个 DynamicSqlSource 对象

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

protected MixedSqlNode parseDynamicTags(XNode node) {
 List<SqlNode> contents = new ArrayList<>();
 NodeList children = node.getNode().getChildNodes();
 for (int i = 0; i < children.getLength(); i++) {
   XNode child = node.newXNode(children.item(i));
   if (child.getNode().getNodeType() == Node.CDATA_SECTION_NODE || child.getNode().getNodeType() == Node.TEXT_NODE) {
     String data = child.getStringBody("");
     TextSqlNode textSqlNode = new TextSqlNode(data);
     if (textSqlNode.isDynamic()) {
       contents.add(textSqlNode);
       isDynamic = true;
     } else {
       contents.add(new StaticTextSqlNode(data));
     }
   } else if (child.getNode().getNodeType() == Node.ELEMENT_NODE) { // issue #628
     String nodeName = child.getNode().getNodeName();
     NodeHandler handler = nodeHandlerMap.get(nodeName);
     if (handler == null) {
       throw new BuilderException("Unknown element <" + nodeName + "> in SQL statement.");
     }
     handler.handleNode(child, contents);
     isDynamic = true;
   }
 }
 return new MixedSqlNode(contents);
}

  3. 经过以上步骤，构建的DynamicSqlSource对象与 SQL 语句脚本的对应关系如下所示，后续就是将这个 SqlSource 封装到 MappedStatement 中的处理，也就是调用 AbstractMethod#addSelectMappedStatementForTable() 方法
    在这里插入图片描述

  4. AbstractMethod#addSelectMappedStatementForTable() 方法其实只是入口，这里是通过一个个方法调用逐步组装适配 MyBatis API 的数据对象，最终通过 Mybatis 内部的 MapperBuilderAssistant#addMappedStatement() 方法构建封装了关键 SQL 信息的 MappedStatement 对象，并将其添加到 Configuration 中缓存起来

     protected MappedStatement addSelectMappedStatementForTable(Class<?> mapperClass, String id, SqlSource sqlSource,
                                                            TableInfo table) {
     String resultMap = table.getResultMap();
     if (null != resultMap) {
         /* 返回 resultMap 映射结果集 */
         return addMappedStatement(mapperClass, id, sqlSource, SqlCommandType.SELECT, null,
             resultMap, null, new NoKeyGenerator(), null, null);
     } else {
         /* 普通查询 */
         return addSelectMappedStatementForOther(mapperClass, id, sqlSource, table.getEntityType());
     }
 }

 protected MappedStatement addSelectMappedStatementForOther(Class<?> mapperClass, String id, SqlSource sqlSource,
                                                            Class<?> resultType) {
     return addMappedStatement(mapperClass, id, sqlSource, SqlCommandType.SELECT, null,
         null, resultType, new NoKeyGenerator(), null, null);
 }

 protected MappedStatement addMappedStatement(Class<?> mapperClass, String id, SqlSource sqlSource,
                                              SqlCommandType sqlCommandType, Class<?> parameterType,
                                              String resultMap, Class<?> resultType, KeyGenerator keyGenerator,
                                              String keyProperty, String keyColumn) {
     String statementName = mapperClass.getName() + DOT + id;
     if (hasMappedStatement(statementName)) {
         logger.warn(LEFT_SQ_BRACKET + statementName + "] Has been loaded by XML or SqlProvider or Mybatis's Annotation, so ignoring this injection for [" + getClass() + RIGHT_SQ_BRACKET);
         return null;
     }
     /* 缓存逻辑处理 */
     boolean isSelect = false;
     if (sqlCommandType == SqlCommandType.SELECT) {
         isSelect = true;
     }
     return builderAssistant.addMappedStatement(id, sqlSource, StatementType.PREPARED, sqlCommandType,
         null, null, null, parameterType, resultMap, resultType,
         null, !isSelect, isSelect, false, keyGenerator, keyProperty, keyColumn,
         configuration.getDatabaseId(), languageDriver, null);
 }

2. MyBatis 对 SqlSource 的使用

  1. 在 MyBatis 缓存实现源码分析 时序图中，笔者详细描绘了上层 Mapper 方法触发到底层数据库操作的流程，可以看到在缓存执行器执行 CachingExecutor#query() 方法时会将 SQL 语句需要的参数包装为 ParamMap 对象传入，并调用 MappedStatement#getBoundSql() 进行对应 SQL 语句的构建

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

  2. MappedStatement#getBoundSql() 源码如下，参考上一节的内容可以知道此处的核心是调用 DynamicSqlSource#getBoundSql() 方法创建封装了 SQL 执行语句全部所需信息的 BoundSql 对象

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

  3. DynamicSqlSource#getBoundSql() 方法的处理主要分为了以下几步：

    1. rootSqlNode.apply() 调用 MixedSqlNode#apply() 方法进入每个 SQL 节点的处理，这个过程会将传入参数值送入 SQL 节点中进行判断，从而决定那个节点最终的 sql 片段，最后将其拼接起来缓存到 DynamicContext 内部
    2. SqlSourceBuilder#parse() 方法处理 SQL 语句中的 #{} 占位符，将其替换为 PreparedStatement 需要的入参形式 “？”
    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;
}

  4. MixedSqlNode#apply() 方法如下，可以看到就是遍历其内部保存的实际节点，调用其 SqlNode#apply() 方法，此处可以对照上文解析 SQL 语句脚本的示意图理解，本文以 IfSqlNode#apply() 方法为例

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

  5. IfSqlNode#apply() 方法的处理比较简练，可以看到重要步骤：

    1. 使用内部的评估器 ExpressionEvaluator 对 Mapper 方法调用时的入参进行检验，此处实际用到了 OGNL表达式 相关 API，有兴趣的读者可以自行了解，本文不再深入
    2. 如果表达式成立，则继续处理当前节点包含的其他节点，此处以处理 ${} 字符串拼接符的TextSqlNode#apply() 为例
     @Override
public boolean apply(DynamicContext context) {
 if (evaluator.evaluateBoolean(test, context.getBindings())) {
   contents.apply(context);
   return true;
 }
 return false;
}

  6. TextSqlNode#apply() 的逻辑如下，可以看到进行的关键操作如下，有关字符串拼接符的解析及替换本文暂不展开，有兴趣的读者可从此处深入

    1. 调用 TextSqlNode#createParser() 创建解析器，用以解析当前节点中保存的字符串拼接符 ${ew.sqlSegment} 等
    2. 调用 GenericTokenParser#parse() 方法通过 OGNL 表达式 从参数值中取得对应字符串，例如拼接字符串${ew.sqlSegment}，会通过反射调用到 MyBatis-plus 中的 AbstractWrapper#getSqlSegment() 方法完成 SQL 条件语句的构建，取到拼接字符串的替换值后通过 DynamicContext#appendSql() 方法将其追加到 SQL 字符串尾部
     @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) {
 return new GenericTokenParser("${", "}", handler);
}

  7. 经过以上步骤，SQL 语句脚本已经被处理为了如下的字符串，脚本中之前预存的 MyBatis-plus 的替换字符串 ${ew.xxx} 已经被替换掉，同时 WHERE 条件中已经填上了 MyBatis-plus 中 Mapper 方法入参的 QueryWrapper 构建的 sql 片段，可以看到 SQL 语句 WHERE 条件的实际参数位置已经被 #{ew.paramNameValuePairs.xxx} 占位符 占住

    /*bind_db*/SELECT  id,name,type  FROM node 
 WHERE (edge_id = #{ew.paramNameValuePairs.MPGENVAL1} AND status = #{ew.paramNameValuePairs.MPGENVAL2} AND deleted = #{ew.paramNameValuePairs.MPGENVAL3})

  8. 回到本节步骤3第二个处理阶段， SqlSourceBuilder#parse() 方法会返回一个新的 StaticSqlSource 对象，并将 SQL 语句中的 #{} 占位符内部的字符串处理为获取参数值的参数映射对象 ParameterMapping，至此 SQL 语句已经更新为如下形式：

    /* bind_db */SELECT id,name,type FROM node WHERE (edge_id = ? AND status = ? AND deleted = ?)

      public SqlSource parse(String originalSql, Class<?> parameterType, Map<String, Object> additionalParameters) {
 ParameterMappingTokenHandler handler = new ParameterMappingTokenHandler(configuration, parameterType, additionalParameters);
 GenericTokenParser parser = new GenericTokenParser("#{", "}", handler);
 String sql;
 if (configuration.isShrinkWhitespacesInSql()) {
   sql = parser.parse(removeExtraWhitespaces(originalSql));
 } else {
   sql = parser.parse(originalSql);
 }
 return new StaticSqlSource(configuration, sql, handler.getParameterMappings());
}

  9. StaticSqlSource#getBoundSql() 方法其实就是新建一个 BoundSql 对象返回，可以看到这个对象中已经包含了预处理的 sql 语句，实际参数值的缓存对象 ParamMap，以及取得参数值的映射路径 ParameterMapping 列表，通过参数值的映射路径即可有方法取得对应参数值
    在这里插入图片描述

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

  10. 实际对预处理的 sql 语句对应的 PreparedStatement 的参数填充在参数处理器 ParameterHandler#setParameters() 子类实现中完成，这个处理由 StatementHandler#parameterize()触发，最终调用到 DefaultParameterHandler#setParameters() 方法

    可以看到此处的处理是从 ParameterMapping 获取参数值的取值路径，然后使用这个路径借助 MetaObject 从参数缓存对象 parameterObject 中取得参数值，最后调用 TypeHandler#setParameter() 将参数值注入到 PreparedStatement 对象中

    public void setParameters(PreparedStatement ps) {
ErrorContext.instance().activity("setting parameters").object(mappedStatement.getParameterMap().getId());
List<ParameterMapping> parameterMappings = boundSql.getParameterMappings();
if (parameterMappings != null) {
  for (int i = 0; i < parameterMappings.size(); i++) {
    ParameterMapping parameterMapping = parameterMappings.get(i);
    if (parameterMapping.getMode() != ParameterMode.OUT) {
      Object value;
      String propertyName = parameterMapping.getProperty();
      if (boundSql.hasAdditionalParameter(propertyName)) { // issue #448 ask first for additional params
        value = boundSql.getAdditionalParameter(propertyName);
      } else if (parameterObject == null) {
        value = null;
      } else if (typeHandlerRegistry.hasTypeHandler(parameterObject.getClass())) {
        value = parameterObject;
      } else {
        MetaObject metaObject = configuration.newMetaObject(parameterObject);
        value = metaObject.getValue(propertyName);
      }
      TypeHandler typeHandler = parameterMapping.getTypeHandler();
      JdbcType jdbcType = parameterMapping.getJdbcType();
      if (value == null && jdbcType == null) {
        jdbcType = configuration.getJdbcTypeForNull();
      }
      try {
        typeHandler.setParameter(ps, i + 1, value, jdbcType);
      } catch (TypeException | SQLException e) {
        throw new TypeException("Could not set parameters for mapping: " + parameterMapping + ". Cause: " + e, e);
      }
    }
  }
}
}
谈谈1974
关注
  • 9
    点赞
  • 踩
  • 14
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
mybatis-plus源码（mybatis-plus-3.5.1.zip）
03-03
通过阅读源码，我们可以了解到MyBatis-Plus是如何将用户操作转化为SQL语句的，以及它是如何处理各种数据库交互细节的。这对于理解框架的工作原理、优化数据库操作和进行二次开发都具有重要的参考价值。同时，学习...
Mybatis-Plus入门系列(11)- MybatisPlus之Sql注入器及源码分析
记录知识、锤炼自我
03-31 1582
简介 什么是sql注入器 /** * SQL 自动注入器 * * @author hubin * @since 2018-04-07 */ public abstract class AbstractSqlInjector implements ISqlInjector { private static final Log logger = LogFactory.getLog(AbstractSqlInjector.class); /** * 检查SQL是否注入(已
BuilderException OgnlException sqlSegment nonEmptyOfWher OutOfMemoryError:GC overhead limit exceeded
global_coding的博客
07-29 890
org.apache.ibatis.builder.BuilderException: Errorevaluatingexpression'ew.sqlSegment!=nullandew.sqlSegment!=''andew.nonEmptyOfWhere'. Cause:org.apache.ibatis.ognl.OgnlException: sqlSegment[java.lang.OutOfMemoryError:GCoverheadlimitexceeded
【MyBatis-Plus 源码分析】核心组件、工作流程、SQL执行过程、源码分析
最新发布
好好学习日记
05-29 1110
MyBatis-Plus 是一个增强版的 MyBatis 框架，它在 MyBatis 的基础上增加了许多实用的功能，例如乐观锁插件、字段自动填充、分页插件、条件构造器和 SQL 注入器等。MyBatis-Plus 允许开发者无需编写 XML 文件，直接通过继承 BaseMapper 接口的类来完成数据库操作。MyBatis-Plus 作为 MyBatis 的增强框架，其工作流程在继承 MyBatis 的基础上进行了优化和扩展。继承 BaseMapper。
Mybatis类型转换器Boolean转int
TaoShao521的博客
03-22 5023
这个类型转换器的意思就是 你前端传过来一个Boolean类型的参数, 但是呢数据库需要存的字段类型是个int或者tinyint, 这个时候呢你就可以写个mybatis的类型转换器了 具体写法如下: 场景 前端传人员状态是Boolean 数据库存0或者1 类型转换器他需要继承这个BaseTypeHandler类 package com.enjoy.stu.handler; import org.apache.ibatis.type.BaseTypeHandler; import org.apache.iba
mybatis-plus高级功能 实现自定义通用方法详解
努力努力再努力
11-10 6197
前言 MP在一开始就给大家提供了很多通用的方法，在DefaultSqlInjector这个类中，在MethodList这个集合当中包含的都是通用方法类，如果想要使用自定义通用方法，也需要添加到这个集合当中。 /** * SQL 默认注入器 * * @author hubin * @since 2018-04-10 */ public class DefaultSqlInjector extends AbstractSqlInjector { @Override public L
spring启动时mybatis-plus注入sql源码解析
u013905744的专栏
05-31 1477
MP在spring启动就会挨个分析xxxMapper中的方法，并且将对应的SQL语句处理好，保存到configuration对象中的mappedStatements中。 首先，在contextApplication.xml文件中配置的sqlSessionFactory配置的是mybatisplus的MyBatisSqlSessionFactoryBean，其implements Appl...
Error evaluating解决xpression ‘ew.sqlSegment != null and ew.sqlSegment != ‘‘ and ew.nonEmptyOfWhere‘.
w3x3g的博客
09-28 2万+
（看文章之前要排除，自身的代码bug，本文是在本身代码没问题的基础上，依赖包版本过低导致的） 先上错误和描述，使用的mybatisplus插件，开始用的是3.1.1版本，然后本地运行项目没有问题，之前将项目打包成war包，也没问题，可以在服务器上正常运行。 但是要求，将项目打包成jar包，本地没有问题，使用项目分离的形式进行打包，并且在服务器上运行的时候，在使用到lambda表达式的代码报错，如下： org.mybatis.spring.MyBatisSystemException: nested exc
mybatis-plus配置控制台打印完整带参数SQL语句的实现
09-07
总之，通过配置MyBatis-Plus的日志实现为`StdOutImpl`，开发者可以在控制台清晰地看到完整的带参数SQL语句，从而提高调试和优化的效率。在实际项目中，根据项目的日志管理需求，可以选择适合的日志框架，并正确配置...
MyBatis-Plus入门+MyBatis-Plus文档手册 中文pdf高清版.rar
11-09
虽然mybatis可以直接在xml中通过SQL语句操作数据库，很是灵活。但正其操作都要通过SQL语句进行，就必须写大量的xml文件，很是麻烦。mybatis-plus就很好的解决了这个问题。 MyBatisPlus是一个Mybatis的增强工具，在 ...
MyBatis-Plus 分页查询以及自定义sql分页的实现
09-07
public class MyBatisPlusConfig { @Bean public PaginationInterceptor paginationInterceptor() { return new PaginationInterceptor(); } } ``` 配置完成后，MyBatis-Plus 将自动处理分页逻辑。 ## 三、...
mybatis-plus-generator-ui:对mybatis-plus-generator进行封装，通过Web UI快速生成兼容的Spring boot，mybatis-plus框架的各类业务代码
03-20
提供一致的Web UI用于生成兼容mybatis-plus框架的相关功能代码，包括Entity，Mapper，Mapper.xml，Service，Controller等，可以自定义模板以及各种输出参数，也可以通过SQL查询语句直接生成代码。 使用方法 ♡maven...
MyBatis-plus 源码解析
谈谈1974
03-14 1万+
文章目录前言1. Mapper 对象映射至 SQL 语句2. Mapper 操作数据库的实现 前言 MyBatis-plus是完全基于MyBatis开发的一个增强工具，是在MyBatis的基础上做增强的框架，为简化开发、提高效率而生。它在MyBatis原本的框架上增加了很多实用性功能，比如乐观锁插件、字段自动填充功能、分页插件、条件构造器、sql 注入器等等。使用 MyBatis-plus 可以完...
mybatis-plus 存储布尔值true、false
Good Luck
07-26 9002
3.存储和获取，存储true的时候数据库会填入1，存储false的时候数据库会存储0，获取的时候，会自动将1和0转换成true和false。1.设置数据库字段类型为tinyint长度为1。2.将实体类中的类型设置成boolean。...
mybatis plus自动生成代码tinyint(1)自动转换为Boolean 的解决办法
huang007guo的专栏
12-23 1万+
说明下为什么会自动转换为Boolean,是因为mybtisplus提供的默认的mysql类型转换器MySqlTypeConvert上特别写了这一段: 对症下药的解决办法是重写一个,在注入到配置里: /** * 自定义类型转换 */ class MySqlTypeConvertCustom extends MySqlTypeConvert implements ITypeConvert...
解决mybatis-plus 3.1.1版本使用lambda表达式查询报错
热门推荐
Kai辉的专栏
05-09 2万+
最近项目中使用了mybatis-plus 3.1.1版本，发现使用lambda表达式方式的条件构造器，执行时会报错；但是我用单元测试却通过，真是一个大坑啊。经过在网上一顿猛查，发现压根就是没有找到类似的问题，所以今天就记录一下这个大坑。 测试代码： @Override public User getByUsername(String username) { return ...
MybatisPlus根据实体类生成sql
m0_59047431的博客
08-25 2495
使用反射 读取
mybatisModelToSql，通过实体获得sql
teng121的博客
01-06 599
通过实体类创建sql语句
Mybatis-plus 怎么使用拦截器拿到SQL，并解析
qq_53374893的博客
11-07 2463
【代码】Mybatis-plus 怎么使用拦截器拿到SQL，并解析。
mybatis-plus生成的sql语句不符合postgresql要求怎么处理？
06-02
如果 MyBatis-Plus 生成的 SQL 语句不符合 PostgreSQL 的要求，可以尝试以下方法解决： 1. 在 MyBatis-Plus 配置文件中指定方言为 PostgreSQL，例如： ```yaml mybatis-plus: configuration: dialect: postgresql ``` 2. 自定义 MyBatis-Plus 的 SQL 解析器，例如： ```java import com.baomidou.mybatisplus.extension.plugins.pagination.dialects.PostgreDialect; import com.baomidou.mybatisplus.extension.plugins.pagination.optimize.JsqlParserCountOptimize; import com.baomidou.mybatisplus.extension.plugins.pagination.optimize.JsqlParserCountOptimize; import com.baomidou.mybatisplus.extension.plugins.pagination.optimize.JsqlParserCountOptimize; import net.sf.jsqlparser.statement.select.SelectStatement; public class CustomPostgreDialect extends PostgreDialect { @Override public String buildCountSql(long count, String sql, SelectStatement statement) { return JsqlParserCountOptimize.builder().build().parser(sql).getSql(); } } ``` 然后在 MyBatis-Plus 配置文件中指定自定义的方言： ```yaml mybatis-plus: configuration: dialect: com.example.CustomPostgreDialect ``` 自定义 SQL 解析器需要根据 PostgreSQL 的语法规则编写，可以参考 MyBatis-Plus 默认的 PostgreDialect 实现。

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值