当前位置：首页 > news >正文

MyBatis SQL映射与动态SQL：构建灵活高效的数据访问层 MyBatis SQL映射与动态SQL：构建灵活高效的数据访问层

news 2025/8/9 6:55:36

🔄 MyBatis SQL映射与动态SQL：构建灵活高效的数据访问层

🚀 引言：动态SQL是MyBatis框架的核心优势之一，它让我们能够根据不同条件动态构建SQL语句，避免了传统JDBC中大量的字符串拼接。本文将深入解析MyBatis动态SQL的核心语法和复杂查询映射技术，助你构建更加灵活和高效的数据访问层。

文章目录

🔄 MyBatis SQL映射与动态SQL：构建灵活高效的数据访问层
- 🔄 动态SQL核心语法
- - 🎯 if、choose、when、otherwise条件判断
  - 🏷️ where、set、trim标签应用
  - 🔁 foreach循环处理集合
  - 🔗 bind变量绑定
- 📊 复杂查询与结果映射
- - 🔗 一对一关联查询（association）
  - 📚 一对多关联查询（collection）
  - 🔄 多对多关联查询
  - 🏗️ 嵌套查询vs嵌套结果
  - ⚡ 延迟加载配置与优化
- 📊 技术成熟度评估
- - MyBatis动态SQL技术成熟度分析
  - 🔮 未来发展趋势
  - 💡 最佳实践建议

🔄 动态SQL核心语法

🎯 if、choose、when、otherwise条件判断

if标签：基础条件判断

if标签是动态SQL中最基础也是最常用的条件判断标签，它根据表达式的真假来决定是否包含某段SQL。

<!-- 基础if条件判断 -->
<select id="findUsersByCondition" resultType="User">SELECT * FROM usersWHERE 1=1<if test="username != null and username != ''">AND username LIKE CONCAT('%', #{username}, '%')</if><if test="email != null and email != ''">AND email = #{email}</if><if test="status != null">AND status = #{status}</if><if test="createTimeStart != null">AND create_time >= #{createTimeStart}</if><if test="createTimeEnd != null">AND create_time <= #{createTimeEnd}</if>
</select><!-- 复杂条件判断 -->
<select id="findUsersWithComplexCondition" resultType="User">SELECT * FROM usersWHERE 1=1<if test="searchType != null and searchType == 'username'">AND username LIKE CONCAT('%', #{keyword}, '%')</if><if test="searchType != null and searchType == 'email'">AND email LIKE CONCAT('%', #{keyword}, '%')</if><if test="ageRange != null"><if test="ageRange.min != null">AND age >= #{ageRange.min}</if><if test="ageRange.max != null">AND age <= #{ageRange.max}</if></if>
</select>

choose/when/otherwise：多分支选择

类似于Java中的switch-case语句，choose标签提供了多分支选择的能力。

<!-- 多分支条件选择 -->
<select id="findUsersByPriority" resultType="User">SELECT * FROM usersWHERE<choose><when test="id != null">id = #{id}</when><when test="username != null and username != ''">username = #{username}</when><when test="email != null and email != ''">email = #{email}</when><otherwise>status = 'ACTIVE'</otherwise></choose>
</select><!-- 复杂业务场景的多分支选择 -->
<select id="findUsersByRole" resultType="User">SELECT u.*, r.role_nameFROM users uLEFT JOIN user_roles ur ON u.id = ur.user_idLEFT JOIN roles r ON ur.role_id = r.idWHERE<choose><when test="roleType == 'ADMIN'">r.role_name IN ('SUPER_ADMIN', 'ADMIN')</when><when test="roleType == 'USER'">r.role_name = 'USER'</when><when test="roleType == 'GUEST'">r.role_name IS NULL OR r.role_name = 'GUEST'</when><otherwise>u.status = 'ACTIVE'</otherwise></choose>
</select>

条件判断最佳实践：

@Data
public class UserQueryCondition {private String username;private String email;private String status;private Date createTimeStart;private Date createTimeEnd;private String searchType;private String keyword;private AgeRange ageRange;@Datapublic static class AgeRange {private Integer min;private Integer max;}// 业务逻辑验证方法public boolean hasSearchCondition() {return StringUtils.hasText(username) || StringUtils.hasText(email) || StringUtils.hasText(status);}public boolean hasTimeRange() {return createTimeStart != null || createTimeEnd != null;}
}

🏷️ where、set、trim标签应用

where标签：智能WHERE子句处理

where标签能够智能地处理WHERE子句，自动去除多余的AND或OR关键字。

<!-- where标签智能处理 -->
<select id="findUsersWithWhere" resultType="User">SELECT * FROM users<where><if test="username != null and username != ''">AND username LIKE CONCAT('%', #{username}, '%')</if><if test="email != null and email != ''">AND email = #{email}</if><if test="status != null">AND status = #{status}</if><if test="departmentIds != null and departmentIds.size() > 0">AND department_id IN<foreach collection="departmentIds" item="deptId" open="(" separator="," close=")">#{deptId}</foreach></if></where>ORDER BY create_time DESC
</select><!-- 复杂where条件组合 -->
<select id="findUsersWithComplexWhere" resultType="User">SELECT DISTINCT u.*FROM users uLEFT JOIN user_profiles up ON u.id = up.user_idLEFT JOIN user_roles ur ON u.id = ur.user_id<where><if test="basicInfo != null"><if test="basicInfo.username != null">AND u.username LIKE CONCAT('%', #{basicInfo.username}, '%')</if><if test="basicInfo.email != null">AND u.email = #{basicInfo.email}</if></if><if test="profileInfo != null"><if test="profileInfo.nickname != null">AND up.nickname LIKE CONCAT('%', #{profileInfo.nickname}, '%')</if><if test="profileInfo.city != null">AND up.city = #{profileInfo.city}</if></if><if test="roleIds != null and roleIds.size() > 0">AND ur.role_id IN<foreach collection="roleIds" item="roleId" open="(" separator="," close=")">#{roleId}</foreach></if></where>
</select>

set标签：智能SET子句处理

set标签用于UPDATE语句，能够智能地处理SET子句，自动去除多余的逗号。

<!-- set标签智能更新 -->
<update id="updateUserSelective">UPDATE users<set><if test="username != null and username != ''">username = #{username},</if><if test="email != null and email != ''">email = #{email},</if><if test="phone != null">phone = #{phone},</if><if test="status != null">status = #{status},</if><if test="lastLoginTime != null">last_login_time = #{lastLoginTime},</if>update_time = NOW()</set>WHERE id = #{id}
</update><!-- 批量更新with set标签 -->
<update id="batchUpdateUserStatus"><foreach collection="users" item="user" separator=";">UPDATE users<set><if test="user.status != null">status = #{user.status},</if><if test="user.updateReason != null">update_reason = #{user.updateReason},</if>update_time = NOW()</set>WHERE id = #{user.id}</foreach>
</update>

trim标签：自定义前缀后缀处理

trim标签提供了最灵活的字符串处理能力，可以自定义前缀、后缀以及需要覆盖的字符。

<!-- trim标签自定义处理 -->
<select id="findUsersWithTrim" resultType="User">SELECT * FROM users<trim prefix="WHERE" prefixOverrides="AND |OR "><if test="username != null">AND username = #{username}</if><if test="email != null">OR email = #{email}</if><if test="phone != null">AND phone = #{phone}</if></trim>
</select><!-- 复杂INSERT语句的trim应用 -->
<insert id="insertUserSelective">INSERT INTO users<trim prefix="(" suffix=")" suffixOverrides=","><if test="username != null">username,</if><if test="email != null">email,</if><if test="phone != null">phone,</if><if test="status != null">status,</if>create_time</trim><trim prefix="VALUES (" suffix=")" suffixOverrides=","><if test="username != null">#{username},</if><if test="email != null">#{email},</if><if test="phone != null">#{phone},</if><if test="status != null">#{status},</if>NOW()</trim>
</insert><!-- 动态ORDER BY子句 -->
<select id="findUsersWithDynamicOrder" resultType="User">SELECT * FROM usersWHERE status = 'ACTIVE'<trim prefix="ORDER BY" suffixOverrides=","><if test="orderBy != null"><if test="orderBy.username != null">username ${orderBy.username},</if><if test="orderBy.createTime != null">create_time ${orderBy.createTime},</if><if test="orderBy.lastLoginTime != null">last_login_time ${orderBy.lastLoginTime},</if></if>id DESC</trim>
</select>

🔁 foreach循环处理集合

基础foreach应用

foreach标签用于处理集合类型的参数，常用于IN查询、批量插入等场景。

<!-- 基础IN查询 -->
<select id="findUsersByIds" resultType="User">SELECT * FROM usersWHERE id IN<foreach collection="ids" item="id" open="(" separator="," close=")">#{id}</foreach>
</select><!-- 复杂集合条件查询 -->
<select id="findUsersByMultipleConditions" resultType="User">SELECT * FROM usersWHERE 1=1<if test="userIds != null and userIds.size() > 0">AND id IN<foreach collection="userIds" item="userId" open="(" separator="," close=")">#{userId}</foreach></if><if test="statuses != null and statuses.size() > 0">AND status IN<foreach collection="statuses" item="status" open="(" separator="," close=")">#{status}</foreach></if><if test="departments != null and departments.size() > 0">AND department_id IN<foreach collection="departments" item="dept" open="(" separator="," close=")">#{dept.id}</foreach></if>
</select><!-- 批量插入 -->
<insert id="batchInsertUsers">INSERT INTO users (username, email, phone, status, create_time)VALUES<foreach collection="users" item="user" separator=",">(#{user.username}, #{user.email}, #{user.phone}, #{user.status}, NOW())</foreach>
</insert><!-- 批量更新 -->
<update id="batchUpdateUsers"><foreach collection="users" item="user" separator=";">UPDATE usersSET username = #{user.username},email = #{user.email},update_time = NOW()WHERE id = #{user.id}</foreach>
</update>

高级foreach应用

<!-- 复杂批量插入with关联数据 -->
<insert id="batchInsertOrdersWithItems"><!-- 插入订单 --><foreach collection="orders" item="order" separator=";">INSERT INTO orders (order_no, user_id, total_amount, status, create_time)VALUES (#{order.orderNo}, #{order.userId}, #{order.totalAmount}, #{order.status}, NOW());<!-- 获取刚插入的订单ID并插入订单项 --><if test="order.items != null and order.items.size() > 0">INSERT INTO order_items (order_id, product_id, quantity, price)VALUES<foreach collection="order.items" item="item" separator=",">(LAST_INSERT_ID(), #{item.productId}, #{item.quantity}, #{item.price})</foreach></if></foreach>
</insert><!-- 动态构建复杂查询条件 -->
<select id="findOrdersByComplexConditions" resultType="Order">SELECT DISTINCT o.*FROM orders oLEFT JOIN order_items oi ON o.id = oi.order_idWHERE 1=1<if test="conditions != null and conditions.size() > 0">AND (<foreach collection="conditions" item="condition" separator="OR">(<if test="condition.orderNos != null and condition.orderNos.size() > 0">o.order_no IN<foreach collection="condition.orderNos" item="orderNo" open="(" separator="," close=")">#{orderNo}</foreach></if><if test="condition.productIds != null and condition.productIds.size() > 0"><if test="condition.orderNos != null and condition.orderNos.size() > 0">AND</if>oi.product_id IN<foreach collection="condition.productIds" item="productId" open="(" separator="," close=")">#{productId}</foreach></if>)</foreach>)</if>
</select>

🔗 bind变量绑定

bind标签的基础应用

bind标签允许你在SQL映射中创建一个变量并将其绑定到上下文中，常用于字符串拼接和复杂表达式计算。

<!-- 基础bind应用 -->
<select id="findUsersByKeyword" resultType="User"><bind name="pattern" value="'%' + keyword + '%'"/>SELECT * FROM usersWHERE username LIKE #{pattern}OR email LIKE #{pattern}OR phone LIKE #{pattern}
</select><!-- 复杂bind表达式 -->
<select id="findUsersWithComplexBind" resultType="User"><bind name="usernamePattern" value="'%' + (username != null ? username : '') + '%'"/><bind name="emailPattern" value="'%' + (email != null ? email : '') + '%'"/><bind name="currentYear" value="@java.time.Year@now().getValue()"/>SELECT *, (#{currentYear} - YEAR(birth_date)) as calculated_ageFROM usersWHERE 1=1<if test="username != null and username != ''">AND username LIKE #{usernamePattern}</if><if test="email != null and email != ''">AND email LIKE #{emailPattern}</if>
</select><!-- bind在动态表名中的应用 -->
<select id="findDataByTableName" resultType="Map"><bind name="tableName" value="'user_data_' + @java.time.LocalDate@now().getYear()"/>SELECT * FROM ${tableName}WHERE create_time >= #{startTime}AND create_time <= #{endTime}
</select>

bind标签高级用法

<!-- 复杂业务逻辑的bind应用 -->
<select id="generateUserReport" resultType="UserReport"><bind name="ageGroup" value="age >= 60 ? 'SENIOR' : age >= 40 ? 'MIDDLE' : age >= 18 ? 'YOUNG' : 'MINOR'"/><bind name="scoreLevel" value="score >= 90 ? 'EXCELLENT' :score >= 80 ? 'GOOD' :score >= 60 ? 'AVERAGE' : 'POOR'"/><bind name="searchPattern" value="searchKeyword != null ? ('%' + searchKeyword + '%') : null"/>SELECT id,username,age,score,#{ageGroup} as age_group,#{scoreLevel} as score_level,CASE WHEN age >= 60 THEN 'SENIOR'WHEN age >= 40 THEN 'MIDDLE' WHEN age >= 18 THEN 'YOUNG'ELSE 'MINOR'END as calculated_age_groupFROM users<where><if test="searchKeyword != null and searchKeyword != ''">AND (username LIKE #{searchPattern} OR email LIKE #{searchPattern})</if><if test="minAge != null">AND age >= #{minAge}</if><if test="maxAge != null">AND age <= #{maxAge}</if></where>
</select>

📊 复杂查询与结果映射

🔗 一对一关联查询（association）

基础一对一关联

一对一关联用于处理两个实体之间的一对一关系，如用户和用户详情的关系。

<!-- 一对一关联映射 -->
<resultMap id="UserWithProfileResultMap" type="User"><id property="id" column="user_id"/><result property="username" column="username"/><result property="email" column="email"/><result property="createTime" column="create_time"/><!-- 一对一关联 --><association property="profile" javaType="UserProfile"><id property="id" column="profile_id"/><result property="nickname" column="nickname"/><result property="avatar" column="avatar"/><result property="bio" column="bio"/><result property="city" column="city"/><result property="birthDate" column="birth_date"/></association>
</resultMap><select id="findUserWithProfile" resultMap="UserWithProfileResultMap">SELECT u.id as user_id,u.username,u.email,u.create_time,p.id as profile_id,p.nickname,p.avatar,p.bio,p.city,p.birth_dateFROM users uLEFT JOIN user_profiles p ON u.id = p.user_idWHERE u.id = #{id}
</select>

嵌套查询方式的一对一关联

<!-- 嵌套查询方式 -->
<resultMap id="UserWithProfileNestedResultMap" type="User"><id property="id" column="id"/><result property="username" column="username"/><result property="email" column="email"/><!-- 嵌套查询关联 --><association property="profile" javaType="UserProfile" column="id" select="findProfileByUserId"/>
</resultMap><select id="findUserWithProfileNested" resultMap="UserWithProfileNestedResultMap">SELECT id, username, email, create_timeFROM usersWHERE id = #{id}
</select><select id="findProfileByUserId" resultType="UserProfile">SELECT id, nickname, avatar, bio, city, birth_dateFROM user_profilesWHERE user_id = #{id}
</select>

复杂一对一关联场景

<!-- 订单与支付信息的一对一关联 -->
<resultMap id="OrderWithPaymentResultMap" type="Order"><id property="id" column="order_id"/><result property="orderNo" column="order_no"/><result property="totalAmount" column="total_amount"/><result property="status" column="order_status"/><!-- 关联用户信息 --><association property="user" javaType="User"><id property="id" column="user_id"/><result property="username" column="username"/><result property="email" column="user_email"/></association><!-- 关联支付信息 --><association property="payment" javaType="Payment"><id property="id" column="payment_id"/><result property="paymentNo" column="payment_no"/><result property="amount" column="payment_amount"/><result property="method" column="payment_method"/><result property="status" column="payment_status"/><result property="paidTime" column="paid_time"/></association>
</resultMap><select id="findOrderWithPayment" resultMap="OrderWithPaymentResultMap">SELECT o.id as order_id,o.order_no,o.total_amount,o.status as order_status,u.id as user_id,u.username,u.email as user_email,p.id as payment_id,p.payment_no,p.amount as payment_amount,p.method as payment_method,p.status as payment_status,p.paid_timeFROM orders oLEFT JOIN users u ON o.user_id = u.idLEFT JOIN payments p ON o.id = p.order_idWHERE o.id = #{orderId}
</select>

📚 一对多关联查询（collection）

基础一对多关联

一对多关联用于处理一个实体对应多个子实体的关系，如用户和订单的关系。

<!-- 用户与订单的一对多关联 -->
<resultMap id="UserWithOrdersResultMap" type="User"><id property="id" column="user_id"/><result property="username" column="username"/><result property="email" column="email"/><!-- 一对多关联 --><collection property="orders" ofType="Order"><id property="id" column="order_id"/><result property="orderNo" column="order_no"/><result property="totalAmount" column="total_amount"/><result property="status" column="order_status"/><result property="createTime" column="order_create_time"/></collection>
</resultMap><select id="findUserWithOrders" resultMap="UserWithOrdersResultMap">SELECT u.id as user_id,u.username,u.email,o.id as order_id,o.order_no,o.total_amount,o.status as order_status,o.create_time as order_create_timeFROM users uLEFT JOIN orders o ON u.id = o.user_idWHERE u.id = #{userId}ORDER BY o.create_time DESC
</select>

嵌套查询方式的一对多关联

<!-- 嵌套查询方式 -->
<resultMap id="UserWithOrdersNestedResultMap" type="User"><id property="id" column="id"/><result property="username" column="username"/><result property="email" column="email"/><!-- 嵌套查询关联 --><collection property="orders" ofType="Order" column="id" select="findOrdersByUserId"/>
</resultMap><select id="findUserWithOrdersNested" resultMap="UserWithOrdersNestedResultMap">SELECT id, username, emailFROM usersWHERE id = #{userId}
</select><select id="findOrdersByUserId" resultType="Order">SELECT id, order_no, total_amount, status, create_timeFROM ordersWHERE user_id = #{userId}ORDER BY create_time DESC
</select>

复杂一对多关联场景

<!-- 订单与订单项的复杂一对多关联 -->
<resultMap id="OrderWithItemsResultMap" type="Order"><id property="id" column="order_id"/><result property="orderNo" column="order_no"/><result property="totalAmount" column="total_amount"/><result property="status" column="order_status"/><!-- 关联用户信息 --><association property="user" javaType="User"><id property="id" column="user_id"/><result property="username" column="username"/></association><!-- 一对多关联订单项 --><collection property="items" ofType="OrderItem"><id property="id" column="item_id"/><result property="productId" column="product_id"/><result property="productName" column="product_name"/><result property="quantity" column="quantity"/><result property="price" column="item_price"/><result property="subtotal" column="subtotal"/><!-- 嵌套关联商品信息 --><association property="product" javaType="Product"><id property="id" column="product_id"/><result property="name" column="product_name"/><result property="description" column="product_description"/><result property="category" column="product_category"/></association></collection>
</resultMap><select id="findOrderWithItems" resultMap="OrderWithItemsResultMap">SELECT o.id as order_id,o.order_no,o.total_amount,o.status as order_status,u.id as user_id,u.username,oi.id as item_id,oi.product_id,oi.quantity,oi.price as item_price,(oi.quantity * oi.price) as subtotal,p.name as product_name,p.description as product_description,p.category as product_categoryFROM orders oLEFT JOIN users u ON o.user_id = u.idLEFT JOIN order_items oi ON o.id = oi.order_idLEFT JOIN products p ON oi.product_id = p.idWHERE o.id = #{orderId}
</select>

🔄 多对多关联查询

基础多对多关联

多对多关联通常通过中间表来实现，如用户和角色的关系。

<!-- 用户与角色的多对多关联 -->
<resultMap id="UserWithRolesResultMap" type="User"><id property="id" column="user_id"/><result property="username" column="username"/><result property="email" column="email"/><!-- 多对多关联角色 --><collection property="roles" ofType="Role"><id property="id" column="role_id"/><result property="roleName" column="role_name"/><result property="description" column="role_description"/><result property="createTime" column="role_create_time"/></collection>
</resultMap><select id="findUserWithRoles" resultMap="UserWithRolesResultMap">SELECT u.id as user_id,u.username,u.email,r.id as role_id,r.role_name,r.description as role_description,r.create_time as role_create_timeFROM users uLEFT JOIN user_roles ur ON u.id = ur.user_idLEFT JOIN roles r ON ur.role_id = r.idWHERE u.id = #{userId}
</select>

复杂多对多关联场景

<!-- 用户-角色-权限的复杂多对多关联 -->
<resultMap id="UserWithRolesAndPermissionsResultMap" type="User"><id property="id" column="user_id"/><result property="username" column="username"/><result property="email" column="email"/><!-- 关联角色信息 --><collection property="roles" ofType="Role"><id property="id" column="role_id"/><result property="roleName" column="role_name"/><result property="description" column="role_description"/><!-- 角色关联的权限 --><collection property="permissions" ofType="Permission"><id property="id" column="permission_id"/><result property="permissionName" column="permission_name"/><result property="resource" column="resource"/><result property="action" column="action"/></collection></collection>
</resultMap><select id="findUserWithRolesAndPermissions" resultMap="UserWithRolesAndPermissionsResultMap">SELECT DISTINCTu.id as user_id,u.username,u.email,r.id as role_id,r.role_name,r.description as role_description,p.id as permission_id,p.permission_name,p.resource,p.actionFROM users uLEFT JOIN user_roles ur ON u.id = ur.user_idLEFT JOIN roles r ON ur.role_id = r.idLEFT JOIN role_permissions rp ON r.id = rp.role_idLEFT JOIN permissions p ON rp.permission_id = p.idWHERE u.id = #{userId}ORDER BY r.id, p.id
</select>

🏗️ 嵌套查询vs嵌套结果

性能对比分析

方式	优点	缺点	适用场景
嵌套结果	一次查询获取所有数据，性能较好	SQL复杂，可能产生数据冗余	数据量适中，关联关系简单
嵌套查询	SQL简单，易于维护	可能产生N+1查询问题	数据量大，关联关系复杂

嵌套结果示例

<!-- 嵌套结果方式 - 一次查询 -->
<resultMap id="UserOrdersNestedResultMap" type="User"><id property="id" column="user_id"/><result property="username" column="username"/><collection property="orders" ofType="Order"><id property="id" column="order_id"/><result property="orderNo" column="order_no"/><result property="totalAmount" column="total_amount"/></collection>
</resultMap><select id="findUsersWithOrdersNestedResult" resultMap="UserOrdersNestedResultMap">SELECT u.id as user_id,u.username,o.id as order_id,o.order_no,o.total_amountFROM users uLEFT JOIN orders o ON u.id = o.user_idWHERE u.status = 'ACTIVE'
</select>

嵌套查询示例

<!-- 嵌套查询方式 - 多次查询 -->
<resultMap id="UserOrdersNestedQueryMap" type="User"><id property="id" column="id"/><result property="username" column="username"/><collection property="orders" ofType="Order" column="id" select="selectOrdersByUserId"/>
</resultMap><select id="findUsersWithOrdersNestedQuery" resultMap="UserOrdersNestedQueryMap">SELECT id, usernameFROM usersWHERE status = 'ACTIVE'
</select><select id="selectOrdersByUserId" resultType="Order">SELECT id, order_no, total_amountFROM ordersWHERE user_id = #{id}ORDER BY create_time DESC
</select>

⚡ 延迟加载配置与优化

延迟加载基础配置

<settings><!-- 开启延迟加载 --><setting name="lazyLoadingEnabled" value="true"/><!-- 关闭积极加载 --><setting name="aggressiveLazyLoading" value="false"/><!-- 延迟加载触发方法 --><setting name="lazyLoadTriggerMethods" value="equals,clone,hashCode,toString"/>
</settings>

延迟加载应用示例

<!-- 延迟加载配置 -->
<resultMap id="UserWithLazyOrdersResultMap" type="User"><id property="id" column="id"/><result property="username" column="username"/><result property="email" column="email"/><!-- 延迟加载订单信息 --><collection property="orders" ofType="Order" column="id" select="selectOrdersByUserId"fetchType="lazy"/><!-- 延迟加载用户详情 --><association property="profile" javaType="UserProfile" column="id" select="selectProfileByUserId"fetchType="lazy"/>
</resultMap><select id="findUserWithLazyLoading" resultMap="UserWithLazyOrdersResultMap">SELECT id, username, emailFROM usersWHERE id = #{userId}
</select>

延迟加载性能优化

@Service
public class UserService {@Autowiredprivate UserMapper userMapper;/*** 延迟加载优化示例*/@Transactional(readOnly = true)public User findUserWithOptimizedLoading(Long userId, boolean includeOrders) {User user = userMapper.findUserWithLazyLoading(userId);// 根据业务需要决定是否加载关联数据if (includeOrders) {// 触发延迟加载user.getOrders().size();}return user;}/*** 批量查询时的延迟加载优化*/@Transactional(readOnly = true)public List<User> findUsersWithOptimizedBatchLoading(List<Long> userIds) {List<User> users = userMapper.findUsersByIds(userIds);// 批量预加载关联数据，避免N+1问题if (!users.isEmpty()) {List<Long> ids = users.stream().map(User::getId).collect(Collectors.toList());Map<Long, List<Order>> ordersMap = userMapper.findOrdersByUserIds(ids).stream().collect(Collectors.groupingBy(Order::getUserId));users.forEach(user -> {List<Order> orders = ordersMap.get(user.getId());if (orders != null) {user.setOrders(orders);}});}return users;}
}

📊 技术成熟度评估

MyBatis动态SQL技术成熟度分析

技术维度	成熟度评分	详细说明
语法完整性	⭐⭐⭐⭐⭐	提供完整的动态SQL语法支持，覆盖各种场景
性能表现	⭐⭐⭐⭐	动态SQL生成高效，支持预编译优化
学习成本	⭐⭐⭐	需要掌握XML语法和OGNL表达式
调试难度	⭐⭐⭐	动态SQL调试相对复杂，需要日志支持
维护性	⭐⭐⭐⭐	结构清晰，便于维护和扩展
社区支持	⭐⭐⭐⭐⭐	丰富的文档和社区资源