1. 首页
  2. 文章中心
  3. SSM框架学习

MyBatis框架的学习(五)——一对一关联映射和一对多关联映射 一对一关联映射 一对多关联映射

59 阅读 0 评论
我是靠谱客的博主 暴躁篮球，最近开发中收集的这篇文章主要介绍MyBatis框架的学习(五)——一对一关联映射和一对多关联映射 一对一关联映射 一对多关联映射，觉得挺不错的，现在分享给大家，希望可以做个参考。

概述

本文是转载文章，文章的来源：csdn博客
博主：李阿昀
文章： MyBatis框架的学习(五)——一对一关联映射和一对多关联映射
博文地址：http://blog.csdn.net/yerenyuan_pku/article/details/71894172

在实际开发中我们不可能只是对单表进行操作，必然要操作多表，本文就来讲解多表操作中的一对一关联映射和一对多(或多对一)关联映射，至于多对多关联映射实质上也是两个一对多(或多对一)关联映射，所以在这里我并不打算讲解。先从一对一关联映射讲起。本文案例代码的编写是建立在前文MyBatis框架的学习(四)——Mapper.xml文件中的输入和输出映射以及动态sql案例基础之上的！

一对一关联映射

我以商品订单数据模型为例来讲解一对一关联映射，如下： 
这里写图片描述

一对一查询

有这样一个需求：查询所有订单信息，关联查询下单用户信息。 
注意：因为一个订单信息只会是一个人下的订单，所以从查询订单信息出发关联查询用户信息为一对一查询(值得注意的一点是这儿我将订单与用户的关系理解为一对多的关系，但实质上从订单角度出发，多个订单可属于一个用户，故订单与用户的关系应该是多对一的关系)。如果从用户信息出发查询用户下的订单信息则为一对多查询，因为一个用户可以下多个订单。 
解决该需求，可有两种方法，先讲第一种方法。

方法一

使用resultType，定义订单信息po类，此po类中包括了订单信息和用户信息。在cn.itheima.mybatis.po包下新建一个OrderUser类：

public class OrderUser extends Orders {

    private String username;
    private String address;
    public String getUsername() {
        return username;
    }
    public void setUsername(String username) {
        this.username = username;
    }
    public String getAddress() {
        return address;
    }
    public void setAddress(String address) {
        this.address = address;
    }

}
 
 
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18

OrderUser类继承Orders类后，OrderUser类包括了Orders类的所有字段，只需要定义用户的信息字段即可。 
接着按照需求编写sql语句，在OrderMapper.xml映射文件中添加如下select元素：

<select id="getOrderUserList" resultType="orderuser">
    SELECT
        o.id,
        o.user_id userId,
        o.number,
        o.createtime,
        o.note,
        u.username,
        u.address
    FROM
        orders o
    LEFT JOIN `user` u ON o.user_id = u.id
</select>
 
 
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13

紧接着在OrderMapper接口中编写如下方法：

List<OrderUser> getOrderUserList();
 
 
  • 1

最后在OrderMapperTest单元测试类中编写如下测试方法：

@Test
public void testGetOrderUserList() {
    SqlSession sqlSession = sqlSessionFactory.openSession();
    OrderMapper orderMapper = sqlSession.getMapper(OrderMapper.class);
    List<OrderUser> orderList = orderMapper.getOrderUserList();
    for (OrderUser orderUser : orderList) {
        System.out.println(orderUser);
    }
    sqlSession.close();
}
 
 
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10

在testGetOrderUserList方法中的以下代码处打一个断点：

for (OrderUser orderUser : orderList) {
 
 
  • 1

然后以Debug模式运行该方法，大概就能看到你想要的结果了。 
小结：定义专门的po类作为输出类型，其中定义了sql查询结果集所有的字段。此方法较为简单，企业中使用普遍。

方法二

使用resultMap，定义专门的resultMap用于映射一对一查询结果。首先在Orders类中加入user属性，user属性中用于存储关联查询的用户信息，因为订单关联查询用户是一对一关系，所以这里使用单个User对象存储关联查询的用户信息。这样Orders类的代码为：

public class Orders {
    private Integer id;

    private Integer userId;

    private String number;

    private Date createtime;

    private String note;

    private User user;

    public User getUser() {
        return user;
    }

    public void setUser(User user) {
        this.user = user;
    }

    public Integer getId() {
        return id;
    }

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

    public Integer getUserId() {
        return userId;
    }

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

    public String getNumber() {
        return number;
    }

    public void setNumber(String number) {
        this.number = number == null ? null : number.trim();
    }

    public Date getCreatetime() {
        return createtime;
    }

    public void setCreatetime(Date createtime) {
        this.createtime = createtime;
    }

    public String getNote() {
        return note;
    }

    public void setNote(String note) {
        this.note = note == null ? null : note.trim();
    }

}
 
 
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23
  • 24
  • 25
  • 26
  • 27
  • 28
  • 29
  • 30
  • 31
  • 32
  • 33
  • 34
  • 35
  • 36
  • 37
  • 38
  • 39
  • 40
  • 41
  • 42
  • 43
  • 44
  • 45
  • 46
  • 47
  • 48
  • 49
  • 50
  • 51
  • 52
  • 53
  • 54
  • 55
  • 56
  • 57
  • 58
  • 59
  • 60
  • 61
  • 62

然后在OrderMapper.xml映射文件中添加如下select元素：

<select id="getOrderUserResultMap" resultMap="order_user_resultmap">
    SELECT
        o.id,
        o.user_id,
        o.number,
        o.createtime,
        o.note,
        u.username,
        u.address
    FROM
        orders o
    LEFT JOIN `user` u ON o.user_id = u.id
</select>
 
 
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13

上面id为order_user_resultmap的resultMap也须定义，如下：

<resultMap type="orders" id="order_user_resultmap">
    <id property="id" column="id"/>
    <result property="userId" column="user_id" />
    <result property="number" column="number" />
    <result property="createtime" column="createtime" />
    <result property="note" column="note" />
    <!-- 配置一对一关联映射 -->
    <association property="user" javaType="cn.itheima.mybatis.po.User">
        <id property="id" column="user_id"/>
        <result property="username" column="username"/>
        <result property="address" column="address"/>
    </association>
</resultMap>
 
 
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13

这里resultMap指定order_user_resultmap。

  • association：表示进行关联查询单条记录。
  • property：表示关联查询的结果存储在cn.itcast.mybatis.po.Orders的user属性中。即property对应Orders类里面一对一关联映射的那个属性，即user属性。
  • javaType：表示关联查询的结果类型。即user属性的数据类型，可使用别名。
  • <id property="id" column="user_id"/>：查询结果的user_id列对应关联对象的id属性，这里是<id />表示user_id是关联查询对象的唯一标识。
  • <result property="username" column="username"/>：查询结果的username列对应关联对象的username属性。

OrderMapper.xml映射文件配置之后，在OrderMapper接口中编写如下方法：

List<Orders> getOrderUserResultMap();
 
 
  • 1

最后在OrderMapperTest单元测试类中编写如下测试方法：

@Test
public void testGetOrderUserResultMap() {
    SqlSession sqlSession = sqlSessionFactory.openSession();
    OrderMapper orderMapper = sqlSession.getMapper(OrderMapper.class);
    List<Orders> orderList = orderMapper.getOrderUserResultMap();
    for (Orders orders : orderList) {
        System.out.println(orders);
    }
    sqlSession.close();
}
 
 
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10

在testGetOrderUserResultMap方法中的以下代码处打一个断点：

for (Orders orders : orderList) {
 
 
  • 1

然后以Debug模式运行该方法，大概就能看到你想要的结果了。 
小结：使用association完成关联查询，将关联查询信息映射到pojo对象中。

一对多关联映射

现有这样一个需求：查询所有用户信息及用户关联的订单信息。这儿，用户信息和订单信息为一对多关系。在此，我使用resultMap来实现。 
为了解决该需求，在User类中加入List<Orders> orders属性，这样User类的代码就为：

public class User {
    private Integer id; // int类型的id是不可能为null的！
    private String username;// 用户姓名
    private String sex;// 性别
    private Date birthday;// 生日
    private String address;// 地址

    private List<Orders> orders;

    public List<Orders> getOrders() {
        return orders;
    }
    public void setOrders(List<Orders> orders) {
        this.orders = orders;
    }
    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 getSex() {
        return sex;
    }
    public void setSex(String sex) {
        this.sex = sex;
    }
    public Date getBirthday() {
        return birthday;
    }
    public void setBirthday(Date birthday) {
        this.birthday = birthday;
    }
    public String getAddress() {
        return address;
    }
    public void setAddress(String address) {
        this.address = address;
    }
    @Override
    public String toString() {
        return "User [id=" + id + ", username=" + username + ", sex=" + sex + ", birthday=" + birthday + ", address="
                + address + "]";
    }
}
 
 
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23
  • 24
  • 25
  • 26
  • 27
  • 28
  • 29
  • 30
  • 31
  • 32
  • 33
  • 34
  • 35
  • 36
  • 37
  • 38
  • 39
  • 40
  • 41
  • 42
  • 43
  • 44
  • 45
  • 46
  • 47
  • 48
  • 49
  • 50
  • 51

然后在OrderMapper.xml映射文件中添加如下select元素：

<select id="getUserWithOrders" resultMap="user_order_resultmap">
    SELECT
        u.id,
        u.username,
        u.birthday,
        u.sex,
        u.address,
        o.id oid,
        o.number,
        o.createtime,
        o.note
    FROM
        `user` u
    LEFT JOIN orders o ON u.id = o.user_id
</select>
 
 
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15

上面id为user_order_resultmap的resultMap也须定义，如下：

<!-- 一对多关联映射 -->
<resultMap type="user" id="user_order_resultmap">
    <id property="id" column="id"/>
    <result property="username" column="username"/>
    <result property="birthday" column="birthday"/>
    <result property="sex" column="sex"/>
    <result property="address" column="address"/>
    <!-- 配置一对多关联映射 -->
    <collection property="orders" ofType="orders">
        <!-- id对应Orders类的主键属性 -->
        <id property="id" column="oid"/>
        <result property="number" column="number"/>
        <result property="createtime" column="createtime"/>
        <result property="note" column="note"/>
    </collection>
</resultMap>
 
 
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16

这里resultMap指定user_order_resultmap。

  • collection部分定义了用户关联的订单信息。表示关联查询结果集。
  • property=”orders”：关联查询的结果集存储在User对象的哪个属性上。即property对应User对象中的集合属性。
  • ofType=”orders”：指定关联查询的结果集中的对象类型即List中的对象类型。此处可以使用别名，也可以使用全限定名。
  • <id />及<result/>的意义同一对一查询。

OrderMapper.xml映射文件配置之后，在OrderMapper接口中编写如下方法：

List<User> getUserWithOrders();
 
 
  • 1

最后在OrderMapperTest单元测试类中编写如下测试方法：

@Test
public void testGetUserWithOrders() {
    SqlSession sqlSession = sqlSessionFactory.openSession();
    OrderMapper orderMapper = sqlSession.getMapper(OrderMapper.class);
    List<User> userList = orderMapper.getUserWithOrders();
    for (User user : userList) {
        System.out.println(user);
    }
    sqlSession.close();
}
 
 
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10

在testGetUserWithOrders方法中的以下代码处打一个断点：

for (User user : userList) {
 
 
  • 1

然后以Debug模式运行该方法，大概就能看到你想要的结果了。 
至此，一对一关联映射和一对多关联映射我就已总结完了，觉得总结得蛮走心的。读者如需查看源码，可参考MyBatis框架的学习(五)——一对一关联映射和一对多关联映射！

最后

以上就是暴躁篮球为你收集整理的MyBatis框架的学习(五)——一对一关联映射和一对多关联映射 一对一关联映射 一对多关联映射的全部内容，希望文章能够帮你解决MyBatis框架的学习(五)——一对一关联映射和一对多关联映射 一对一关联映射 一对多关联映射所遇到的程序开发问题。

如果觉得靠谱客网站的内容还不错，欢迎将靠谱客网站推荐给程序员好友。

本图文内容来源于网友提供，作为学习参考使用，或来自网络收集整理，版权属于原作者所有。
点赞(39)

相关文章

SSM框架学习之MyBatis（三）——MyBatis关联关系（多对一）一、创建订单表二、创建实体类（称为javabean/entity/domain）三、创建Mapper文件四、在mybatis-config.xml添加OrderMapper映射五、测试六、面向对象编程七、多对一关系图解（结果映射关系）
SSM框架学习之MyBatis（三）——MyBatis关联关系（多对一）一、创建订单表二、创建实体类（称为javabean/entity/domain）三、创建Mapper文件四、在mybatis-config.xml添加OrderMapper映射五、测试六、面向对象编程七、多对一关系图解（结果映射关系）
SSM框架学习之MyBatis（四）——MyBatis关联关系（一对多）增加客户的订单集合属性修改CustomerMapper.xml修改查询输出方式测试结果
SSM框架学习之MyBatis（四）——MyBatis关联关系（一对多）增加客户的订单集合属性修改CustomerMapper.xml修改查询输出方式测试结果
MyBatis学习笔记（六）——高级查询之一对多映射前言collection标签总结
MyBatis学习笔记（六）——高级查询之一对多映射前言collection标签总结
MyBatis 框架学习——一对一关联映射和一对多关联映射
MyBatis 框架学习——一对一关联映射和一对多关联映射
MyBatis框架的学习(五)——一对一关联映射和一对多关联映射 一对一关联映射 一对多关联映射
MyBatis框架的学习(五)——一对一关联映射和一对多关联映射 一对一关联映射 一对多关联映射
Mybatis学习笔记——1、第一个程序
Mybatis学习笔记——1、第一个程序
Mybatis学习01——MyBatis简介、MyBatis第一个程序、CRUD操作、配置解析MyBatis简介CRUD操作配置解析
Mybatis学习01——MyBatis简介、MyBatis第一个程序、CRUD操作、配置解析MyBatis简介CRUD操作配置解析
mybatis 注解开发之（多表查询的一对一及一对多查询）---------------主表Account所对应的dao文件--------------------   ---------------从表user所对应的dao文件--------------------
mybatis 注解开发之（多表查询的一对一及一对多查询）---------------主表Account所对应的dao文件--------------------   ---------------从表user所对应的dao文件--------------------

评论列表共有 0 条评论

立即
投稿
返回
顶部