MyBatis动态SQL标签总结、开发手册、高阶用法（动态SQL、OGNL、批量操作、片段重用、 SQL 组合、执行优化、嵌套查询与延迟加载）

胡耀超

于 2024-09-08 14:13:18 发布

阅读量1.8k

点赞数 32

分类专栏： Spring 手册文章标签： mybatis sql java spring 手册

本文链接：https://blog.csdn.net/hyc010110/article/details/142026077

版权

Spring 同时被 2 个专栏收录

18 篇文章 1 订阅

订阅专栏

手册

13 篇文章 1 订阅

订阅专栏

MyBatis提供了一个非常强大的动态SQL功能，它使用了一组XML标签来帮助我们根据不同条件生成动态SQL。动态SQL的设计让开发者可以根据业务需求，灵活地构建SQL查询语句。以下是MyBatis动态SQL标签的总结。

动态SQL标签	说明	特点
`<if>`	条件判断语句，用于在满足条件时生成SQL	灵活、简洁，常用于简单条件的动态拼接
`<choose>`	类似于Java中的`switch-case`，实现多分支选择	避免多个`<if>`嵌套，代码更清晰
`<when>`	`<choose>`中的条件分支，与`<otherwise>`搭配使用	逻辑清晰，适合多条件判断
`<otherwise>`	`<choose>`中的默认分支，相当于`else`	用于定义默认情况的SQL
`<where>`	自动处理`WHERE`子句的拼接，避免前后多余的`AND`或`OR`	语法整洁，自动优化条件拼接
`<set>`	自动处理`UPDATE`语句中的`SET`子句，避免最后的逗号问题	便于更新操作时的动态SQL生成
`<trim>`	自定义去除SQL前后多余的字符，通常用于`WHERE`或`SET`子句	灵活，可以指定前后缀和修饰符
`<foreach>`	循环构造SQL片段，适合用于`IN`查询或批量插入	高效处理批量操作
`<bind>`	动态绑定变量	可以通过OGNL表达式为SQL传递动态变量

各标签的详细分析及特点

<if> 标签：

用法：根据条件是否满足来决定是否生成SQL片段。
特点：简洁且灵活，可以在SQL语句中动态插入条件，是最常用的动态标签之一。

<select id="findUserByCondition" parameterType="User">
    SELECT * FROM users
    <where>
        <if test="username != null">
            AND username = #{username}
        </if>
        <if test="age != null">
            AND age = #{age}
        </if>
    </where>
</select>

优点：适用于简单条件的判断和拼接，便于根据参数的存在与否动态生成不同的SQL。

<choose> 标签：

用法：实现类似switch-case的逻辑，多条件下选择生成SQL片段。
特点：避免了多个<if>嵌套，代码更易读，逻辑更清晰。

<choose>
    <when test="username != null">
        AND username = #{username}
    </when>
    <when test="age != null">
        AND age = #{age}
    </when>
    <otherwise>
        AND status = 'active'
    </otherwise>
</choose>

优点：对于多个条件判断且互斥的情况下，<choose>比多个<if>更高效和清晰。

<where> 标签：
- 用法：用于SQL的WHERE子句，自动处理前后多余的AND、OR等。
- 特点：通过自动处理逻辑，避免手动控制拼接，提升代码整洁度。
```
<where>
    <if test="username != null">
        username = #{username}
    </if>
    <if test="age != null">
        AND age = #{age}
    </if>
</where>
```
- 优点：自动优化SQL结构，特别适合用于动态条件的查询。

<set> 标签：

用法：处理UPDATE语句中的SET子句，避免拼接时多余的逗号。
特点：自动去掉最后多余的逗号，使UPDATE操作更为高效。

<update id="updateUser">
    UPDATE users
    <set>
        <if test="username != null">
            username = #{username},
        </if>
        <if test="age != null">
            age = #{age},
        </if>
    </set>
</update>

优点：处理更新操作时，代码简洁，并且自动去除末尾的多余标点。

<foreach> 标签：
- 用法：用于在SQL中处理集合，如IN查询、批量插入等。
- 特点：支持集合循环操作，适合大批量的SQL语句生成。
```
<select id="findUsersByIds">
    SELECT * FROM users WHERE id IN
    <foreach item="id" collection="list" open="(" separator="," close=")">
        #{id}
    </foreach>
</select>
```
- 优点：极大简化了批量操作的SQL构造，减少代码冗余，提高效率。
<trim> 标签：
- 用法：自定义去除SQL片段中的多余字符，如前后缀。
- 特点：提供了对SQL结构的高度自定义控制，便于精细化管理SQL。
```
<trim prefix="WHERE" prefixOverrides="AND | OR">
    <if test="username != null">
        AND username = #{username}
    </if>
    <if test="age != null">
        AND age = #{age}
    </if>
</trim>
```
- 优点：灵活地控制SQL片段拼接，尤其在多条件拼接时避免SQL错误。
<bind> 标签：
- 用法：用于绑定OGNL表达式，动态生成SQL变量。
- 特点：能够将动态变量引入SQL，使得SQL更灵活。
```
<bind name="pattern" value="'%' + username + '%'"/>
SELECT * FROM users WHERE username LIKE #{pattern}
```
- 优点：适合于需要灵活绑定变量的场景，使查询条件更加多样化。

案例：通过MyBatis实现动态查询

以下是一个实际应用中的场景，通过综合使用多种MyBatis动态SQL标签，实现用户的动态查询。

<select id="findUsersByCondition" parameterType="map">
    SELECT * FROM users
    <where>
        <if test="username != null">
            username = #{username}
        </if>
        <if test="age != null">
            AND age = #{age}
        </if>
        <if test="status != null">
            AND status = #{status}
        </if>
        <if test="idList != null">
            AND id IN
            <foreach collection="idList" item="id" open="(" separator="," close=")">
                #{id}
            </foreach>
        </if>
    </where>
</select>

高级用法

MyBatis 的动态 SQL 基本标签虽然覆盖了大部分常见场景，但在更复杂的业务场景下，还有一些高级用法和技巧可以用来提升代码的灵活性和性能。以下是一些常见的高级用法：

1. 动态生成复杂的SQL查询

在某些情况下，可能需要根据复杂的业务逻辑生成 SQL。这时可以利用 MyBatis 标签的组合和嵌套来处理。通过 <choose>、<if> 和 <foreach> 的组合，可以实现复杂的 SQL 查询。

案例：多条件动态查询带分页

<select id="findUsersByConditions" parameterType="map" resultType="User">
    SELECT * FROM users
    <where>
        <if test="username != null and username != ''">
            username = #{username}
        </if>
        <if test="email != null and email != ''">
            AND email = #{email}
        </if>
        <if test="age != null">
            AND age = #{age}
        </if>
        <if test="roles != null">
            AND role IN 
            <foreach collection="roles" item="role" open="(" separator="," close=")">
                #{role}
            </foreach>
        </if>
    </where>
    ORDER BY created_at DESC
    LIMIT #{offset}, #{limit}
</select>

2. 使用 OGNL 表达式做更复杂的条件判断

MyBatis 支持 OGNL（Object-Graph Navigation Language）表达式，使得条件判断更为灵活。你可以在 <if> 或 <bind> 标签中使用这些表达式，甚至进行复杂的逻辑运算。

案例：判断对象内部属性

<select id="findUsers" parameterType="User">
    SELECT * FROM users
    <where>
        <if test="username != null and username.length > 3">
            username = #{username}
        </if>
        <if test="email != null and email.contains('@')">
            AND email = #{email}
        </if>
    </where>
</select>

3. 动态生成表名或列名

在一些动态表结构或者多表查询场景中，可能需要动态地指定表名或者列名。MyBatis 不支持直接将参数传递到表名或列名的占位符中，但可以通过 <bind> 标签动态构造 SQL 片段。

案例：动态表名

<select id="selectFromDynamicTable" parameterType="map">
    <bind name="dynamicTable" value="tableName"/>
    SELECT * FROM ${dynamicTable} WHERE id = #{id}
</select>

注意：使用 ${} 而非 #{}，因为 ${} 是字符串替换，适合动态表名，而 #{} 是参数化查询，适合传递值。

4. 高级批量操作

通过 <foreach> 标签，可以在 INSERT、UPDATE、DELETE 中进行高级的批量操作。

案例：批量插入

<insert id="batchInsertUsers" parameterType="list">
    INSERT INTO users (username, email, age)
    VALUES
    <foreach collection="list" item="user" separator=",">
        (#{user.username}, #{user.email}, #{user.age})
    </foreach>
</insert>

案例：批量更新

<update id="batchUpdateUsers" parameterType="list">
    <foreach collection="list" item="user" separator=";">
        UPDATE users
        <set>
            <if test="user.username != null">username = #{user.username},</if>
            <if test="user.email != null">email = #{user.email},</if>
            <if test="user.age != null">age = #{user.age}</if>
        </set>
        WHERE id = #{user.id}
    </foreach>
</update>

5. 动态 SQL 片段重用

在大型系统中，可能有很多类似的 SQL 片段会被多处调用，MyBatis 提供了 SQL 片段的复用机制，可以使用 <sql> 标签定义一个可复用的 SQL 片段，再通过 <include> 标签引入。

案例：重用 SQL 片段

<!-- 定义 SQL 片段 -->
<sql id="userColumns">
    id, username, email, age, created_at
</sql>

<!-- 在查询中引入 -->
<select id="findUserById" resultType="User">
    SELECT <include refid="userColumns" />
    FROM users
    WHERE id = #{id}
</select>

这样避免了代码冗余，使 SQL 语句更加简洁易维护。

6. 动态 SQL 组合

可以通过将不同的 SQL 查询片段拼接在一起，生成动态查询。这在某些场景下非常有用，尤其是在查询条件繁多时。你可以将 SQL 片段存储为不同的 <sql> 片段，并通过 <include> 引入。

案例：动态组合查询

<!-- SQL 片段 -->
<sql id="userCondition">
    <where>
        <if test="username != null and username != ''">
            username = #{username}
        </if>
        <if test="email != null and email != ''">
            AND email = #{email}
        </if>
        <if test="age != null">
            AND age = #{age}
        </if>
    </where>
</sql>

<!-- 引用 SQL 片段 -->
<select id="findUsersByDynamicCondition" resultType="User">
    SELECT * FROM users
    <include refid="userCondition" />
</select>

7. 动态 SQL 执行优化

对于一些复杂且频繁执行的 SQL 语句，可以通过缓存机制或延迟加载机制来优化动态 SQL 的执行。

一级缓存：MyBatis 默认开启一级缓存，缓存作用于会话级别，确保在一个会话中，相同的 SQL 只会执行一次。
二级缓存：MyBatis 支持二级缓存，可以跨会话缓存结果集，适用于静态数据查询。

8. 嵌套查询与延迟加载

当你使用嵌套查询（如查询一个对象的同时查询其关联的子对象）时，可以通过配置延迟加载来提高性能。

<resultMap id="userResultMap" type="User">
    <id property="id" column="id"/>
    <result property="username" column="username"/>
    <result property="email" column="email"/>
    <association property="address" column="address_id" select="findAddressById" fetchType="lazy"/>
</resultMap>