10.1.3 多对多

发表于 2019-06-08 更新于 2020-06-22 分类于 4 Spring+Mybatis企业应用实战(第2版) ，第10章深入使用MyBatis ， 10.1 MyBatis关联映射 Waline：本文字数： 16k 阅读时长 ≈ 15 分钟

10.1.3 多对多

在实际项目开发中,多对多关系也是非常常见的关系,比如,一个购物系统中,一个用户可以有多个订单,这是一对多的关系;一个订单中可以购买多种商品,一种商品也可以属于多个不同的订单,订单和商品之间就是多对多的关系。
对于数据库中多对多的关系建议使用一个中间表来维护关系,中间表中的订单id作为外键参照订单表的id,商品id作为外键参照商品表的id。下面我们就用一个示例来看看MyBatis怎么处理多对多关系。

示例: ManyToManyTest

项目结构

展开/折叠

D:\Desktop\书籍\Java\Java EE\随书源码\Spring+Mybatis企业应用实战(第2版)\codes\10\ManyToManyTest
├─src\
│ ├─db.properties
│ ├─log4j.xml
│ ├─mybatis-config.xml
│ └─org\
│   └─fkit\
│     ├─domain\
│     │ ├─Article.java
│     │ ├─Order.java
│     │ └─User.java
│     ├─factory\
│     ├─mapper\
│     │ ├─ArticleMapper.xml
│     │ ├─OrderMapper.java
│     │ ├─OrderMapper.xml
│     │ ├─UserMapper.java
│     │ └─UserMapper.xml
│     └─test\
│       └─ManyToManyTest.java
└─WebContent\
  ├─META-INF\
  │ └─MANIFEST.MF
  └─WEB-INF\
    ├─lib\
    │ ├─ant-1.9.6.jar
    │ ├─ant-launcher-1.9.6.jar
    │ ├─asm-5.2.jar
    │ ├─cglib-3.2.5.jar
    │ ├─commons-logging-1.2.jar
    │ ├─javassist-3.22.0-CR2.jar
    │ ├─log4j-1.2.17.jar
    │ ├─log4j-api-2.3.jar
    │ ├─log4j-core-2.3.jar
    │ ├─mybatis-3.4.5.jar
    │ ├─mysql-connector-java-5.1.44-bin.jar
    │ ├─ognl-3.1.15.jar
    │ ├─slf4j-api-1.7.25.jar
    │ └─slf4j-log4j12-1.7.25.jar
    └─web.xml

创建数据库表

首先,给之前创建的mybatis数据库创建三个表tb_user、tb_article和tb_order,再创建一个中间表tb_item维护tb_article和tb_order的关系,并插入测试数据。SQL脚本如下:

use mybatis;
-- 创建用户表
DROP TABLE IF EXISTS `tb_user`;
CREATE TABLE `tb_user` (
  `id` int(11) NOT NULL AUTO_INCREMENT,
  `username` varchar(18) DEFAULT NULL,
  `loginname` varchar(18) NOT NULL,
  `password` varchar(18) NOT NULL,
  `phone` varchar(18) DEFAULT NULL,
  `address` varchar(18) DEFAULT NULL,
  PRIMARY KEY (`id`)
) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4;

-- 插入用户
INSERT INTO `tb_user` VALUES ('1', '小明', 'xiaoming', 'xiaoming', '123456789123', '北京');

-- 创建商品表
DROP TABLE IF EXISTS `tb_article`;
CREATE TABLE `tb_article` (
  `id` int(11) NOT NULL AUTO_INCREMENT,
  `name` varchar(18) DEFAULT NULL,
  `price` double DEFAULT NULL,
  `remark` varchar(18) DEFAULT NULL,
  PRIMARY KEY (`id`)
) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4;

-- 插入商品
INSERT INTO `tb_article` VALUES ('1', '商品1', '123.12', 'xxx的伟大著作');
INSERT INTO `tb_article` VALUES ('2', '商品2', '12.3', 'yyy的伟大著作');
INSERT INTO `tb_article` VALUES ('3', '商品3', '34.22', 'zzz的著作');

-- 创建订单表
DROP TABLE IF EXISTS `tb_order`;
CREATE TABLE `tb_order` (
  `id` int(11) NOT NULL AUTO_INCREMENT,
  `code` varchar(32) DEFAULT NULL,
  `total` double DEFAULT NULL,
  `user_id` int(11) DEFAULT NULL,
  PRIMARY KEY (`id`),
  KEY `user_id` (`user_id`),
  CONSTRAINT `tb_order_ibfk_1` FOREIGN KEY (`user_id`) REFERENCES `tb_user` (`id`) ON DELETE CASCADE ON UPDATE CASCADE
) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4;

-- 插入订单
INSERT INTO `tb_order` VALUES ('1', 'abcseeeahoaugoeijgiej', '223.33', '1');
INSERT INTO `tb_order` VALUES ('2', 'sfaofosfhodsfuefie', '111.22', '1');

-- 创建订单-商品关系表
DROP TABLE IF EXISTS `tb_item`;
CREATE TABLE `tb_item` (
  `order_id` int(11) NOT NULL DEFAULT '0',
  `article_id` int(11) NOT NULL DEFAULT '0',
  `amount` int(11) DEFAULT NULL,
  PRIMARY KEY (`order_id`,`article_id`),
  KEY `article_id` (`article_id`),
  CONSTRAINT `tb_item_ibfk_1` FOREIGN KEY (`order_id`) REFERENCES `tb_order` (`id`) ON DELETE CASCADE ON UPDATE CASCADE,
  CONSTRAINT `tb_item_ibfk_2` FOREIGN KEY (`article_id`) REFERENCES `tb_article` (`id`) ON DELETE CASCADE ON UPDATE CASCADE
) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4;

-- 插入商品-订单关系
INSERT INTO `tb_item` VALUES ('1', '1', '1');
INSERT INTO `tb_item` VALUES ('1', '2', '1');
INSERT INTO `tb_item` VALUES ('1', '3', '3');
INSERT INTO `tb_item` VALUES ('2', '1', '2');
INSERT INTO `tb_item` VALUES ('2', '2', '3');

tb_order表的user_id作为外键参照tb_user表的主键id。
tb_item表作为中间表,用来维护tb_article和tb_order的多对多关系,
- tb_item表的
  - order_id作为外键参照tb_order表的主键id,
  - article_id作为外键参照tb_artic1e表的主键id。

在mybatis数据库中执行SQL脚本,完成创建数据库和表的操作。

创建持久化类

接下来,创建一个User对象、一个Article对象和一个Order对象分别映射tb_user,tb_article和tb_order表。

创建持久化类User.java

public class User
    implements Serializable
{
    private static final long serialVersionUID = 1L;
    private Integer id;  // 用户id，主键
    private String username;  // 用户名
    private String loginname; // 登录名
    private String password;  // 密码
    private String phone;    // 联系电话
    private String address;  // 收货地址
    // 用户和订单是一对多的关系，即一个用户可以有多个订单
    private List<Order> orders;
    public User()
    {
        super();
        // TODO Auto-generated constructor stub
    }
    public User(String username, String loginname, String password, String phone, String address)
    {
        super();
        this.username = username;
        this.loginname = loginname;
        this.password = password;
        this.phone = phone;
        this.address = address;
    }
    // 此处省略getter和setter方法,请自己补上
    @Override
    public String toString()
    {
        return "User [id=" + id + ", username=" + username + ", loginname=" + loginname
                + ", password=" + password + ", phone=" + phone + ", address=" + address + "]";
    }
}

用户和订单之间是一对多的关系,即一个用户可以有多个订单。在User类中定义了个orders属性,该属性是一个List集合,用来映射一对多的关联关系,表示一个用户有多个订单。

创建持久化类Order.java

public class Order
    implements Serializable
{
    private static final long serialVersionUID = 1L;
    private Integer id;  // 订单id，主键
    private String code;  // 订单编号
    private Double total; // 订单总金额
    // 订单和用户是多对一的关系，即一个订单只属于一个用户
    private User user;
    // 订单和商品是多对多的关系，即一个订单可以包含多种商品
    private List<Article> articles;
    public Order()
    {
        super();
        // TODO Auto-generated constructor stub
    }
    public Order(String code, Double total)
    {
        super();
        this.code = code;
        this.total = total;
    }
    // 此处省略getter和setter方法,请自己补上
    @Override
    public String toString()
    {
        return "Order [id=" + id + ", code=" + code + ", total=" + total + "]";
    }
}

订单和用户之间是多对一的关系,一个订单只属于一个用户,在Order类中定义了一个user属性,用来映射多对一的关联关系,表示该订单的用户;
订单和商品之间是多对多的关系,即一个订单中可以包含多种商品,在Order类中定义了一个articles属性该属性是一个List集合,用来映射多对多的关联关系,表示一个订单中包含多种商品。

创建持久化类Article.java

public class Article
    implements Serializable
{
    private static final long serialVersionUID = 1L;
    private Integer id;        // 商品id，主键
    private String name;    // 商品名称
    private Double price;    // 商品价格
    private String remark;    // 商品描述
    // 商品和订单是多对多的关系，即一种商品可以包含在多个订单中
    private List<Order> orders;
    public Article()
    {
        super();
        // TODO Auto-generated constructor stub
    }
    public Article(String name, Double price, String remark)
    {
        super();
        this.name = name;
        this.price = price;
        this.remark = remark;
    }
    // 此处省略getter和setter方法,请自己补上
    @Override
    public String toString()
    {
        return "Article [id=" + id + ", name=" + name + ", price=" + price + ", remark=" + remark
                + "]";
    }
}

商品和订单之间是多对多的关系,即一种商品可以出现在多个订单中。在Article类中定义了一个orders属性,该属性是一个List集合,用来映射多对多的关联关系,表示该商品关联的多个订单。

创建XML映射文件

再接下来是XML映射文件。

UserMapper.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">
<!-- namespace指用户自定义的命名空间。 -->
<mapper namespace="org.fkit.mapper.UserMapper">
    <select
        id="selectUserById"
        parameterType="int"
        resultMap="userResultMap"> SELECT * FROM tb_user WHERE id = #{id}
    </select>
    <resultMap
        type="org.fkit.domain.User"
        id="userResultMap">
        <id
            property="id"
            column="id"/>
        <result
            property="username"
            column="username"/>
        <result
            property="loginname"
            column="loginname"/>
        <result
            property="password"
            column="password"/>
        <result
            property="phone"
            column="phone"/>
        <result
            property="address"
            column="address"/>
        <!-- 一对多关联映射:collection -->
        <collection
            property="orders"
            javaType="ArrayList"
            column="id"
            ofType="org.fkit.domain.User"
            select="org.fkit.mapper.OrderMapper.selectOrderByUserId"
            fetchType="lazy">
            <id
                property="id"
                column="id"/>
            <result
                property="code"
                column="code"/>
            <result
                property="total"
                column="total"/>
        </collection>
    </resultMap>
</mapper>

UserMapper.xml中定义了一个select标签,该标签根据id查询用户信息。由于User类除了简单的属性id、username、loginname、password、phone和address之外,还有关联对象orders,所以返回的是一个名为userResultMap的resultMap。由于orders是一个List集合,因此userResultMap中使用了collection元素映射一对多的关联关系。
collection元素说明如下:

select属性表示会使用column属性的id值作为参数执行OrderMapper中定义的selectOrderByUserId标签,以查询该用户下的所有订单,
查询出的数据将被封装到property表示的orders对象当中。注意,一对多使用的都是lazy(懒加载)。

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">
<!-- namespace指用户自定义的命名空间。 -->
<mapper namespace="org.fkit.mapper.OrderMapper">
    <!-- 注意，如果查询出来的列同名，例如tb_user表的id和tb_order表的id都是id，同名，需要使用别名区分 -->
    <select
        id="selectOrderById"
        parameterType="int"
        resultMap="orderResultMap"> SELECT u.*,o.id AS oid,CODE,total,user_id FROM tb_user
        u,tb_order o WHERE u.id = o.user_id AND o.id = #{id}
    </select>
    <!-- 根据userid查询订单 -->
    <select
        id="selectOrderByUserId"
        parameterType="int"
        resultType="org.fkit.domain.Order"> SELECT * FROM tb_order WHERE user_id = #{id}
    </select>
    <resultMap
        type="org.fkit.domain.Order"
        id="orderResultMap">
        <id
            property="id"
            column="oid"/>
        <result
            property="code"
            column="code"/>
        <result
            property="total"
            column="total"/>
        <!-- 多对一关联映射:association -->
        <association
            property="user"
            javaType="org.fkit.domain.User">
            <id
                property="id"
                column="id"/>
            <result
                property="username"
                column="username"/>
            <result
                property="loginname"
                column="loginname"/>
            <result
                property="password"
                column="password"/>
            <result
                property="phone"
                column="phone"/>
            <result
                property="address"
                column="address"/>
        </association>
        <!-- 多对多映射的关键:collection -->
        <collection
            property="articles"
            javaType="ArrayList"
            column="oid"
            ofType="org.fkit.domain.Article"
            select="org.fkit.mapper.ArticleMapper.selectArticleByOrderId"
            fetchType="lazy">
            <id
                property="id"
                column="id"/>
            <result
                property="name"
                column="name"/>
            <result
                property="price"
                column="price"/>
            <result
                property="remark"
                column="remark"/>
        </collection>
    </resultMap>
</mapper>

selectOrderByUserId

OrderMapper.xml中定义了一个id="selectOrderByUserId"的select标签.其根据用户id查询订单信息,返回的是简单的Order对象。

<!-- 根据userid查询订单 -->
<select
    id="selectOrderByUserId"
    parameterType="int"
    resultType="org.fkit.domain.Order"> SELECT * FROM tb_order WHERE user_id = #{id}
</select>

selectOrderById

同时定义了一个id="selectOrderById"的select标签,其根据订单id查询订单信息,由于Order类和用户是多对一关系,和商品是多对多关系,而多对一通常都是立即加载,因此SQL语句是一条关联了tb_user和tb_order的多表查询语句。查询结果返回个名为orderResultMap的resultMap。

orderResultMap中使用了association元素映射多对一的关联关系,其将查询到的用户信息装载到Order对象的user属性当中。

<select
    id="selectOrderById"
    parameterType="int"
    resultMap="orderResultMap"> SELECT u.*,o.id AS oid,CODE,total,user_id FROM tb_user
    u,tb_order o WHERE u.id = o.user_id AND o.id = #{id}
</select>

orderResultMap中还使用了collection元素映射多对多的关联关系,select属性表示会使用column属性的oid值作为参数执行ArticleMapper中定义的selectArticleByOrderId查询该订单中的所有商品,查询出的数据将被封装到property属性表示的articles对象当中。注意,**一对多使用的都是lazy(懒加载)**。

提示

因为多表查询返回的结果集中tb_user有个id列,tb_order也有个id列,当列同名时MyBatis使用的元素中的colum属性如果是id,则MyBatis会默认使用査询出的第一个id列。为了区分同名的列,最好的方法是给列取一个别名。SQL语句中的o.id As oid,resultMap中的column="oid"就是指使用的是tb_order表的id值。

ArticleMapper.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">
<!-- namespace指用户自定义的命名空间。 -->
<mapper namespace="org.fkit.mapper.ArticleMapper">
    <select
        id="selectArticleByOrderId"
        parameterType="int"
        resultType="org.fkit.domain.Article"> SELECT * FROM tb_article WHERE id IN ( SELECT article_id
        FROM tb_item WHERE order_id = #{id} )
    </select>
</mapper>

ArticleMapper.xml中定义了一个id="selectArticleByOrderId"的select标签,其根据订单id查询订单关联的所有商品,由于订单和商品是多对多的关系,数据库使用了一个中间表tb_item维护多对多的关系,故此处使用了一个子查询,首先根据订单id到中间表中査询出所有的商品,之后根据所有商品的id查询出所有的商品信息,并将这些信息封装到Article对象当中。

编写Mapper接口

再接下来是mapper接口对象。

UserMapper接口

1
2
3

public interface UserMapper {
    User selectUserById(int id);
}

OrderMapper接口

1
2
3

public interface OrderMapper {
    Order selectOrderById(int id);
}

编写测试类

public class ManyToManyTest {
    public static void main(String[] args)
    {
        // 定义SqlSession变量
        SqlSession sqlSession = null;
        try
        {
            // 创建SqlSession实例
            sqlSession = FKSqlSessionFactory.getSqlSession();
            ManyToManyTest t = new ManyToManyTest();
            // 根据用户id查询用户，测试一对多
            // t.testSelectUserById(sqlSession);
            // 根据订单id查询订单，测试多对多
            t.testSelectOrderById(sqlSession);
            // 提交事务
            sqlSession.commit();
        } catch (Exception e)
        {
            // 回滚事务
            sqlSession.rollback();
            e.printStackTrace();
        } finally
        {
            // 关闭SqlSession
            if (sqlSession != null)
                sqlSession.close();
        }
    }
    // 测试一对多，查询班级User（一）的时候级联查询订单Order（多）
    public void testSelectUserById(SqlSession sqlSession)
    {
        // 获得UserMapper接口的代理对象
        UserMapper um = sqlSession.getMapper(UserMapper.class);
        // 调用selectUserById方法
        User user = um.selectUserById(1);
        // 查看查询到的user对象信息
        System.out.println(user.getId() + " " + user.getUsername());
        // 查看user对象关联的订单信息
        List<Order> orders = user.getOrders();
        orders.forEach(order -> System.out.println(order));
    }
    // 测试多对多，查询订单Order（多）的时候级联查询订单的商品Article（多）
    public void testSelectOrderById(SqlSession sqlSession)
    {
        // 获得OrderMapper接口的代理对象
        OrderMapper om = sqlSession.getMapper(OrderMapper.class);
        // 调用selectOrderById方法
        Order order = om.selectOrderById(2);
        // 查看查询到的order对象信息
        System.out.println(order.getId() + " " + order.getCode() + " " + order.getTotal());
        // 查看order对象关联的用户信息
        User user = order.getUser();
        System.out.println(user);
//        // 查看order对象关联的商品信息
//        List<Article> articles = order.getArticles();
//        articles.forEach(article -> System.out.println(article));
    }
}

testSelectUserById

运行ManyToManyTest类的main方法,首先测试testSelectUserById()方法,根据用户id查询用户。控制台显示如下:

控制台输出

DEBUG [main] ==>  Preparing: SELECT * FROM tb_user WHERE id = ? 
DEBUG [main] ==> Parameters: 1(Integer)
DEBUG [main] <==      Total: 1
1 小明
DEBUG [main] ==>  Preparing: SELECT * FROM tb_order WHERE user_id = ? 
DEBUG [main] ==> Parameters: 1(Integer)
DEBUG [main] <==      Total: 2
Order [id=1, code=abcseeeahoaugoeijgiej, total=223.33]
Order [id=2, code=sfaofosfhodsfuefie, total=111.22]

可以看到,MyBatis执行了根据用户id查询用户的SQL语句,查询出了用户信息;
由于在测试方法中立即又获取了用户的订单集合,所以MyBatis又执行了根据用户id查询订单的SQL语句,查询出了该用户的两个订单。

testSelectOrderById

接下来测试testSelectOrderById()方法,根据订单id查询订单信息。控制台显示:

控制台输出

DEBUG [main] ==>  Preparing: SELECT u.*,o.id AS oid,CODE,total,user_id FROM tb_user u,tb_order o WHERE u.id = o.user_id AND o.id = ? 
DEBUG [main] ==> Parameters: 2(Integer)
DEBUG [main] <==      Total: 1
2 sfaofosfhodsfuefie 111.22
User [id=1, username=小明, loginname=xiaoming, password=xiaoming, phone=123456789123, address=北京]

可以看到,MyBatis执行了一个多表连接查询,同时查询出了订单信息和用户信息,由于测试方法中注释了查询订单中的商品代码,故MyBatis采用了懒加载机制,没有立即查询商品信息。

取消testSelectOrderById()方法中査询订单中的商品的代码注释,再次执行。控制台显示如下：

控制台输出

DEBUG [main] ==>  Preparing: SELECT u.*,o.id AS oid,CODE,total,user_id FROM tb_user u,tb_order o WHERE u.id = o.user_id AND o.id = ? 
DEBUG [main] ==> Parameters: 2(Integer)
DEBUG [main] <==      Total: 1
2 sfaofosfhodsfuefie 111.22
User [id=1, username=小明, loginname=xiaoming, password=xiaoming, phone=123456789123, address=北京]
DEBUG [main] ==>  Preparing: SELECT * FROM tb_article WHERE id IN ( SELECT article_id FROM tb_item WHERE order_id = ? ) 
DEBUG [main] ==> Parameters: 2(Integer)
DEBUG [main] <==      Total: 2
Article [id=1, name=商品1, price=123.12, remark=xxx的伟大著作]
Article [id=2, name=商品2, price=12.3, remark=yyy的伟大著作]

可以看到,MyBatis执行了ArticleMapper.xml中定义的子查询,查询出了订单所关联的所有商品信息。

总结

collection标签

collection标签的属性

column属性指定要将哪一列,作为select标签关联的查询语句的参数。
select属性指定关联查询的select标签
property属性指定接收select结果集的集合的变量名
javaType属性指定集合的类型
ofType属性指定集合中存放的元素的类型

collection标签的子标签

这些子标签表示集合中元素的各个属性。

association标签

对于多对一,一对一联系,使用多表连接查询即可。

association标签的属性

property设置持久化对象的属性
javaType设置该属性的类型

association标签的子标签

这些子标签表示关联的持久化对象的各个属性。