MyBatis的多对多关联关系 转载

分析关系

用户和订单是一对多的关系，即一个用户可以有多个订单。

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

订单和用户是多对一的关系，一个订单只属于一个用户。

在Order类中定义了一个user属性，用来映射多对一的关联关系，表示该订单的用户；

订单和商品是多对多的关系，即一个订单中可以包含多种商品，一种商品可以包含在多个订单中。

在Order类中定义了一个articles属性，该属性是一个List集合，用来映射多对多的关联关系，表示一个订单中包含多种商品。

SQL脚本

在数据库创建三个表：tb_user、tb_article和tb_order，再创建一个中间表tb_item维护tb_article和tb_order 的关系，并插入测试数据。SQL脚本如下:

复制收展SQL-- 创建用户表
CREATE TABLE tb_user (
id INT PRIMARY KEY AUTO_INCREMENT,
username VARCHAR(18),
loginname VARCHAR(18),
PASSWORD VARCHAR (18),
phone VARCHAR (18),
address VARCHAR (18)
);
-- 插入用户表测试数据
INSERT INTO tb_user (username,loginname,PASSWORD,phone,address)
VALUES('马云','jack','123456','13600000000','杭州');
-- 创建商品表
CREATE TABLE tb_article(
id INT PRIMARY KEY AUTO_INCREMENT,
NAME VARCHAR (18),
price DOUBLE,
remark VARCHAR (18)
);
-- 插入商品表测试数据
INSERT INTO tb_article(NAME,price,remark)
VALUES('精通Python自然语言处理',108.9,'经典著作');
INSERT INTO tb_article(NAME,price,remark)
VALUES('自然语言处理原理与实践',99.9,'经典著作');
INSERT INTO tb_article(NAME,price,remark)
VALUES('大数据架构详解',89.9,'经典著作');
INSERT INTO tb_article(NAME,price,remark)
VALUES('推荐系统实践',69.9,'经典著作');
-- 创建订单表
CREATE TABLE tb_order(
id INT PRIMARY KEY AUTO_INCREMENT,
CODE VARCHAR(32),
total DOUBLE,
user_id INT,
FOREIGN KEY (user_id) REFERENCES tb_user(id)
);
-- 插入订单表测试数据
INSERT INTO tb_order (CODE,total,user_id)
VALUES('20180315ORDER1212',388.6,1);
INSERT INTO tb_order(CODE,total,user_id)
VALUES('20180315ORDER1213',217.8,1);
-- 创建中间表
CREATE TABLE tb_item(
order_id INT,
article_id INT,
amount INT,
PRIMARY KEY (order_id,article_id),
FOREIGN KEY (order_id) REFERENCES tb_order(id),
FOREIGN KEY (article_id) REFERENCES tb_article(id)
);
-- 创建插入中间表数据
INSERT INTO tb_item(order_id,article_id,amount)
VALUES(1,1,1);
INSERT INTO tb_item(order_id,article_id,amount)
VALUES(1,2,1);
INSERT INTO tb_item(order_id,article_id,amount)
VALUES(1,3,2);
INSERT INTO tb_item(order_id,article_id,amount)
VALUES(2,4,2);
INSERT INTO tb_item(order_id,article_id,amount)
VALUES(2,1,1);
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

实体类

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

复制收展Javapublic 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 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 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;
}
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

映射文件

一对多映射

UserMapper.xml  

复制收展XML<mapper namespace="cn.mybatis.mydemo3.mapper.UserMapper">

    <resultMap type="cn.mybatis.mydemo3.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="cn.mybatis.mydemo3.domain.Order"
            select="cn.mybatis.mydemo3.mapper.OrderMapper.selectOrderByUserId"
            fetchType="lazy">
            <id property="id" column="id" />
            <result property="code" column="code" />
            <result property="total" column="total" />
        </collection>
    </resultMap>

    <select id="selectUserById" parameterType="int"
        resultMap="userResultMap">
        SELECT * FROM tb_user WHERE id = #{id}
    </select>

</mapper>
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

UserMapper.xml中定义了一一个<select.../>，其根据id查询用户信息。由于User 类除了简单的属性id、usemame、loginame、password和address之外，还有一个关联对象orders，所以返回的是一个名为userResultMap的resultMap。

由于orders是一个List集合，因此userResultMap 中使用了<collection.../>元素映射一对多的关联关系，

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

多对一 和 多对多映射

OrderMapper.xml  

复制收展XML<mapper namespace="cn.mybatis.mydemo3.mapper.OrderMapper">

    <resultMap type="cn.mybatis.mydemo3.domain.Order"
        id="orderResultMap">
        <id property="id" column="oid" />
        <result property="code" column="code" />
        <result property="total" column="total" />
        <!-- 多对一关联映射:association -->
        <association property="user"
            javaType="cn.mybatis.mydemo3.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="cn.mybatis.mydemo3.domain.Article"
            select="cn.mybatis.mydemo3.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>

    <!-- 注意，如果查询出来的列同名，例如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="cn.mybatis.mydemo3.domain.Order">
        SELECT * FROM tb_order WHERE user_id = #{id}
    </select>

</mapper>
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