从入门到精通：MyBatis之resultMap 核心剖析与电商场景应用实战

周小闯

已于 2025-02-19 10:30:34 修改

阅读量680

点赞数 33

分类专栏： mybatis 项目实战文章标签： mybatis tomcat java

于 2025-02-18 23:51:06 首次发布

本文链接：https://blog.youkuaiyun.com/i_YOLO/article/details/145717421

版权

项目实战同时被 2 个专栏收录

5 篇文章

订阅专栏

mybatis

1 篇文章

订阅专栏

MyBatis 中的 resultMap 是其核心功能之一，用于将数据库查询结果集中的列与 Java 对象的属性进行灵活映射。它不仅可以解决数据库字段名与 Java 类属性名不一致的问题，还能支持复杂的关联映射，如一对一、一对多、多对多以及基于条件的鉴别映射等。

一、拆解resultMap核心知识点

1. 基本概念

定义与作用
resultMap 是在 MyBatis 的 XML 映射文件中定义的一个映射规则，它告诉 MyBatis 如何把 SQL 查询返回的每一行数据转换为一个 Java 对象。通过配置 <resultMap> 标签，你可以明确指定数据库列与 JavaBean 属性之间的对应关系，从而避免了自动映射时因为命名不一致而导致数据丢失或映射错误的问题。
自动映射与手动映射
如果数据库字段名和 Java 对象属性名一致，MyBatis 可以自动完成映射，此时你可以直接使用 resultType。但当字段名与属性名不一致或需要进行复杂处理时，就需要使用 resultMap 进行手动映射，明确指定 <id>（主键映射）和 <result>（普通字段映射）等子标签。

2. 基本用法

简单映射
假设有一个 User 类，其属性与数据库中的字段不完全对应，你可以这样定义 resultMap：
```
<resultMap id="userResultMap" type="User">
    <id property="id" column="id"/>
    <result property="username" column="username"/>
    <result property="password" column="pwd"/>
</resultMap>
```
在 <select> 语句中引用该 resultMap，即可将查询结果正确映射到 User 对象上。
使用 resultType 的自动映射
如果数据库列名与 Java 属性名完全匹配，可以直接使用 resultType，但这对字段名称要求较高。

3. 复杂映射

当涉及到多表联合查询或者对象嵌套时，resultMap 显得尤为重要。常见的高级映射有：

association（一对一映射）
用于将查询结果中的一部分数据映射到 Java 对象的嵌套属性中。例如，一个用户对象中包含一个地址对象，可使用 <association> 标签进行映射。
collection（一对多映射）
用于将查询结果中的多行数据映射到 Java 对象的集合属性中，如一个订单包含多个订单项。
constructor（构造器映射）
如果 POJO 没有无参构造函数，可以通过 <constructor> 标签来指定使用构造方法注入属性。
discriminator（鉴别器映射）
当同一查询可能返回不同类型的结果时，可以用 <discriminator> 标签根据某个字段的值决定映射到哪个子类，实现类似于 Java 中的 switch 语句。

4. 嵌套查询与嵌套结果

嵌套查询
使用嵌套查询可以在主查询中通过调用另一个 SQL 映射语句来加载关联对象，这种方式虽然灵活但可能引起“ N+1 查询问题”。
嵌套结果
通过在同一 SQL 中联合多个表，并使用 resultMap 的嵌套映射（association/collection）来处理关联数据，这种方式通常能减少 SQL 调用次数，提升性能。

5. 使用场景与注意事项

解决字段不匹配问题
当数据库字段与 Java 对象属性名称不一致时，resultMap 允许你通过 <result> 标签指定明确的映射关系，而不必修改数据库或 Java 类。
性能与复杂度平衡
虽然 resultMap 能映射复杂的对象关系，但配置过于复杂可能会增加维护难度。推荐从简单映射开始，逐步引入关联映射，并利用单元测试验证映射的正确性。
resultMap 与 resultType 不能同时使用
在同一个 <select> 标签中，resultType 与 resultMap 只能二选一。

二、电商系统实战演练

下面以一个电商系统为例，说明如何在真实场景中利用 MyBatis 的 resultMap 来处理各种映射需求。

假设系统中有以下几个实体类：

User：用户信息（数据库字段与 Java 属性名称可能不一致，例如数据库中为 user_id，而 Java 中属性命名为 id）。
Address：用户地址（User 与 Address 为一对一关系）。
Order：订单信息（包含订单号、下单时间、总金额等）。
OrderItem：订单项（一个订单包含多个订单项，一对多关系，每个订单项包含产品信息）。
Product：产品详情。

下面分别对各个映射点进行说明：

1. 简单映射：字段与属性名不一致

假设数据库中的用户表字段为：

user_id
user_name
user_pwd

而 User 类定义如下：

public class User {
    private int id;
    private String username;
    private String password;
    // getters 和 setters
}

为了映射查询结果，我们在 XML 中定义 resultMap，如下：

<resultMap id="userResultMap" type="User">
    <id property="id" column="user_id"/>
    <result property="username" column="user_name"/>
    <result property="password" column="user_pwd"/>
</resultMap>

<select id="selectUserById" resultMap="userResultMap" parameterType="int">
    SELECT user_id, user_name, user_pwd FROM users WHERE user_id = #{id}
</select>

这样，无论字段名如何不同，MyBatis 都能根据 resultMap 将数据正确赋值到 User 对象上。

2. 关联映射（一对一）：User 与 Address

假设每个用户都有一个详细地址，数据库中 Address 表字段为：

addr_id
user_id
street
city
zip_code

对应的 Address 类：

public class Address {
    private int id;
    private String street;
    private String city;
    private String zipCode;
    // getters 和 setters
}

而 User 类增加一个 Address 属性：

public class User {
    private int id;
    private String username;
    private String password;
    private Address address;
    // getters 和 setters
}

在 XML 中可以使用 <association> 来完成一对一映射：

<resultMap id="userWithAddressMap" type="User">
    <id property="id" column="user_id"/>
    <result property="username" column="user_name"/>
    <result property="password" column="user_pwd"/>
    <!-- 关联映射，通过 user_id 关联地址 -->
    <association property="address" javaType="Address" column="user_id" select="selectAddressByUserId"/>
</resultMap>

<select id="selectUserWithAddress" resultMap="userWithAddressMap" parameterType="int">
    SELECT user_id, user_name, user_pwd FROM users WHERE user_id = #{id}
</select>

<!-- 定义查询地址的 SQL -->
<select id="selectAddressByUserId" resultType="Address" parameterType="int">
    SELECT addr_id AS id, street, city, zip_code AS zipCode FROM address WHERE user_id = #{userId}
</select>

这里采用了嵌套查询的方式，通过 association 调用另一个 SQL 来加载 Address 对象。

3. 集合映射（一对多）：Order 与 OrderItem

假设每个订单可以包含多个订单项，数据库中：

orders 表：order_id、user_id、order_date、total_amount
order_items 表：item_id、order_id、product_id、quantity、price
products 表：product_id、product_name、description、price

对应 Order 类：

public class Order {
    private int id;
    private Date orderDate;
    private BigDecimal totalAmount;
    private List<OrderItem> items; // 一对多关系
    // getters 和 setters
}

OrderItem 类中可以嵌套 Product 信息：

public class OrderItem {
    private int id;
    private int quantity;
    private BigDecimal price;
    private Product product; // 每个订单项对应一个产品
    // getters 和 setters
}

Product 类：

public class Product {
    private int id;
    private String productName;
    private String description;
    private BigDecimal price;
    // getters 和 setters
}

使用嵌套结果映射实现订单与订单项的一对多映射：

<resultMap id="orderResultMap" type="Order">
    <id property="id" column="order_id"/>
    <result property="orderDate" column="order_date"/>
    <result property="totalAmount" column="total_amount"/>
    <!-- 集合映射：一个订单包含多个订单项 -->
    <collection property="items" ofType="OrderItem">
        <id property="id" column="item_id"/>
        <result property="quantity" column="quantity"/>
        <result property="price" column="item_price"/>
        <!-- 嵌套关联：订单项关联产品 -->
        <association property="product" javaType="Product">
            <id property="id" column="product_id"/>
            <result property="productName" column="product_name"/>
            <result property="description" column="description"/>
            <result property="price" column="product_price"/>
        </association>
    </collection>
</resultMap>

<select id="selectOrderById" resultMap="orderResultMap" parameterType="int">
    SELECT 
        o.order_id, o.order_date, o.total_amount,
        i.item_id, i.quantity, i.price AS item_price,
        p.product_id, p.product_name, p.description, p.price AS product_price
    FROM orders o
    LEFT JOIN order_items i ON o.order_id = i.order_id
    LEFT JOIN products p ON i.product_id = p.product_id
    WHERE o.order_id = #{id}
</select>

这种方式利用嵌套结果，将多表联合查询的结果映射到 Order 对象，其中嵌套的 <collection> 元素负责构造 OrderItem 列表，而 <association> 则构造嵌套的 Product 对象。

4. 构造器映射

如果某个类没有无参构造函数，则可以使用 <constructor> 映射。假设 Order 类只有一个带参数的构造器：

public class Order {
    private int id;
    private Date orderDate;
    private BigDecimal totalAmount;
    private List<OrderItem> items;

    public Order(int id, Date orderDate, BigDecimal totalAmount) {
        this.id = id;
        this.orderDate = orderDate;
        this.totalAmount = totalAmount;
    }
    // getters 和 setters（items 通过 setter 注入）
}

在 XML 中，可以这样配置：

<resultMap id="orderConstructorMap" type="Order">
    <constructor>
        <idArg column="order_id" javaType="int"/>
        <arg column="order_date" javaType="java.util.Date"/>
        <arg column="total_amount" javaType="java.math.BigDecimal"/>
    </constructor>
    <!-- 后续字段可以通过 setter 注入，比如集合 -->
    <collection property="items" ofType="OrderItem">
        <id property="id" column="item_id"/>
        <result property="quantity" column="quantity"/>
        <result property="price" column="item_price"/>
        <association property="product" javaType="Product">
            <id property="id" column="product_id"/>
            <result property="productName" column="product_name"/>
            <result property="description" column="description"/>
            <result property="price" column="product_price"/>
        </association>
    </collection>
</resultMap>

通过构造器映射，MyBatis 能直接调用 Order 的带参构造器来实例化对象。

5. 鉴别器映射：根据状态映射不同子类

假设订单可能分为普通订单和折扣订单。我们可以创建两个类，DiscountOrder 继承自 Order，用来存放额外的折扣信息。数据库中 orders 表有一个字段 order_type（1 表示普通订单，2 表示折扣订单）。

定义鉴别器映射：

<resultMap id="vehicleResultMap" type="Order">
    <id property="id" column="order_id"/>
    <result property="orderDate" column="order_date"/>
    <result property="totalAmount" column="total_amount"/>
    <discriminator javaType="int" column="order_type">
        <case value="2" resultMap="discountOrderMap"/>
    </discriminator>
    <!-- 如果没有匹配到鉴别器，则按普通订单处理 -->
</resultMap>

<resultMap id="discountOrderMap" type="DiscountOrder" extends="vehicleResultMap">
    <result property="discount" column="discount_amount"/>
</resultMap>

这样，当查询返回的 order_type 为 2 时，MyBatis 会自动构造 DiscountOrder 对象，并映射额外的折扣字段。

6. 嵌套查询 vs. 嵌套结果

在上述地址和订单项的示例中，我们演示了两种方式：

嵌套查询：例如在 User 与 Address 的例子中，通过 <association> 标签的 select 属性调用单独的查询。优点是 SQL 简单、易维护，但可能引起 N+1 查询问题。

N+1 查询问题是一种常见的性能陷阱，通常出现在使用 ORM 框架（例如 MyBatis、Hibernate 等）进行对象映射时。其核心问题在于：

概念说明：
当你执行一个查询（即“1”），返回 N 条父记录后，为了加载每个父记录的关联数据（例如子集合），ORM 框架会针对每个父记录再执行一条查询（即“N”）。这样，总共就会执行 1 + N 条查询。
举例说明：
例如，在一个电商系统中，你需要查询所有订单及其对应的订单项。如果系统首先查询出 100 个订单（1 条查询），然后对于每个订单单独查询订单项（100 条查询），最终就会执行 101 条 SQL。这种额外的查询会显著影响性能，尤其当父记录数量很多时，SQL 查询次数会呈线性增长。
影响：
如果父记录数量较大，N+1 查询问题会导致大量 SQL 调用，进而引起数据库负载过高、响应时间延长，从而影响整个系统的性能。
解决办法：
常见的解决方案包括使用联合查询（JOIN）一次性加载所有关联数据，或者利用批量查询、缓存等手段来减少重复查询的次数。

这种问题提醒开发者在设计数据访问层时，需要特别注意如何高效加载关联数据，避免因频繁调用数据库而带来的性能瓶颈。

嵌套结果：例如在 Order 与 OrderItem 的例子中，通过联合查询一次性返回所有数据，并在 resultMap 中使用 <collection> 进行分组映射。优点是只发起一次查询，性能更好，但 SQL 书写稍显复杂。

三、总结

MyBatis 的 resultMap 提供了强大而灵活的机制，使得开发者能够精准地控制 SQL 查询结果与 Java 对象之间的映射关系。无论是简单的单表查询还是复杂的多表联合查询，通过合理设计 resultMap，都能大幅提高数据访问层代码的可读性、可维护性和性能。

这种灵活性正是 MyBatis 被广泛使用的重要原因之一，也为开发者在实际项目中处理复杂数据模型提供了极大便利。

在电商系统中，从用户登录、查看订单到订单详情展示，都涉及到对数据库中多张表的数据进行映射。MyBatis 的 resultMap 提供了以下灵活的解决方案：

简单映射：解决字段与属性名称不一致的问题。
关联映射（association）：处理一对一关系，如用户与地址。
集合映射（collection）：处理一对多关系，如订单与订单项。
构造器映射：在 POJO 无无参构造器时，通过构造函数注入数据。
鉴别器映射：根据特定字段值决定映射到哪个子类，适用于多态场景。
嵌套查询与嵌套结果：提供两种加载关联数据的策略，分别适用于不同性能和维护要求的场景。

通过这些配置，开发者可以针对复杂的业务场景，灵活地将查询结果映射成所需的 Java 对象，既提高了代码的清晰度，也确保了系统的高效运行。

这种灵活性正是 MyBatis 被广泛使用的重要原因之一，也为开发者在实际项目中处理复杂数据模型提供了极大便利。