Mybatis之SQL执行

已于 2023-08-09 21:32:59 修改
阅读量808 收藏
点赞数
文章标签： mybatis sql python
于 2023-08-09 21:32:18 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/2302_77659577/article/details/132176058
版权

上文我们简单描述了Mybatis从配置到Sql执行的步骤，本文将从获取SqlSession开始，通过获取Mapper，最终分析Mapper方法的执行流程。我们将借助源码逐步探索这一过程。

在这里插入图片描述

获取SqlSession

// 通过sqlSessionFactory获取sqlSession
SqlSession sqlSession = sqlSessionFactory.openSession();
// 进入openSession()
private SqlSession openSessionFromDataSource(ExecutorType execType, TransactionIsolationLevel level, boolean autoCommit) {
    Transaction tx = null;
    try {
      // 1.获取配置环境
      final Environment environment = configuration.getEnvironment();
      // 2.获取事务工厂
      final TransactionFactory transactionFactory = getTransactionFactoryFromEnvironment(environment);
      // 3.创建新的事务
      tx = transactionFactory.newTransaction(environment.getDataSource(), level, autoCommit);
      // 4.获取执行器
      final Executor executor = configuration.newExecutor(tx, execType);
      // 5.并返回默认的SqlSession
      return new DefaultSqlSession(configuration, executor, autoCommit);
...
  }

数据源信息

1-3步骤数据源配置信息都是之前加载全局文件mybatis-config.xml解析好放入了configuration对象中,如下图：
在这里插入图片描述

Excutor执行器

下图是Excutor的简单介绍
在这里插入图片描述

// 下面来看获取执行器的逻辑
// 传入参数tx（事务）+ execType (执行类型,SIMPLE, REUSE, BATCH)
final Executor executor = configuration.newExecutor(tx, execType);
// -> 
public Executor newExecutor(Transaction transaction, ExecutorType executorType) {
    // 如果未指定执行器类型，则使用默认执行器类型
    executorType = executorType == null ? defaultExecutorType : executorType;
    // 如果仍未指定执行器类型，则使用简单执行器
    executorType = executorType == null ? ExecutorType.SIMPLE : executorType;
    Executor executor;

    // 根据执行器类型选择创建对应的执行器实例
    if (ExecutorType.BATCH == executorType) {
      executor = new BatchExecutor(this, transaction);
    } else if (ExecutorType.REUSE == executorType) {
      executor = new ReuseExecutor(this, transaction);
    } else {
      executor = new SimpleExecutor(this, transaction);
    }
    
    // 如果启用了缓存，则将执行器包装为缓存执行器
    if (cacheEnabled) {
      executor = new CachingExecutor(executor);
    }
    
    // 对执行器应用拦截器链中的所有拦截器
    executor = (Executor) interceptorChain.pluginAll(executor);
    
    // 返回最终的执行器
    return executor;
}
// 我们这边的例子是个简单类型，所以创建的是SimpleExecutor
// 并且cacheEnabled默认是打开的(解析settings节点的时候的默认值)
// 所以这里最终的Executor为CachingExecutor

构建SqlSession

// 最终构建的SqlSession为DefaultSqlSession
return new DefaultSqlSession(configuration, executor, autoCommit);

获取Mapper

// 通过sqlSession获取UserMapper
UserMapper userMapper = sqlSession.getMapper(UserMapper.class);
// ->
// 构建sqlSession的时候会有configuration,mapper信息也都提前解析到configuration对象中了
 public <T> T getMapper(Class<T> type) {
    return configuration.getMapper(type, this);
  }
// ->
// 使用了动态代理来创建UserMapper接口的实现
public <T> T getMapper(Class<T> type, SqlSession sqlSession) {
    // 获取给定类型的 MapperProxyFactory
    final MapperProxyFactory<T> mapperProxyFactory = (MapperProxyFactory<T>) knownMappers.get(type);
    
    // 如果未找到对应的 MapperProxyFactory，抛出异常
    if (mapperProxyFactory == null) {
      throw new BindingException("类型 " + type + " 在 MapperRegistry 中未知。");
    }
    
    try {
      // 创建并返回 Mapper 接口的代理实例
      return mapperProxyFactory.newInstance(sqlSession);
    } catch (Exception e) {
      // 抛出异常，指明获取 Mapper 实例时出错原因
      throw new BindingException("获取 Mapper 实例时出错。原因：" + e, e);
    }
  }

// ->
public T newInstance(SqlSession sqlSession) {
    // 创建一个 MapperProxy 实例，用于代理 Mapper 接口的方法调用
    // sqlSession：用于执行数据库操作的 SqlSession 实例
    // mapperInterface：要代理的 Mapper 接口类型
    // methodCache：缓存 Mapper 方法的信息
    final MapperProxy<T> mapperProxy = new MapperProxy<>(sqlSession, mapperInterface, methodCache);
    
    // 通过 MapperProxy 创建并返回 Mapper 接口的代理实例
    return newInstance(mapperProxy);
}
// 见下图返回的是个代理对象

在这里插入图片描述

Mapper方法的执行流程

// userMapper执行方法
User user = userMapper.selectById(1);
// 调用Mapper接口的所有方法都会先调用到MapperProxy这个代理类的invoke方法
@Override
public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
    try {
        // 如果调用的方法是 Object 类的方法，则直接执行
        if (Object.class.equals(method.getDeclaringClass())) {
            return method.invoke(this, args);
        }
        // 如果调用的方法是默认方法（default method），则执行默认方法
        else if (isDefaultMethod(method)) {
            return invokeDefaultMethod(proxy, method, args);
        }
    } catch (Throwable t) {
        // 捕获并重新抛出可能出现的异常，将其转换为运行时异常
        throw ExceptionUtil.unwrapThrowable(t);
    }

    // 根据方法获取相应的 MapperMethod，然后执行该方法
    final MapperMethod mapperMethod = cachedMapperMethod(method);
    return mapperMethod.execute(sqlSession, args);
}

先来看 cachedMapperMethod(method);

final MapperMethod mapperMethod = cachedMapperMethod(method);
// ->
// 这里构造了MapperMethod对象,里面包括执行的 SQL 命令、参数映射、结果处理等，以及其他与数据库操作相关的配置。这些信息使得 MyBatis 能够在执行 Mapper 接口方法时，根据配置来构造和执行对应的 SQL 操作
 private MapperMethod cachedMapperMethod(Method method) {
    return methodCache.computeIfAbsent(method, k -> new MapperMethod(mapperInterface, method, sqlSession.getConfiguration()));
  }

再来看mapperMethod.execute(sqlSession, args);

return mapperMethod.execute(sqlSession, args);
// -> 
public Object execute(SqlSession sqlSession, Object[] args) {
    Object result;
    
    // 根据 SQL 命令类型进行处理
    switch (command.getType()) {
        // 对于 INSERT 类型的命令
        case INSERT: {
            // 将方法参数转换为对应的 SQL 命令参数
            Object param = method.convertArgsToSqlCommandParam(args);
            // 执行插入操作并获取影响的行数
            result = rowCountResult(sqlSession.insert(command.getName(), param));
            break;
        }
        
        // 对于 UPDATE 类型的命令
        case UPDATE: {
            // 将方法参数转换为对应的 SQL 命令参数
            Object param = method.convertArgsToSqlCommandParam(args);
            // 执行更新操作并获取影响的行数
            result = rowCountResult(sqlSession.update(command.getName(), param));
            break;
        }
        
        // 对于 DELETE 类型的命令
        case DELETE: {
            // 将方法参数转换为对应的 SQL 命令参数
            Object param = method.convertArgsToSqlCommandParam(args);
            // 执行删除操作并获取影响的行数
            result = rowCountResult(sqlSession.delete(command.getName(), param));
            break;
        }
        
        // 对于 SELECT 类型的命令
        case SELECT:
            if (method.returnsVoid() && method.hasResultHandler()) {
                // 对于返回值为 void 且使用了 ResultHandler 的情况，执行查询并使用 ResultHandler 处理结果
                executeWithResultHandler(sqlSession, args);
                result = null;
            } else if (method.returnsMany()) {
                // 对于返回多个结果的情况，执行查询返回列表
                result = executeForMany(sqlSession, args);
            } else if (method.returnsMap()) {
                // 对于返回 Map 结果的情况，执行查询返回 Map
                result = executeForMap(sqlSession, args);
            } else if (method.returnsCursor()) {
                // 对于返回 Cursor 结果的情况，执行查询返回 Cursor
                result = executeForCursor(sqlSession, args);
            } else {
                // 对于其他情况，执行查询返回单个结果
                Object param = method.convertArgsToSqlCommandParam(args);
                result = sqlSession.selectOne(command.getName(), param);
                if (method.returnsOptional()
                        && (result == null || !method.getReturnType().equals(result.getClass()))) {
                    result = Optional.ofNullable(result);
                }
            }
            break;
        
        // 对于 FLUSH 类型的命令
        case FLUSH:
            // 执行缓存刷新操作
            result = sqlSession.flushStatements();
            break;
        
        default:
            // 抛出异常，表示不支持的执行方法
            throw new BindingException("未知的执行方法：" + command.getName());
    }
    
    // 对于返回值为基本类型的情况，不允许返回 null
    if (result == null && method.getReturnType().isPrimitive() && !method.returnsVoid()) {
        throw new BindingException("Mapper 方法 '" + command.getName()
                + "' 在使用基本类型返回时尝试返回了 null（返回类型：" + method.getReturnType() + "）。");
    }
    
    // 返回执行结果
    return result;
}

现在直接来到我们当前sql的代码块

// args 是传递给代理方法的参数数组；param将被用作SQL命令的参数
// command.getName() 获取了与方法对应的SQL命令的 id（通常对应 XML 配置文件中的 id 属性）
result = sqlSession.selectOne(command.getName(), param);
// ->
// 1.调用 selectList 方法执行查询操作，获取结果列表。
// 2.如果结果列表中有且仅有一个元素，则返回该元素作为查询结果。
// 3.如果结果列表中有多个元素，则抛出 TooManyResultsException 异常，表示查询结果过多。
// 4.如果结果列表为空，则返回 null，表示没有查询到结果。
@Override
public <T> T selectOne(String statement, Object parameter) {
    List<T> list = this.selectList(statement, parameter);
    if (list.size() == 1) {
        return list.get(0);
    } 
    else if (list.size() > 1) {
        throw new TooManyResultsException("在 selectOne() 中期望返回一个结果（或 null），但发现了多个结果：" + list.size());
    } 
    else {
        return null;
    }
}
// -> this.selectList(statement, parameter);
// statement：要执行的 SQL 语句的唯一标识（对应 XML 映射文件中的 id 属性）。
// parameter：传递给 SQL 语句的参数。
// rowBounds：用于限制结果集返回的行数
// 主要步骤：
// 1.通过调用 configuration.getMappedStatement 获取被映射的 SQL 语句信息。
// 2.使用 executor 执行查询操作，executor.query 方法接受 SQL 语句信息、参数、行数限制和结果处理器等参数，返回结果列表。
// 3.在执行过程中，如果出现异常，将异常重新包装为运行时异常，抛出并指明错误原因。
// 4.无论是否发生异常，最后会重置 MyBatis 的错误上下文。
@Override
public <E> List<E> selectList(String statement, Object parameter, RowBounds rowBounds) {
    try {
        MappedStatement ms = configuration.getMappedStatement(statement);
        return executor.query(ms, wrapCollection(parameter), rowBounds, Executor.NO_RESULT_HANDLER);
    } catch (Exception e) {
        throw ExceptionFactory.wrapException("查询数据库时出错。原因：" + e, e);
    } finally {
        ErrorContext.instance().reset();
    }
}
// 执行器执行executor.query(..)
// 又上文知道这里执行器被包装过,所有最外层是CachingExecutor
// ->
// ms：被映射的 SQL 语句信息，包含了 SQL 语句、参数映射等信息。
// parameter：传递给 SQL 语句的参数。
// rowBounds：用于限制结果集返回的行数。
// resultHandler：用于处理查询结果的结果处理器。
@Override
public <E> List<E> query(MappedStatement ms, Object parameter, RowBounds rowBounds, ResultHandler resultHandler) throws SQLException {
    // 获取BoundSql 主要包含以下信息：
    // 1.sql：这是包含占位符的原始的SQL语句
    // 2.parameterMappings:包含了参数映射信息的列表
    // 3.parameterObject:传递给SQL语句的参数对象
    // 4.additionalParameters:额外的参数映射
    // 5.metaParameters:用于访问和操作 Java 对象属性的工具类
    BoundSql boundSql = ms.getBoundSql(parameter);
    
    // 创建用于缓存的 CacheKey
    CacheKey key = createCacheKey(ms, parameter, rowBounds, boundSql);
    
    // 调用 query 方法执行查询操作，并返回结果列表
    return query(ms, parameter, rowBounds, resultHandler, key, boundSql);
}

进入查询操作query(…)

@Override
public <E> List<E> query(MappedStatement ms, Object parameterObject, RowBounds rowBounds, ResultHandler resultHandler, CacheKey key, BoundSql boundSql)
        throws SQLException {
    // 获取 MappedStatement 对应的缓存
    Cache cache = ms.getCache();
    
    // 如果存在缓存
    if (cache != null) {
        // 根据需要刷新缓存
        flushCacheIfRequired(ms);
        
        // 如果 MappedStatement 配置了使用缓存，并且没有结果处理器
        if (ms.isUseCache() && resultHandler == null) {
            // 确保没有输出参数
            ensureNoOutParams(ms, boundSql);
            
            // 尝试从缓存中获取结果列表
            @SuppressWarnings("unchecked")
            List<E> list = (List<E>) tcm.getObject(cache, key);
            
            // 如果缓存中没有结果列表
            if (list == null) {
                // 执行查询操作获取结果列表
                list = delegate.query(ms, parameterObject, rowBounds, resultHandler, key, boundSql);
                
                // 将结果列表放入缓存中（issue #578 and #116）
                tcm.putObject(cache, key, list);
            }
            return list;
        }
    }
    
    // 如果不满足缓存条件，直接执行查询操作
    return delegate.query(ms, parameterObject, rowBounds, resultHandler, key, boundSql);
}

第一次缓存肯定没有值，所以直接查询delegate.query(…)

// 一直往下跟,直接来到查询代码
// ->
return delegate.query(ms, parameterObject, rowBounds, resultHandler, key, boundSql);
// -> 
list = queryFromDatabase(ms, parameter, rowBounds, resultHandler, key, boundSql);
// -> 
list = doQuery(ms, parameter, rowBounds, resultHandler, boundSql);
// -> doQuery(...)
// 综合来看，这段代码负责执行 SQL 查询操作，并将查询结果交给结果处理器进行处理，最终返回处理后的结果列表。
@Override
public <E> List<E> doQuery(MappedStatement ms, Object parameter, RowBounds rowBounds, ResultHandler resultHandler, BoundSql boundSql) throws SQLException {
    Statement stmt = null;
    try {
        // 获取 MappedStatement 的配置信息
        Configuration configuration = ms.getConfiguration();
        
        // 创建 StatementHandler 对象，用于处理 SQL 语句
        StatementHandler handler = configuration.newStatementHandler(wrapper, ms, parameter, rowBounds, resultHandler, boundSql);
        
        // 准备 Statement 对象，并记录日志
        stmt = prepareStatement(handler, ms.getStatementLog());
        
        // 调用 StatementHandler 的 query 方法执行查询操作
        return handler.query(stmt, resultHandler);
    } finally {
        // 在 finally 中关闭 Statement 对象
        closeStatement(stmt);
    }
}

总结

Mybatis的代码还是比较清晰的,跟着一步一步下来，都能摸清大致的脉络,捋起袖子加油干～～
在这里插入图片描述

我就是胖着玩玩的
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
mybatis之动态SQL
security_linsho的博客
05-14 280
Mybatis的映射文件中，前面我们的SQL都是比较简单的，有些时候业务逻辑复杂时，我们的SQL是动态变化的，此时在前面的学习中我们的SQL就不能满足要求了。 有时候的参数是不一定的，以前我们学的都是固定死的，参数的个数也是确定的，动态SQL的参数是不一定的。 在这里我们主要讲解一下if和foreach两种： 准备条件：配置方面用的是代理方式。跟mybatis的的代理开发_Outlier_Lin的博客-CSDN博客这个是一样的。 关于if:（我们查询一个但有多个限制条件） <mapper
mybatis之sql执行有数据但返回结果为null
h19910518的博客
09-13 3335
最近在使用mybatis查询数据库时，发现在pl/sql中单独执行sql时结果是有值的，但是在程序中拿到的却是null，相关配置如下： 　　（1） 　　<resultMap type="monitorTaskStatus" id="monitorTaskStatusMap"> 　　<result column="BATCH_NUM" property="batchNum"/> 　　<result column="TASK_STATUS" property...
SpringBoot+Mybatis-plus执行原生Sql的三种方式
hyzhangjun的专栏
06-06 433
二、使用Mybatis-plus的SqlRunner。一、使用Spring的JdbcTemplate。三、使用Mybatis-plus的Mapper。
【MyBatis】MyBatis SQL是如何执行
九师兄
06-04 83
ParameterHandler 相比于其他的组件就简单很多了，ParameterHandler 译为参数处理器，负责为 PreparedStatement 的 sql 语句参数动态赋值，这个接口很简单只有两个方法ParameterHandler 只有一个实现类 DefaultParameterHandler ， 它实现了这两个方法。getParameterObject： 用于读取参数setParameters : 用于对 PreparedStatement 的参数赋值。
mybatis执行sql语句
涛哥是个大帅比
11-18 3884
使用注解的方式，直接执行sql语句。使用SqlRunner的方式执行原生SQL，MyBatis提供了一个用于操作数据库的SqlRunner工具类，对JDBC做了很好的封装。结合工具类SQL，能够很方便地通过Java代码执行SQL语句并检索SQL执行结果。
mybatis配置批量执行SQL
limingdepoxiao的博客
07-06 1098
mybatis配置批量执行SQL
MyBatis的SQL执行流程
Pastxu的小屋
04-22 3240
前言 MyBatis可能很多人都一直在用，但是MyBatis的SQL执行流程可能并不是所有人都清楚了，那么既然进来了，通读本文你将收获如下： 1、Mapper接口和映射文件是如何进行绑定的 2、MyBatis中SQL语句的执行流程 3、自定义MyBatis中的参数设置处理器typeHandler 4、自定义MyBatis中结果集处理器typeHandler PS：本文基于MyBatis3.5.5版本源码 概要 在MyBatis中，利用编程式进行数据查询，主要就是
mybatis执行sql脚本
lxyoucan的博客
04-05 3485
最近在学习若依这个开源项目： https://gitee.com/y_project/RuoYi-Vue 默认的代码生成模块用起来总感觉别扭，比如说，每次生成的代码还要单独的手动执行一下SQL语句。我就在想能不能代码生成的时候就自己帮我执行好了。这样能省个10几秒时间。 由于若依这个框架默认的数据库操作组件是mybatis，所以本文就来研究一下如何通过mybatis来执行sql脚本。 Service 我修改的如下代码： RuoYi-Vue/ruoyi-generator/src/main/java/com/
SpringBoot+mybatis之sql执行有数据但返回结果为null
qq_52095625的博客
05-15 1407
看看你的实体的数据类型和你数据库数据类型是否一致，因为resultType使用的是你建立的实体，数据类型不一致无法转换。 还有就是你的实体属性名称尽量和你的数据库属性名称一致。 其实很好想明白，你属性名称不一样那我数据库怎么知道那个属性给实体的那个属性呢。个别字段没有值也可参照。只有查询会有问题。 ...
MyBatis执行sql的整个流程
baidu_33067195的博客
11-19 2097
MyBatis执行sql的整个流程 大致过程：启动->解析配置文件->创建executor->绑定参数->执行sql->结果集映射 MyBatis的核心部件 Configuration：初始化基础配置，比如MyBatis的别名等，一些重要的类型对象，如，插件，映射器，ObjectFactory和typeHandler对象，MyBatis所有的配置信息都维持在Configuration对象之中。 SqlSession及其相关类 SqlSessionFactoryBuilder 用
mybatis直接执行sql
m0_37539286的博客
05-08 7125
注意：需要手动校验sql中参数，防止sql注入 1. 注解方式 Mapper接口 @Mapper public interface PublicSqlMapper { /** * 通用查询 * @return */ @Select("${sql}") List<LinkedHashMap<String, Object>> select(Map<String, Object> map); /** *
MyBatis 执行动态 SQL语句详解
09-01
在 MyBatis 中，动态 SQL 是一个强大的特性，允许我们在 XML 映射文件或注解中编写条件语句，根据运行时的参数来决定 SQL 的具体执行内容。下面我们将深入探讨如何在 MyBatis 中执行动态 SQL 语句。 首先，我们要...
在mybatis执行SQL语句之前进行拦击处理实例
08-30
MyBatis拦截器实践 - 在MyBatis执行SQL语句之前进行拦截处理实例 MyBatis作为一个流行的持久层框架，提供了强大的数据库交互能力，但是在某些特殊场景下，我们需要在MyBatis执行SQL语句之前进行拦截处理，这便需要...
mybatis-sql的执行过程
06-13
mybatis-sql的执行过程，UML时序图，UML时序图，UML时序图，UML时序图，UML时序图 mybatis-sql的执行过程，UML时序图，UML时序图，UML时序图，UML时序图，UML时序图 mybatis-sql的执行过程，UML时序图，UML时序图，...
mybatis慢SQL插件
07-19
基于mybatis的慢SQL小插件，原理是mybatis拦截器。只需要在springboot的配置文件做简单的配置，mybatis拦截器将SQL中所有参数自动做了填充。拦截器监控慢SQL并将完整的可执行的SQL语句打印在日志文件中，复制该SQL...
原样输出mybatis的sql执行语句（mysql和oracle都可用）.zip
08-19
本文将深入探讨如何在SpringBoot（整合MyBatis）和传统的SSM（Spring、SpringMVC、MyBatis）项目中，原样输出MyBatis的SQL执行语句，以便于开发者直观地检查SQL语句是否正确和高效，从而进行优化和调试。此方法对...
SQL Server中 LOP_FORMAT_PAGE日志记录解释
qq_55914897的博客
07-24 381
是SQL Server事务日志中的一种重要记录类型，负责描述页面整理操作。它在页面初始化、事务日志记录和数据库恢复中扮演了关键角色，确保数据库操作的可靠性和一致性。是一种事务日志记录类型，表示SQL Server对数据页（Data Page）进行删除的操作。详细的背景和任务类型有助于深入理解SQL Server的内部机制，尤其是在恢复和日志管理方面。在数据库恢复过程中，SQL Server会读取事务日志并应用其中的记录和数据。是日志记录的一种类型，用于描述页面的格式化操作。在SQL Server中，
会Excel就会sql？
svygh123的专栏
07-20 1493
以上就是通过具体的例子来说明Excel中对应的操作，以便更好地对比SQL，通过这些步骤，你可以直观地在Excel中实现类似数据库操作的功能，SQL就像是数据库世界的Excel，但它更加强大，适用于大规模数据处理和复杂的数据关系管理。虽然开始时可能会觉得SQL语法有些抽象，但一旦掌握了基础，你会发现它非常高效且强大，特别是在处理大量数据和执行复杂查询时。就像在Excel中一样，实践中学习SQL会更加有效，尝试编写一些简单的查询，逐渐增加难度，你会很快上手的！
SQL Server 数据误删的恢复
最新发布
踏雨歌青春，诗酒趁年华
07-24 9624
在日常的数据库管理中，数据的误删操作是难以避免的。为了确保数据的安全性和完整性，我们必须采取一些措施来进行数据的备份和恢复。本文将详细介绍如何在 SQL Server 中进行数据的备份和恢复操作，特别是在发生数据误删的情况下。假设我们已经开启了全量备份，并且在误操作之前有一个全量备份文件。
mybatis动态sql执行原理
03-04
MyBatis是一种开源的Java持久层框架，它能够帮助Java程序员通过XML或注解的方式编写SQL语句，实现对数据库的访问。MyBatis支持动态SQL语句，这意味着它可以根据不同的条件来生成不同的SQL语句。 MyBatis的动态SQL语句是通过XML或注解中的一些特殊标记来实现的。这些标记可以让开发者在SQL语句中加入条件、循环、判断等逻辑。 例如，假设有一个查询语句需要根据不同的条件来动态生成： ``` SELECT * FROM user WHERE 1=1 <if test="username != null"> AND username=#{username} </if> <if test="age != null"> AND age=#{age} </if> ``` 在这个例子中，`<if>`标记用来判断是否需要加入条件，`test`属性用来指定条件，`#{}`语法用来表示SQL参数。 MyBatis还支持其他动态SQL标记，例如： - `<where>`和`<set>`：用来生成WHERE和SET子句。 - `<foreach>`：用来循环生成SQL语句。 - `<choose>`、`<when>`和`<otherwise>`：用来实现多重条件判断。 总的来说，MyBatis的动态SQL语句机制使得开发者可以更加灵活地编写SQL语句，提高了开发效率和代码质量。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值