Java EE学习笔记（九）

MyBatis的关联映射

1、关联关系概述

1)、实际的开发中，对数据库的操作常常会涉及到多张表，这在面向对象中就涉及到了对象与对象之间的关联关系。针对多表之间的操作，MyBatis提供了关联映射，通过关联映射就可以很好的处理对象与对象之间的关联关系。

2)、在关系型数据库中，多表之间存在着三种关联关系，分别为一对一、一对多和多对多，如下图所示：

a)、一对一：在任意一方引入对方主键作为外键；

b)、一对多：在“多”的一方，添加“一”的一方的主键作为外键；

c)、多对多：产生中间关系表，引入两张表的主键作为外键，两个主键成为联合主键或使用新的字段作为主键。

3)、在Java中，通过对象也可以进行关联关系描述，如图下图所示：

a)、一对一：在本类中定义对方类型的对象，如A类中定义B类类型的属性b，B类中定义A类类型的属性a；

b)、一对多：一个A类类型对应多个B类类型的情况，需要在A类中以集合的方式引入B类类型的对象，在B类中定义A类类型的属性a；

c)、多对多：在A类中定义B类类型的集合，在B类中定义A类类型的集合。

2、一对一

1)、<resultMap>元素中，包含了一个<association>子元素，MyBatis就是通过该元素来处理一对一关联关系的。

2)、在<association>元素中，通常可以配置以下属性：

a)、property：指定映射到的实体类对象中的属性，与表字段一一对应。

b)、column：指定数据库表中对应的字段。

c)、javaType：指定映射到实体对象属性的类型。

d)、select：指定引入嵌套查询的子SQL语句，该属性用于关联映射中的嵌套查询。

e)、fetchType：指定在关联查询时是否启用延迟加载。该属性有lazy和eager两个属性值，默认值为lazy（即默认关联映射延迟加载）。

3)、MyBatis加载关联关系对象主要通过两种方式：嵌套查询和嵌套结果。

4)、疑惑：虽然使用嵌套查询的方式比较简单，但是嵌套查询的方式要执行多条SQL语句，这对于大型数据集合和列表展示不是很好，因为这样可能会导致成百上千条关联的SQL语句被执行，从而极大的消耗数据库性能并且会降低查询效率。

5)、解决办法：MyBatis延迟加载的配置。使用MyBatis的延迟加载在一定程度上可以降低运行消耗并提高查询效率。MyBatis默认没有开启延迟加载，需要在核心配置文件中的<settings>元素内进行配置，具体配置方式如下：

    <settings>
            <setting name="lazyLoadingEnabled" value="true" />  
            <setting name="aggressiveLazyLoading" value="false"/>  
    </settings>

6)、在映射文件中，<association>元素和<collection>元素中都已默认配置了延迟加载属性，即默认属性fetchType="lazy"（属性fetchType="eager"表示立即加载），所以在配置文件中开启延迟加载后，无需在映射文件中再做配置。

7)、使用<association>元素进行一对一关联映射非常简单，只需要参考如下两种示例配置即可。

<!--方式1：嵌套查询-->
<association property="card" column="card_id" 
          javaType="com.itheima.po.IdCard"     
        select="com.itheima.mapper.IdCardMapper.findCodeById" />
<!--方式2：嵌套结果-->
<association property="card" javaType="com.itheima.po.IdCard">
              <id property="id" column="card_id" />
              <result property="code" column="code" />
</association>

8)、创建数据库表---tb_idcard和tb_person。

 1 CREATE TABLE tb_idcard(
 2     id INT PRIMARY KEY AUTO_INCREMENT,
 3     CODE VARCHAR(18)
 4 );
 5 
 6 INSERT INTO tb_idcard(CODE) VALUES('13341631331213');
 7 INSERT INTO tb_idcard(CODE) VALUES('21311211321111');
 8 
 9 CREATE TABLE tb_person(
10     id INT PRIMARY KEY AUTO_INCREMENT,
11     NAME VARCHAR(32),
12     age INT,
13     sex VARCHAR(8),
14     card_id INT UNIQUE,
15     FOREIGN KEY(card_id) REFERENCES tb_idcard(id)
16 );
17 
18 INSERT INTO tb_person(NAME, age, sex, card_id) VALUES('Rose', 29, '女', 1);
19 INSERT INTO tb_person(NAME, age, sex, card_id) VALUES('tom', 27, '男', 2);

执行SQL查询语句如图所示：

9)、本章文件结构如下：

①证件持久化类：src/com/itheima/po/IdCard.java

 1 package com.itheima.po;
 2 /**
 3  * 证件持久化类
 4  */
 5 public class IdCard {
 6     private Integer id;
 7     private String code;
 8     
 9     public Integer getId() {
10         return id;
11     }
12     
13     public void setId(Integer id) {
14         this.id = id;
15     }
16     
17     public String getCode() {
18         return code;
19     }
20     
21     public void setCode(String code) {
22         this.code = code;
23     }
24     
25     @Override
26     public String toString() {
27         return "IdCard [id=" + id + ", code=" + code + "]";
28     }
29 }

②个人持久化类：src/com/itheima/po/Person.java

 1 package com.itheima.po;
 2 /**
 3  * 个人持久化类
 4  */
 5 public class Person {
 6     private Integer id;
 7     private String name;
 8     private Integer age;
 9     private String sex;
10     private IdCard card;  //个人关联的证件
11     
12     public Integer getId() {
13         return id;
14     }
15     
16     public void setId(Integer id) {
17         this.id = id;
18     }
19     
20     public String getName() {
21         return name;
22     }
23     
24     public void setName(String name) {
25         this.name = name;
26     }
27     
28     public Integer getAge() {
29         return age;
30     }
31     
32     public void setAge(Integer age) {
33         this.age = age;
34     }
35     
36     public String getSex() {
37         return sex;
38     }
39     
40     public void setSex(String sex) {
41         this.sex = sex;
42     }
43     
44     public IdCard getCard() {
45         return card;
46     }
47     
48     public void setCard(IdCard card) {
49         this.card = card;
50     }
51     
52     @Override
53     public String toString() {
54         return "Person [id=" + id + ", name=" + name + ", age=" + age + ", sex=" + sex + ", card=" + card + "]";
55     }
56 }

③创建证件映射文件：src/com/itheima/mapper/IdCardMapper.xml

 1 <?xml version="1.0" encoding="UTF-8"?>
 2 <!DOCTYPE mapper PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN"
 3                 "http://mybatis.org/dtd/mybatis-3-mapper.dtd">
 4                 
 5 <mapper namespace="com.itheima.mapper.IdCardMapper">
 6   
 7   <!-- 根据id查询证件信息 -->
 8   <select id="findCodeById" parameterType="Integer" resultType="IdCard">
 9       SELECT * from tb_idcard where id=#{id}
10   </select>
11 </mapper>

④个人配置文件：src/com/itheima/mapper/PersonMapper.xml

 1 <?xml version="1.0" encoding="UTF-8"?>
 2 <!DOCTYPE mapper PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN"
 3                  "http://mybatis.org/dtd/mybatis-3-mapper.dtd">
 4                  
 5 <mapper namespace="com.itheima.mapper.PersonMapper">
 6     
 7     <!-- 嵌套查询：通过执行另外一条SQL映射语句来返回预期的特殊类型
 8         引用下面定义的resultMap的ID，作一个实体类属性和数据库列属性的映射关系
 9      -->
10     <select id="findPersonById" parameterType="Integer" 
11              resultMap="IdCardWithPersonResultID">
12         SELECT * from tb_person where id=#{id}
13     </select>
14     
15     
16     <resultMap type="Person" id="IdCardWithPersonResultID">
17         <id property="id" column="id" />
18         <result property="name" column="name" />
19         <result property="age" column="age" />
20         <result property="sex" column="sex" />
21         
22         <!--除了返回个人对象的基本属性外还有一个关联的card属性，需要手动编写结果映射 
23             一对一：<association>元素使用select属性引入另外一条SQL语句 
24             javaType：映射到实体对象属性card的类型为IdCard
25             property：映射到的实体类对象属性card
26             嵌套查询的方法是先执行一个简单的SQL语句，然后进行结果映射时，
27             将关联对象在<association>元素中使用select属性执行另一条SQL语句（即在IdCardMapper.xml中的SQL）
28         -->
29         <association property="card" column="card_id" javaType="IdCard"
30             select="com.itheima.mapper.IdCardMapper.findCodeById" />
31     </resultMap>
32     
33     <!-- 嵌套结果：使用嵌套结果映射 来处理重复的联合结果的子集 -->
34     <select id="findPersonById2" parameterType="Integer" 
35             resultMap="IdCardWithPersonResult2ID">
36         <!-- 编写一条复杂的多表关联的SQL查询语句 -->
37         SELECT p.*,idcard.code
38         from tb_person p,tb_idcard idcard
39         where p.card_id=idcard.id 
40         and p.id= #{id}
41     </select>
42     
43     <resultMap type="Person" id="IdCardWithPersonResult2ID">
44     
45         <id property="id" column="id" />
46         <result property="name" column="name" />
47         <result property="age" column="age" />
48         <result property="sex" column="sex" />
49         
50         <!-- 嵌套结果查询：
51             在<association>元素中继续使用相关子元素进行数据库表字段和实体类属性的一一映射，详细展开一一映射
52          -->
53         <association property="card" javaType="IdCard">
54             <id property="id" column="card_id" />
55             <result property="code" column="code" />
56         </association>
57     </resultMap>
58     
59 </mapper>

⑤编写MyBatis的配置文件：src/mybatis-config.xml

 1 <?xml version="1.0" encoding="UTF-8" ?>
 2 <!DOCTYPE configuration PUBLIC "-//mybatis.org//DTD Config 3.0//EN"
 3                         "http://mybatis.org/dtd/mybatis-3-config.dtd">
 4                         
 5 <configuration>
 6 
 7     <!-- 引入数据库连接配置文件 -->
 8     <properties resource="db.properties" />
 9     
10     <settings>
11      <!-- MyBatis默认没有开启延迟加载器，
12          只需在配置文件中打开延迟加载的开关，然后无需在映射文件中再做配置 -->  
13     <setting name="lazyLoadingEnabled" value="true" />  
14     
15     <!-- 将积极加载改为消息加载，即按需加载 -->  
16     <setting name="aggressiveLazyLoading" value="false"/>  
17     </settings>
18     
19     <!--使用扫描包的形式定义别名
20         <typeAliases>元素的子元素<package>中的name属性用于指定要被定义别名的包，
21 　　        MyBatis会将所有com.itheima.po包中的POJO类以首字母小写的非限定类名（如：String）来作为它的别名，
22 　        比如com.itheima.po.User的别名为user，com.itheima.po.Customer的别名是customer等。
23      -->
24     <typeAliases>
25         <package name="com.itheima.po" />
26     </typeAliases>
27     
28     <!--配置环境 ，默认的环境id为mysql -->
29     <environments default="mysql">
30     
31         <!-- 配置id为mysql的数据库环境 -->
32         <environment id="mysql">
33         
34             <!-- 使用JDBC的事务管理 -->
35             <transactionManager type="JDBC" />
36             
37             <!--数据库连接池 -->
38             <dataSource type="POOLED">
39                 <property name="driver" value="${jdbc.driver}" />
40                 <property name="url" value="${jdbc.url}" />
41                 <property name="username" value="${jdbc.username}" />
42                 <property name="password" value="${jdbc.password}" />
43             </dataSource>
44             
45         </environment>
46         
47     </environments>
48     
49     <!--最后要配置Mapper的位置 -->
50      <mappers>
51          <mapper resource="com/itheima/mapper/IdCardMapper.xml" />
52          <mapper resource="com/itheima/mapper/PersonMapper.xml" />
53          <mapper resource="com/itheima/mapper/UserMapper.xml" />
54          <mapper resource="com/itheima/mapper/OrdersMapper.xml" />
55           <mapper resource="com/itheima/mapper/ProductMapper.xml" />
56      </mappers>
57 </configuration>

⑥一对一映射查询测试：src/com/itheima/test/MybatisAssociatedTest.java

 1 package com.itheima.test;
 2 import org.apache.ibatis.session.SqlSession;
 3 import org.junit.Test;
 4 
 5 import com.itheima.po.Orders;
 6 import com.itheima.po.Person;
 7 import com.itheima.po.User;
 8 import com.itheima.utils.MybatisUtils;
 9 /**
10  * Mybatis关联查询映射测试类
11  */
12 public class MybatisAssociatedTest {
13     /**
14      * 嵌套查询
15      */
16     @Test
17     public void findPersonByIdTest() {
18         
19         // 1、通过工具类生成SqlSession对象
20         SqlSession session = MybatisUtils.getSession();
21        
22         // 2.使用MyBatis嵌套查询的方式查询id为1的人的信息
23         Person person = session.selectOne("com.itheima.mapper.PersonMapper.findPersonById", 1);
24         
25         // 3、输出查询结果信息
26         System.out.println(person);
27         
28         // 4、关闭SqlSession
29         session.close();
30     }
31     
32     /**
33      * 嵌套结果
34      */
35     @Test
36     public void findPersonByIdTest2() {
37         
38         // 1、通过工具类生成SqlSession对象
39         SqlSession session = MybatisUtils.getSession();
40         
41         // 2.使用MyBatis嵌套结果的方法查询id为1的人的信息
42         Person person = session.selectOne("com.itheima.mapper.PersonMapper.findPersonById2", 1);
43         
44         // 3、输出查询结果信息
45         System.out.println(person);
46         
47         // 4、关闭SqlSession
48         session.close();
49     }
50 }

⑦嵌套查询如图所示：

⑧嵌套结果如图所示：

3、一对多

1)、开发人员接触更多的关联关系是一对多（或多对一）。例如，一个用户可以有多个订单，同时多个订单归一个用户所有。<resultMap>元素中，包含了一个<collection>子元素，MyBatis就是通过该元素来处理一对多关联关系的。

2)、<collection>子元素的属性大部分与<association>元素相同，但其还包含一个特殊属性--ofType 。

3)、ofType属性与javaType属性对应，它用于指定实体对象中集合类属性所包含的元素类型。<collection >元素的使用也非常简单，同样可以参考如下两种示例进行配置，具体代码如下：

4)、创建数据库表tb_user和tb_orders：

 1 CREATE TABLE tb_user(
 2     id INT(32) PRIMARY KEY AUTO_INCREMENT,
 3     username VARCHAR(32),
 4     address VARCHAR(256)
 5 );
 6 INSERT INTO tb_user VALUES('1', '张三', '深圳');
 7 INSERT INTO tb_user VALUES('2', '李四', '东莞');
 8 
 9 CREATE TABLE tb_orders(
10     id INT(32) PRIMARY KEY AUTO_INCREMENT,
11     number VARCHAR(32) NOT NULL, #订单号
12     user_id INT(32) NOT NULL, #外键，该订单上客户id
13     FOREIGN KEY(user_id) REFERENCES tb_user(id) # 定义外键引用
14 );
15 INSERT INTO tb_orders VALUES('2', '100111', '1');
16 INSERT INTO tb_orders VALUES('3', '100112', '2');

执行SQL查询语句后如图所示：

①创建订单持久化类：src/com/itheima/po/Orders.java

 1 package com.itheima.po;
 2 
 3 import java.util.List;
 4 
 5 /**
 6  * 订单持久化类
 7  */
 8 public class Orders {
 9     private Integer id;    //订单id
10     private String number; //订单编号
11 
12     
13     public Integer getId() {
14         return id;
15     }
16     
17     public void setId(Integer id) {
18         this.id = id;
19     }
20     
21     public String getNumber() {
22         return number;
23     }
24     
25     public void setNumber(String number) {
26         this.number = number;
27     }
28     
29     @Override
30     public String toString() {
31         return "Orders [id=" + id + ", number=" + number + "]";
32     }
33     
34 }

②创建用户持久化类：src/com/itheima/po/User.java

 1 package com.itheima.po;
 2 import java.util.List;
 3 /**
 4  * 用户持久化类
 5  */
 6 public class User {
 7     private Integer id;                 // 用户编号
 8     private String username;           // 用户姓名
 9     private String address;            // 用户地址
10     private List<Orders> ordersList;  //用户关联的订单，一对多：即一个用户可以有多个订单
11     
12     public Integer getId() {
13         return id;
14     }
15     
16     public void setId(Integer id) {
17         this.id = id;
18     }
19     
20     public String getUsername() {
21         return username;
22     }
23     
24     public void setUsername(String username) {
25         this.username = username;
26     }
27     
28     public String getAddress() {
29         return address;
30     }
31     
32     public void setAddress(String address) {
33         this.address = address;
34     }
35     
36     public List<Orders> getOrdersList() {
37         return ordersList;
38     }
39     
40     public void setOrdersList(List<Orders> ordersList) {
41         this.ordersList = ordersList;　　
42     }
43     
44     @Override
45     public String toString() {
46         return "User [id=" + id + ", username=" + username + ", address=" + address + ", ordersList=" + ordersList + "]";
47     }
48 }

③创建用户实体映射文件：src/com/itheima/mapper/UserMapper.xml

 1 <?xml version="1.0" encoding="UTF-8"?>
 2 <!DOCTYPE mapper PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN"
 3                     "http://mybatis.org/dtd/mybatis-3-mapper.dtd">
 4                     
 5 <!-- <mapper>是根元素，包括一个属性namespace表示命名空间，通常会设置成“包名+SQL映射文件名”的形式 --> 
 6 <mapper namespace="com.itheima.mapper.UserMapper">
 7     
 8     <!-- 一对多：查看某一用户及其关联的订单信息 
 9           注意：当关联查询出的列名相同，则需要使用别名区分！！！
10       以下使用嵌套结果的方式定义了一个根据用户id查询用户及其关联的订单信息的select语句。
11       因为返回的用户对象中，包含Orders集合对象的属性，所以需要手动编写结果映射信息。
12      -->
13     <select id="findUserWithOrders" parameterType="Integer" 
14             resultMap="UserWithOrdersResultID">
15         SELECT u.*, o.id as orders_id, o.number 
16         from tb_user u,tb_orders o 
17         WHERE u.id=o.user_id and u.id=#{id}
18     </select>
19     
20     <resultMap type="User" id="UserWithOrdersResultID">
21     
22         <id property="id" column="id"/>
23         <result property="username" column="username"/>
24         <result property="address" column="address"/>
25         
26         <!-- 一对多关联映射：<collection>元素：对关联查询到多条记录映射到集合对象中 
27             <collection>元素中property属性表示：将关联查询到多条记录映射到User类中的订单对象实例属性ordersList
28                             ofType表示属性集合中元素的类型，这里的List<Orders>属性即Orders类 
29             <id>元素表示订单明细的唯一标识；
30             <result>元素表示其他属性和数据库做一一映射
31             -->
32         <collection property="ordersList" ofType="Orders">
33             <!-- 下面是Orders实体类与数据库表做一个映射关系
34                 注意：column属性应该和编写复杂SQL语句字段对应，否则会对应不上正确数据
35              -->
36             <id property="id" column="orders_id"/>
37             <result property="number" column="number"/>
38         </collection>
39     </resultMap>
40 </mapper>

④单元测试：

 1     /**
 2      * 一对多    
 3      */
 4     @Test
 5     public void findUserTest() {
 6         
 7         // 1、通过工具类生成SqlSession对象
 8         SqlSession session = MybatisUtils.getSession();
 9         
10         // 2、查询id为1的用户信息
11         User user = session.selectOne("com.itheima.mapper.UserMapper.findUserWithOrders", 1);
12         
13         // 3、输出查询结果信息
14         System.out.println(user);
15         
16         // 4、关闭SqlSession
17         session.close();
18     }

⑤执行结果：

4、多对多

1)、在实际项目开发中，多对多的关联关系也是非常常见的。以订单和商品为例，一个订单可以包含多种商品，而一种商品又可以属于多个订单。

2)、在数据库中，多对多的关联关系通常使用一个中间表来维护，中间表中的订单id作为外键参照订单表的id，商品id作为外键参照商品表的id。

3)、在MyBatis中，多对多的关联关系查询，同样可以使用前面介绍的<collection >元素进行处理（其用法和一对多关联关系查询语句用法基本相同）。

4)、创建数据库表tb_product和tb_ordersitem：

 1 CREATE TABLE tb_product(
 2     id INT(32) PRIMARY KEY AUTO_INCREMENT,
 3     NAME VARCHAR(32),
 4     price DOUBLE
 5 );
 6 INSERT INTO tb_product VALUES('1', 'JAVA入门基础', '96');
 7 INSERT INTO tb_product VALUES('2', 'JAVAWEB程序开发入门', '90');
 8 INSERT INTO tb_product VALUES('3', 'SSM框架整合实战', '90');
 9 
10 CREATE TABLE tb_ordersitem( #创建中间表
11     id INT(32) PRIMARY KEY AUTO_INCREMENT,
12     orders_id INT(32),
13     product_id INT(32),
14     FOREIGN KEY(orders_id) REFERENCES tb_orders(id),
15     FOREIGN KEY(product_id) REFERENCES tb_product(id)
16 ); 
17 
18 INSERT INTO tb_ordersitem VALUES('1', '2', '1');
19 INSERT INTO tb_ordersitem VALUES('2', '2', '3');
20 INSERT INTO tb_ordersitem VALUES('3', '3', '3'); #注意引用值的存在

①创建商品持久化类：src/com/itheima/po/Product.java

 1 package com.itheima.po;
 2 import java.util.List;
 3 /**
 4  * 商品持久化类
 5  */
 6 public class Product {
 7     private Integer id;  //商品id
 8     private String name; //商品名称
 9     private Double price;//商品单价
10     private List<Orders> orders; //与订单的关联属性
11     
12     public Integer getId() {
13         return id;
14     }
15     
16     public void setId(Integer id) {
17         this.id = id;
18     }
19     
20     public String getName() {
21         return name;
22     }
23     
24     public void setName(String name) {
25         this.name = name;
26     }
27     
28     public Double getPrice() {
29         return price;
30     }
31     
32     public void setPrice(Double price) {
33         this.price = price;
34     }
35     
36     public List<Orders> getOrders() {
37         return orders;
38     }
39     
40     public void setOrders(List<Orders> orders) {
41         this.orders = orders;
42     }
43     
44     @Override
45     public String toString() {
46         return "Product [id=" + id + ", name=" + name + ", price=" + price + "]";
47     }
48 }

②创建订单持久化类：src/com/itheima/po/Orders.java

 1 package com.itheima.po;
 2 
 3 import java.util.List;
 4 
 5 /**
 6  * 订单持久化类
 7  */
 8 public class Orders {
 9     private Integer id;    //订单id
10     private String number; //订单编号
11     
12     //关联商品集合信息
13     private List<Product> productList; // 一个订单可以包含多个商品，即一对多
14 
15     
16     public Integer getId() {
17         return id;
18     }
19     
20     public void setId(Integer id) {
21         this.id = id;
22     }
23     
24     public String getNumber() {
25         return number;
26     }
27     
28     public void setNumber(String number) {
29         this.number = number;
30     }
31     
32     
33     public List<Product> getProductList() {
34         return productList;
35     }
36     
37     public void setProductList(List<Product> productList) {
38         this.productList = productList;
39     }
40     
41     @Override
42     public String toString() {
43         return "Orders [id=" + id + ", number=" + number + ", productList=" + productList + "]";
44     }
45 }

③创建订单实体映射文件：src/com/itheima/mapper/OrdersMapper.xml

 1 <?xml version="1.0" encoding="UTF-8"?>
 2 <!DOCTYPE mapper PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN" 
 3                   "http://mybatis.org/dtd/mybatis-3-mapper.dtd">
 4    
 5 <mapper namespace="com.itheima.mapper.OrdersMapper">
 6     
 7     <!-- 多对多嵌套查询：通过执行另外一条SQL映射语句来返回预期的特殊类型，查询订单id中的商品信息 -->
 8     <select id="findOrdersWithPorduct" parameterType="Integer" 
 9               resultMap="OrdersWithProductResultID">
10         select * from tb_orders WHERE id=#{id}    
11     </select>
12     
13     <resultMap type="Orders" id="OrdersWithProductResultID">
14     
15         <id property="id" column="id" />
16         <result property="number" column="number" />
17         
18         <!-- 使用<collection>来映射多对多的关系关联
19             property属性表示订单持久化类Orders中的商品属性productList，
20             ofType表示集合productList中数据类型为Product，
21             column属性值会作为参数执行ProductMapper中定义的id为findProductById的执行语句来查询订单中的商品信息。
22          -->
23         <collection property="productList" column="id" ofType="Product" 
24              select="com.itheima.mapper.ProductMapper.findProductById">
25         </collection>
26     </resultMap>
27     
28     <!-- 多对多嵌套结果查询：查询某订单及其关联的商品详情 -->
29     <select id="findOrdersWithPorduct2" parameterType="Integer" 
30              resultMap="OrdersWithPorductResult2ID">
31         select o.*,p.id as pid,p.name,p.price
32         from tb_orders o,tb_product p,tb_ordersitem oi
33         WHERE oi.orders_id=o.id 
34         and oi.product_id=p.id 
35         and o.id=#{id}
36     </select>
37     
38     <!-- 自定义手动映射类型 -->
39     <resultMap type="Orders" id="OrdersWithPorductResult2ID">
40     
41         <id property="id" column="id" />
42         <result property="number" column="number" />
43         
44         <!-- 多对多关联映射：collection -->
45         <collection property="productList" ofType="Product">
46         
47             <id property="id" column="pid" />
48             <result property="name" column="name" />
49             <result property="price" column="price" />
50         </collection>
51     </resultMap>
52     
53 </mapper>

④创建商品映射文件：src/com/itheima/mapper/ProductMapper.xml

 1 <?xml version="1.0" encoding="UTF-8"?>
 2 <!DOCTYPE mapper PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN"
 3                  "http://mybatis.org/dtd/mybatis-3-mapper.dtd">
 4                  
 5 <mapper namespace="com.itheima.mapper.ProductMapper">
 6 
 7     <select id="findProductById" parameterType="Integer" 
 8                resultType="Product">
 9         SELECT * from tb_product where id IN (
10            SELECT product_id FROM tb_ordersitem  WHERE orders_id = #{id}
11            <!-- tb_ordersitem为中间表，通过中间表的orders_id和订单中的id进行匹配找商品id
12                    找订单编号id中所有商品的id值
13             -->
14         )
15     </select>
16 </mapper>

⑤多对多关联查询测试：

 1     /**
 2      * 多对多
 3      */
 4     @Test
 5     public void findOrdersTest(){
 6         
 7         // 1、通过工具类生成SqlSession对象
 8         SqlSession session = MybatisUtils.getSession();
 9         
10         // 2、查询id为1的订单中的商品信息
11         Orders orders = session.selectOne("com.itheima.mapper.OrdersMapper.findOrdersWithPorduct", 1);
12         
13         // 3、输出查询结果信息
14         System.out.println(orders);
15         
16         // 4、关闭SqlSession
17         session.close();
18     }

⑥执行结果：

个人总结：

Mybatis的关联映射很好地模拟了数据库多表查询，感觉很方便，初学还不太熟悉，应该多操作，多理解！

posted @ 2019-04-06 15:57 霜雪千年阅读(944) 评论(0) 编辑收藏举报

刷新页面返回顶部

霜雪千年

A thousand miles begins with a single step.