Mybatis关联查询

雪球不会消失了

已于 2024-08-21 22:28:26 修改

阅读量1k

点赞数 23

文章标签： mybatis oracle 数据库

于 2024-04-18 14:27:30 首次发布

本文链接：https://blog.csdn.net/m0_61925586/article/details/137886409

版权

以前都是查询一张表、做一张表的映射：即将Java对象 映射成(转换成) 数据库表中的一行记录，或是将数据库表中一行记录 映射成 一个Java对象。

现在是关联查询、做多张表的映射：将关联查询多张表的查询结果集 映射到 实体类对象中。

使用association、collection标签可以将关联查询多张表的结果集映射成实体类对象。

注意：

如果两张表有主外键关联关系，那么他们的业务关系是一对一/一对多，或者是双向一对一（比如用户表和用户详情表）。
如果两张表是双向一对多关系，那么他们是多对多关系，并且多对多关系一定有一张中间表来联系它们。
关联查询就是同时查询两张以上的表，那么表和表之间一定存在关联关系，关联关系是双向的。

1. 数据模型分析

1.1 表功能介绍

用户表: 记录用户的基本信息。
订单表: 记录用户所创建的订单（购买商品的订单）。
订单详情表: 记录订单的详细信息，即购买商品的信息。
商品表: 记录商品的基本信息。

1.2 表之间的业务关系

用户表和订单表：

用户表 ---> 订单表: 一个用户可以创建多个订单，一对多关系；
订单表 ---> 用户表: 一个订单只由一个用户创建，一对一关系；

订单表和订单详情表：

订单表 ---> 订单详情表: 一个订单可以包含多个订单详情，因为一个订单可以购买多个商品，每个商品的购买信息在订单详情表中记录，一对多关系；
订单详情表 ---> 订单表: 一个订单详情只能包括在一个订单中，一对一关系；

订单详情表和商品表：

订单详情表 ---> 商品表: 一个订单详情只对应一个商品信息，一对一关系；
商品表 ---> 订单详情表: 一个商品可以包括在多个订单详情，一对多关系；

订单表和商品表：

订单表 <---> 商品表: 一个订单中包含多个商品，一个商品可以添加在多个订单中，两者是通过订
单详情表建立关系，多对多关系；

1.3 数据表

users表：

orders表：

order_detail表：

goods表：

2. 一对一查询

2.1 需求

查询订单信息，并关联查询其相关的用户信息。

2.1.1 通过resultType方式实现

不建议使用这种方式，因为这种方式需要创建一个新的vo类。

实体类：

实体类Orders类不能映射全部字段，需要新创建的实体类，创建一个包括查询字段较多的实体类。
OrdersQuery中包含了Orders以及Users需要查询的属性。

package com.gs.vo;
/**
* OrdersQuery值对象,不是entity/po,因为它和数据库中表的字段不是对应关系
*/
public class OrdersQuery {
    //订单属性
    private Integer id;
    private String orderNumber;
    private Double totalPrice;
    private String status;
    private Integer userId;
    //用户属性
    private String username;
    private String password;
    private String realname;
    public Integer getId() {
        return id;
    }
    public void setId(Integer id) {
        this.id = id;
    }
    public String getOrderNumber() {
        return orderNumber;
    }
    public void setOrderNumber(String orderNumber) {
        this.orderNumber = orderNumber;
    }
    public Double getTotalPrice() {
        return totalPrice;
    }
    public void setTotalPrice(Double totalPrice) {
        this.totalPrice = totalPrice;
    }
    public String getStatus() {
        return status;
    }
    public void setStatus(String status) {
        this.status = status;
    }
    public Integer getUserId() {
        return userId;
    }
    public void setUserId(Integer userId) {
        this.userId = userId;
    }
    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 getRealname() {
        return realname;
    }
    public void setRealname(String realname) {
        this.realname = realname;
    }
    @Override
    public String toString() {
        return "OrdersQuery{" +
        "id=" + id +
        ", orderNumber='" + orderNumber + '\'' +
        ", totalPrice=" + totalPrice +
        ", status='" + status + '\'' +
        ", userId=" + userId +
        ", username='" + username + '\'' +
        ", password='" + password + '\'' +
        ", realname='" + realname + '\'' +
    '}';
    }
}

mapper接口：

import com.gs.vo.OrdersQuery;

import java.util.List;

public interface OrdersMapper {
    List<OrdersQuery> selectUseResultType();
}

mapper文件：

<?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.gs.mapper.OrdersMapper">
    <select id="selectUseResultType" resultType="com.gs.vo.OrdersQuery">
        select a.id,
               a.order_number,
               a.total_price,
               a.status,
               a.user_id,
               b.username,
               b.password,
               b.realname
        from orders a,users b
        where a.user_id = b.id
    </select>
</mapper>

测试：

public class QueryTest {
    @Test
    public void testOneToOneResultType() {
        SqlSession sqlSession = MybatisUtil.getSession();
        OrdersMapper ordersMapper = sqlSession.getMapper(OrdersMapper.class);
        List<OrdersQuery> list = ordersMapper.selectUseResultType();
        for (OrdersQuery ordersQuery : list) {
            System.out.println(ordersQuery);
        }
        sqlSession.close();
    }
}

2.1.2 通过resultMap方式实现

先看实体类：

用户类：

public class Users {
    private Integer id;
    private String username;
    private String password;
    private String realname;

    public Integer getId() {
        return id;
    }

    public void setId(Integer 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 getRealname() {
        return realname;
    }

    public void setRealname(String realname) {
        this.realname = realname;
    }

    @Override
    public String toString() {
        return "Users{" +
                "id=" + id +
                ", username='" + username + '\'' +
                ", password='" + password + '\'' +
                ", realname='" + realname + '\'' +
                '}';
    }
}

订单类：

要实现一对一查询，需要在(主查询的实体类)Orders类中定义一个(关联查询的实体类对象)Users类型的成员变量，Users属性用于存储关联查询的用户信息。

public class Orders {
    private Integer id;
    private String orderNumber;
    private Double totalPrice;
    private String status;
    private Integer userId;
    /**
     * 一对一关系属性
     */
    private Users users;

    public Integer getId() {
        return id;
    }

    public void setId(Integer id) {
        this.id = id;
    }

    public String getOrderNumber() {
        return orderNumber;
    }

    public void setOrderNumber(String orderNumber) {
        this.orderNumber = orderNumber;
    }

    public Double getTotalPrice() {
        return totalPrice;
    }

    public void setTotalPrice(Double totalPrice) {
        this.totalPrice = totalPrice;
    }

    public String getStatus() {
        return status;
    }

    public void setStatus(String status) {
        this.status = status;
    }

    public Integer getUserId() {
        return userId;
    }

    public void setUserId(Integer userId) {
        this.userId = userId;
    }

    public Users getUsers() {
        return users;
    }

    public void setUsers(Users users) {
        this.users = users;
    }

    @Override
    public String toString() {
        return "Orders{" +
                "id=" + id +
                ", orderNumber='" + orderNumber + '\'' +
                ", totalPrice=" + totalPrice +
                ", status='" + status + '\'' +
                ", userId=" + userId +
                ", users=" + users +
                '}';
    }
}

mapper接口：

    /*
    一对一：查询订单信息，并关联查询其相关用户信息
    通过resultMap实现，orders实现类添加一对一关联属性Users
    怎么把结果集里面的数据映射到关联属性Users中
     */
    List<Orders> selectUseResultMap();

mapper文件：

在resultMap标签里面使用association标签：实现一对一映射，指定一个类里面关联的另一个类的对象，如：一个Orders对象关联一个Users对象

property属性:关联的pojo类的属性。
javaType属性:关联的属性的类型。

然后在association标签中嵌套id和result标签告诉mybatis将查询结果集中的哪些列映射到实体类的哪些属性上。

column：查询结果集中的列名
property：实体类的属性名

<?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="org.example.mapper.OrdersMapper">
    <resultMap id="selectResultMap" type="com.gs.entity.Orders">
        <id column="id" property="id"/>
        <result column="order_number" property="orderNumber"/>
        <result column="total_price" property="totalPrice"/>
        <result column="status" property="status"/>
        <result column="user_id" property="userId"/>
        <association property="users" javaType="com.gs.entity.Users">
            <id column="user_id" property="id"/>
            <result column="username" property="username"/>
            <result column="password" property="password"/>
            <result column="realname" property="realname"/>
        </association>
    </resultMap>
    <select id="selectUseResultMap" resultMap="selectResultMap">
        select a.id,
               a.order_number,
               a.total_price,
               a.status,
               a.user_id,
               b.username,
               b.password,
               b.realname
        from orders a,users b
        where a.user_id = b.id
    </select>
</mapper>

测试：

@Test
public void testOneToOneResultMap() {
        SqlSession sqlSession = MybatisUtil.getSession();
        OrdersMapper ordersMapper = sqlSession.getMapper(OrdersMapper.class);
        List<Orders> list = ordersMapper.selectUseResultMap();
        for (Orders orders : list) {
        System.out.println(orders);
        }
        sqlSession.close();
}

3. 一对多查询

3.1 需求

查询订单信息。关联如下：

关联查询其相关用户信息。
关联查询其相关订单详情信息。

下面先来看实体类：

订单详情类：

public class OrdersDetail {
    private Integer id;
    private Integer amount;
    private Integer ordersId;
    private Integer goodsId;

    public Integer getId() {
        return id;
    }

    public void setId(Integer id) {
        this.id = id;
    }

    public Integer getAmount() {
        return amount;
    }

    public void setAmount(Integer amount) {
        this.amount = amount;
    }

    public Integer getOrdersId() {
        return ordersId;
    }

    public void setOrdersId(Integer ordersId) {
        this.ordersId = ordersId;
    }

    public Integer getGoodsId() {
        return goodsId;
    }

    public void setGoodsId(Integer goodsId) {
        this.goodsId = goodsId;
    }

    @Override
    public String toString() {
        return "OrdersDetail{" +
                "id=" + id +
                ", amount=" + amount +
                ", ordersId=" + ordersId +
                ", goodsId=" + goodsId +
                '}';
    }
}

订单类：

一对多映射，通常需要在(主查询的实体类)Orders类中定义(要关联查询实体类的List集合)List<OrdersDetail>类型的成员变量，details属性用于存储关联查询的订单详情。

因为订单关联查询订单详情是一对多关系，所以这里使用集合对象存储关联查询的订单详情信息。

public class Orders {
    private Integer id;
    private String orderNumber;
    private Double totalPrice;
    private String status;
    private Integer userId;
    /**
     * 一对一关系属性
     */
    private Users users;
    /**
     * 一对多关系属性
     */
    private List<OrdersDetail> detailList;

    public Integer getId() {
        return id;
    }

    public void setId(Integer id) {
        this.id = id;
    }

    public String getOrderNumber() {
        return orderNumber;
    }

    public void setOrderNumber(String orderNumber) {
        this.orderNumber = orderNumber;
    }

    public Double getTotalPrice() {
        return totalPrice;
    }

    public void setTotalPrice(Double totalPrice) {
        this.totalPrice = totalPrice;
    }

    public String getStatus() {
        return status;
    }

    public void setStatus(String status) {
        this.status = status;
    }

    public Integer getUserId() {
        return userId;
    }

    public void setUserId(Integer userId) {
        this.userId = userId;
    }

    public Users getUsers() {
        return users;
    }

    public void setUsers(Users users) {
        this.users = users;
    }

    public List<OrdersDetail> getDetailList() {
        return detailList;
    }

    public void setDetailList(List<OrdersDetail> detailList) {
        this.detailList = detailList;
    }

    @Override
    public String toString() {
        return "Orders{" +
                "id=" + id +
                ", orderNumber='" + orderNumber + '\'' +
                ", totalPrice=" + totalPrice +
                ", status='" + status + '\'' +
                ", userId=" + userId +
                ", users=" + users +
                ", detailList=" + detailList +
                '}';
    }
}

mapper接口：

    /**
     * 一对多：查询订单信息，关联查询订单详情信息
     * 一个订单对应多个订单详情
     */
List<Orders> selectOrdersAndDetail();

mapper文件：

在resultMap标签里面使用collection标签: 实现一对多映射。

property属性：关联的属性名。
ofType：集合中元素的类型。

<?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="org.example.mapper.OrdersMapper">
    <resultMap id="detailResultMap" type="com.gs.entity.Orders">
        <id column="id" property="id"/>
        <result column="order_number" property="orderNumber"/>
        <result column="total_price" property="totalPrice"/>
        <result column="status" property="status"/>
        <result column="user_id" property="userId"/>
        <association property="users" javaType="com.gs.entity.Users">
            <id column="user_id" property="id"/>
            <result column="username" property="username"/>
            <result column="password" property="password"/>
            <result column="realname" property="realname"/>
        </association>
        <!--
            collection标签：实现一对多映射
                property属性：要映射的实体类属性名
                ofType：集合里面存储的类型
        -->
        <collection property="detailList" ofType="com.gs.entity.OrdersDetail">
        <!--
            在collection标签中继续把数据库表的字段名映射成java类的属性名
        -->
            <id column="detail_id" property="id"/>
            <result column="amount" property="amount"/>
            <result column="goods_id" property="goodsId"/>
            <result column="id" property="ordersId"/>
        </collection>
    </resultMap>
    <select id="selectOrdersAndDetail" resultMap="detailResultMap">
        select a.id,
               a.order_number,
               a.total_price,
               a.status,
               a.user_id,
               b.username,
               b.password,
               b.realname,
               c.id detail_id,
               c.amount,
               c.goods_id
        from orders a
                 join users b on a.user_id = b.id
                 join orders_detail c on a.id = c.orders_id
    </select>
</mapper>

测试：

@Test
public void testOneToMany(){
        SqlSession sqlSession=MybatisUtil.getSession();
        OrdersMapper ordersMapper=sqlSession.getMapper(OrdersMapper.class);
        List<Orders> list=ordersMapper.selectOrdersAndDetail();
        for(Orders orders:list){
        System.out.println(orders);
        }
        sqlSession.close();
}

4. 多对多查询

订单与商品

需求

查询订单信息。关联如下：

关联查询其相关用户信息。
关联查询其相关订单详情信息。
关联查询订单详情中的商品信息。

实体类：

在OrderDetail类中，定义Goods类型的属性，goods属性用于存储关联查询的商品信息。

订单与订单详情是一对多关系，订单详情与商品是一对一关系，反之商品与订单详情是一对多关系，订单详情与订单是一对一关系，所以订单与商品为多对多关系。

商品类：

public class Goods {
    private Integer id;
    private String goodsName;
    private String description;
    private Double price;

    public Integer getId() {
        return id;
    }

    public void setId(Integer id) {
        this.id = id;
    }

    public String getGoodsName() {
        return goodsName;
    }

    public void setGoodsName(String goodsName) {
        this.goodsName = goodsName;
    }

    public String getDescription() {
        return description;
    }

    public void setDescription(String description) {
        this.description = description;
    }

    public Double getPrice() {
        return price;
    }

    public void setPrice(Double price) {
        this.price = price;
    }

    @Override
    public String toString() {
        return "Goods{" +
                "id=" + id +
                ", goodsName='" + goodsName + '\'' +
                ", description='" + description + '\'' +
                ", price=" + price +
                '}';
    }
}

订单详情类：

public class OrdersDetail {
    private Integer id;
    private Integer amount;
    private Integer ordersId;
    private Integer goodsId;
    /**
     * 一对一关系
     */
    private Goods goods;

    public Integer getId() {
        return id;
    }

    public void setId(Integer id) {
        this.id = id;
    }

    public Integer getAmount() {
        return amount;
    }

    public void setAmount(Integer amount) {
        this.amount = amount;
    }

    public Integer getOrdersId() {
        return ordersId;
    }

    public void setOrdersId(Integer ordersId) {
        this.ordersId = ordersId;
    }

    public Integer getGoodsId() {
        return goodsId;
    }

    public void setGoodsId(Integer goodsId) {
        this.goodsId = goodsId;
    }

    public Goods getGoods() {
        return goods;
    }

    public void setGoods(Goods goods) {
        this.goods = goods;
    }

    @Override
    public String toString() {
        return "OrdersDetail{" +
                "id=" + id +
                ", amount=" + amount +
                ", ordersId=" + ordersId +
                ", goodsId=" + goodsId +
                ", goods=" + goods +
                '}';
    }
}

mapper接口：

    /**
     * 多对多：查询订单，关联查询商品信息
     *  订单和商品没有直接联系，但是和订单详情中有直接联系，所以在订单详情类中定义一对一关系属性
     */
List<Orders> selectOrdersAndGoods();

mapper文件：

多对多查询，它的本质就是两个一对多的组合，同样它所使用的标签元素也是 collection

<?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="org.example.mapper.OrdersMapper">
    <!--
        多对多，一个订单包含多个商品，一个商品可以存在多个订单
    -->
    <resultMap id="goodsResultMap" type="com.gs.entity.Orders">
        <id column="id" property="id"/>
        <result column="order_number" property="orderNumber"/>
        <result column="total_price" property="totalPrice"/>
        <result column="status" property="status"/>
        <result column="user_id" property="userId"/>
        <association property="users" javaType="com.gs.entity.Users">
            <id column="user_id" property="id"/>
            <result column="username" property="username"/>
            <result column="password" property="password"/>
            <result column="realname" property="realname"/>
        </association>
        <collection property="detailList" ofType="com.gs.entity.OrdersDetail">
            <id column="detail_id" property="id"/>
            <result column="amount" property="amount"/>
            <result column="goods_id" property="goodsId"/>
            <result column="id" property="ordersId"/>
            <association property="goods" javaType="com.gs.entity.Goods">
                <id column="goods_id" property="id"/>
                <result column="goods_name" property="goodsName"/>
                <result column="description" property="description"/>
                <result column="price" property="price"/>
            </association>
        </collection>
    </resultMap>
    <select id="selectOrdersAndGoods" resultMap="goodsResultMap">
        select a.id,
               a.order_number,
               a.total_price,
               a.status,
               a.user_id,
               b.username,
               b.password,
               b.realname,
               c.id detail_id,
               c.amount,
               c.goods_id,
               d.goods_name,
               d.description,
               d.price
        from orders a
                 join users b on a.user_id = b.id
                 join orders_detail c on a.id = c.orders_id
                 join goods d on c.goods_id = d.id
    </select>
</mapper>

测试：

@Test
public void testManyToMany1() {
        SqlSession sqlSession = MybatisUtil.getSession();
        OrdersMapper ordersMapper = sqlSession.getMapper(OrdersMapper.class);
        List<Orders> list = ordersMapper.selectOrdersAndGoods();
        for (Orders orders : list) {
        System.out.println(orders);
        }
        sqlSession.close();
}

学生与课程之间的多对多关系

需求

查询学生信息，并关联查询学生相应的课程信息。

表结构

-- 课程表
CREATE TABLE `course` (
`id` int(11) PRIMARY KEY AUTO_INCREMENT,
`cname` varchar(20)
);
INSERT INTO `course` VALUES (1, '大学语文');
INSERT INTO `course` VALUES (2, '大学英语');
INSERT INTO `course` VALUES (3, '高等数学');
INSERT INTO `course` VALUES (4, 'JAVA语言');
INSERT INTO `course` VALUES (5, '网络维护');
INSERT INTO `course` VALUES (6, '通信原理');

-- 学生表
CREATE TABLE `student` (
`id` int(11) PRIMARY KEY AUTO_INCREMENT,
`name` varchar(20),
`gender` varchar(20),
`major` varchar(20)
);
INSERT INTO `student` VALUES (1, '小明', '男', '软件工程');
INSERT INTO `student` VALUES (2, '小红', '女', '网络工程');
INSERT INTO `student` VALUES (3, '小丽', '女', '物联网');

-- 学生选课表：一个学生可以选修多门课程，一门课程可以被多个学生选修，所以它们之间是多对多关系
CREATE TABLE `student_course` (
`id` int(11) PRIMARY KEY AUTO_INCREMENT,
`student_id` int(11),
`course_id` int(11)
);
INSERT INTO `student_course` VALUES (1, 1, 1);
INSERT INTO `student_course` VALUES (2, 1, 3);
INSERT INTO `student_course` VALUES (3, 1, 4);
INSERT INTO `student_course` VALUES (4, 2, 1);
INSERT INTO `student_course` VALUES (5, 2, 2);
INSERT INTO `student_course` VALUES (6, 2, 5);
INSERT INTO `student_course` VALUES (7, 3, 2);
INSERT INTO `student_course` VALUES (8, 3, 3);
INSERT INTO `student_course` VALUES (9, 3, 6);

实体类：

课程类：

public class Course {
    private Integer id;
    private String cname;

    public Integer getId() {
        return id;
    }

    public void setId(Integer id) {
        this.id = id;
    }

    public String getCname() {
        return cname;
    }

    public void setCname(String cname) {
        this.cname = cname;
    }

    @Override
    public String toString() {
        return "Course{" +
                "id=" + id +
                ", cname='" + cname + '\'' +
                '}';
    }
}

学生类：

public class Student {
    private Integer id;
    private String name;
    private String gender;
    private String major;
    /**
     * 一对多
     */
    private List<Course> courseList;

    public Integer getId() {
        return id;
    }

    public void setId(Integer id) {
        this.id = id;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public String getGender() {
        return gender;
    }

    public void setGender(String gender) {
        this.gender = gender;
    }

    public String getMajor() {
        return major;
    }

    public void setMajor(String major) {
        this.major = major;
    }

    public List<Course> getCourseList() {
        return courseList;
    }

    public void setCourseList(List<Course> courseList) {
        this.courseList = courseList;
    }

    @Override
    public String toString() {
        return "Student{" +
                "id=" + id +
                ", name='" + name + '\'' +
                ", gender='" + gender + '\'' +
                ", major='" + major + '\'' +
                ", courseList=" + courseList +
                '}';
    }
}

mapper接口

public interface StudentMapper {
    List<Student> select();
}

mapper文件

<?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.gs.mapper.StudentMapper">
    <resultMap id="selectResultMap" type="com.gs.entity.Student">
        <id column="id" property="id"/>
        <result column="name" property="name"/>
        <result column="gender" property="gender"/>
        <result column="major" property="major"/>
        <collection property="courseList" ofType="com.gs.entity.Course">
            <id column="course_id" property="id"/>
            <result column="cname" property="cname"/>
        </collection>
    </resultMap>
    <select id="select" resultMap="selectResultMap">
        select a.id, a.name, a.gender, a.major, b.course_id, c.cname
        from student a
        left join student_course b on a.id = b.student_id
        left join course c ON b.course_id = c.id
    </select>
</mapper>

测试

@Test
public void testManyToMany2() {
        SqlSession sqlSession = MybatisUtil.getSession();
        StudentMapper studentMapper = sqlSession.getMapper(StudentMapper.class);
        List<Student> list = studentMapper.select();
        for (Student student : list) {
        System.out.println(student);
        }
        sqlSession.close();
}

5. 关联查询总结

5.1 resultType

作用：将查询结果按照SQL列名与实体类属性名一致性映射到实体类对象中。
场合：常见一些明细记录的展示，比如用户购买商品明细，将关联查询信息全部展示在页面时，此时可直接使用resultType将每一条记录映射到实体类中，在前端页面遍历list（list中是实体类）即可。

通常查询单表的时候使用。

5.2 resultMap

在resultMap标签中，使用association和collection完成一对一和一对多高级映射（对结果有特殊的映射要求）。

通常要查询多个表的时候使用。

5.2.1 association

作用：将关联查询信息映射到一个实体类对象中。
场合：为了方便查询关联信息可以使用association将关联信息映射为当前对象的一个属性，比如：查询订单以及关联用户信息。

5.2.2 collection

作用：将关联查询信息映射到一个list集合中。

场合：为了方便查询遍历关联信息可以使用collection将关联信息映射到list集合中，比如：查询用户权限范围模块及模块下的菜单，可使用collection将模块映射到模块list中，将菜单列表映射到模块对象的菜单list属性中，这样的作的目的也是方便对查询结果集进行遍历查询。如果使用resultType无法将查询结果映射到list集合中。

5.2.3 resultMap的继承

resultMap标签可以通过extends属性来继承一个已有的或公共的resultMap，避免重复配置的出现，减少配置量。

例子如下：

<?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="某个Mapper接口的全限定类名">
    <!-- 父resultMap标签-->
    <resultMap id="baseResultMap" type="com.gs.entity.Orders">
        <id column="id" property="id"/>
        <result column="order_number" property="orderNumber"/>
        <result column="total_price" property="totalPrice"/>
        <result column="status" property="status"/>
        <result column="user_id" property="userId"/>
    </resultMap>
    <!-- 继承父resultMap标签中的配置，避免重复配置 -->
    <resultMap id="subResultMap" type="com.gs.entity.Orders" extends="baseResultMap">
        <association property="users" javaType="com.gs.entity.Users">
            <id column="id" property="id"/>
            <result column="username" property="username"/>
            <result column="password" property="password"/>
            <result column="realname" property="realname"/>
        </association>
    </resultMap>
</mapper>