MyBatis 结果映射的几种实现方式

一、 什么是结果映射？ 😮

在我们的 Java 应用程序中，数据通常以对象（JavaBeans/POJOs）的形式存在。然而，关系型数据库是以行和列的形式存储数据。当我们从数据库查询数据时，得到的是一个包含多行多列的结果集（ResultSet）。

结果映射（Result Mapping） 就是 MyBatis 中定义如何将数据库查询结果集中的列（Columns）映射到 Java 对象的属性（Properties）上的规则和过程。它是解决数据库中心的数据表示（表结构）与应用程序中心的对象模型（类结构）之间“阻抗失配”问题的核心机制。

简单来说： 告诉 MyBatis，数据库查出来的 user_id 这一列的值，应该赋给 User 这个 Java 类的 userId 这个属性。

二、 为何需要结果映射？ 🤔

1. 命名差异：数据库列名常用下划线命名法（snake_case，如 order_id），而 Java 属性常用驼峰命名法（camelCase，如 orderId）。需要转换。
2. 类型转换 🔄：数据库类型（如 VARCHAR, TIMESTAMP, NUMBER）需要转换为相应的 Java 类型（如 String, java.util.Date, Integer, BigDecimal）。
3. 复杂关系：实际应用中，数据往往不是扁平的。一个对象可能包含另一个对象（一对一/多对一），或者包含一个对象集合（一对多）。需要机制来处理这些关联。
4. 显式控制 🔧：有时自动映射无法满足需求，需要更精细地控制映射过程，例如列名和属性名差异很大，或需要使用自定义的类型处理器（TypeHandler）。

三、 如何映射？（基础）✨

MyBatis 提供了多种方式进行结果映射：

1、 别名映射 ✍️

这是最直接的方式，在 SQL 语句中使用 AS 关键字为查询的列指定别名，让别名与 Java 对象的属性名完全一致。

Java Bean (User.java)

public class User {
    private Integer userId;
    private String userName;
    private String userEmail;
    // getters and setters...
}

Mapper XML (UserMapper.xml)

<select id="findUserById" resultType="com.yourcompany.domain.User">
  SELECT
      user_id   AS userId,  -- 使用 AS 将列名映射到属性名
      user_name AS userName,
      email     AS userEmail -- 列名和属性名不一致时必须用 AS
  FROM users
  WHERE user_id = #{id}
</select>

• 优点：非常明确，SQL 本身就定义了映射关系。
• 缺点：SQL 语句会变得冗长，尤其当字段很多时。SQL 掺杂了部分映射逻辑。

2、 驼峰命名自动映射👍

这是 MyBatis 提供的一个便捷功能。开启后，MyBatis 会自动尝试将下划线命名法的列（column_name）映射到驼峰命名法的属性（columnName）。

Java Bean (User.java) - 同上

Mapper XML (UserMapper.xml)

<select id="findUserById" resultType="com.yourcompany.domain.User">
  SELECT
      user_id,   -- 无需 AS
      user_name,
      email     -- 如果属性名是 email，也能自动映射
  FROM users
  WHERE user_id = #{id}
</select>

(注意：如果 Java 属性名不是标准的驼峰转换，驼峰映射也无法自动处理)

如何开启？

MyBatis 配置文件 (mybatis-config.xml):

<settings>
    <setting name="mapUnderscoreToCamelCase" value="true"/>
</settings>

Spring Boot 配置文件 (application.properties 或 application.yml):

# application.properties
mybatis.configuration.map-underscore-to-camel-case=true

# application.yml
mybatis:
  configuration:
    map-underscore-to-camel-case: true

通过 Java 配置 (如 Spring):

@Bean
public SqlSessionFactory sqlSessionFactory(DataSource dataSource) throws Exception {
    // ... 其他配置
    org.apache.ibatis.session.Configuration configuration = new org.apache.ibatis.session.Configuration();
    configuration.setMapUnderscoreToCamelCase(true); // 开启驼峰映射
    factoryBean.setConfiguration(configuration);
    // ... 其他配置
    return factoryBean.getObject();
}

• 优点：保持 SQL 简洁 ✅，配置一次全局生效，是目前推荐的主流简单映射方式。
• 缺点：需要配置开启；对于非标准驼峰映射的场景无能为力。

3、 resultMap 显式映射 🛠️

当自动映射（包括驼峰）无法满足需求，或者需要处理复杂类型、关联查询时，resultMap 是最强大、最灵活的武器。它允许你显式地、精确地定义列与属性之间的映射关系。

Java Bean (User.java) - 同上

Mapper XML (UserMapper.xml)

定义 <resultMap>:

<resultMap id="userResultMap" type="com.yourcompany.domain.User">
    <!-- <id> 标签用于映射主键字段，有助于 MyBatis 性能优化 -->
    <id property="userId" column="user_id" />
    <!-- <result> 标签用于映射普通字段 -->
    <result property="userName" column="user_name"/>
    <result property="userEmail" column="email"/>
    <!-- 可以指定 javaType 和 jdbcType，通常 MyBatis 能自动推断 -->
    <!-- <result property="status" column="user_status" javaType="java.lang.Integer" jdbcType="INTEGER"/> -->
</resultMap>

在 <select> 标签中使用 resultMap 属性引用:

<select id="findUserById" resultMap="userResultMap">
  SELECT user_id, user_name, email FROM users WHERE user_id = #{id}
</select>

• <resultMap> 属性:

  • id: 在当前 Mapper XML 命名空间内的唯一标识符。
  • type: 映射的目标 Java 类的完全限定名或 MyBatis 配置的别名。

• 子标签 <id> 和 <result> 属性:

  • property: Java 对象的属性名。
  • column: SQL 查询结果集中的列名（或别名）。
  • javaType: Java 属性的完整类名或别名（通常可省略）。
  • jdbcType: 数据库列的 JDBC 类型（枚举 org.apache.ibatis.type.JdbcType）。
  • typeHandler: 指定自定义的类型处理器。

• 优点：控制力最强 💪！能处理各种复杂映射场景，是实现高级映射的基础。代码更清晰，SQL 保持纯净。

• 缺点：配置相对繁琐，增加了 XML 的代码量。

四、 高级结果映射 (处理关联关系) 🔗

当查询结果需要映射到包含其他对象或对象集合的复杂 Java 对象时，就需要使用 resultMap 的高级特性：<association> 和 <collection>。

场景设定：

• 实体类:
  • Department.java: 包含 id, name 属性。
  • Employee.java: 包含 id, name, email, department (Department 对象), departmentId (Integer)。
• 数据库表:
  • departments (id PK, dept_name)
  • employees (id PK, emp_name, emp_email, dept_id FK references departments.id)

1、<association>(处理 “有一个” 关系 - To-One) ➡️👤

用于映射一个对象中包含的另一个对象，通常对应数据库中的 一对一 或 多对一 关系。

两种主要实现方式：

1. 嵌套 Select 查询 (Nested Select)

• 思路: 先查询主对象（Employee），然后根据外键（dept_id），再执行一个单独的 SQL 查询获取关联对象（Department）。
• Mapper XML:

  <select id="findDepartmentById" resultType="com.yourcompany.domain.Department">...</select>
  
  <resultMap id="employeeWithDeptSelectMap" type="com.yourcompany.domain.Employee">
      <id property="id" column="id"/>
      <result property="name" column="emp_name"/>
      <!-- association: 映射 department 属性 -->
      <association property="department" javaType="com.yourcompany.domain.Department"
                   column="dept_id"        select="findDepartmentById" />
                   <!-- column: 传递给 select 查询的参数列 -->
                   <!-- select: 指定用于查询关联对象的 select 语句 ID -->
                   <!-- fetchType="lazy": 可配置懒加载 -->
  </resultMap>
  
  <select id="findEmployeeByIdWithDeptSelect" resultMap="employeeWithDeptSelectMap">...</select>
  

• 优点: 简单直观，SQL 语句分离，支持懒加载。
• 缺点: N+1 查询问题！性能可能很差 🐌，通常不推荐使用 ❌。

2. 嵌套结果映射 (Nested Result Map) ✅

• 思路: 使用 SQL 的 JOIN 操作一次性查询出所有需要的数据，然后在 resultMap 中定义嵌套结构来映射连接后的结果。
• Mapper XML:

  <resultMap id="employeeWithDeptNestedMap" type="com.yourcompany.domain.Employee">
      <id property="id" column="emp_id"/>
      <result property="name" column="emp_name"/>
      <result property="departmentId" column="dept_id"/>
  
      <!-- association: 映射 department 属性 -->
      <association property="department" javaType="com.yourcompany.domain.Department">
          <!-- 嵌套定义 Department 的映射规则 -->
          <id property="id" column="dept_id"/>
          <result property="name" column="dept_name"/>
      </association>
  </resultMap>
  
  <select id="findEmployeeByIdWithDeptNested" resultMap="employeeWithDeptNestedMap">
      SELECT
          e.id AS emp_id, e.emp_name, e.emp_email, e.dept_id,
          d.id AS dept_id, d.dept_name -- 查询关联表的列，注意别名
      FROM employees e
      LEFT JOIN departments d ON e.dept_id = d.id
      WHERE e.id = #{empId}
  </select>
  

• 优点: 性能好 👍，只需执行一次 SQL 查询。结构清晰。这是处理关联关系推荐的方式 ✨。
• 缺点: SQL 语句可能因 JOIN 变得复杂；不支持懒加载（但通常性能好就不需要了）。

2、<collection>(处理 “有很多” 关系 - To-Many) ➡️👥

用于映射一个对象中包含的对象集合，通常对应数据库中的 一对多 关系。

同样有两种实现方式：

1. 嵌套 Select 查询 (Nested Select)

• 思路: 先查询主对象（Department），然后根据主键（id），再执行一个单独的 SQL 查询获取关联的对象集合（List）。
• Java Bean (Department.java): (需要有 List<Employee> employees; 属性)
• Mapper XML:

  <select id="findEmployeesByDeptId" resultType="com.yourcompany.domain.Employee">...</select>
  
  <resultMap id="deptWithEmployeesSelectMap" type="com.yourcompany.domain.Department">
      <id property="id" column="id"/>
      <result property="name" column="dept_name"/>
      <!-- collection: 映射 employees 集合属性 -->
      <collection property="employees" ofType="com.yourcompany.domain.Employee"
                  column="id"           select="findEmployeesByDeptId" />
                  <!-- column: 传递给 select 查询的参数列 -->
                  <!-- select: 指定用于查询关联集合的 select 语句 ID -->
                  <!-- ofType: 指定集合中元素的类型 -->
                  <!-- fetchType="lazy": 支持懒加载 -->
  </resultMap>
  
  <select id="findDeptByIdWithEmployeesSelect" resultMap="deptWithEmployeesSelectMap">...</select>
  

• 优点: 简单直观，SQL 分离，支持懒加载。
• 缺点: N+1 查询问题！性能问题严重 🐌，通常不推荐使用 ❌。

2. 嵌套结果映射 (Nested Result Map) ✅

• 思路: 使用 SQL 的 LEFT JOIN 一次性查询出部门及其所有员工的信息。MyBatis 的 resultMap 机制能智能地将重复的主对象信息合并，并将关联的从对象信息收集到集合中。
• Mapper XML:

  <resultMap id="employeeBaseMap" type="com.yourcompany.domain.Employee">...</resultMap>
  
  <resultMap id="deptWithEmployeesNestedMap" type="com.yourcompany.domain.Department">
      <id property="id" column="dept_id"/> <!-- 部门 ID 是主键 -->
      <result property="name" column="dept_name"/>
      <!-- collection: 映射 employees 集合属性 -->
      <collection property="employees" ofType="com.yourcompany.domain.Employee"
                  resultMap="employeeBaseMap" />
                  <!-- ofType: 指定集合元素类型 -->
                  <!-- resultMap: 引用 Employee resultMap 来映射集合中的每个对象 -->
                  <!-- 或者可以直接在 collection 内部定义映射规则 -->
  </resultMap>
  
  <select id="findDeptByIdWithEmployeesNested" resultMap="deptWithEmployeesNestedMap">
      SELECT
          d.id AS dept_id, d.dept_name,
          e.id AS emp_id, e.emp_name, e.emp_email
      FROM departments d
      LEFT JOIN employees e ON d.id = e.dept_id
      WHERE d.id = #{deptId}
  </select>
  

• 优点: 性能好 👍，只需一次 SQL 查询。MyBatis 自动处理结果聚合。映射逻辑集中。这是处理一对多关系推荐的方式 ✨。
• 缺点: SQL 语句可能较复杂；返回的数据量可能较大（主表信息会重复）。

五、 选择哪种映射方式？ 🤔

• 简单场景（列名与属性名一致或符合驼峰规则）：优先使用驼峰自动映射 👍。
• 列名与属性名不一致/不规则：少数几个字段用 SQL 别名 AS ✍️；较多或想保持 SQL 纯净，使用 resultMap 🛠️。
• 需要类型转换/自定义 TypeHandler：必须使用 resultMap 🔧。
• 处理一对一/多对一/一对多关联关系：必须使用 resultMap 的 <association> 或 <collection> 🔗。强烈推荐使用 嵌套结果映射 (Nested Result Map) 方式（基于 JOIN）✅，避免 N+1 问题。只有在明确需要懒加载且能接受其潜在性能影响时，才考虑嵌套 Select。

六、 总结 🎉

MyBatis 的结果映射机制是其强大功能的核心之一。从简单的别名、驼峰自动映射到强大的 resultMap（包括处理复杂关联的 <association> 和 <collection>），它提供了灵活多样的手段来连接数据库表结构和 Java 对象模型。理解并熟练运用这些映射方式，特别是掌握 resultMap 的高级用法并优先选择嵌套结果映射来处理关联，对于编写高效、可维护的 MyBatis 应用至关重要。

到此这篇关于MyBatis 结果映射的几种实现方式的文章就介绍到这了,更多相关MyBatis 结果映射内容请搜索脚本之家以前的文章或继续浏览下面的相关文章希望大家以后多多支持脚本之家！

最新评论