mybatis mapper sql 还是xml如何选择

--------------------------------------------------------------------------------------------------

在 MyBatis 中，SQL 语句的编写有两种主流方式：注解方式（直接在 Mapper 接口上写 SQL）和 XML 映射文件方式。两种方式各有优缺点，选择需结合 SQL 复杂度、项目规模、团队协作习惯等因素。以下是详细对比和选择建议：

一、两种方式的基本用法

1. 注解方式（SQL 写在接口中）

直接在 Mapper 接口的方法上通过 @Select、@Insert、@Update、@Delete 等注解编写 SQL，适合简单场景。示例：

java
 
运行
 
public interface UserMapper {
    // 简单查询：通过 ID 查询用户
    @Select("SELECT id, username, age FROM t_user WHERE id = #{id}")
    User selectById(Long id);
    
    // 简单插入
    @Insert("INSERT INTO t_user (username, age) VALUES (#{username}, #{age})")
    @Options(useGeneratedKeys = true, keyProperty = "id") // 返回自增 ID
    int insert(User user);
}

2. XML 映射文件方式（SQL 写在独立 XML 中）

SQL 语句定义在独立的 XML 文件中，Mapper 接口仅定义方法，通过 namespace 与 XML 关联。适合复杂场景。示例：UserMapper.java（接口）：

java
 
运行
 
public interface UserMapper {
    User selectById(Long id);
    int insert(User user);
    List<User> selectByCondition(@Param("username") String username, @Param("minAge") Integer minAge);
}

UserMapper.xml（XML 映射文件）：

xml
 
 

<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE mapper PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN" "http://mybatis.org/dtd/mybatis-3-mapper.dtd">
<mapper namespace="com.example.mapper.UserMapper">
    <!-- 简单查询 -->
    <select id="selectById" resultType="com.example.entity.User">
        SELECT id, username, age FROM t_user WHERE id = #{id}
    </select>
    
    <!-- 简单插入 -->
    <insert id="insert" useGeneratedKeys="true" keyProperty="id">
        INSERT INTO t_user (username, age) VALUES (#{username}, #{age})
    </insert>
    
    <!-- 复杂动态查询（多条件、动态拼接） -->
    <select id="selectByCondition" resultType="com.example.entity.User">
        SELECT id, username, age FROM t_user
        <where>
            <if test="username != null and username != ''">
                AND username LIKE CONCAT('%', #{username}, '%')
            </if>
            <if test="minAge != null">
                AND age >= #{minAge}
            </if>
        </where>
        ORDER BY create_time DESC
    </select>
</mapper>

 

二、核心差异对比

维度	注解方式（SQL 在接口）	XML 映射文件方式
适用场景	简单 SQL（单表 CRUD、无动态条件）	复杂 SQL（多表 JOIN、动态条件、子查询等）
可读性	简单 SQL 直观，复杂 SQL 臃肿（注解内写长文本）	结构化标签（`<select>`、`<if>` 等）更清晰
动态 SQL 支持	需用 `@SelectProvider` 等 Provider 类，语法繁琐	原生支持 `<if>`、`<foreach>`、`<where>` 等标签，简洁直观
维护性	SQL 与 Java 代码耦合，修改需改 Java 文件	SQL 与代码分离，修改只需改 XML，不影响编译
团队协作	不适合 DBA 参与（DBA 通常更熟悉 XML / 纯 SQL）	适合 DBA 直接优化 XML 中的 SQL
代码整洁度	简单场景下无需额外文件，代码集中	需维护 XML 文件，可能增加项目文件数量
分库分表适配	复杂分片 SQL（如跨表查询）可读性差	分片 SQL 结构清晰，便于关联分表规则

三、选择建议

1. 优先选注解方式的场景

简单 SQL 操作：如单表的增删改查（CRUD），SQL 语句短且固定（无动态条件）。
快速开发场景：小型项目或原型开发，追求简洁高效，避免创建大量 XML 文件。
SQL 与代码强关联：SQL 逻辑简单且与业务代码紧密相关，开发者更习惯在接口中直接看到 SQL。

2. 优先选 XML 方式的场景

复杂 SQL 或动态 SQL：涉及多表 JOIN、子查询、条件动态拼接（如 if、foreach）等，XML 的标签化语法更易维护。
大型项目或团队协作：多人开发时，XML 可集中管理 SQL，便于 DBA 介入优化，且避免接口类过于臃肿。
SQL 需要频繁优化：XML 中 SQL 独立存储，修改后无需重新编译 Java 代码，适合需要频繁调整 SQL 的场景。
分库分表场景：结合 ShardingSphere 等中间件时，XML 中写分片 SQL（如逻辑表名）更清晰，便于与分片规则对应。

3. 混合使用（推荐）

实际项目中无需严格二选一，可根据 SQL 复杂度灵活搭配：

简单 CRUD 用注解（如 @Select、@Insert），保持代码简洁；
复杂查询或动态 SQL 用 XML，保证可读性和维护性。

四、总结

注解方式胜在简洁高效，适合简单场景和快速开发；
XML 方式胜在结构化和可维护性，适合复杂场景和团队协作。

核心原则：让简单的 SQL 更简洁，让复杂的 SQL 更清晰。根据项目规模和 SQL 复杂度灵活选择，必要时混合使用即可。

--------------------------------------------------------------------------------------------------

在 MyBatis 中，Mapper 接口的 SQL 实现方式（注解式 SQL 与 XML 映射文件）的选择，核心取决于 SQL 复杂度、项目规模、团队协作模式以及维护成本。两种方式没有绝对的优劣，只有 “更适合” 的场景。以下从实际开发角度详细分析：

一、核心区别与适用场景

1. 注解式 SQL（直接在 Mapper 接口上写 SQL）

本质：通过 @Select、@Insert 等注解将 SQL 直接嵌入 Java 接口方法中，无需额外文件。

适用场景：

简单 SQL 操作：单表的基础 CRUD（增删改查），SQL 语句短且固定（无动态条件）。

例：根据 ID 查询、简单插入一条数据。
快速开发 / 小型项目：无需创建 XML 文件，减少文件数量，适合原型开发或小工具。
SQL 与业务逻辑强绑定：SQL 逻辑简单且与接口方法高度关联，开发者可在接口中直接看到 SQL，减少跳转成本。

示例：

java
 
运行
 
public interface UserMapper {
    // 简单查询：注解直接写SQL
    @Select("SELECT id, name, age FROM user WHERE id = #{id}")
    User getById(Long id);

    // 简单插入：带自增ID返回
    @Insert("INSERT INTO user (name, age) VALUES (#{name}, #{age})")
    @Options(useGeneratedKeys = true, keyProperty = "id")
    int insert(User user);
}

优点：

简洁：无需维护额外 XML 文件，代码集中在接口中。
快速：开发时无需切换文件，适合简单场景。

缺点：

复杂 SQL 可读性差：长 SQL 或多换行的 SQL 写在注解里会非常臃肿（注解内字符串拼接繁琐）。
动态 SQL 麻烦：如需动态拼接条件（如 if、foreach），需用 @SelectProvider 等 Provider 类，语法晦涩（类似在 Java 中拼接 SQL）。
不适合 DBA 参与：DBA 通常更习惯直接操作纯 SQL 或 XML，而非在 Java 代码中改 SQL。

2. XML 映射文件（SQL 写在独立 XML 中）

本质：SQL 语句定义在独立的 .xml 文件中，通过 namespace 与 Mapper 接口关联，接口仅定义方法签名。

适用场景：

复杂 SQL 或动态 SQL：涉及多表 JOIN、子查询、动态条件（如根据参数是否为空拼接 WHERE 条件）、批量操作等。

例：多条件搜索（姓名模糊查询 + 年龄范围 + 部门筛选）、批量插入 / 更新。
大型项目 / 团队协作：多人开发时，XML 可集中管理 SQL，便于统一规范和版本控制。
需要 DBA 介入优化：DBA 可直接修改 XML 中的 SQL 进行调优，无需关注 Java 代码。
分库分表 / 复杂业务：结合 ShardingSphere 等中间件时，XML 中逻辑表名与分片规则的对应关系更清晰。

示例：UserMapper.java（接口）：

java
 
运行
 
public interface UserMapper {
    User getById(Long id);
    List<User> search(@Param("name") String name, @Param("minAge") Integer minAge, @Param("deptId") Long deptId);
    int batchInsert(@Param("users") List<User> users);
}

UserMapper.xml（XML 映射文件）：

xml
 
 

<mapper namespace="com.example.mapper.UserMapper">
    <!-- 简单查询 -->
    <select id="getById" resultType="com.example.entity.User">
        SELECT id, name, age, dept_id FROM user WHERE id = #{id}
    </select>

    <!-- 复杂动态查询 -->
    <select id="search" resultType="com.example.entity.User">
        SELECT id, name, age, dept_id FROM user
        <where>
            <if test="name != null and name != ''">
                AND name LIKE CONCAT('%', #{name}, '%')
            </if>
            <if test="minAge != null">
                AND age >= #{minAge}
            </if>
            <if test="deptId != null">
                AND dept_id = #{deptId}
            </if>
        </where>
        ORDER BY create_time DESC
    </select>

    <!-- 批量插入 -->
    <insert id="batchInsert">
        INSERT INTO user (name, age, dept_id)
        VALUES
        <foreach collection="users" item="u" separator=",">
            (#{u.name}, #{u.age}, #{u.deptId})
        </foreach>
    </insert>
</mapper>

 

优点：

结构化强：XML 标签（<select>、<if>、<foreach> 等）让复杂 SQL 和动态逻辑更清晰，可读性高。
维护性好：SQL 与 Java 代码完全分离，修改 SQL 无需重新编译 Java 类，适合频繁优化场景。
支持复杂场景：天然支持动态 SQL、多表关联、存储过程调用等，语法直观。

缺点：

文件较多：每个 Mapper 接口对应一个 XML 文件，项目规模大时可能有大量 XML 文件需要管理。
开发时需切换文件：写接口方法和 SQL 时需在 Java 类和 XML 间切换，略增加操作成本。

二、选择建议：“简单用注解，复杂用 XML”

在实际开发中，混合使用两种方式是最灵活的选择：

单表简单 CRUD → 用注解：如 getById、insert、deleteById 等，SQL 短且固定，注解方式更简洁，减少文件冗余。
复杂查询 / 动态 SQL → 用 XML：如多条件搜索、批量操作、多表 JOIN 等，XML 的标签化语法能清晰表达动态逻辑，便于维护和优化。
团队协作 / 大型项目 → 优先 XML：统一 SQL 管理规范，便于 DBA 介入，且避免接口类因注解 SQL 过多而臃肿。
分库分表场景 → 优先 XML：逻辑表名与分片规则的对应关系在 XML 中更直观，且复杂的跨表查询 SQL 更易维护。

三、总结

注解式 SQL 是 “轻量型选手”：适合简单场景，追求开发效率和代码集中性。
XML 映射文件是 “重型选手”：适合复杂场景，追求可读性、可维护性和团队协作效率。

核心原则：让 SQL 的复杂度决定实现方式—— 简单 SQL 用注解减少冗余，复杂 SQL 用 XML 保证清晰。无需严格二选一，混合使用可兼顾效率与可维护性。

--------------------------------------------------------------------------------------------------

mybatis mapper 注解和xml详解

在 MyBatis 中，Mapper 接口的 SQL 实现有两种主流方式：注解式（通过 Java 注解直接在接口中定义 SQL）和 XML 映射文件（将 SQL 定义在独立的 .xml 文件中）。两者各有侧重，分别适用于不同场景。以下从核心用法、功能特性、优缺点三个维度详细解析：

一、注解式 Mapper（SQL 写在接口中）

注解式 Mapper 直接在 Mapper 接口的方法上通过 MyBatis 提供的注解定义 SQL，无需额外 XML 文件。核心依赖注解与 Java 代码的绑定，适合简单场景。

1. 核心注解与基础用法

MyBatis 提供了一套完整的注解用于 CRUD 操作，最常用的包括：

注解	作用	示例
`@Select`	定义查询 SQL	`@Select("SELECT * FROM t_user WHERE id = #{id}")`
`@Insert`	定义插入 SQL	`@Insert("INSERT INTO t_user(name) VALUES(#{name})")`
`@Update`	定义更新 SQL	`@Update("UPDATE t_user SET name = #{name} WHERE id = #{id}")`
`@Delete`	定义删除 SQL	`@Delete("DELETE FROM t_user WHERE id = #{id}")`
`@Options`	配置额外参数（如自增 ID）	`@Options(useGeneratedKeys = true, keyProperty = "id")`
`@Param`	定义参数别名（多参数时使用）	`List<User> selectByAge(@Param("min") int min, @Param("max") int max);`

示例：基础 CRUD 操作

java
 
运行
 
 
 
 

public interface UserMapper {
    // 1. 查询：根据 ID 查询用户
    @Select("SELECT id, name, age, create_time AS createTime FROM t_user WHERE id = #{id}")
    User selectById(Long id);

    // 2. 插入：新增用户，返回自增 ID
    @Insert("INSERT INTO t_user(name, age, create_time) VALUES(#{name}, #{age}, #{createTime})")
    @Options(useGeneratedKeys = true, keyProperty = "id") // 自动生成 ID 并注入到实体的 id 字段
    int insert(User user);

    // 3. 更新：根据 ID 更新用户信息
    @Update("UPDATE t_user SET name = #{name}, age = #{age} WHERE id = #{id}")
    int updateById(User user);

    // 4. 删除：根据 ID 删除用户
    @Delete("DELETE FROM t_user WHERE id = #{id}")
    int deleteById(Long id);

    // 5. 多参数查询：根据年龄范围查询
    @Select("SELECT * FROM t_user WHERE age BETWEEN #{min} AND #{max}")
    List<User> selectByAgeRange(@Param("min") int minAge, @Param("max") int maxAge);
}

 

2. 结果映射（复杂对象映射）

当数据库字段名与实体类属性名不一致（如数据库 create_time vs 实体 createTime），或需要映射复杂对象（如嵌套对象）时，可通过 @Results 和 @Result 注解手动指定映射关系：

java
 
运行
 
 
 
 

public interface UserMapper {
    @Select("SELECT id, username, user_age AS age, create_time AS createTime FROM t_user WHERE id = #{id}")
    @Results({
        @Result(column = "id", property = "id", id = true), // id=true 表示主键
        @Result(column = "username", property = "name"),   // 数据库字段 username → 实体 name
        @Result(column = "age", property = "age"),
        @Result(column = "createTime", property = "createTime")
    })
    User selectById(Long id);
}

 

column：数据库表字段名；
property：实体类属性名；
id = true：标记为主键字段。

3. 动态 SQL 处理（注解式局限性）

注解式 SQL 处理动态条件（如根据参数是否为空拼接 SQL）时，需使用 @SelectProvider、@InsertProvider 等 Provider 注解，通过 Java 类动态生成 SQL。这种方式语法较繁琐，适合简单动态场景。

示例：动态查询用户（根据姓名和年龄可选条件）

java
 
运行
 
 
 
 

// 1. 定义 SQL 提供者类（生成动态 SQL）
public class UserSqlProvider {
    // 动态生成查询 SQL
    public String selectByCondition(@Param("name") String name, @Param("age") Integer age) {
        SQL sql = new SQL().SELECT("*").FROM("t_user");
        if (name != null && !name.isEmpty()) {
            sql.WHERE("name LIKE CONCAT('%', #{name}, '%')");
        }
        if (age != null) {
            sql.WHERE("age = #{age}");
        }
        return sql.toString();
    }
}

// 2. Mapper 接口中引用 Provider
public interface UserMapper {
    @SelectProvider(type = UserSqlProvider.class, method = "selectByCondition")
    List<User> selectByCondition(@Param("name") String name, @Param("age") Integer age);
}

 

type：指定 Provider 类；
method：指定 Provider 类中生成 SQL 的方法。

二、XML 映射文件（SQL 写在独立 XML 中）

XML 映射文件是 MyBatis 最传统的 SQL 定义方式，将 SQL 与 Java 代码完全分离，通过 namespace 与 Mapper 接口绑定。XML 提供了丰富的标签支持复杂场景，尤其是动态 SQL。

1. XML 文件基本结构

XML 映射文件需放在 src/main/resources/mapper 目录下（Spring Boot 约定），基本结构如下：

xml
 
<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE mapper PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN" 
"http://mybatis.org/dtd/mybatis-3-mapper.dtd">

<!-- namespace 必须与 Mapper 接口全类名一致 -->
<mapper namespace="com.example.mapper.UserMapper">
    <!-- SQL 语句定义 -->
</mapper>

2. 核心标签与基础用法

XML 提供了与注解对应的标签，用于定义 CRUD 操作，同时支持更灵活的配置：

标签	作用	核心属性
`<select>`	查询 SQL	`id`（对应接口方法名）、`resultType`（返回类型）、`resultMap`（结果映射）
`<insert>`	插入 SQL	`id`、`useGeneratedKeys`（自增 ID）、`keyProperty`（主键属性）
`<update>`	更新 SQL	`id`
`<delete>`	删除 SQL	`id`

示例：基础 CRUD 操作

xml
 
 

<mapper namespace="com.example.mapper.UserMapper">
    <!-- 1. 查询：根据 ID 查询用户 -->
    <select id="selectById" resultType="com.example.entity.User">
        SELECT id, name, age, create_time AS createTime 
        FROM t_user 
        WHERE id = #{id}
    </select>

    <!-- 2. 插入：新增用户，返回自增 ID -->
    <insert id="insert" useGeneratedKeys="true" keyProperty="id">
        INSERT INTO t_user(name, age, create_time) 
        VALUES(#{name}, #{age}, #{createTime})
    </insert>

    <!-- 3. 更新：根据 ID 更新用户 -->
    <update id="updateById">
        UPDATE t_user 
        SET name = #{name}, age = #{age} 
        WHERE id = #{id}
    </update>

    <!-- 4. 删除：根据 ID 删除用户 -->
    <delete id="deleteById">
        DELETE FROM t_user WHERE id = #{id}
    </delete>
</mapper>

 

对应的 Mapper 接口只需定义方法签名（无需注解）：

java
 
运行
 
public interface UserMapper {
    User selectById(Long id);
    int insert(User user);
    int updateById(User user);
    int deleteById(Long id);
}

3. 结果映射（resultMap）

XML 中通过 <resultMap> 标签定义数据库字段与实体类的映射关系，比注解式的 @Results 更灵活，适合复杂对象（如嵌套对象、集合）：

xml
 
 

<mapper namespace="com.example.mapper.UserMapper">
    <!-- 定义结果映射：userMap -->
    <resultMap id="userMap" type="com.example.entity.User">
        <id column="id" property="id"/> <!-- 主键映射 -->
        <result column="username" property="name"/> <!-- 普通字段映射 -->
        <result column="user_age" property="age"/>
        <result column="create_time" property="createTime"/>
        
        <!-- 嵌套对象映射（如用户关联的部门） -->
        <association property="dept" javaType="com.example.entity.Dept">
            <id column="dept_id" property="id"/>
            <result column="dept_name" property="name"/>
        </association>
    </resultMap>

    <!-- 使用 resultMap 查询 -->
    <select id="selectUserWithDept" resultMap="userMap">
        SELECT 
            u.id, u.username, u.user_age, u.create_time,
            d.id AS dept_id, d.name AS dept_name
        FROM t_user u
        LEFT JOIN t_dept d ON u.dept_id = d.id
        WHERE u.id = #{id}
    </select>
</mapper>

 

<id>：主键映射；
<result>：普通字段映射；
<association>：嵌套对象映射（一对一）；
<collection>：集合映射（一对多，如用户的订单列表）。

4. 动态 SQL（XML 核心优势）

XML 提供了丰富的动态 SQL 标签，可直观地处理条件拼接、循环等逻辑，这是 XML 方式的核心优势：

标签	作用	示例场景
`<if>`	条件判断（满足条件则拼接 SQL）	根据参数是否为空决定是否添加 WHERE 条件
`<where>`	自动处理 AND/OR 前缀，避免 SQL 语法错误	包裹 `<if>` 标签，自动去除多余的 AND
`<set>`	用于 UPDATE 语句，自动处理逗号	动态更新非空字段，去除最后一个逗号
`<foreach>`	循环遍历集合（如批量插入、IN 条件）	批量插入数据、`WHERE id IN (...)`
`<choose>`	类似 Java 的 switch 语句（多条件分支）	优先满足某条件，否则使用默认条件

示例：复杂动态查询

xml
 
 

<select id="selectByCondition" resultType="com.example.entity.User">
    SELECT * FROM t_user
    <where>
        <!-- 条件1：姓名模糊查询（参数不为空时生效） -->
        <if test="name != null and name != ''">
            AND name LIKE CONCAT('%', #{name}, '%')
        </if>
        <!-- 条件2：年龄范围查询（参数不为空时生效） -->
        <if test="minAge != null">
            AND age >= #{minAge}
        </if>
        <if test="maxAge != null">
            AND age <= #{maxAge}
        </if>
        <!-- 条件3：创建时间范围（参数不为空时生效） -->
        <if test="startTime != null">
            AND create_time >= #{startTime}
        </if>
    </where>
    ORDER BY create_time DESC
</select>

 

示例：批量插入

xml
 
 

<insert id="batchInsert">
    INSERT INTO t_user(name, age)
    VALUES
    <!-- 遍历 users 集合，拼接多个值 -->
    <foreach collection="users" item="user" separator=",">
        (#{user.name}, #{user.age})
    </foreach>
</insert>

 

collection：集合参数名（与 @Param 对应）；
item：集合元素别名；
separator：元素间分隔符（如逗号）。

三、注解式 vs XML 方式：核心差异对比

维度	注解式 Mapper	XML 映射文件
SQL 复杂度	适合简单 SQL（无动态条件、单表操作）	适合复杂 SQL（动态条件、多表 JOIN、子查询等）
动态 SQL 支持	需通过 Provider 类实现，语法繁琐，可读性差	原生支持 `<if>`、`<foreach>` 等标签，直观简洁
结果映射	依赖 `@Results` 注解，复杂映射（嵌套对象）繁琐	支持 `<resultMap>` 标签，灵活处理复杂映射
代码耦合度	SQL 与 Java 代码耦合（修改需改 Java 文件）	SQL 与代码完全分离（修改只需改 XML）
维护性	复杂 SQL 维护困难（长字符串拼接）	结构化标签，便于阅读和优化（DBA 友好）
团队协作	不适合 DBA 参与（SQL 在 Java 中）	适合 DBA 直接优化 XML 中的 SQL
文件数量	无需额外文件（仅 Mapper 接口）	每个接口对应一个 XML 文件，数量较多

四、选择建议

优先注解式：
- 简单 CRUD 操作（单表查询、插入等）；
- 快速开发的小型项目或工具类；
- SQL 逻辑简单且与业务代码强绑定的场景。
优先 XML 方式：
- 复杂查询（多表 JOIN、子查询）或动态 SQL（多条件拼接、批量操作）；
- 大型项目或团队协作（需统一管理 SQL，便于 DBA 介入）；
- 分库分表场景（逻辑表名与分片规则在 XML 中更清晰）。
混合使用：实际开发中无需严格二选一：简单操作（如 selectById）用注解，复杂操作（如 selectByCondition）用 XML，兼顾效率与可维护性。

总结

注解式是 “轻量方案”，胜在简洁高效，适合简单场景；
XML 方式是 “全能方案”，胜在灵活强大，适合复杂场景和团队协作。

两种方式的核心目标都是 “高效管理 SQL”，选择时需结合 SQL 复杂度、项目规模、团队习惯综合决策，无需绝对对立。

--------------------------------------------------------------------------------------------------

posted @ 2025-09-30 11:03 hanease 阅读(84) 评论(0) 收藏举报

刷新页面返回顶部

hanease

mybatis mapper sql 还是xml如何选择

一、两种方式的基本用法

1. 注解方式（SQL 写在接口中）

2. XML 映射文件方式（SQL 写在独立 XML 中）

二、核心差异对比

三、选择建议

1. 优先选 注解方式 的场景

2. 优先选 XML 方式 的场景

3. 混合使用（推荐）

四、总结

一、核心区别与适用场景

1. 注解式 SQL（直接在 Mapper 接口上写 SQL）

2. XML 映射文件（SQL 写在独立 XML 中）

二、选择建议：“简单用注解，复杂用 XML”

三、总结

一、注解式 Mapper（SQL 写在接口中）

1. 核心注解与基础用法

2. 结果映射（复杂对象映射）

3. 动态 SQL 处理（注解式局限性）

二、XML 映射文件（SQL 写在独立 XML 中）

1. XML 文件基本结构

2. 核心标签与基础用法

3. 结果映射（resultMap）

4. 动态 SQL（XML 核心优势）

三、注解式 vs XML 方式：核心差异对比

四、选择建议

总结

公告

1. 优先选注解方式的场景

2. 优先选 XML 方式的场景