MyBatis总结六：resultMap详解(包含多表查询)

简介：　　

　　MyBatis的每一个查询映射的返回类型都是ResultMap，只是当我们提供的返回类型属性是resultType的时候，MyBatis对自动的给我们把对应的值赋给resultType所指定对象的属性，而当我们提供的返回类型是resultMap的时候，将数据库中列数据复制到对象的相应属性上，可以用于复制查询，两者不能同时用。

　　resultMap 元素是 MyBatis 中最重要最强大的元素。它就是让你远离 90%的需要从结果 集中取出数据的 JDBC 代码的那个东西, 而且在一些情形下允许你做一些 JDBC 不支持的事 情。 事实上, 编写相似于对复杂语句联合映射这些等同的代码, 也许可以跨过上千行的代码。 ResultMap 的设计就是简单语句不需要明确的结果映射,而很多复杂语句确实需要描述它们 的关系。

首先来说一下resultType

　　使用resultType进行输出映射，只有查询出来的列名和pojo（实体bean）中的属性名一致，该列才可以映射成功。

　　简单来说也就是你的数据库字段和JavaBean里的字段名称必须一致才能映射成功。

　　所以当我们JavaBean中的字段名和数据库字段名称有不同的时候，或者是多表查询的时候，一般会使用resultMap

resultMap

　　resultMap是Mybatis最强大的元素，它可以将查询到的复杂数据（比如查询到几个表中数据）映射到一个结果集当中。

属性	描述
property	需要映射到JavaBean 的属性名称。
column	数据表的列名或者标签别名。
javaType	一个完整的类名，或者是一个类型别名。如果你匹配的是一个JavaBean，那MyBatis 通常会自行检测到。然后，如果你是要映射到一个HashMap，那你需要指定javaType 要达到的目的。
jdbcType	数据表支持的类型列表。这个属性只在insert,update 或delete 的时候针对允许空的列有用。JDBC 需要这项，但MyBatis 不需要。如果你是直接针对JDBC 编码，且有允许空的列，而你要指定这项。
typeHandler	使用这个属性可以覆写类型处理器。这项值可以是一个完整的类名，也可以是一个类型别名。

元素简介：

<!--column不做限制，可以为任意表的字段，而property须为type 定义的pojo属性-->
<resultMap id="唯一的标识" type="映射的pojo对象">
  <id column="表的主键字段，或者可以为查询语句中的别名字段" jdbcType="字段类型" property="映射pojo对象的主键属性" />
  <result column="表的一个字段（可以为任意表的一个字段）" jdbcType="字段类型" property="映射到pojo对象的一个属性（须为type定义的pojo对象中的一个属性）"/>
  <association property="pojo的一个对象属性" javaType="pojo关联的pojo对象">
    <id column="关联pojo对象对应表的主键字段" jdbcType="字段类型" property="关联pojo对象的主席属性"/>
    <result  column="任意表的字段" jdbcType="字段类型" property="关联pojo对象的属性"/>
  </association>
  <!-- 集合中的property须为oftype定义的pojo对象的属性-->
  <collection property="pojo的集合属性" ofType="集合中的pojo对象">
    <id column="集合中pojo对象对应的表的主键字段" jdbcType="字段类型" property="集合中pojo对象的主键属性" />
    <result column="可以为任意表的字段" jdbcType="字段类型" property="集合中的pojo对象的属性" />
  </collection>
</resultMap>

使用具体案例来讲述：

首先我们数据库中的表结构如下：

可以看出我们表字段中有很多字段内有下划线，而我们的JavaBean里面的命名是按照驼峰规则命名的，下面我们贴上JavaBean：

package com.zy.domain;
 
import java.util.Date;
 
public class User {
 
    private Long id;
 
    // 用户名
    private String userName;
 
    // 密码
    private String password;
 
    // 姓名
    private String name;
 
    // 年龄
    private Integer age;
 
    // 性别，1男性，2女性
    private Integer sex;
 
    // 出生日期
    private Date birthday;
 
    // 创建时间
    private Date created;
 
    // 更新时间
    private Date updated;
 
    public Long getId() {
        return id;
    }
 
    public void setId(Long id) {
        this.id = id;
    }
 
    public String getuserName() {
        return userName;
    }
 
    public void setuserName(String userName) {
        this.userName = userName;
    }
 
    public String getPassword() {
        return password;
    }
 
    public void setPassword(String password) {
        this.password = password;
    }
 
    public String getName() {
        return name;
    }
 
    public void setName(String name) {
        this.name = name;
    }
 
    public Integer getAge() {
        return age;
    }
 
    public void setAge(Integer age) {
        this.age = age;
    }
 
    public Integer getSex() {
        return sex;
    }
 
    public void setSex(Integer sex) {
        this.sex = sex;
    }
 
    public Date getBirthday() {
        return birthday;
    }
 
    public void setBirthday(Date birthday) {
        this.birthday = birthday;
    }
 
    public Date getCreated() {
        return created;
    }
 
    public void setCreated(Date created) {
        this.created = created;
    }
 
    public Date getUpdated() {
        return updated;
    }
 
    public void setUpdated(Date updated) {
        this.updated = updated;
    }
 
    @Override
    public String toString() {
        return "User [id=" + id + ", userName=" + userName + ", password=" + password + ", name=" + name
                + ", age=" + age + ", sex=" + sex + ", birthday=" + birthday + ", created=" + created
                + ", updated=" + updated + "]";
    }
 
}

User JavaBean

package com.zy.domain;
 
import java.util.List;
 
/**
 * 订单表
 *
 */
public class Order {
 
    private Integer oid;
 
    private Long userId;
 
    private String orderNumber;
 
    private User user;
 
    private List<Orderitem> orderitemList;
 
    public List<Orderitem> getOrderitemList() {
        return orderitemList;
    }
 
    public void setOrderitemList(List<Orderitem> orderitemList) {
        this.orderitemList = orderitemList;
    }
 
    public User getUser() {
        return user;
    }
 
    public void setUser(User user) {
        this.user = user;
    }
 
    public Integer getOid() {
        return oid;
    }
 
    public void setOid(Integer oid) {
        this.oid = oid;
    }
 
    public Long getUserId() {
        return userId;
    }
 
    public void setUserId(Long userId) {
        this.userId = userId;
    }
 
    public String getOrderNumber() {
        return orderNumber;
    }
 
    public void setOrderNumber(String orderNumber) {
        this.orderNumber = orderNumber;
    }
 
    @Override
    public String toString() {
        return "Order [oid=" + oid + ", userId=" + userId + ", orderNumber=" + orderNumber + ", user=" + user
                + ", orderitemList=" + orderitemList + "]";
    }
 
}

Order JavaBean

package com.zy.domain;
 
/**
 * 商品表
 */
public class Product {
 
    private Integer pid;
 
    private String pname;
 
    private Float price;
 
    private String description;
 
    public Integer getPid() {
        return pid;
    }
 
    public void setPid(Integer pid) {
        this.pid = pid;
    }
 
    public String getPname() {
        return pname;
    }
 
    public void setPname(String pname) {
        this.pname = pname;
    }
 
    public Float getPrice() {
        return price;
    }
 
    public void setPrice(Float price) {
        this.price = price;
    }
 
    public String getDescription() {
        return description;
    }
 
    public void setDescription(String description) {
        this.description = description;
    }
 
    @Override
    public String toString() {
        return "Product [pid=" + pid + ", pname=" + pname + ", price=" + price + ", description=" + description + "]";
    }
 
}

Product JavaBean

package com.zy.domain;
 
public class Orderitem {
 
    private Integer itemId;
    private int orderId;
    private int productId;
 
    private Double totalPrice;
 
    private Integer status;
 
    private Product product;
 
    public Double getTotalPrice() {
        return totalPrice;
    }
 
    public void setTotalPrice(Double totalPrice) {
        this.totalPrice = totalPrice;
    }
 
    public Integer getStatus() {
        return status;
    }
 
    public void setStatus(Integer status) {
        this.status = status;
    }
 
    public Product getProduct() {
        return product;
    }
 
    public void setProduct(Product product) {
        this.product = product;
    }
 
    public Integer getItemId() {
        return itemId;
    }
 
    public void setItemId(Integer itemId) {
        this.itemId = itemId;
    }
 
    public int getOrderId() {
        return orderId;
    }
 
    public void setOrderId(int orderId) {
        this.orderId = orderId;
    }
 
    public int getProductId() {
        return productId;
    }
 
    public void setProductId(int productId) {
        this.productId = productId;
    }
 
    @Override
    public String toString() {
        return "Orderitem{" +
                "itemId=" + itemId +
                ", orderId=" + orderId +
                ", productId=" + productId +
                ", totalPrice=" + totalPrice +
                ", status=" + status +
                ", product=" + product +
                '}';
    }
}

Orderitem JavaBean

首先我们把配置文件中的驼峰规则关闭

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

单表查询（查询所有订单信息）：

OrderMapper.xml

<mapper namespace="com.zy.mapper.OrderMapper">
    <resultMap id="OrderResultMap" type="com.zy.domain.Order">
        <id column="oid" property="oid"></id>
        <result column="user_id" property="userId"></result>
        <result column="order_number" property="orderNumber"></result>
    </resultMap>
    <!--查询订单表信息-->
    <select id="getOrderList" resultMap="OrderResultMap">
        select * from tb_order
    </select>
</mapper>

OrderMapper接口

public interface OrderMapper {
    public List<Order> getOrderList();
}

测试：

public class OrderMapperTest {
    OrderMapper mapper;
 
    @org.junit.Before
    public void setUp() throws Exception {
        InputStream inputStream = Resources.getResourceAsStream("mybatis-config.xml");
        SqlSessionFactory sqlSessionFactory = new SqlSessionFactoryBuilder().build(inputStream);
        SqlSession sqlSession = sqlSessionFactory.openSession(true);
        mapper = sqlSession.getMapper(OrderMapper.class);
    }
 
    @org.junit.Test
    public void getOrderList() throws Exception {
        List<Order> list = mapper.getOrderList();
        for (Order order : list) {
            System.out.println(order);
        }
    }
 
}

运行结果：

一对一多表查询（根据订单编号查询订单信息并带出订单所属用户信息）：

这里引出了association联合：

　　联合元素用来处理“一对一”的关系。需要指定映射的Java实体类的属性，属性的javaType（通常MyBatis 自己会识别）。

OrderMapper.xml

<mapper namespace="com.zy.mapper.OrderMapper">
    <resultMap id="OrderResultMap" type="com.zy.domain.Order">
        <id column="oid" property="oid"></id>
        <result column="user_id" property="userId"></result>
        <result column="order_number" property="orderNumber"></result>
    </resultMap>
    <!--查询订单表信息-->
    <select id="getOrderList" resultMap="OrderResultMap">
        select * from tb_order
    </select>
 
    <!--extends 表示继承 autoMapping表示自动映射JavaBean中字段和数据表字段一致的字段信息-->
    <resultMap id="OrderWithUserResultMap" type="com.zy.domain.Order" extends="OrderResultMap">
        <!--由于继承了OrderResultMap 所以这里就不用再写order表的信息了-->
        <!--用户表信息-->
        <association property="user" javaType="com.zy.domain.User" autoMapping="true">
            <id column="user_id" property="id"></id>
            <result column="user_name" property="userName"></result>
        </association>
    </resultMap>
    <!--根据订单编号查询订单信息并带出订单所属用户信息-->
    <select id="getOrderWithUser" resultMap="OrderWithUserResultMap">
        select * from tb_order as o left join tb_user as u on o.user_id=u.id
        where o.order_number=#{ordernumber}
    </select>
</mapper>

OrderMapper接口：

public interface OrderMapper {
    /**
     * 获取所有订单列表
     */
    public List<Order> getOrderList();
 
    /**
     * 根据订单编号 获取单个订单及所属用户信息
     */
    public Order getOrderWithUser(@Param("ordernumber") String orderNumber);
}

测试：

public class OrderMapperTest {
    OrderMapper mapper;
 
    @Before
    public void setUp() throws Exception {
        InputStream inputStream = Resources.getResourceAsStream("mybatis-config.xml");
        SqlSessionFactory sqlSessionFactory = new SqlSessionFactoryBuilder().build(inputStream);
        SqlSession sqlSession = sqlSessionFactory.openSession(true);
        mapper = sqlSession.getMapper(OrderMapper.class);
    }
 
    @Test
    public void getOrderList() throws Exception {
        List<Order> list = mapper.getOrderList();
        for (Order order : list) {
            System.out.println(order);
        }
    }
 
    @Test
    public void getOrderWithUser() throws Exception {
        Order order = mapper.getOrderWithUser("20140921002");
        System.out.println(order);
    }
 
}

一对多多表查询（根据订单号 查询订单，并且查询出所有订单详情（子订单）及所属用户）：

由于是一对多，所以这里就引出了collection聚集：

　　聚集元素用来处理“一对多”的关系。需要指定映射的Java实体类的属性，属性的javaType（一般为ArrayList）；列表中对象的类型ofType（Java实体类）。

OrderMapper.xml

<mapper namespace="com.zy.mapper.OrderMapper">
    <resultMap id="OrderResultMap" type="com.zy.domain.Order">
        <id column="oid" property="oid"></id>
        <result column="user_id" property="userId"></result>
        <result column="order_number" property="orderNumber"></result>
    </resultMap>
    <!--查询订单表信息-->
    <select id="getOrderList" resultMap="OrderResultMap">
        select * from tb_order
    </select>
 
    <!--extends 表示继承-->
    <resultMap id="OrderWithUserResultMap" type="com.zy.domain.Order" extends="OrderResultMap">
        <!--由于继承了OrderResultMap 所以这里就不用再写order表的信息了-->
        <!--用户表信息-->
        <association property="user" javaType="com.zy.domain.User" autoMapping="true">
            <id column="user_id" property="id"></id>
            <result column="user_name" property="userName"></result>
        </association>
    </resultMap>
    <!--根据订单编号查询订单信息并带出订单所属用户信息-->
    <select id="getOrderWithUser" resultMap="OrderWithUserResultMap">
        select * from tb_order as o left join tb_user as u on o.user_id=u.id
        where o.order_number=#{ordernumber}
    </select>
 
    <resultMap id="OrderWithItemAndUserResultMap" type="com.zy.domain.Order"
               extends="OrderWithUserResultMap">
        <!--javaType为list list代表List类型  ofType为Orderitem-->
        <collection property="orderitemList" javaType="list" ofType="com.zy.domain.Orderitem"
                    autoMapping="true">
            <id column="item_id" property="itemId"></id>
            <result column="order_id" property="orderId"></result>
            <result column="product_id" property="productId"></result>
            <result column="total_price" property="totalPrice"></result>
        </collection>
    </resultMap>
    <!--根据订单号 查询订单，并且查询出所有订单详情（子订单）及所属用户-->
    <select id="getOrderWithItenAndUser" resultMap="OrderWithItemAndUserResultMap">
        select * from tb_order o
        left join tb_user u on o.user_id=u.id
        left join tb_orderitem oi on o.oid=oi.order_id
        where o.order_number=#{ordernumber}
    </select>
</mapper>

OrderMapper接口：

public interface OrderMapper {
    /**
     * 获取所有订单列表
     */
    public List<Order> getOrderList();
 
    /**
     * 根据订单编号 获取单个订单及所属用户信息
     */
    public Order getOrderWithUser(@Param("ordernumber") String orderNumber);
 
    /**
     * 根据订单号 查询订单，并且查询出所有订单详情（子订单）及所属用户
     */
    public Order getOrderWithItenAndUser(@Param("ordernumber") String orderNumber);
}

测试：

public class OrderMapperTest {
    OrderMapper mapper;
 
    @Before
    public void setUp() throws Exception {
        InputStream inputStream = Resources.getResourceAsStream("mybatis-config.xml");
        SqlSessionFactory sqlSessionFactory = new SqlSessionFactoryBuilder().build(inputStream);
        SqlSession sqlSession = sqlSessionFactory.openSession(true);
        mapper = sqlSession.getMapper(OrderMapper.class);
    }
 
    @Test
    public void getOrderList() throws Exception {
        List<Order> list = mapper.getOrderList();
        for (Order order : list) {
            System.out.println(order);
        }
    }
 
    @Test
    public void getOrderWithUser() throws Exception {
        Order order = mapper.getOrderWithUser("20140921002");
        System.out.println(order);
    }
 
    @Test
    public void getOrderWithItenAndUser() throws Exception {
        Order order = mapper.getOrderWithItenAndUser("20140921001");
        System.out.println(order);
    }
 
}

多对多 多表查询（根据订单号 查询订单，查询出所属用户，并且查询出订单的详情，及订单详情中的对应的商品信息   订单详情和商品为多对多关系）：

这一次我们开启驼峰规则，可以少写一些符合规则的字段：

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

OrderMapper.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.zy.mapper.OrderMapper">
    <resultMap id="OrderFullInfoResultMap" type="com.zy.domain.Order" autoMapping="true">
        <!--order表主键-->
        <id column="oid" property="oid"></id>
        <!--关联用户表-->
        <association property="user" javaType="com.zy.domain.User" autoMapping="true">
            <!--用户表主键-->
            <id column="user_id" property="id"></id>
        </association>
        <!--关联订单详情表-->
        <collection property="orderitemList" javaType="list" ofType="com.zy.domain.Orderitem"
                    autoMapping="true">
            <!--订单详情表主键-->
            <id column="item_id" property="itemId"></id>
            <!--关联商品-->
            <association property="product" javaType="com.zy.domain.Product" autoMapping="true">
                <!--商品表主键-->
                <id column="product_id" property="pid"></id>
            </association>
        </collection>
    </resultMap>
 
    <!--根据订单号 查询订单，查询出所属用户，并且查询出订单的详情，及订单详情中的对应的商品信息-->
    <select id="getOrderFullInfo" resultMap="OrderFullInfoResultMap">
        select * from tb_order o
        left join tb_user u on o.user_id=u.id
        left join tb_orderitem oi on o.oid=oi.order_id
        left join tb_product p on oi.product_id=p.pid
        where o.order_number=#{ordernumber}
    </select>
</mapper>

OrderMapper接口：

public interface OrderMapper {
 
    /**
     * 根据订单号 查询订单，查询出所属用户，并且查询出订单的详情，及订单详情中的对应的商品信息
     */
    public Order getOrderFullInfo(@Param("ordernumber") String orderNumber);
}

测试：

public class OrderMapperTest {
    OrderMapper mapper;
 
    @Before
    public void setUp() throws Exception {
        InputStream inputStream = Resources.getResourceAsStream("mybatis-config.xml");
        SqlSessionFactory sqlSessionFactory = new SqlSessionFactoryBuilder().build(inputStream);
        SqlSession sqlSession = sqlSessionFactory.openSession(true);
        mapper = sqlSession.getMapper(OrderMapper.class);
    }
 
    @Test
    public void getOrderFullInfo() throws Exception{
        Order order = mapper.getOrderFullInfo("20140921001");
        System.out.println(order);
    }
 
}

最终测试结果：