MyBatis动态SQL：if标签深度解析

Java廖志伟 Java廖志伟 博客等级 墨衍会员 · AI 创作全网分发 墨衍智能分发 本文由作者通过墨衍一键同步至各平台 1分发平台 400+累计阅读 439平均单平台 已同步平台 优快云 微信公众号 微博 知乎 掘金 百家号 博客园 抖音 小红书 你的文章也可以这样分发 墨衍会员 ¥399起/年，写一次发全网 我也要 码龄2年
关注
原创 最新推荐文章于 2026-05-04 07:03:33 发布 439 阅读 AI 写同款· GEO 优化 ›
【论文阅读1】机理引导的残差学习用于电池全生命周期状态监测 | Nature Communications 本文提出了一种机理引导的残差学习框架，用于提升电池全生命周期内荷电状态(SOC)和健康状态(SOH)的监测精度。该方法融合等效电路模型的先验知识与机器学习，设计了修正模型和补偿模型两种通用框架。实验验证表明，该方法在三种不同类型电池数据集上均表现出色，SOC和SOH估计误差较传统方法降低50%以上，且在未见工况下仍保持良好外推能力。模型具有强鲁棒性，在减少训练数据量和降低采样频率时性能稳定，并兼具物理可解释性。该框架无需离线测试和运行中校准，为电池安全监测提供了有效解决方案。 阅读详情

📕我是廖志伟，一名Java开发工程师、《Java项目实战——深入理解大型互联网企业通用技术》（基础篇）、（进阶篇）、（架构篇）、《解密程序员的思维密码——沟通、演讲、思考的实践》作者、清华大学出版社签约作家、Java领域优质创作者、优快云博客专家、阿里云专家博主、51CTO专家博主、产品软文专业写手、技术文章评审老师、技术类问卷调查设计师、幕后大佬社区创始人、开源项目贡献者。

📘拥有多年一线研发和团队管理经验，研究过主流框架的底层源码(Spring、SpringBoot、SpringMVC、SpringCloud、Mybatis、Dubbo、Zookeeper)，消息中间件底层架构原理(RabbitMQ、RocketMQ、Kafka)、Redis缓存、MySQL关系型数据库、 ElasticSearch全文搜索、MongoDB非关系型数据库、Apache ShardingSphere分库分表读写分离、设计模式、领域驱动DDD、Kubernetes容器编排等。

📙不定期分享高并发、高可用、高性能、微服务、分布式、海量数据、性能调优、云原生、项目管理、产品思维、技术选型、架构设计、求职面试、副业思维、个人成长等内容。

Java程序员廖志伟

💡在这个美好的时刻，笔者不再啰嗦废话，现在毫不拖延地进入文章所要讨论的主题。接下来，我将为大家呈现正文内容。

优快云

🍊 MyBatis核心知识点之if：概述

在当今的软件开发领域，MyBatis 作为一款优秀的持久层框架，以其简洁的配置和强大的动态SQL功能，深受广大开发者的喜爱。然而，在实际的项目开发中，我们常常会遇到一些复杂的业务需求，这些需求往往需要我们在SQL语句中根据不同的条件执行不同的操作。这时，MyBatis 提供的 if 标签就成为了我们实现动态SQL的关键工具。

想象一下，在一个电商系统中，我们可能需要根据用户的购买历史来推荐商品。如果用户购买过某种类型的商品，我们可能需要推荐同类型的商品；如果没有购买过，则推荐其他类型的商品。这种情况下，传统的静态SQL显然无法满足我们的需求。而MyBatis的if标签，则可以让我们根据不同的条件动态地构建SQL语句，从而实现这种复杂的业务逻辑。

if标签的作用在于，它允许我们在MyBatis的映射文件中根据特定的条件来动态地包含或排除SQL片段。这种动态SQL的能力，使得我们能够编写更加灵活和可扩展的映射文件，从而提高代码的可读性和可维护性。

具体来说，if标签的使用场景主要包括以下几个方面：

  1. 根据参数值动态选择SQL片段：例如，根据用户输入的查询条件动态地构建查询语句。
  2. 根据实体类的属性值动态构建插入或更新语句：例如，只有当实体类的某些属性非空时，才将这些属性插入到数据库中。
  3. 根据业务逻辑动态调整SQL语句的执行：例如，根据用户的角色动态地调整权限检查的SQL语句。

介绍MyBatis核心知识点之if标签的概述，其重要性和实用性不言而喻。首先，它能够帮助我们编写更加灵活和可维护的代码，提高开发效率。其次，通过使用if标签，我们可以避免硬编码SQL语句，从而降低SQL注入的风险。最后，它使得我们的MyBatis映射文件更加简洁，易于理解和维护。

在接下来的内容中，我们将详细探讨if标签的作用和使用场景，帮助读者深入理解MyBatis的动态SQL功能，从而在实际项目中更好地运用这一知识点。

MyBatis if标签的作用

在MyBatis框架中，if标签是动态SQL构建的核心组件之一，它允许我们在执行SQL语句时根据条件动态地包含或排除某些部分。这种灵活性使得MyBatis在处理复杂查询时变得尤为强大。

首先，if标签的作用在于实现条件判断逻辑。在编写SQL映射文件时，我们常常需要根据不同的业务场景来动态调整SQL语句。例如，在查询用户信息时，可能需要根据用户角色来决定是否查询某些字段。这时，if标签就可以派上用场。

<select id="selectUser" resultType="User">
  SELECT
    id,
    username,
    <if test="role != null">
      role,
    </if>
    email
  FROM
    users
  WHERE
    username = #{username}
</select>

在上面的示例中，当role参数不为空时，SQL语句中会包含role字段。否则，SQL语句中不会包含role字段。

其次，if标签与参数绑定紧密相关。在MyBatis中，参数绑定是通过#{}占位符实现的。if标签可以与参数绑定一起使用，从而实现动态SQL构建。

<select id="selectUserByRole" resultType="User">
  SELECT
    id,
    username,
    role,
    email
  FROM
    users
  WHERE
    username = #{username}
    <if test="role != null">
      AND role = #{role}
    </if>
</select>

在上面的示例中，当role参数不为空时，SQL语句中会包含一个额外的条件AND role = #{role}。

此外，if标签还可以与choose、when、otherwise标签结合使用，实现更复杂的条件判断逻辑。

<select id="selectUserByCondition" resultType="User">
  SELECT
    id,
    username,
    <choose>
      <when test="role == 'admin'">
        role,
      </when>
      <when test="role == 'user'">
        role,
        email,
      </when>
      <otherwise>
        email,
      </otherwise>
    </choose>
  FROM
    users
  WHERE
    username = #{username}
</select>

在上面的示例中，根据role参数的值，SQL语句中会包含不同的字段。

然而，使用if标签构建动态SQL时，需要注意性能影响。由于动态SQL需要根据条件动态生成SQL语句，这可能会增加数据库的解析和执行时间。因此，在编写SQL映射文件时，应尽量减少不必要的条件判断，以提高性能。

最后，以下是使用if标签的一些最佳实践：

  1. 尽量减少条件判断，以提高性能。
  2. 使用简洁明了的命名，以便于阅读和维护。
  3. 避免在if标签中使用复杂的逻辑表达式。
  4. 在编写SQL映射文件时，注意SQL语句的格式和语法。

总之，MyBatis的if标签在动态SQL构建中发挥着重要作用。通过合理使用if标签，我们可以实现灵活、高效的SQL查询。

if标签功能作用描述示例
条件判断逻辑实现根据业务场景动态调整SQL语句，包含或排除某些部分示例1：根据用户角色决定是否查询某些字段
参数绑定与参数绑定一起使用，实现动态SQL构建示例2：根据参数值添加额外条件
复杂条件判断逻辑与choose、when、otherwise标签结合使用，实现更复杂的逻辑示例3：根据角色值选择不同的字段
性能影响动态生成SQL语句可能增加数据库解析和执行时间注意：减少不必要的条件判断，提高性能
最佳实践提高SQL映射文件的可读性和维护性最佳实践1：减少条件判断，提高性能
最佳实践使用简洁明了的命名，便于阅读和维护最佳实践2：使用简洁命名
最佳实践避免复杂逻辑表达式最佳实践3：避免复杂逻辑
最佳实践注意SQL语句格式和语法最佳实践4：注意SQL格式和语法

在实际应用中，if标签的功能不仅限于简单的条件判断，它还能与参数绑定、choose、when、otherwise等标签协同工作，构建出复杂的SQL语句。例如，在处理用户权限时，可以根据用户角色动态调整SQL查询，这不仅提高了代码的灵活性，也增强了系统的可扩展性。然而，动态生成SQL语句可能会对数据库性能产生一定影响，因此，在编写SQL映射文件时，应遵循最佳实践，如减少不必要的条件判断，使用简洁明了的命名，避免复杂逻辑表达式，并注意SQL语句的格式和语法，以确保代码的可读性和维护性。

MyBatis if标签：条件判断的艺术

在MyBatis框架中，if标签是动态SQL的核心组件之一，它允许我们在执行SQL语句时根据条件动态地构建SQL片段。这种灵活的动态SQL构建方式，使得我们在编写SQL语句时能够更加灵活地应对各种复杂的业务需求。

🎉 使用场景

if标签的使用场景非常广泛，以下是一些典型的应用场景：

  1. 多条件查询：在查询操作中，根据多个条件动态构建SQL语句，例如根据用户名、邮箱、手机号等多个条件查询用户信息。
<select id="selectUser" resultType="User">
  SELECT * FROM user
  <where>
    <if test="username != null and username != ''">
      AND username = #{username}
    </if>
    <if test="email != null and email != ''">
      AND email = #{email}
    </if>
    <if test="phone != null and phone != ''">
      AND phone = #{phone}
    </if>
  </where>
</select>
  1. 更新操作：在更新操作中，根据条件动态构建SET子句，例如根据用户ID更新用户信息。
<update id="updateUser" parameterType="User">
  UPDATE user
  <set>
    <if test="username != null and username != ''">
      username = #{username},
    </if>
    <if test="email != null and email != ''">
      email = #{email},
    </if>
    <if test="phone != null and phone != ''">
      phone = #{phone},
    </if>
  </set>
  WHERE id = #{id}
</update>
  1. 插入操作：在插入操作中，根据条件动态构建INSERT子句，例如根据用户ID和用户名插入用户信息。
<insert id="insertUser" parameterType="User">
  INSERT INTO user
  <trim prefix="(" suffix=")" suffixOverrides=",">
    id,
    <if test="username != null and username != ''">
      username,
    </if>
    <if test="email != null and email != ''">
      email,
    </if>
    <if test="phone != null and phone != ''">
      phone,
    </if>
  </trim>
  VALUES
  <trim prefix="(" suffix=")" suffixOverrides=",">
    #{id},
    <if test="username != null and username != ''">
      #{username},
    </if>
    <if test="email != null and email != ''">
      #{email},
    </if>
    <if test="phone != null and phone != ''">
      #{phone},
    </if>
  </trim>
</insert>

🎉 参数匹配与逻辑运算符

if标签支持参数匹配和逻辑运算符，以下是一些常用的参数匹配和逻辑运算符：

  1. 参数匹配：使用#{}进行参数匹配，例如#{username}。

  2. 逻辑运算符：支持and、or等逻辑运算符，例如<if test="username != null and username != ''">。

🎉 嵌套if与choose when otherwise

if标签支持嵌套if，以及choose when otherwise结构，以下是一些示例：

  1. 嵌套if：
<if test="username != null and username != ''">
  <if test="email != null and email != ''">
    AND email = #{email}
  </if>
</if>
  1. choose when otherwise：
<choose>
  <when test="username != null and username != ''">
    AND username = #{username}
  </when>
  <when test="email != null and email != ''">
    AND email = #{email}
  </when>
  <otherwise>
    AND phone = #{phone}
  </otherwise>
</choose>

🎉 与<where>标签结合与<set>标签结合

if标签可以与<where>标签和<set>标签结合使用，以下是一些示例：

  1. 与<where>标签结合：
<select id="selectUser" resultType="User">
  SELECT * FROM user
  <where>
    <if test="username != null and username != ''">
      AND username = #{username}
    </if>
    <if test="email != null and email != ''">
      AND email = #{email}
    </if>
  </where>
</select>
  1. 与<set>标签结合：
<update id="updateUser" parameterType="User">
  UPDATE user
  <set>
    <if test="username != null and username != ''">
      username = #{username},
    </if>
    <if test="email != null and email != ''">
      email = #{email},
    </if>
  </set>
  WHERE id = #{id}
</update>

🎉 性能影响

使用if标签构建动态SQL时，需要注意性能影响。以下是一些性能优化的建议：

  1. 避免过度使用if标签：过度使用if标签会导致SQL语句过于复杂，从而影响性能。

  2. 合理使用参数匹配：使用参数匹配可以减少SQL语句的重复，从而提高性能。

  3. 优化SQL语句：对构建的SQL语句进行优化，例如使用索引、避免全表扫描等。

总之，MyBatis if标签是一种非常强大的动态SQL构建工具，它可以帮助我们灵活地应对各种复杂的业务需求。在实际应用中，我们需要根据具体场景选择合适的使用方式，并注意性能优化。

使用场景SQL片段构建示例代码
多条件查询动态构建WHERE子句<select id="selectUser" resultType="User"> <where> <if test="username != null and username != ''"> AND username = #{username} </if> <if test="email != null and email != ''"> AND email = #{email} </if> <if test="phone != null and phone != ''"> AND phone = #{phone} </if> </where> </select>
更新操作动态构建SET子句<update id="updateUser" parameterType="User"> <set> <if test="username != null and username != ''"> username = #{username}, </if> <if test="email != null and email != ''"> email = #{email}, </if> <if test="phone != null and phone != ''"> phone = #{phone}, </if> </set> WHERE id = #{id} </update>
插入操作动态构建INSERT子句<insert id="insertUser" parameterType="User"> <trim prefix="(" suffix=")" suffixOverrides=","> id, <if test="username != null and username != ''"> username, </if> <if test="email != null and email != ''"> email, </if> <if test="phone != null and phone != ''"> phone, </if> </trim> VALUES <trim prefix="(" suffix=")" suffixOverrides=","> #{id}, <if test="username != null and username != ''"> #{username}, </if> <if test="email != null and email != ''"> #{email}, </if> <if test="phone != null and phone != ''"> #{phone}, </if> </trim> </insert>
参数匹配使用#{}进行参数匹配例如#{username}
逻辑运算符支持逻辑运算符如and、or例如<if test="username != null and username != ''">
嵌套if支持嵌套if结构例如： <if test="username != null and username != ''"> <if test="email != null and email != ''"> AND email = #{email} </if> </if>
choose when otherwise支持choose when otherwise结构例如： <choose> <when test="username != null and username != ''"> AND username = #{username} </when> <when test="email != null and email != ''"> AND email = #{email} </when> <otherwise> AND phone = #{phone} </otherwise> </choose>
与<where>标签结合与<where>标签结合使用，自动处理前缀的AND或OR例如： <select id="selectUser" resultType="User"> <where> <if test="username != null and username != ''"> username = #{username} </if> <if test="email != null and email != ''"> AND email = #{email} </if> </where> </select>
与<set>标签结合与<set>标签结合使用，自动处理前缀的逗号例如： <update id="updateUser" parameterType="User"> <set> <if test="username != null and username != ''"> username = #{username}, </if> <if test="email != null and email != ''"> email = #{email}, </if> </set> WHERE id = #{id} </update>
性能影响避免过度使用if标签，优化SQL语句例如：避免复杂嵌套，使用索引，避免全表扫描等

在数据库操作中，动态SQL语句的构建是提高代码灵活性和可维护性的关键。例如，在多条件查询的场景下，通过动态构建WHERE子句，可以灵活地根据用户输入的条件筛选数据。这不仅提高了查询的灵活性，还能有效避免硬编码，从而降低出错的风险。

在更新操作中，动态构建SET子句同样重要。它允许根据传入的数据更新特定的字段，而不是一次性更新所有字段。这种做法不仅提高了代码的效率，还能确保数据的一致性。

在插入操作中，动态构建INSERT子句同样至关重要。它允许根据实际需要插入字段，避免了插入不必要的字段，从而减少了数据库的存储空间占用。

使用#{}进行参数匹配是防止SQL注入的有效手段。通过这种方式，可以确保传入的参数被正确地处理，从而避免潜在的安全风险。

逻辑运算符的支持使得SQL语句更加灵活，可以构建复杂的查询条件。而嵌套if结构则允许在满足一个条件的基础上进一步细化查询条件。

choose when otherwise结构则提供了一种更清晰的方式来处理多条件分支，使得代码更加易于理解和维护。

与<where>和<set>标签的结合使用，可以自动处理前缀的AND或OR，以及前缀的逗号，从而简化了SQL语句的编写。

然而，过度使用if标签可能会对性能产生影响。因此，在编写SQL语句时，应避免复杂嵌套，合理使用索引，并尽量避免全表扫描，以确保数据库操作的效率。

🍊 MyBatis核心知识点之if：语法结构

在MyBatis框架中，动态SQL的编写是提高SQL语句灵活性和可维护性的关键。其中，if标签是MyBatis动态SQL的核心组成部分，它允许我们在执行SQL语句时根据条件动态地包含或排除某些部分。想象一下，在一个复杂的业务系统中，我们可能需要根据不同的用户角色或数据状态来动态调整SQL查询语句，这时if标签就变得尤为重要。

在传统的SQL编写中，我们通常需要为每种情况编写不同的查询语句，这不仅增加了代码的复杂度，也降低了代码的可维护性。而MyBatis的if标签则能够帮助我们实现这种动态SQL的编写，它允许我们在映射文件中根据条件动态地构建SQL语句。

介绍MyBatis核心知识点之if的语法结构，其重要性在于它能够帮助我们更好地理解和运用MyBatis的动态SQL功能。在开发过程中，合理地使用if标签可以让我们编写出更加灵活、高效的SQL语句，从而提高整个应用程序的性能和可维护性。

接下来，我们将深入探讨if标签的基本语法和属性表达式。首先，我们将介绍if标签的基本语法结构，包括如何使用test属性来指定条件表达式。然后，我们将详细讲解if标签的属性和表达式，包括如何使用内置的MyBatis变量和自定义的SQL片段，以及如何通过这些属性和表达式来构建复杂的动态SQL语句。

通过本节内容的介绍，读者将能够掌握if标签的基本使用方法，并能够根据实际需求构建出满足不同条件的动态SQL语句。这不仅能够提高SQL语句的灵活性和可维护性，还能够帮助我们更好地应对复杂的业务场景。

// MyBatis if 标签的基本语法示例
<select id="selectUsers" resultType="User">
  SELECT * FROM users
  <where>
    <if test="username != null">
      AND username = #{username}
    </if>
    <if test="email != null">
      AND email = #{email}
    </if>
  </where>
</select>

MyBatis 的 if 标签是动态 SQL 的核心之一，它允许我们在运行时根据条件动态地构建 SQL 语句。下面将详细阐述 if 标签的基本语法。

首先，if 标签通常位于 <where> 标签内部，用于处理 SQL 语句中的条件部分。在 <if> 标签中，我们使用 test 属性来指定条件表达式。这个表达式是一个基于传入参数的布尔值，如果为 true，则 if 标签内的内容将被包含在最终的 SQL 语句中。

在上述代码示例中，我们定义了一个名为 selectUsers 的查询，它从 users 表中检索数据。if 标签用于根据 username 和 email 参数的值来动态构建查询条件。

  • 当 username 不为 null 时，if 标签将生成 AND username = #{username} 条件。
  • 当 email 不为 null 时，if 标签将生成 AND email = #{email} 条件。

这里，#{username} 和 #{email} 是参数绑定，它们将替换为实际的参数值。这种绑定方式可以防止 SQL 注入攻击，因为它会将参数值作为预处理语句的一部分。

if 标签不仅可以处理单个条件，还可以嵌套使用，以构建更复杂的条件表达式。例如，我们可以根据 username 的值来决定是否包含 email 条件：

<select id="selectUsers" resultType="User">
  SELECT * FROM users
  <where>
    <if test="username != null">
      AND username = #{username}
    </if>
    <if test="email != null and username != null">
      AND email = #{email}
    </if>
  </where>
</select>

在这个例子中，只有当 username 和 email 都不为 null 时，email 条件才会被包含。

此外，if 标签还支持逻辑运算符，如 and 和 or，以组合多个条件。例如：

<select id="selectUsers" resultType="User">
  SELECT * FROM users
  <where>
    <if test="username != null">
      username = #{username}
    </if>
    <if test="email != null">
      OR email = #{email}
    </if>
  </where>
</select>

在这个例子中，如果 username 或 email 不为 null，查询将返回相应的结果。

使用 if 标签时，需要注意性能影响。动态 SQL 可能会导致查询计划的变化，这可能会影响查询性能。因此，在构建复杂的动态 SQL 语句时，应仔细考虑性能因素。

最后，以下是一些使用 if 标签的最佳实践：

  • 尽量保持 SQL 语句的简洁性，避免过度使用动态 SQL。
  • 在可能的情况下，使用预定义的查询和参数，而不是动态构建 SQL 语句。
  • 在开发过程中，测试动态 SQL 语句的性能，以确保它们不会对应用程序的性能产生负面影响。
MyBatis if 标签特性描述
位置通常位于 <where> 标签内部，用于动态构建 SQL 语句的条件部分
条件表达式使用 test 属性指定，基于传入参数的布尔值表达式
参数绑定使用 #{} 占位符进行参数绑定，防止 SQL 注入
单个条件当条件表达式为 true 时，包含 if 标签内的内容
嵌套使用可以嵌套使用，构建更复杂的条件表达式
逻辑运算符支持 and 和 or 等逻辑运算符，组合多个条件
性能影响动态 SQL 可能导致查询计划变化，影响查询性能
最佳实践保持 SQL 语句简洁，使用预定义查询和参数，测试性能

MyBatis 的 if 标签在动态构建 SQL 语句时扮演着至关重要的角色。它不仅能够根据条件动态地添加或删除 SQL 语句的部分，还能有效地防止 SQL 注入的风险。在实际应用中，合理地使用 if 标签可以显著提升代码的可读性和可维护性。然而，需要注意的是，动态 SQL 的使用可能会对查询性能产生一定的影响，因此在设计 SQL 语句时，应尽量保持简洁，并考虑使用预定义查询和参数，以确保系统的稳定性和高效性。

// MyBatis if标签的使用场景
// 场景一：根据条件动态构建SQL语句
// 场景二：实现动态表名和字段名
// 场景三：根据不同条件执行不同的SQL操作

// MyBatis if标签的属性介绍
// property：指定一个属性，用于判断是否执行SQL片段
// test：表达式，用于判断是否执行SQL片段

// MyBatis if标签的表达式类型
// ==：等于
// !=：不等于
// >：大于
// <：小于
// >=：大于等于
// <=：小于等于
// &&：逻辑与
// ||：逻辑或
// !：逻辑非

// MyBatis if标签与choose、when、otherwise标签的配合使用
// 场景一：根据多个条件选择执行不同的SQL片段
// 场景二：实现多表查询的动态SQL

// MyBatis if标签在动态SQL中的实际应用
// 动态构建SQL语句，实现条件查询、分页查询、排序查询等

// MyBatis if标签的性能影响
// 正确使用if标签可以提高SQL语句的执行效率，减少数据库的查询次数

// MyBatis if标签的最佳实践
// 1. 尽量使用简单的表达式，避免复杂的逻辑判断
// 2. 尽量减少if标签的使用，避免SQL语句过于复杂
// 3. 使用choose、when、otherwise标签代替多个if标签

// MyBatis if标签的注意事项
// 1. 注意属性和表达式的正确使用
// 2. 避免使用过于复杂的逻辑判断
// 3. 注意SQL语句的执行效率

// MyBatis if标签与其他动态SQL标签的比较
// 与<choose>、<when>、<otherwise>标签相比，if标签更加灵活，但使用起来较为复杂
// 与<foreach>标签相比，if标签主要用于条件判断，而<foreach>标签主要用于循环遍历

MyBatis if标签在动态SQL中扮演着重要的角色，它可以根据不同的条件动态构建SQL语句，实现灵活的数据库操作。下面将详细介绍MyBatis if标签的相关知识点。

首先，if标签的使用场景主要包括以下几种：

  1. 根据条件动态构建SQL语句，例如根据用户输入的条件查询数据库中的数据。
  2. 实现动态表名和字段名，例如根据不同的业务需求动态选择表名和字段名。
  3. 根据不同条件执行不同的SQL操作，例如根据用户权限动态执行不同的SQL语句。

if标签的属性介绍如下：

  • property：指定一个属性，用于判断是否执行SQL片段。
  • test：表达式，用于判断是否执行SQL片段。

if标签的表达式类型包括：

  • ==：等于
  • !=：不等于

  • ：大于

  • <：小于

  • =：大于等于

  • <=：小于等于
  • &&：逻辑与
  • ||：逻辑或
  • !：逻辑非

if标签与choose、when、otherwise标签的配合使用可以实现更复杂的条件判断。例如，根据多个条件选择执行不同的SQL片段，或者实现多表查询的动态SQL。

在实际应用中，if标签可以动态构建SQL语句，实现条件查询、分页查询、排序查询等功能。例如，以下是一个使用if标签实现条件查询的示例：

<select id="selectUsers" resultType="User">
  SELECT * FROM users
  <where>
    <if test="username != null">
      AND username = #{username}
    </if>
    <if test="email != null">
      AND email = #{email}
    </if>
  </where>
</select>

在使用if标签时，需要注意以下几点：

  1. 注意属性和表达式的正确使用。
  2. 避免使用过于复杂的逻辑判断。
  3. 注意SQL语句的执行效率。

与choose、when、otherwise标签相比，if标签更加灵活，但使用起来较为复杂。与foreach标签相比，if标签主要用于条件判断，而foreach标签主要用于循环遍历。在实际应用中，应根据具体需求选择合适的动态SQL标签。

MyBatis if标签使用场景描述
根据条件动态构建SQL语句根据用户输入的条件动态构建查询语句，如根据用户名或邮箱查询数据库数据。
实现动态表名和字段名根据不同的业务需求动态选择表名和字段名，以适应不同的数据结构。
根据不同条件执行不同的SQL操作根据用户权限或其他条件动态执行不同的SQL语句，如权限控制下的数据访问。
MyBatis if标签属性介绍属性描述
property属性名用于判断是否执行SQL片段的属性。
test表达式用于判断是否执行SQL片段的表达式。
MyBatis if标签表达式类型表达式描述
==等于判断两个值是否相等。
!=不等于判断两个值是否不相等。
>大于判断左侧值是否大于右侧值。
<小于判断左侧值是否小于右侧值。
>=大于等于判断左侧值是否大于或等于右侧值。
<=小于等于判断左侧值是否小于或等于右侧值。
&&逻辑与判断两个条件是否同时为真。
逻辑或判断两个条件中至少有一个为真。
!逻辑非判断条件是否为假。
MyBatis if标签与choose、when、otherwise标签配合使用场景描述
根据多个条件选择执行不同的SQL片段复杂条件判断时，根据多个条件选择执行不同的SQL片段。
实现多表查询的动态SQL在多表查询中，根据条件动态构建SQL语句。
MyBatis if标签在动态SQL中的实际应用功能示例
条件查询根据条件查询数据<select id="selectUsers" resultType="User"> ... <where> ... <if test="username != null"> AND username = #{username} </if> ... </where> </select>
分页查询实现数据的分页显示<select id="selectUsersByPage" resultType="User"> ... <if test="page != null and pageSize != null"> LIMIT #{page}, #{pageSize} </if> ... </select>
排序查询根据指定字段排序数据<select id="selectUsersSorted" resultType="User"> ... ORDER BY <if test="sortField != null"> #{sortField} </if> <if test="sortOrder != null"> #{sortOrder} </if> ... </select>
MyBatis if标签的性能影响描述
正确使用if标签可以提高SQL语句的执行效率通过减少不必要的数据库查询次数，提高整体性能。
MyBatis if标签的最佳实践建议
尽量使用简单的表达式避免复杂的逻辑判断，提高代码可读性和维护性。
尽量减少if标签的使用避免SQL语句过于复杂，降低性能。
使用choose、when、otherwise标签代替多个if标签简化条件判断逻辑，提高代码可读性。
MyBatis if标签的注意事项建议
注意属性和表达式的正确使用确保属性和表达式符合预期，避免错误。
避免使用过于复杂的逻辑判断简化逻辑判断，提高代码可维护性。
注意SQL语句的执行效率优化SQL语句，减少数据库查询次数。
MyBatis if标签与其他动态SQL标签的比较标签特点
if灵活但复杂适用于复杂的条件判断，但使用较为复杂。
choose、when、otherwise简化逻辑适用于多条件选择，代码更简洁。
foreach循环遍历适用于循环遍历集合，如in语句。

MyBatis的if标签在动态SQL构建中扮演着至关重要的角色，它允许开发者根据运行时条件动态地决定是否包含特定的SQL片段。这种灵活性不仅提高了SQL语句的适应性，而且还能有效减少不必要的数据库访问，从而优化性能。例如，在处理用户权限验证时，可以根据用户的角色动态地构建查询语句，确保只有授权用户才能访问特定的数据。此外，if标签在处理多表关联查询时同样表现出色，它能够根据查询条件动态地选择参与查询的表，从而简化了复杂的查询逻辑。通过合理运用if标签，开发者可以构建出既高效又灵活的数据库访问策略。

🍊 MyBatis核心知识点之if：条件判断

在开发过程中，我们常常需要根据不同的业务需求动态地构建SQL语句。MyBatis框架提供了强大的动态SQL功能，其中if标签是实现条件判断的关键。以下是一个典型的场景：假设我们正在开发一个用户管理系统，需要根据用户的角色动态地查询用户信息。如果用户是管理员，则查询所有字段；如果用户是普通用户，则只查询用户名和邮箱。这种情况下，if标签就派上了用场。

MyBatis的if标签允许我们在SQL语句中根据条件动态地包含或排除某些部分。这是MyBatis动态SQL的核心特性之一，它使得我们能够编写灵活、可扩展的SQL语句，而不必硬编码条件。

首先，我们来介绍if标签的基本条件判断。基本条件判断通常用于根据单个条件来决定是否包含某个SQL片段。例如，我们可以根据用户角色来决定是否查询所有字段：

<select id="selectUsers" resultType="User">
  SELECT
    <if test="role == 'admin'">
      id, username, email, role
    </if>
    <if test="role != 'admin'">
      username, email
    </if>
  FROM users
</select>

接下来，我们将探讨复合条件判断。复合条件判断允许我们根据多个条件来决定是否包含某个SQL片段。例如，我们可能需要根据用户角色和状态来决定查询哪些字段：

<select id="selectUsers" resultType="User">
  SELECT
    <if test="role == 'admin' and status == 'active'">
      id, username, email, role, status
    </if>
    <if test="role == 'admin' and status != 'active'">
      id, username, email, role
    </if>
    <if test="role != 'admin'">
      username, email
    </if>
  FROM users
</select>

通过使用if标签，我们可以根据不同的业务需求灵活地构建SQL语句，从而提高代码的可读性和可维护性。在接下来的内容中，我们将详细探讨MyBatis的if标签在不同场景下的应用，包括基本条件判断和复合条件判断的详细使用方法。

MyBatis 是一款优秀的持久层框架，它消除了几乎所有的 JDBC 代码和手动设置参数以及获取结果集的工作。在 MyBatis 中，动态 SQL 是一个非常强大的功能，它允许我们在运行时构建 SQL 语句。其中，if 标签是 MyBatis 动态 SQL 的核心之一，主要用于实现基本的条件判断。

🎉 基本条件判断

在 MyBatis 中，if 标签通常与 select、update、delete 等元素结合使用，以实现基于条件的动态 SQL。以下是一个简单的例子：

<select id="selectUser" resultType="User">
  SELECT * FROM user
  <where>
    <if test="name != null and name != ''">
      AND name = #{name}
    </if>
    <if test="age != null">
      AND age = #{age}
    </if>
  </where>
</select>

在这个例子中，我们根据 name 和 age 的值动态构建 SQL 语句。如果 name 不为空且不为空字符串，则 SQL 语句中会包含 AND name = #{name}；如果 age 不为空，则 SQL 语句中会包含 AND age = #{age}。

🎉 参数绑定

在 MyBatis 中，参数绑定是通过 #{} 占位符实现的。在上面的例子中，#{name} 和 #{age} 分别表示将传入的 name 和 age 参数值绑定到 SQL 语句中对应的占位符。

🎉 逻辑运算符

在 if 标签中，我们可以使用逻辑运算符（如 and、or）来组合多个条件。以下是一个使用逻辑运算符的例子：

<select id="selectUser" resultType="User">
  SELECT * FROM user
  <where>
    <if test="name != null and name != ''">
      AND name = #{name}
    </if>
    <if test="age != null">
      OR age = #{age}
    </if>
  </where>
</select>

在这个例子中，如果 name 不为空且不为空字符串，则 SQL 语句中会包含 AND name = #{name}；如果 age 不为空，则 SQL 语句中会包含 OR age = #{age}。

🎉 条件组合

在实际应用中，我们可能需要根据多个条件组合来构建 SQL 语句。以下是一个使用条件组合的例子：

<select id="selectUser" resultType="User">
  SELECT * FROM user
  <where>
    <if test="name != null and name != ''">
      AND name = #{name}
    </if>
    <if test="age != null">
      AND age = #{age}
    </if>
    <if test="email != null and email != ''">
      AND email = #{email}
    </if>
  </where>
</select>

在这个例子中，如果 name、age 和 email 都不为空，则 SQL 语句中会包含 AND name = #{name} AND age = #{age} AND email = #{email}。

🎉 嵌套条件

在某些情况下，我们需要根据嵌套条件来构建 SQL 语句。以下是一个使用嵌套条件的例子：

<select id="selectUser" resultType="User">
  SELECT * FROM user
  <where>
    <if test="name != null and name != ''">
      AND name = #{name}
    </if>
    <if test="age != null">
      AND age = #{age}
    </if>
    <if test="email != null and email != ''">
      AND email = #{email}
    </if>
    <if test="role != null">
      AND (
        <if test="role == 'admin'">
          role = 'admin'
        </if>
        <if test="role == 'user'">
          role = 'user'
        </if>
      )
    </if>
  </where>
</select>

在这个例子中，如果 role 为 admin 或 user，则 SQL 语句中会包含 AND role = 'admin' OR role = 'user'。

🎉 性能优化

在使用 if 标签时，我们需要注意性能优化。以下是一些优化建议：

  1. 尽量减少条件判断的数量，避免过多的 if 标签嵌套。
  2. 使用 trim 标签去除多余的 AND 或 OR 关键字。
  3. 使用 choose、when、otherwise 标签代替多个 if 标签，提高可读性。

通过以上介绍，相信大家对 MyBatis 中的 if 标签有了更深入的了解。在实际开发中，灵活运用 if 标签，可以有效地构建动态 SQL，提高代码的可读性和可维护性。

功能点描述示例
动态 SQLMyBatis 允许在运行时构建 SQL 语句，无需手动编写完整的 SQL 语句。使用 if 标签根据条件动态添加 SQL 语句部分。
if 标签实现基本的条件判断，是动态 SQL 的核心之一。根据 name 和 age 的值动态构建 SQL 语句。
参数绑定使用 #{} 占位符将传入的参数值绑定到 SQL 语句中。#{name} 和 #{age} 将参数值绑定到 SQL 语句的占位符。
逻辑运算符使用 and、or 等逻辑运算符组合多个条件。使用 AND 和 OR 在 if 标签中组合条件。
条件组合根据多个条件组合构建 SQL 语句。同时检查 name、age 和 email 的值。
嵌套条件根据嵌套条件构建 SQL 语句。根据 role 的值，嵌套判断 role 是否为 admin 或 user。
性能优化减少条件判断数量，使用 trim 标签去除多余关键字，使用 choose 标签提高可读性。减少嵌套 if 标签，使用 trim 去除多余的 AND 或 OR，使用 choose 替代多个 if。

动态 SQL 的引入，极大地简化了数据库操作的开发过程，尤其是在处理复杂查询时，无需编写冗长的 SQL 语句，只需通过 MyBatis 提供的标签和功能，就能实现动态构建 SQL 的目的。例如，在处理用户查询时，可以根据用户输入的姓名和年龄，动态地拼接出相应的 SQL 语句，从而提高了代码的可读性和可维护性。此外，动态 SQL 还支持嵌套条件，使得在处理多级查询时，能够更加灵活地构建 SQL 语句，满足各种复杂的业务需求。

MyBatis的if标签是动态SQL的核心之一，它允许我们在执行SQL查询时根据条件动态地构建SQL语句。在处理复合条件判断时，if标签能够帮助我们构建灵活且高效的查询语句。

首先，我们需要了解if标签的基本用法。在MyBatis的XML映射文件中，我们可以使用if标签来根据传入的参数值动态地决定是否包含某个SQL片段。下面是一个简单的例子：

<select id="selectUsers" resultType="User">
  SELECT * FROM users
  <where>
    <if test="username != null">
      AND username = #{username}
    </if>
    <if test="email != null">
      AND email = #{email}
    </if>
  </where>
</select>

在这个例子中，我们根据username和email参数的值来动态地构建SQL语句。如果这两个参数都不为null，那么SQL语句将包含这两个条件。

接下来，让我们探讨一些复合条件判断的高级用法。

🎉 条件组合

在MyBatis中，我们可以使用逻辑运算符来组合多个条件。例如，如果我们想同时检查username和email是否为null，我们可以这样写：

<select id="selectUsers" resultType="User">
  SELECT * FROM users
  <where>
    <if test="username != null and email != null">
      AND username = #{username} AND email = #{email}
    </if>
  </where>
</select>

🎉 嵌套条件

有时候，我们需要在条件判断中嵌套其他条件。MyBatis允许我们这样做：

<select id="selectUsers" resultType="User">
  SELECT * FROM users
  <where>
    <if test="username != null">
      AND username = #{username}
      <if test="email != null">
        AND email = #{email}
      </if>
    </if>
  </where>
</select>

在这个例子中，如果username不为null，那么SQL语句将检查email是否也不为null。

🎉 多条件判断

在处理多条件查询时，我们需要注意性能问题。过多的条件可能会导致查询效率降低。以下是一些最佳实践：

  1. 避免使用过多的嵌套条件：嵌套条件会增加SQL语句的复杂度，从而降低查询效率。
  2. 使用索引：确保查询中使用的列都有适当的索引，这可以显著提高查询速度。
  3. 避免使用LIKE操作符：LIKE操作符通常会导致全表扫描，从而降低查询效率。

🎉 最佳实践

  1. 使用if标签来动态构建SQL语句：这样可以避免硬编码SQL语句，提高代码的可维护性。
  2. 避免使用过多的条件：过多的条件会导致查询效率降低。
  3. 使用索引：确保查询中使用的列都有适当的索引。

通过合理地使用MyBatis的if标签，我们可以构建灵活且高效的查询语句，从而提高应用程序的性能。

条件类型例子说明
单个条件判断<if test="username != null">AND username = #{username}</if>根据单个参数值动态构建SQL语句，如根据用户名查询用户。
复合条件判断<if test="username != null and email != null">AND username = #{username} AND email = #{email}</if>根据多个参数值组合逻辑运算符动态构建SQL语句，如同时根据用户名和邮箱查询用户。
嵌套条件判断<if test="username != null"><if test="email != null">AND email = #{email}</if></if>在条件判断中嵌套其他条件，如先判断用户名，再判断邮箱。
多条件判断<if test="username != null or email != null">AND (username = #{username} OR email = #{email})</if>处理多个条件时，注意性能问题，如使用逻辑运算符组合条件。
最佳实践- 使用if标签动态构建SQL语句<br>- 避免使用过多的条件<br>- 使用索引提高查询效率通过合理使用if标签，提高代码可维护性和应用程序性能。

在实际应用中，合理运用条件判断可以显著提升SQL语句的灵活性和可读性。例如，在用户登录验证时，我们可能需要同时检查用户名和密码的有效性。通过使用if标签，我们可以根据用户输入动态构建查询条件，从而避免硬编码，提高代码的复用性和可维护性。然而，过多的条件判断可能导致SQL语句变得复杂，影响执行效率。因此，在编写条件判断时，应遵循最佳实践，如避免冗余条件，并充分利用数据库索引来优化查询性能。

🍊 MyBatis核心知识点之if：常用属性

在MyBatis框架中，动态SQL的编写是提高SQL语句灵活性和可维护性的关键。特别是在处理复杂业务逻辑时，静态SQL往往难以满足需求。本文将围绕MyBatis核心知识点之if：常用属性展开，探讨其重要性和实用性。

在实际开发中，我们常常会遇到根据不同条件动态构建SQL语句的需求。例如，在查询数据库时，可能需要根据用户输入的参数动态地添加查询条件。这时，MyBatis的if标签就派上了用场。通过使用if标签，我们可以根据条件动态地包含或排除SQL片段，从而实现动态SQL的编写。

介绍MyBatis核心知识点之if：常用属性的原因在于，它能够极大地提高SQL语句的灵活性和可维护性。在传统的静态SQL编写中，如果需要添加或修改查询条件，往往需要对整个SQL语句进行修改，这无疑增加了代码的复杂度和出错的可能性。而使用if标签，我们可以将SQL语句的各个部分独立出来，根据条件动态地组合，从而简化了SQL的编写和维护。

接下来，我们将对MyBatis核心知识点之if：常用属性进行详细讲解。首先，我们将介绍test属性，它用于判断是否执行if标签内的SQL片段。test属性可以是一个布尔表达式，当表达式的结果为true时，执行if标签内的SQL片段。

随后，我们将探讨choose、when、otherwise属性。这三个属性用于实现类似于Java中的switch-case语句的功能。通过使用choose标签，我们可以根据不同的条件执行不同的when子标签中的SQL片段，而otherwise子标签则用于处理所有未匹配到的条件。

通过以上对MyBatis核心知识点之if：常用属性的介绍，读者可以了解到如何根据条件动态构建SQL语句，从而提高SQL语句的灵活性和可维护性。在后续的内容中，我们将详细介绍test属性和choose、when、otherwise属性的具体用法，帮助读者更好地掌握MyBatis动态SQL的编写技巧。

MyBatis的动态SQL是MyBatis框架中一个非常重要的特性，它允许我们在编写SQL语句时，根据不同的条件动态地拼接SQL片段。其中，if标签结合test属性是实现条件判断的关键。下面，我们将深入探讨MyBatis中if: test属性的核心知识点。

在MyBatis的XML映射文件中，if标签用于在SQL语句中根据条件动态地包含或排除某些片段。test属性是if标签的核心，它定义了条件表达式，当表达式为真时，if标签内的内容才会被包含在最终的SQL语句中。

<select id="selectUsers" resultType="User">
  SELECT * FROM users
  <where>
    <if test="username != null">
      AND username = #{username}
    </if>
    <if test="email != null">
      AND email = #{email}
    </if>
  </where>
</select>

在上面的例子中，如果username或email参数非空，那么SQL语句中会包含相应的条件。

🎉 条件判断

test属性可以是一个简单的布尔表达式，也可以是一个包含参数的表达式。MyBatis会根据表达式的结果来决定是否包含if标签内的内容。

<if test="username != null and username != ''">
  AND username = #{username}
</if>

在这个例子中，只有当username非空且不为空字符串时，才会包含AND username = #{username}这一片段。

🎉 参数绑定

在if标签中，可以使用#{}来绑定参数。这种方式可以防止SQL注入攻击，因为MyBatis会自动处理参数的转义。

<if test="username != null">
  AND username = #{username}
</if>

🎉 SQL片段

if标签不仅可以用于简单的条件判断，还可以用于复杂的SQL片段。例如，我们可以根据不同的条件选择不同的排序方式。

<select id="selectUsers" resultType="User">
  SELECT * FROM users
  <where>
    <if test="orderBy != null">
      ORDER BY ${orderBy}
    </if>
  </where>
</select>

在这个例子中，如果orderBy参数非空，那么SQL语句会根据orderBy参数的值来决定排序方式。

🎉 逻辑运算符

在test属性中，可以使用逻辑运算符来组合多个条件。例如，我们可以使用and和or来组合多个条件。

<if test="username != null and email != null">
  AND username = #{username} OR email = #{email}
</if>

在这个例子中，只有当username和email都不为空时，才会包含AND username = #{username} OR email = #{email}这一片段。

🎉 性能影响

使用动态SQL时，需要注意性能问题。如果条件过多，可能会导致SQL语句过于复杂，从而影响查询性能。因此，在设计SQL语句时，应尽量保持简洁。

🎉 使用场景

动态SQL在以下场景中非常有用：

  • 根据不同的条件查询数据
  • 根据不同的条件更新数据
  • 根据不同的条件删除数据

🎉 最佳实践

  • 尽量保持SQL语句简洁，避免过于复杂的条件
  • 使用#{}来绑定参数，防止SQL注入攻击
  • 在test属性中使用逻辑运算符来组合多个条件

通过以上对MyBatis中if: test属性的核心知识点的探讨，我们可以更好地理解如何在MyBatis中使用动态SQL，从而提高代码的可读性和可维护性。

特性/概念描述示例
动态SQLMyBatis中根据条件动态拼接SQL片段的特性。<if test="username != null">AND username = #{username}</if>
if标签用于在SQL语句中根据条件动态包含或排除某些片段。<if test="username != null">AND username = #{username}</if>
test属性定义条件表达式，当表达式为真时，if标签内的内容才会被包含。<if test="username != null">AND username = #{username}</if>
条件判断test属性可以是一个简单的布尔表达式，也可以是一个包含参数的表达式。<if test="username != null and username != ''">AND username = #{username}</if>
参数绑定使用#{}来绑定参数，防止SQL注入攻击。<if test="username != null">AND username = #{username}</if>
SQL片段if标签可以用于复杂的SQL片段，如选择不同的排序方式。<if test="orderBy != null">ORDER BY ${orderBy}</if>
逻辑运算符在test属性中使用逻辑运算符来组合多个条件。<if test="username != null and email != null">AND username = #{username} OR email = #{email}</if>
性能影响条件过多可能导致SQL语句复杂，影响查询性能。避免过于复杂的条件，保持SQL语句简洁。
使用场景根据不同条件查询、更新、删除数据。根据用户名或邮箱查询用户信息。
最佳实践保持SQL语句简洁，使用#{}绑定参数，使用逻辑运算符组合条件。避免复杂条件，使用参数绑定，合理使用逻辑运算符。

动态SQL在MyBatis框架中的应用，极大地提高了SQL语句的灵活性和可维护性。通过if标签和test属性，开发者可以轻松地根据不同的业务需求动态地拼接SQL语句，从而避免了硬编码和重复代码的产生。然而，在实际使用中，我们需要注意避免过度使用动态SQL，以免造成SQL语句过于复杂，影响数据库的查询性能。例如，在处理大量数据时，应尽量减少条件判断的使用，以保持SQL语句的简洁性。

// MyBatis if 标签的使用场景
// 在编写动态 SQL 时，根据不同的条件动态拼接 SQL 语句，以实现灵活的查询需求。

// choose、when、otherwise 属性的语法结构
// <choose>
//     <when test="条件1">
//         SQL片段1
//     </when>
//     <when test="条件2">
//         SQL片段2
//     </when>
//     <otherwise>
//         默认SQL片段
//     </otherwise>
// </choose>

// if 标签在动态 SQL 中的作用
// if 标签用于根据条件动态拼接 SQL 语句，提高 SQL 的灵活性和可维护性。

// 与其他动态 SQL 标签（如 where、set）的配合使用
// if 标签可以与 where、set 等标签配合使用，实现复杂的动态 SQL 拼接。

// if 标签的性能影响
// if 标签的使用会增加 SQL 拼接的复杂度，可能会对性能产生一定影响。

// 实际应用案例
// 假设有一个用户表，根据用户名和年龄查询用户信息。

// 与传统 SQL 语句的对比
// 传统 SQL 语句需要编写多个查询语句，而 MyBatis 的动态 SQL 可以通过 if 标签实现条件判断，简化代码。

// 代码示例
// <select id="selectUser" resultType="User">
//     SELECT * FROM user
//     <where>
//         <if test="username != null">
//             AND username = #{username}
//         </if>
//         <if test="age != null">
//             AND age = #{age}
//         </if>
//     </where>
// </select>

// 错误处理与调试技巧
// 在使用 if 标签时，需要注意条件的正确性，避免出现 SQL 异常。同时，可以使用日志记录 SQL 语句，方便调试。
标签名称语法结构作用配合使用性能影响实际应用案例与传统 SQL 对比代码示例错误处理与调试技巧
if<if test="条件">SQL片段</if>根据条件动态拼接 SQL 语句与 where、set 等标签配合使用增加SQL拼接复杂度，可能影响性能根据用户名和年龄查询用户信息简化代码，提高可维护性<select id="selectUser" resultType="User">SELECT * FROM user <where> <if test="username != null">AND username = #{username}</if> <if test="age != null">AND age = #{age}</if> </where></select>注意条件正确性，使用日志记录SQL语句方便调试
choose<choose> <when test="条件">SQL片段</when> <when test="条件">SQL片段</when> <otherwise>默认SQL片段</otherwise> </choose>根据多个条件选择执行不同的 SQL 片段无增加SQL拼接复杂度，可能影响性能根据不同条件查询不同用户信息提供更灵活的条件判断无无
where<where>自动处理前导 AND 或 OR 关键字，避免生成无效的 WHERE 子句与 if 标签配合使用无无自动优化 WHERE 子句，提高性能<select id="selectUser" resultType="User">SELECT * FROM user <where> <if test="username != null">username = #{username}</if> <if test="age != null">AND age = #{age}</if> </where></select>无无
set<set>自动处理前导逗号，避免生成无效的 SET 子句无无无自动优化 SET 子句，提高性能<update id="updateUser" parameterType="User">UPDATE user <set> <if test="username != null">username = #{username}</if> <if test="age != null">age = #{age}</if> </set></update>无无

在实际应用中，使用MyBatis的动态SQL标签可以显著提高代码的可读性和可维护性。例如，在处理复杂的查询逻辑时，if标签能够根据不同的条件动态地拼接SQL语句，从而避免了硬编码和复杂的逻辑判断。然而，这也可能导致SQL拼接的复杂度增加，进而可能对性能产生一定影响。因此，在编写SQL语句时，应仔细考虑条件的正确性，并利用日志记录功能来追踪和调试SQL语句，确保其正确执行。此外，与传统SQL相比，MyBatis的动态SQL标签能够更好地适应业务需求的变化，使得代码更加灵活和可扩展。

🍊 MyBatis核心知识点之if：示例

在开发过程中，MyBatis框架的灵活运用对于构建高效、可维护的数据库操作至关重要。特别是在处理复杂查询时，如何根据不同的条件动态构建SQL语句，成为了一个关键问题。本文将围绕MyBatis的核心知识点之一——if标签的使用进行深入探讨。

在实际应用中，我们常常需要根据业务逻辑动态调整SQL查询条件。例如，在查询用户信息时，可能需要根据用户的角色、状态或者是否活跃等条件来筛选数据。如果使用传统的硬编码方式，不仅代码冗长，而且可维护性差。MyBatis的if标签正是为了解决这一问题而设计的。

if标签允许开发者根据特定的条件动态地包含或排除SQL片段。这种动态SQL的能力极大地提高了MyBatis的灵活性和实用性。通过使用if标签，我们可以根据不同的业务场景灵活地构建SQL语句，从而避免硬编码，提高代码的可读性和可维护性。

接下来，我们将通过三个示例来详细讲解if标签的使用。首先，我们将介绍if标签的基本使用方法，展示如何根据简单的条件动态地添加SQL片段。然后，我们将探讨如何使用复合条件进行更复杂的判断，以适应更复杂的业务需求。最后，我们将深入探讨choose、when、otherwise属性的使用，这些属性提供了类似于Java中的switch语句的功能，使得动态SQL的构建更加灵活和强大。

通过这三个示例，读者将能够全面理解MyBatis中if标签的强大功能，并在实际项目中灵活运用，从而提高数据库操作的效率和代码质量。在后续的内容中，我们将逐一展开这三个示例，帮助读者逐步掌握MyBatis动态SQL的构建技巧。

MyBatis的if标签是动态SQL的核心组成部分，它允许我们在运行时根据条件动态地构建SQL语句。下面，我们将通过一个示例来详细讲解MyBatis的if标签的基本使用。

在MyBatis中，if标签通常被用在<select>、<update>、<delete>等标签内部，用于根据传入的参数动态地决定是否包含某些SQL片段。下面是一个简单的示例：

<select id="selectUsers" resultType="User">
  SELECT * FROM users
  <where>
    <if test="username != null">
      AND username = #{username}
    </if>
    <if test="email != null">
      AND email = #{email}
    </if>
  </where>
</select>

在这个示例中，我们定义了一个名为selectUsers的查询，它从users表中检索用户信息。<where>标签用于自动处理SQL语句中的AND或OR关键字，避免生成无效的SQL语句。

接下来，我们使用if标签来根据传入的参数动态地添加条件。如果username不为空，则添加AND username = #{username}条件；如果email不为空，则添加AND email = #{email}条件。

在MyBatis中，test属性用于指定一个布尔表达式，该表达式将决定if标签内的SQL片段是否被包含在最终的SQL语句中。在上面的示例中，如果username或email至少有一个不为空，那么生成的SQL语句将包含相应的条件。

下面是MyBatis配置文件中对应的Mapper接口：

public interface UserMapper {
  List<User> selectUsers(@Param("username") String username, @Param("email") String email);
}

在这个接口中，我们定义了一个selectUsers方法，它接受两个参数：username和email。这些参数将被传递到MyBatis的XML映射文件中。

通过使用MyBatis的if标签，我们可以轻松地构建动态SQL语句，从而提高代码的可读性和可维护性。此外，动态SQL还可以提高性能，因为它可以避免生成无效的SQL语句。

总结一下，MyBatis的if标签是一种强大的工具，可以帮助我们在运行时根据条件动态地构建SQL语句。通过上面的示例，我们可以看到如何使用if标签来根据传入的参数动态地添加条件，从而构建灵活且高效的SQL查询。

MyBatis if标签特性说明
动态SQL构建允许在运行时根据条件动态构建SQL语句，提高代码的可读性和可维护性
标签位置通常用于<select>、<update>、<delete>等标签内部
条件判断通过test属性指定布尔表达式，决定SQL片段是否被包含
自动处理关键字<where>标签自动处理SQL语句中的AND或OR关键字，避免生成无效的SQL语句
参数传递通过接口方法参数将条件传递到XML映射文件中
示例场景根据用户名和邮箱查询用户信息，根据参数动态添加条件
性能优化避免生成无效的SQL语句，提高性能
代码示例XML映射文件中<if>标签的使用
接口定义Mapper接口中定义方法，接收参数并传递到XML映射文件

MyBatis的if标签特性在动态SQL构建中扮演着至关重要的角色。它不仅允许开发者根据运行时的条件动态构建SQL语句，从而提升代码的可读性和可维护性，而且还能在XML映射文件中灵活地处理各种复杂的查询需求。通过合理运用if标签，开发者可以避免编写冗长且难以维护的SQL代码，同时还能通过自动处理关键字如AND或OR，有效避免生成无效的SQL语句，从而优化性能。例如，在根据用户名和邮箱查询用户信息的场景中，if标签能够根据传入的参数动态添加查询条件，极大地提高了代码的灵活性和可扩展性。

// MyBatis if标签的使用
// MyBatis的if标签是动态SQL的核心，它允许我们在执行SQL语句时根据条件动态地添加或删除部分SQL片段。

// 复合条件判断的语法结构
// 复合条件判断通常涉及到多个条件，MyBatis通过使用`<choose>`、`<when>`和`<otherwise>`标签来实现。

// 条件表达式编写技巧
// 在编写条件表达式时，应尽量使用简洁明了的表达式，避免复杂的逻辑判断。

// 示例代码分析
// 假设我们有一个用户实体，包含姓名、年龄和性别属性，以下是一个使用MyBatis的if标签进行复合条件判断的示例。

public interface UserMapper {
    // 根据用户名、年龄和性别查询用户信息
    List<User> findUserByCondition(@Param("username") String username, @Param("age") Integer age, @Param("gender") String gender);
}

// MyBatis的Mapper.xml配置文件
<mapper namespace="com.example.mapper.UserMapper">
    <select id="findUserByCondition" resultType="com.example.entity.User">
        SELECT * FROM users
        <where>
            <if test="username != null and username != ''">
                AND username = #{username}
            </if>
            <if test="age != null">
                AND age = #{age}
            </if>
            <if test="gender != null and gender != ''">
                AND gender = #{gender}
            </if>
        </where>
    </select>
</mapper>

// 与其他标签的配合使用
// MyBatis提供了多种标签，如`<foreach>`、`<choose>`等，可以与if标签配合使用，实现更复杂的动态SQL。

// 实际应用场景举例
// 在实际应用中，我们可以根据不同的业务需求，使用if标签进行动态SQL的编写，例如查询满足特定条件的用户、商品等。

// 性能影响分析
// 使用if标签进行动态SQL的编写可能会对性能产生一定影响，因为数据库需要解析和执行动态生成的SQL语句。

// 与其他ORM框架的对比
// 与其他ORM框架相比，MyBatis的动态SQL功能更加灵活，但同时也需要开发者手动编写更多的SQL语句。

// 优化建议
// 为了提高性能，建议在编写动态SQL时尽量减少条件判断的数量，并使用合适的索引。

以上代码块展示了MyBatis中if标签的使用、复合条件判断的语法结构、条件表达式编写技巧、示例代码分析、与其他标签的配合使用、实际应用场景举例、性能影响分析、与其他ORM框架的对比以及优化建议。

标签/概念描述语法示例
if标签MyBatis动态SQL的核心，用于根据条件动态添加或删除SQL片段。<if test="username != null and username != ''"> AND username = #{username} </if>
choose标签类似于Java中的switch语句，用于多条件判断。<choose> <when test="条件1"> ... </when> <when test="条件2"> ... </when> <otherwise> ... </otherwise> </choose>
when标签choose标签中的分支，用于匹配特定的条件。<when test="条件"> ... </when>
otherwise标签choose标签中的默认分支，当所有when条件都不满足时执行。<otherwise> ... </otherwise>
where标签用于自动添加WHERE关键字，并处理前导AND或OR。<where> <if test="条件"> ... </if> <if test="条件"> ... </if> </where>
foreach标签用于遍历集合，常用于in语句和批量操作。<foreach collection="集合" item="变量" separator="," open="(" close=")"> ... </foreach>
实际应用场景根据不同的业务需求，使用if标签进行动态SQL的编写。查询满足特定条件的用户、商品等。
性能影响使用if标签进行动态SQL的编写可能会对性能产生一定影响。数据库需要解析和执行动态生成的SQL语句。
与其他ORM框架对比与其他ORM框架相比，MyBatis的动态SQL功能更加灵活，但需要手动编写更多SQL语句。MyBatis更灵活，但其他ORM框架可能提供更简洁的API。
优化建议减少条件判断的数量，使用合适的索引。避免复杂的条件表达式，合理使用索引以提升查询效率。

MyBatis的动态SQL功能，如if标签，choose标签等，为开发者提供了极大的便利，尤其是在处理复杂业务逻辑时。然而，这种灵活性也带来了一定的性能挑战。在实际应用中，我们需要权衡性能与灵活性，合理使用动态SQL。例如，在查询用户信息时，我们可以利用if标签来动态添加查询条件，如用户名、邮箱等。但要注意，过多的条件判断和复杂的SQL语句可能会降低查询效率。因此，在编写动态SQL时，建议尽量简化条件表达式，并合理使用数据库索引，以提升查询性能。此外，与其他ORM框架相比，MyBatis的动态SQL功能虽然更加灵活，但也需要开发者具备一定的SQL编写能力。因此，在实际开发过程中，我们需要根据项目需求，选择合适的ORM框架和动态SQL策略。

// MyBatis的动态SQL中，choose、when、otherwise标签用于实现类似于Java中的switch-case结构，下面是一个示例代码：

// 假设有一个用户表，包含字段：id, username, age, gender
// 我们需要根据不同的条件查询用户信息

// XML配置文件中的MyBatis映射器
public interface UserMapper {
    // 根据用户名和年龄查询用户信息
    List<User> findUserByUsernameAndAge(@Param("username") String username, @Param("age") Integer age);
}

// MyBatis的XML映射文件
<mapper namespace="com.example.mapper.UserMapper">
    <select id="findUserByUsernameAndAge" resultType="com.example.entity.User">
        SELECT id, username, age, gender
        FROM user
        WHERE 1=1
        <choose>
            <when test="username != null">
                AND username = #{username}
            </when>
            <when test="age != null">
                AND age = #{age}
            </when>
            <otherwise>
                AND username IS NULL AND age IS NULL
            </otherwise>
        </choose>
    </select>
</mapper>

// 在实际应用中，我们可以这样调用这个方法：
// UserMapper userMapper = sqlSession.getMapper(UserMapper.class);
// List<User> users = userMapper.findUserByUsernameAndAge(null, 20);
// for (User user : users) {
//     System.out.println(user.getUsername() + ", " + user.getAge());
// }

在上面的示例中，我们使用了MyBatis的动态SQL功能，通过choose、when、otherwise标签实现了条件判断。当查询条件中的username和age都不为null时，会查询出所有符合条件的用户；当username为null且age不为null时，会查询出所有年龄为指定值的用户；当username和age都为null时，会查询出所有用户。

在实际应用中，我们可以根据不同的业务需求，灵活地使用choose、when、otherwise标签来实现复杂的条件判断。通过这种方式，我们可以避免在SQL语句中硬编码条件，提高了代码的可读性和可维护性。

动态SQL标签功能描述代码示例适用场景
choose类似于Java中的switch-case结构，根据多个条件选择执行其中一个分支<choose> <when test="username != null"> <otherwise> </choose>实现复杂的条件判断，避免SQL语句硬编码，提高代码可读性和可维护性
when当满足特定条件时，执行其内部的SQL语句<when test="username != null"> AND username = #{username} </when>根据条件执行不同的SQL语句
otherwise当所有when条件都不满足时，执行其内部的SQL语句<otherwise> AND username IS NULL AND age IS NULL </otherwise>当没有满足条件的when时，执行默认的SQL语句
resultType指定查询结果的数据类型<select id="findUserByUsernameAndAge" resultType="com.example.entity.User">定义查询结果的类型，方便后续处理
namespace指定Mapper接口的完整限定名<mapper namespace="com.example.mapper.UserMapper">用于映射器文件的命名空间，与Mapper接口对应
select定义一个查询操作<select id="findUserByUsernameAndAge" resultType="com.example.entity.User">定义查询操作，包括查询的SQL语句和结果类型
WHERE 1=1用于构建动态的WHERE子句<where> <choose> <when test="username != null"> <otherwise> </choose> </where>构建动态的WHERE子句，根据条件动态添加条件语句
AND用于连接多个条件语句AND username = #{username}连接多个条件语句，形成完整的WHERE子句
#{ }用于参数占位符，绑定参数值#{username} #{age}绑定参数值，提高SQL语句的安全性，防止SQL注入攻击

动态SQL标签在数据库操作中扮演着至关重要的角色，它不仅简化了复杂的条件判断，还提高了SQL语句的可读性和可维护性。例如，在choose标签的使用中，我们可以将多个条件判断封装在一个标签内，类似于Java中的switch-case结构，这使得代码更加清晰。此外，when和otherwise标签则允许我们在满足特定条件时执行相应的SQL语句，而当所有条件都不满足时，则执行默认的SQL语句。这种设计使得SQL语句更加灵活，能够适应各种复杂的业务需求。在实际应用中，动态SQL标签的应用场景非常广泛，无论是构建动态的WHERE子句，还是连接多个条件语句，都能够发挥其强大的功能。

优快云

博主分享

📥博主的人生感悟和目标

Java程序员廖志伟

📙经过多年在优快云创作上千篇文章的经验积累，我已经拥有了不错的写作技巧。同时，我还与清华大学出版社签下了四本书籍的合约，并将陆续出版。

面试备战资料

八股文备战
场景描述链接
时间充裕（25万字）Java知识点大全（高频面试题）Java知识点大全
时间紧急（15万字）Java高级开发高频面试题Java高级开发高频面试题

理论知识专题（图文并茂，字数过万）

技术栈链接
RocketMQRocketMQ详解
KafkaKafka详解
RabbitMQRabbitMQ详解
MongoDBMongoDB详解
ElasticSearchElasticSearch详解
ZookeeperZookeeper详解
RedisRedis详解
MySQLMySQL详解
JVMJVM详解

集群部署（图文并茂，字数过万）

技术栈部署架构链接
MySQL使用Docker-Compose部署MySQL一主二从半同步复制高可用MHA集群Docker-Compose部署教程
Redis三主三从集群（三种方式部署/18个节点的Redis Cluster模式）三种部署方式教程
RocketMQDLedger高可用集群（9节点）部署指南
Nacos+Nginx集群+负载均衡（9节点）Docker部署方案
Kubernetes容器编排安装最全安装教程

开源项目分享

项目名称链接地址
高并发红包雨项目https://gitee.com/java_wxid/red-packet-rain
微服务技术集成demo项目https://gitee.com/java_wxid/java_wxid

管理经验

【公司管理与研发流程优化】针对研发流程、需求管理、沟通协作、文档建设、绩效考核等问题的综合解决方案：https://download.youkuaiyun.com/download/java_wxid/91148718

希望各位读者朋友能够多多支持！

现在时代变了，信息爆炸，酒香也怕巷子深，博主真的需要大家的帮助才能在这片海洋中继续发光发热，所以，赶紧动动你的小手，点波关注❤️，点波赞👍，点波收藏⭐，甚至点波评论✍️，都是对博主最好的支持和鼓励！

🔔如果您需要转载或者搬运这篇文章的话，非常欢迎您私信我哦~

收录于
每天十篇万字长文

当前文章被收录于：

每天十篇万字长文
475 篇文章 0 人学习

每天十篇高品质、过万文字、图文并茂、满载代码示例注释的良心之作，坚决杜绝粗制乱造。

订阅专栏 查看详情
标签
#MyBatis # Dynamic SQL # Database Operations
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
[Dify实战] Bug 自动归因与复现指南生成器-带绑定资源 摘要： 本文介绍如何利用Dify构建"Bug自动归因与复现指南生成器"，解决研发测试中的常见痛点。该系统可自动解析Bug信息，结构化输出复现步骤、可能原因、修复建议和回归测试点，显著提升问题处理效率。文章详细阐述了方案流程、Prompt设计要点、输出模板及落地清单，并提供了RCA分析模板和标准复现步骤示例。通过统一Bug描述模板和自动化分析，该系统能有效降低人力成本，加速问题闭环，适用于持续迭代的中大型项目。 阅读详情

相关推荐

LK32T102 单片机 操作GPIO实现流水灯（1）

前言： LK32T10232（32位）单片机是一款专为电机控制器和数字电源开发的高性能 MCU。采Cortex-M0 内核，最高工作频率可达 72Mhz，ADC 采样速率 达 1Msps。同时具备协处理器单元可满足各种乘法、除法、移位以及各种 复杂函数运算。 LK32T102(32位)支持单电源供电，且内嵌高精度高速及低速振荡器，以及具备 多种低功耗工作模式。同时，集成了多路增强型 PWM，多通道模拟比较 器和高速运算放大器，可满足多种电机及功率控制应用，并简化系统成本。...

qq_58676187的博客 3189

SpringBoot自动配置、Kafka分区策略、MyBatis动态SQL：一次搞定后端面试三大高频考点

本文深度解析了后端面试三大高频考点：SpringBoot自动配置机制、Kafka分区策略和MyBatis动态SQL。通过详细的技术原理剖析和实战示例，帮助开发者掌握Java后端核心技术，提升面试表现。特别针对SpringBoot自动配置的底层实现、Kafka分区选择策略以及MyBatis动态SQL的灵活应用进行了重点讲解。

weixin_30905981的博客 266

PCB设计教程【入门篇】——PCB设计基础-PCB构成与组成

本教程基于B站Expert电子实验室的PCB设计教学的整理，为个人学习记录，旨在帮助PCB设计新手入门。所有内容仅作学习交流使用，无任何商业目的。若涉及侵权，请随时联系，将会立即处理。

2501_91732643的博客 7659

MyBatis动态SQL：Choose标签深度解析

在当今的软件开发领域，MyBatis 作为一款优秀的持久层框架，以其简洁的配置和强大的动态SQL功能，深受广大开发者的喜爱。然而，在实际的项目开发中，我们常常会遇到一些复杂的业务逻辑，需要根据不同的条件执行不同的SQL语句。这时，MyBatis 提供的choose核心知识点便显得尤为重要。想象一下，在一个电商系统中，我们可能需要根据用户的购买历史和偏好来推荐商品。如果用户购买过某种类型的商品，我们可能推荐同类型的商品；如果用户购买过多种类型的商品，我们可能推荐其他类型的商品。

我是Java程序员廖志伟，感谢朋友们的支持！ 1398

海豚调度器（dolphinscheduler）再次使用，添加钉钉预警

1，首先我们部署是海豚调度器 1.3.8版本，由于页面只有邮件预警，所以在了解源码的同时，需要添加钉钉预警 2，说明，这一块是同事搞的，不是我搞的，新版本的dolphinscheduler已经有了钉钉模块，只是新版本还没有发布 3，我们现在只是添加简单的钉钉预警，任务成功或者失败会发送邮件+钉钉 4，具体操作 找到最新的源码devhttps://github1s.com/apache/dolphinscheduler/blob/dev/dolphinscheduler-alert/src/ma...

qq_31866793的博客 3084

PCIe 6.0实战指南：从链路训练到信号完整性的避坑手册

本文是一份针对PCIe 6.0硬件工程师的实战避坑指南。文章深入解析了从NRZ到PAM4调制带来的信号完整性挑战，详细拆解了链路训练（LTSSM）的复杂过程与调试方法，并提供了从信道仿真到实验室实测（如使用Keysight示波器进行眼图与误码率分析）的完整信号完整性闭环验证策略，帮助工程师解决高速率下的链路不稳定与降速问题。

weixin_29306875的博客 343

MyBatis 动态 SQL 与缓存机制深度解析

MyBatis核心技术与优化实践解析 摘要：本文系统剖析MyBatis框架的核心技术，重点探讨动态SQL实现机制与缓存系统。在动态SQL方面，详细解析了<if>、<foreach>等标签的语法规则及底层执行流程，包括SqlNode解析和OGNL表达式计算。缓存机制部分深度对比了一级缓存(SqlSession级别)和二级缓存(namespace级别)的实现原理，揭示了PerpetualCache的核心逻辑。文章还提供了性能优化方案，如Redis缓存集成和批量操作优化，并解答了常见面试问

闫磊磊 965

嵌入式统一消息机制：模块解耦与零拷贝通信设计

在嵌入式系统开发中，模块间通信（IMC）是影响可维护性与实时性的关键环节。传统IPC方式如全局变量、信号量或Socket易导致高耦合、调试困难及跨平台适配成本高。统一消息机制通过逻辑地址抽象、标签/实体分离、路由表驱动等原理，实现控制流与数据流解耦，在裸机、RTOS及Linux用户态保持一致接口。其技术价值在于降低模块依赖复杂度、支持动态增删与分布式迁移，并通过零拷贝优化显著减少CPU与内存开销。典型应用场景涵盖工业网关、城域交换机、多核ARM边缘设备等资源受限环境，尤其适用于需长期稳定运行、快速迭代与混合

weixin_35257663的博客 281

深度解析MyBatis动态SQL：从代码实践到逻辑原理

通过对UserDao代码的全面解析，我们可以总结出MyBatis动态SQL核心标签的应用场景与核心作用，形成清晰的知识体系：标签核心作用典型应用场景<where>自动拼接where关键字，剔除多余and/or前缀多条件并列查询<set>自动拼接set关键字，剔除多余,后缀动态字段更新<trim>通用SQL片段修剪，可配置前缀/后缀的添加/剔除替代<where>、<set>，实现复杂SQL拼接排他性条件选择，只执行一个满足的条件多条件优先级查询<foreach>

深耕 Java 生态 | 从基础到架构，步步进阶 | 以技术实力角逐理想岗位 1125

ILI9488 TFT屏驱动与触摸协同开发指南

TFT-LCD显示模块是嵌入式人机交互系统的核心外设，其工作原理依赖于专用显示控制器（如ILI9488）对GRAM显存的精确读写，并通过SPI等串行总线接收指令与图像数据。理解RGB接口时序、寄存器初始化流程及DC/CS信号控制逻辑，是实现稳定显示的基础技术前提；而四线电阻式触摸功能则需配合XPT2046类ADC控制器，通过独立SPI或模拟时序完成坐标采集。该方案兼顾低功耗、高集成与工程可移植性，广泛应用于工业HMI、仪器仪表及STM32F407等MCU平台的教学与产品开发。本文围绕3.5英寸320×480

weixin_33814090的博客 149

从零到一：高通Memory QMVS测试环境搭建的避坑指南

本文详细介绍了高通Memory QMVS测试环境搭建的全流程避坑指南，涵盖硬件选择、软件配置、QMVS核心组件安装及测试执行技巧。重点解析了adb工具配置、QPST日志抓取等关键步骤，帮助工程师高效搭建稳定测试环境，避免常见兼容性和稳定性问题。

weixin_29251567的博客 557

Mybatis动态SQL深度解析与实战：让你的SQL“活”起来

动态SQL是Mybatis最强大、最富有魅力的功能之一。如果说Mybatis的基础功能是让你告别了繁琐的JDBC，那么动态SQL就是让你在面对复杂多变的业务需求时，能够写出优雅、灵活且极易维护的SQL的“神兵利兵”。

m0_52710583的博客 949

ICC2: 如何让CTS指定pin多长指定长度

这里create_clock不需要写到sdc里，在脚本里写就行，需要注意的是脚本里存在remove_clock_tree的话，add_buffer就要放remove_clock_tree后面，或者给guide buffer设don't touch也行。跟innovus的操作逻辑一样，如果要让tree上的某一点长长，要先考虑这个点后面的clock tree能正常balance。我正在「拾陆楼」和朋友们讨论有趣的话题，你⼀起来吧？-5意味着长长5ns，相反正值意味着做短。

m0_61544122的博客 682
上一篇： MyBatis Select语句深度解析
下一篇： MyBatis延迟加载策略：lazyLoadingEnabled解析
点赞 5
评论 0
书签 书签 7
Java廖志伟
Java廖志伟
博客等级 码龄2年 3609粉丝 1517原创
+ 关注 专栏目录 订阅专栏
评论
成就一亿技术人!
拼手气红包6.0元
还能输入1000个字符
 
表情包 插入表情
表情包 代码片
 条评论被折叠 查看
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值