MyBatis（７）MyBatis高级映射

最新推荐文章于 2024-06-29 16:00:00 发布
最新推荐文章于 2024-06-29 16:00:00 发布
阅读量891 收藏
点赞数
分类专栏： # MyBatis 文章标签： mybatis assocation collection resultType resultMap
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/xl890727/article/details/49835211
版权

数据库关系分析

现在，存在如下的数据库：

CREATE TABLE IF NOT EXISTS `test`.`user` (
  `id` INT(11) NOT NULL AUTO_INCREMENT,
  `name` VARCHAR(45) CHARACTER SET 'utf8' COLLATE 'utf8_bin' NOT NULL COMMENT '用户名称',
  `pass` VARCHAR(45) CHARACTER SET 'utf8' COLLATE 'utf8_bin' NOT NULL COMMENT '用户密码',
  `birthday` DATE NULL DEFAULT NULL COMMENT '生日',
  `sex` CHAR(1) CHARACTER SET 'utf8' COLLATE 'utf8_bin' NULL DEFAULT NULL COMMENT '性别',
  `address` VARCHAR(256) CHARACTER SET 'utf8' COLLATE 'utf8_bin' NULL DEFAULT NULL COMMENT '地址',
  PRIMARY KEY (`id`),
  UNIQUE INDEX `id_UNIQUE` (`id` ASC))
ENGINE = InnoDB
DEFAULT CHARACTER SET = utf8
COLLATE = utf8_bin;

CREATE TABLE IF NOT EXISTS `test`.`items` (
  `id` INT(11) NOT NULL AUTO_INCREMENT,
  `name` VARCHAR(32) CHARACTER SET 'utf8' COLLATE 'utf8_bin' NOT NULL COMMENT '商品名称',
  `price` FLOAT(10,1) NOT NULL COMMENT '商品价格',
  `detail` TEXT CHARACTER SET 'utf8' COLLATE 'utf8_bin' NULL DEFAULT NULL COMMENT '商品描述',
  `pic` VARCHAR(512) CHARACTER SET 'utf8' COLLATE 'utf8_bin' NULL DEFAULT NULL COMMENT '商品图片',
  `createtime` DATETIME NULL DEFAULT NULL COMMENT '生产日期',
  PRIMARY KEY (`id`),
  UNIQUE INDEX `id_UNIQUE` (`id` ASC))
ENGINE = InnoDB
DEFAULT CHARACTER SET = utf8
COLLATE = utf8_bin;

CREATE TABLE IF NOT EXISTS `test`.`purchase` (
  `id` INT(11) NOT NULL AUTO_INCREMENT,
  `uid` INT(11) NOT NULL COMMENT '下订单用户ID',
  `number` VARCHAR(32) CHARACTER SET 'utf8' COLLATE 'utf8_bin' NOT NULL COMMENT '订单号',
  `createtime` DATETIME NOT NULL COMMENT '创建订单时间',
  `note` VARCHAR(100) CHARACTER SET 'utf8' COLLATE 'utf8_bin' NULL DEFAULT NULL COMMENT '备注',
  PRIMARY KEY (`id`),
  UNIQUE INDEX `id_UNIQUE` (`id` ASC),
  INDEX `FK_ORDERS_UID` (`uid` ASC),
  CONSTRAINT `FK_ORDERS_UID`
    FOREIGN KEY (`uid`)
    REFERENCES `test`.`user` (`id`))
ENGINE = InnoDB
DEFAULT CHARACTER SET = utf8
COLLATE = utf8_bin;

CREATE TABLE IF NOT EXISTS `test`.`purchasedetail` (
  `id` INT(11) NOT NULL AUTO_INCREMENT,
  `orders_id` INT(11) NOT NULL COMMENT '订单ID',
  `items_id` INT(11) NOT NULL COMMENT '商品ID',
  `items_num` INT(11) NOT NULL COMMENT '商品数购买量',
  PRIMARY KEY (`id`),
  UNIQUE INDEX `id_UNIQUE` (`id` ASC),
  INDEX `FK_ORDERDETAIL_ORDERSID` (`orders_id` ASC),
  INDEX `FK_ORDERDETAIL_ITEMSID` (`items_id` ASC),
  CONSTRAINT `FK_ORDERDETAIL_ITEMSID`
    FOREIGN KEY (`items_id`)
    REFERENCES `test`.`items` (`id`),
  CONSTRAINT `FK_ORDERDETAIL_ORDERSID`
    FOREIGN KEY (`orders_id`)
    REFERENCES `test`.`purchase` (`id`))
ENGINE = InnoDB
DEFAULT CHARACTER SET = utf8
COLLATE = utf8_bin;

其数据库的关系图如图所示：
数据库关系表

表与表之间业务关系：
数据库的映射关系都是基于业务的需求基础上来进行分析的。上面的数据库中，test.user与test.purchase、test.purchase与test.purchasedetail、purchasedetail与test.items都分别存在外键关联。

  1. test.user与test.purchase
    a. test.user->test.purchase
    一个用户可以生成多个订单：一对多
    b. test.purchase->test.user
    一个订单只能由一个用户生成：一对一

  2. test.purchase与test.purchasedetail
    a. test.purchase->test.purchasedetail
    一个订单可以包含多个订单明细：一对多
    b. test.purchasedetail->test.purchase
    一个订单明细只能在一个订单中：一对一

  3. test.purchasedetail与test.items
    a. test.purchasedetail->test.items
    一个订单明细只能包含一个商品的信息：一对一
    b. test.items->test.purchasedetail
    一个商品可以存在于多个订单明细中：一对多

  4. test.user与test.purchasedetail
    test.user与test.purchasedetail之间没有直接的外键关联关系。但是中间可以通过test.purchase相关联。
    a. test.user–>test.purchase–>test.purchasedetail
    一个用户生成多个订单，一个订单可以包含多个订单明细：一对多
    b. test.purchasedetail–>test.purchase–>test.user
    一个订单明细只能存在于一个订单当中，而一个订单只能由一个用户创建：一对一

  5. test.purchase与test.items
    test.purchase与test.items之间没有直接的外键关联关系。但是中间可以通过test.purchasedetail相关联。
    a. test.purchase–>test.purchasedetail–>test.items
    一个订单可以包含多个订单明细，并且一个订单明细只能包含一个商品的信息：一对多
    b. test.items–>test.purchasedetail–>test.purchase
    一个商品可以存在于多个订单明细中，然而一个订单详情只能在一个订单中：一对多

  6. test.user与test.items
    test.user与test.items之间没有直接的外键关联关系。但是中间可以通过test.purchase、test.purchasedetail相关联。
    a.test.user–>test.purchase–>test.purchasedetail–>test.items
    一个用户可以生成多个订单，一个订单可以包含多个订单明细，一个订单明细只能包含一个商品的信息：一对多
    b.test.items–>test.purchasedetail–>test.purchase–>test.user
    一个商品可以存在于多个订单明细中，一个订单详情只能在一个订单中，一个订单只能由一个用户创建：一对多

一对一映射

需求

查询某个订单信息，关联查其用户信息。

分析

根据以上的分析，我们知道这是个一对一的关系映射。在此采用ResultType以及ResultMap两种方法来实现。

1. ResultType
SQL语句
SELECT
    purchase.id, purchase.uid, purchase.number, purchase.note, user.name, user.sex, user.address
FROM
    test.purchase
        JOIN
    test.user ON test.purchase.uid = test.user.id
WHERE
    test.purchase.id = #{id}
POJO
public class OrderUserPojo extends OrderPojo {
    private String name;
    private int sex;
    private String address;
    //getter & setter
}
Mapper映射文件
<select id="selectOrderUserByID" parameterType="int" resultType="indi.latch.mybatis.pojo.OrderUserPojo">
SELECT
    purchase.id, purchase.uid, purchase.number, purchase.note, user.name, user.sex, user.address
FROM
    test.purchase
        JOIN
    test.user ON test.purchase.uid = test.user.id
WHERE
    test.purchase.id = #{id}
</select>
接口
public OrderUserPojo selectOrderUserByID () throws Exception;
测试代码
@Test
public void selectOrderUser () throws Exception {
    SqlSession sqlSession = sqlSessionFactory.openSession();
    OrderDao orderDao = sqlSession.getMapper(OrderDao.class);
    OrderUserPojo orderUser = orderDao.selectOrderUserByID();

    System.out.println(orderUser.toString());

    sqlSession.close();
}
2. ResultMap
POJO
public class OrderPojo {
    private int id;
    private int uid;
    private String number;
    private Date createtime;
    private String note;
    private UserPojo user;

    //getter & setter
}
Mapper映射文件
<!--resultMap开发-->
<resultMap id="OrderUserMap" type="indi.latch.mybatis.pojo.OrderPojo">
    <id column="id" property="id"></id>
    <result column="uid" property="uid"></result>
    <result column="number" property="number"></result>
    <result column="note" property="note"></result>

    <association property="user" javaType="indi.latch.mybatis.pojo.UserPojo">
        <id column="uid" property="id"></id>
        <result column="name" property="name"></result>
        <result column="sex" property="sex"></result>
        <result column="address" property="address"></result>
    </association>
</resultMap>

<select id="selectOrderUserMapByID" resultMap="OrderUserMap">
SELECT
    purchase.id, purchase.uid, purchase.number, purchase.note, user.name, user.sex, user.address
FROM
    test.purchase
JOIN
    test.user ON test.purchase.uid = test.user.id
WHERE
    test.purchase.id = #{id}
</select>
接口
public OrderPojo selectOrderUserMapByID () throws Exception;
测试代码
@Test
public void selectOrderUserMap() throws Exception {
    SqlSession sqlSession = sqlSessionFactory.openSession();
    OrderDao orderDao = sqlSession.getMapper(OrderDao.class);
    OrderPojo order = orderDao.selectOrderUserMapByID();

    System.out.println(order.toString());

    sqlSession.close();
}

代码

  1. git@code.csdn.net:xl890727/mybatisdemo.git
  2. https://code.csdn.net/xl890727/mybatisdemo.git
    中的advance-one2one分支

一对多映射

需求

查询某个订单信息，关联查询用户信息，并关联查询订单详情信息。

分析

从上面的数据库分析，接合需求，可知此关系为一对多映射关系。此处只采用ResultMap实现。

SQL语句
SELECT
    purchase.id,
    purchase.uid,
    purchase.number,
    purchase.note,
    user.name,
    user.sex,
    user.address,
    purchasedetail.id AS purchasedetail_id,
    purchasedetail.items_id,
    purchasedetail.items_num
FROM
    test.purchase,
    test.user,
    test.purchasedetail
WHERE
    test.purchase.id = #{id}
    AND purchase.uid = user.id
    AND purchase.id = purchasedetail.orders_id;
POJO
public class OrderPojo {
    private int id;
    private int uid;
    private String number;
    private Date createtime;
    private String note;

    private UserPojo user;
    private List<OrderDetailPojo> orderDetails;

    //setter & getter
}
Mapper映射文件
<resultMap id="OrderWithDetailsMap" type="OrderPojo">
    <id column="id" property="id"></id>
    <result column="uid" property="uid"></result>
    <result column="number" property="number"></result>
    <result column="note" property="note"></result>

    <association property="user" javaType="indi.latch.mybatis.pojo.UserPojo">
        <id column="uid" property="id"></id>
        <result column="name" property="name"></result>
        <result column="sex" property="sex"></result>
        <result column="address" property="address"></result>
    </association>

    <collection property="orderDetails" ofType="indi.latch.mybatis.pojo.OrderDetailPojo">
        <id column="purchasedetail_id" property="id"></id>
        <result column="items_id" property="itemId"></result>
        <result column="items_num" property="itemNum"></result>
    </collection>
</resultMap>

<select id="selectOrderWithDetails" resultMap="OrderWithDetailsMap">
    SELECT
        purchase.id,
        purchase.uid,
        purchase.number,
        purchase.note,
        user.name,
        user.sex,
        user.address,
        purchasedetail.id AS purchasedetail_id,
        purchasedetail.items_id,
        purchasedetail.items_num
    FROM
        test.purchase,
        test.user,
        test.purchasedetail
    WHERE
        test.purchase.id = #{id}
        AND purchase.uid = user.id
        AND purchase.id = purchasedetail.orders_id;
</select>
接口
public OrderPojo selectOrderWithDetails() throws Exception;
测试代码
@Test
public void selectOrderWithDetails () throws Exception {
    SqlSession sqlSession = sqlSessionFactory.openSession();
    OrderDao orderDao = sqlSession.getMapper(OrderDao.class);
    OrderPojo orderWithDetail = orderDao.selectOrderWithDetails();
    System.out.println(orderWithDetail.toString());

    sqlSession.close();
}

代码

  1. git@code.csdn.net:xl890727/mybatisdemo.git
  2. https://code.csdn.net/xl890727/mybatisdemo.git
    中的advance-one2multi分支

多对多映射

需求

查询所有用户信息，关联查询对应购买的商品信息。

分析

当查询所有用户以及其购买的商品信息时，根据以上的分析可知是多对多的关系。

SQL
SELECT
    user.*,
    purchase.id AS purchase_id,
    purchase.number,
    purchase.note,
    purchasedetail.id AS purchasedetail_id,
    purchasedetail.items_id,
    purchasedetail.items_num,
    items.name AS item_name,
    items.price,
    items.detail
FROM
    test.user,
    test.purchase,
    test.purchasedetail,
    test.items
WHERE
    user.id = purchase.uid
        AND purchase.id = purchasedetail.orders_id
        AND items.id = purchasedetail.items_id;
POJO
public class UserPojo {
    private int id;
    private String name;
    private String pass;
    private Date birthday;
    private int sex;
    private String address;
    private List<OrderPojo> orders;
    //getter & setter
}

public class OrderPojo {
    private int id;
    private int uid;
    private String number;
    private Date createtime;
    private String note;
    private List<OrderDetailPojo> orderDetails;
    //getter & setter
}

public class OrderDetailPojo {
    private int id;
    private int orderId;
    private int itemId;
    private int itemNum;

    private ItemPojo item;
    //getter & setter
}

public class ItemPojo {
    private int id;
    private String name;
    private float price;
    private String detail;
    private String pic;
    private Date createtime;
    //getter & setter
}
Mapper映射文件
<resultMap id="UserWithItems" type="indi.latch.mybatis.pojo.UserPojo">
    <id column="id" property="id"></id>
    <result column="name" property="name"></result>
    <result column="sex" property="sex"></result>
    <result column="address" property="address"></result>

    <!--用户与订单的一对一关系-->
    <collection property="orders" ofType="indi.latch.mybatis.pojo.OrderPojo">
        <id column="purchase_id" property="id"></id>
        <result column="number" property="number"></result>
        <result column="note" property="note"></result>
        <!--订单与订单详情的一对多关系-->
        <collection property="orderDetails" ofType="indi.latch.mybatis.pojo.OrderDetailPojo">
            <id column="purchasedetail_id" property="id"></id>
            <result column="items_id" property="itemId"></result>
            <result column="items_num" property="itemNum"></result>
            <!--订单详情与商品信息的一对一关系-->
            <association property="item" javaType="indi.latch.mybatis.pojo.ItemPojo">
                <id column="items_id" property="id"></id>
                <result column="item_name" property="name"></result>
                <result column="price" property="price"></result>
            </association>
        </collection>
    </collection>
</resultMap>

<select id="selectUserWithItems" resultMap="UserWithItems">
    SELECT
        user . *,
        purchase.id AS purchase_id,
        purchase.number,
        purchase.note,
        purchasedetail.id AS purchasedetail_id,
        purchasedetail.items_id,
        purchasedetail.items_num,
        items.name AS item_name,
        items.price,
        items.detail
    FROM
        test.user,
        test.purchase,
        test.purchasedetail,
        test.items
    WHERE
        user.id = purchase.uid
        AND purchase.id = purchasedetail.orders_id
        AND items.id = purchasedetail.items_id;
</select>
接口
public List<UserPojo> selectUserWithItems() throws Exception;
测试代码
@Test
public void selectUserWithItems () throws Exception {
    SqlSession sqlSession = sqlSessionFactory.openSession();
    OrderDao orderDao = sqlSession.getMapper(OrderDao.class);
    List<UserPojo> userItemList = orderDao.selectUserWithItems();
    System.out.println(userItemList.toString());

    sqlSession.close();
}

代码

  1. git@code.csdn.net:xl890727/mybatisdemo.git
  2. https://code.csdn.net/xl890727/mybatisdemo/tree/advance-one2one

总结

  1. ResultType最终需要我们自己创建符合查询结果的POJO；
  2. ResultMap，其实是POJO与POJO之间的包含关系；
  3. POJO与POJO之间的包含关系，不外乎一对一、一对多，如果是一对一，则采用assocation，反之则为collection；
  4. ResultMap相比于ResultType，虽然写起来比较复杂，但是ResultMap可以具有更多的功能。譬如后面将会介绍的延迟加载。
修巴利耶
关注
专栏目录
mybatis中批量插入的两种方式(高效插入)
09-01
MyBatis是一个支持普通SQL查询，存储过程和高级映射的优秀持久层框架。这篇文章主要介绍了mybatis中批量插入的两种方式(高效插入)的相关资料，非常不错，具有参考借鉴价值，感兴趣的朋友一起看看吧
Mybatis高级映射
iiiiiiiiiooooo的博客
04-08 1097
Mybatis高级映射本质上来说是多个表的联合查询过程 订单数据模型分析思路 数据表： 用户表user：记录了购买商品的用户信息 订单表orders：记录了用户创建的订单（购买商品的订单） 订单明细表orderdatail：记录了订单的详细信息即购买商品的信息 商品表items：记录了商品信息 数据模型分析： 表与表之间的业务关系： 用户表user和订单表order的关系：（一对多关系） user->orders：一个用户可以创建多个订单，一对多 orders->u
mybatis的高级映射
ArrayAda的博客
06-29 568
从表（orders）实体类应该包含主表(user)实体对象的引用。1. 分析需求：查询杜兰特同学的信息并且显示上哪一门课程。主表（user）应该包含从表(orders)的实体对象的集合。1. 分析需求：查询用户"郭襄"的个人信息并且包含所属订单的名字。应该包含另外一个表的实体对象的集合引用。5. 在映射配置文件中配置特殊：单独拿出一个订单来对应一个用户，一对一的关系。5. 在映射配置文件中配置5. 在映射配置文件中配置
玩转Mybatis的高级关系映射(实战加详解，保姆级教程)
浪里小白龙nbw的博客
11-08 2213
详解+实战，零基础也能玩转！
【SSM】Mybatis的高级映射
qq_63691275的博客
02-05 1104
分布查询中，`association` 标签下的`javaType` 属性和`collection` 标签下的 `ofType` 属性，如果对应的查询语句（映射接口方法）有返回值的话，`mybatis`可以自行推断，不写也不会报错。但是非分布查询的，`javaType` 和 `ofType` 属性是必须设置的，不然mybatis 无法知道所指定的类型。
mybatis的association
tanghuan0827的博客
05-29 4605
前言: 在项目中，某些实体类之间肯定有关键关系，比如一对一，一对多等。在hibernate 中用one to one和one to many，而mybatis 中就用association和collection。association: 一对一关联(has one)collection:一对多关联(has many) 注意，只有在做select查询时才会用到这两个标签，都有三种用法，且用法类似。 一、association的三种用法: 先看如下代码(省略set、get方法): public c
MyBatis高级映射学习教程
09-02
在MyBatis中，高级映射主要涉及一对一、一对多和多对多等复杂关系的映射处理。这些映射在实际开发中非常常见，例如在构建购物车功能时，订单与用户是一对一关系，用户与订单是一对多，而用户与商品则是多对多关系。...
mybatis映射文件.xml
最新发布
09-12
mybatis映射文件.xml
Mybatis高级映射查询
07-22
7. 动态结果集映射：Mybatis 提供了动态结果集映射功能，通过 `<collection>` 和 `<association>` 标签可以处理复杂的一对多和多对一关系。例如，一个用户可能有多个订单，那么在查询用户时，可以将订单信息一同返回...
关于MyBatis找不到映射文件的问题
09-06
一、MyBatis映射文件的配置 在MyBatis中，映射文件是用于定义SQL语句和Java对象之间的映射关系的配置文件。通常情况下，映射文件会被放在资源目录（resources）下的某个子目录（如mapper）下。在MyBatis的核心配置...
MyBatis Mapper映射文件
09-07
MyBatis Mapper映射文件
MyBatis中的association的使用
热门推荐
qq_41982223的博客
07-06 2万+
MyBatis中association的联表查询
MyBatis高级映射（一对一映射、一对多映射、多对多映射）
菜园子丶For丨丶Tomorrow的博客
07-30 1870
一、什么是MyBatis高级映射        mybatis是一个持久层框架，不完全的ORM（对象关系映射）框架。sql语句需要程序员自己去写，都是mybatis也有映射（输入参数映射，输出结果映射）。pojo通过映射数据库字段才能对数据进行增删改查操作，让程序员把精力放在写sql语句上，并对sql语句优化非常方便。即mapper.xml（映射文件）。       1、输入映射：parame...
MyBatis 学习（五）之 高级映射
zjs246813的博客
03-01 863
在之前的 SQL 映射文件中提及了 resultMap 元素的和标签，这两个标签是用来的，它们的属性几乎一致，以下是对它们属性的描述，红色标注的是常用属性。
【Mybatis】mybatis的笔记系列之一
~yzzheng～的博客
09-07 405
第一章 MyBatis框架概述 最重要的功能就是把SQL语句和代码解耦 把sql语句放在xml文档中 第二章 Mybatis入门 2.1 第一个例子 建表 建maven项目 修改pom.xml 1)加入mybatis依赖，mysql驱动 junit 在加入资源插件 创建实体类，定义属性、属性名和列名保持一致 写Dao，定理操作数据库的方法 写xml文件（mapper文件），写sql语句：mapper文件：定义和dao接口在同一个目录，一个表一个mapper文件 创建mybat
mybatis高级映射
m0_46853673的博客
03-24 1953
mybatis高级映射订单数据模型分析思路一对一映射 高级映射本质来说是多个表的联合查询的过程。 订单数据模型分析思路 数据表： 用户表user：记录了购买商品的用户信息。 订单表orders：记录了用户所创建的订单（购买商品的订单） 订单明细表orderdetail：记录了订单的详细信息即购买商品的信息。 商品表items：记录了商品信息。 数据模型分析： 表与表之间的业务关系 user和orders：（一对多关系） user->orders:一个用户可以创建多个订单，一对多。 orders-&g
MyBatis 高级映射
weixin_44930615的博客
05-11 249
MyBatis 是如何处理多张数据库表之间的关联关系，其中包括： 一对一的查询 一对多查询 多对多查询 延迟加载 mybatis项目中,必须先创建mybatis-config.xml和引入jar包 <?xml version="1.0" encoding="UTF-8"?> <!DOCTYPE configuration PUBLIC "-//mybatis.org//DTD Config 3.0//EN" "http://mybatis.org/dtd/.
MyBatis
rwyfg的博客
01-03 219
MyBatis学习笔记
MyBatis高级映射实战教程：一对一查询解析
"MyBatis高级映射学习教程" 在深入探讨MyBatis的高级映射之前，我们首先需要了解MyBatis的基本概念。MyBatis是一个优秀的持久层框架，它支持定制化SQL、存储过程以及高级映射。它避免了几乎所有的JDBC代码和手动...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值