学习Mybatis框架（五）—高级映射（多表关联查询） - 好文

本节主要对订单商品数据模型进行分析。并分析以下2个点：
高级映射：（了解）
实现一对一查询、一对多、多对多查询。
延迟加载

高级映射

订单商品数据模型

1.1 数据模型分析思路
1、每张表记录的数据内容
2、每张表重要的字段设置（非空字段、外键字段）
3、数据库级别表与表之间的关系（外键关系）
4、表与表之间的业务关系（建立在某个业务意义基础上去分析）
1.2 数据模型分析

用户表user：
记录了购买商品的用户信息

订单表：orders
记录了用户所创建的订单（购买商品的订单）

订单明细表：orderdetail：
记录了订单的详细信息即购买商品的信息

商品表：items
记录了商品信息

orders和user：
orders—>user：一个订单只由一个用户创建，一对一
user—->orders：一个用户可以创建多个订单，一对多

orders和orderdetail：
orders—>orderdetail：一个订单可以包括
多个订单明细，因为一个订单可以购买多个商品，每个商品的购买信息在orderdetail记录，一对多关系
orderdetail–> orders：一个订单明细只能包括在一个订单中，一对一

orderdetail和items：
orderdetail—>itesms：一个订单明细只对应一个商品信息，一对一
items–> orderdetail:一个商品可以包括在多个订单明细，一对多

再分析数据库级别没有关系的表之间是否有业务关系：
orders和items：
orders和items之间可以通过orderdetail表建立关系。

一对一关联映射

需求：查询订单信息，关联查询创建订单的用户信息
方式一：resultType
第一步：创建pojo—->OrdersCustom
/ * 作用：将sql查询的订单orders和用户user结果集全部成功映射到 pojo中，
但是Orders.java中属性包含不全，因此在写一个pojo类在继承Orders基础上，补充添加其它属性信息，
注意让此类继承包括字段较多的pojo类，比如这里继承Orders而不是user, 因为查询结果集中user属性全部有5个，Orders只有3个 */
package cn.itcast.mybatis.pojo; public class OrdersCustom extends Orders{
//继承Orders是为了补充添加以下用户属性 /*USER.username, USER.sex, USER.address */ private
String username;private String sex; private String address; 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 String getAddress() { return
address; }public void setAddress(String address) { this.address = address; } }
第二步：在OrdersMapperCustom.xml中添加如下sql语句

确定查询的主表：订单表
确定查询的关联表：用户表
关联查询使用内链接？还是外链接？
：由于orders表中有一个外键（user_id），通过外键关联查询用户表只能查询出一条记录，可以使用内链接。
 <select id="findOrderUser" resultType=
"cn.itcast.mybatis.pojo.OrdersCustom"> SELECT orders.* , USER.username,
USER.sex, USER.address FROM orders, USER where orders.user_id=user.id</select>
第三步：在接口OrdersMapperCustom.java中添加
//查询订单关联查询用户信息 public List<OrdersCustom>findOrderUser()throws Exception;
第四步：在OrdersMapperCustomTest.java中添加测试
@Test public void testFindOrdersUser() throws Exception { //得到会话sqlSession
SqlSession sqlSession=sqlSessionFactory.openSession();//创建代理对象
OrdersMapperCustom
ordersMapperCustom=sqlSession.getMapper(OrdersMapperCustom.class);//调用mapper的方法
List<OrdersCustom>list=ordersMapperCustom.findOrderUser();
System.out.println(list); sqlSession.close(); }
方式二：resultMap
第一步：创建pojo—->OrdersCustom（同上）
第二步：在OrdersMapperCustom.xml中添加如下配置语句
 <
resultMap type="cn.itcast.mybatis.pojo.Orders" id="OrdersUserResultMap">    <id
column="id" property="id"/> <result column="user_id" property="userId"/> <result
column="number" property="number"/> <result column="createtime" property=
"createtime"/> <result column="note" property="note"/> 
  <association
property="user" javaType="cn.itcast.mybatis.pojo.User">  <id column="user_id" property="id"/> <
result column="username" property="username"/> <result column="sex" property=
"sex"/> <result column="address" property="address"/> </association> </resultMap
>  <select id="findOrdersUserResultMap"
resultMap="OrdersUserResultMap"> SELECT orders.* , USER.username, USER.sex,
USER.address FROM orders, USER WHERE orders.user_id=user.id</select>
第三步：在接口OrdersMapperCustom.java中添加
//可查询订单关联查询用户使用resultMap public List<Orders>findOrdersUserResultMap()throws
Exception;
第四步：在OrdersMapperCustomTest.java中测试
@Test public void testFindOrdersUserResultMap() throws Exception {
//得到会话sqlSession SqlSession sqlSession=sqlSessionFactory.openSession(); //创建代理对象
OrdersMapperCustom
ordersMapperCustom=sqlSession.getMapper(OrdersMapperCustom.class);
//调用mapper的方法,返回映射在pojo 中Orders(里面补充了User user)
List<Orders>list=ordersMapperCustom.findOrdersUserResultMap();
System.out.println(list); sqlSession.close(); }
resultType和resultMap实现一对一查询小结
实现一对一查询：
resultType：使用resultType实现较为简单，如果pojo中没有包括查询出来的列名，需要增加列名对应的属性，即可完成映射。
如果没有查询结果的特殊要求建议使用resultType。

resultMap：需要单独定义resultMap，实现有点麻烦，如果对查询结果有特殊的要求，使用resultMap可以完成将关联查询映射pojo的属性中。

resultMap可以实现延迟加载，resultType无法实现延迟加载。

一对多关联映射

需求：查询订单orders关联的订单明细信息orderdetails
第一步：创建pojo—->Orders.java
//表orders public class Orders { private Integer id; private Integer userId;
private String number; private Date createtime; private String note;
//添加user用户属性信息，将关联的用户信息映射到pojo(User user)的属性中 private User user; //添加订单明细
Orderdetail的属性信息，将关联的订单明细信息映射到此order类 private List<Orderdetail>orderdetails;
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(); } //用户的getter setter方法 public User
getUser() { return user; } public void setUser(User user) { this.user = user; }
//添加订单明细的getter setter方法 public List<Orderdetail> getOrderdetails() { return
orderdetails; }public void setOrderdetails(List<Orderdetail> orderdetails) {
this.orderdetails = orderdetails; } }
使用resultType将上边的查询结果映射到pojo中，订单信息的就是重复。
对orders映射不能出现重复记录。

在orders.java类中添加List<orderDetail>orderDetails属性。
最终会将订单信息映射到orders中，订单所对应的订单明细映射到orders中的orderDetails属性中。

第二步：在OrdersMapperCustom.xml中添加如下配置语句
sql语句：
确定主查询表：订单表
确定关联查询表：订单明细表
在一对一查询基础上添加订单明细表关联即可。
 <resultMap type=
"cn.itcast.mybatis.pojo.Orders" id="OrdersAndOrderDetailResultMap" extends=
"OrdersUserResultMap">        <collection property="orderdetails" ofType=
"cn.itcast.mybatis.pojo.Orderdetail"> <id column="orderdetail_id" property="id"
/> <result column="items_id" property="itemsId"/> <result column="items_num"
property="itemsNum"/> <result column="orders_id" property="ordersId"/> </
collection> </resultMap>  <select id=
"findOrdersAndOrderDetailResultMap" resultMap="OrdersAndOrderDetailResultMap">
SELECT orders.* , USER.username, USER.sex, USER.address, orderdetail.id
orderdetail_id, orderdetail.orders_id, orderdetail.items_id,
orderdetail.items_num FROM orders, USER, orderdetail WHERE
orders.user_id=user.id AND orderdetail.orders_id=orders.id</select>
第三步：在接口OrdersMapperCustom.java中添加
//查询订单关联订单明细信息 public List<Orders>findOrdersAndOrderDetailResultMap()throws
Exception;
第四步：在OrdersMapperCustomTest.java中添加测试代码：
@Test public void testFindOrdersAndOrderDetailResultMap() throws Exception {
//得到会话sqlSession SqlSession sqlSession=sqlSessionFactory.openSession(); //创建代理对象
OrdersMapperCustom
ordersMapperCustom=sqlSession.getMapper(OrdersMapperCustom.class);
//调用mapper的方法,返回映射在pojo 中Orders(里面补充了Orderdetail orderDetails)
List<Orders>list=ordersMapperCustom.findOrdersAndOrderDetailResultMap();
System.out.println(list); sqlSession.close(); }
多对多关联映射

需求：查询用户及用户购买商品信息。

第一步：创建pojo—->User.java,Orders.java,Orderdetail.java,Items.java
映射思路:

* 将用户信息映射到user中
* 在user类中添加订单列表属性private List<Orders>orderList;，将用户创建的订单映射到ordersList
* 在Orders中添加订单明细列表属性
private List<Orderdetail>orderdetails;，将订单的明细映射到orderdetails
* 在Orderdetail中添加Items属性private Items items，将订单明细所对应的商品映射到Items
第二步：在OrdersMapperCustom.xml中添加如下配置语句
 <resultMap type="cn.itcast.mybatis.pojo.User" id=
"UserAndItemsResultMap">  <id column="user_id" property="id"
/> <result column="username" property="username"/> <result column="sex" property
="sex"/> <result column="address" property="address"/>  <collection property="orderList" ofType=
"cn.itcast.mybatis.pojo.Orders"> <id column="id" property="id"/> <result column=
"user_id" property="userId"/> <result column="number" property="number"/> <
result column="createtime" property="createtime"/> <result column="note"
property="note"/>  <collection property=
"orderdetails" ofType="cn.itcast.mybatis.pojo.Orderdetail"> <id column=
"orderdetail_id" property="id"/> <result column="items_id" property="itemsId"/>
<result column="items_num" property="itemsNum"/> <result column="orders_id"
property="ordersId"/>  <association property=
"items" javaType="cn.itcast.mybatis.pojo.Items"> <id column="items_id" property=
"id"/> <result column="items_name" property="name"/> <result column=
"items_detail" property="detail"/> <result column="items_price" property="price"
/> </association> </collection> </collection> </resultMap>  <select id="findUserAndItemsResultMap"
resultMap="UserAndItemsResultMap"> SELECT orders.*, USER.username, USER.sex,
USER.address, orderdetail.id orderdetail_id, orderdetail.items_id,
orderdetail.items_num, orderdetail.orders_id, items.name items_name,
items.detail items_detail, items.price items_price FROM orders, USER,
orderdetail, items WHERE orders.user_id = user.id AND
orderdetail.orders_id=orders.id AND orderdetail.items_id=items.id</select>
第三步：在接口OrdersMapperCustom.java中添加
//查询用户购买的商品信息 public List<User>findUserAndItemsResultMap()throws Exception;
第四步：在OrdersMapperCustomTest.java中测试
@Test public void testFindUserAndItemsResultMap() throws Exception {
//得到会话sqlSession SqlSession sqlSession=sqlSessionFactory.openSession(); //创建代理对象
OrdersMapperCustom
ordersMapperCustom=sqlSession.getMapper(OrdersMapperCustom.class);
//调用mapper的方法,返回映射在pojo 中Orders(里面补充了Orderdetail orderdetails)
List<User>list=ordersMapperCustom.findUserAndItemsResultMap();
System.out.println(list); sqlSession.close(); }
延迟加载

定义

resultMap可以实现高级映射（使用association、collection实现一对一及一对多映射），association、collection具备延迟加载功能。

延迟加载：先从单表查询、需要时再从关联表去关联查询，大大提高数据库性能，因为查询单表要比关联查询多张表速度要快。

如果查询订单并且关联查询用户信息。如果先查询订单信息即可满足要求，当我们需要查询用户信息时再查询用户信息。把对用户信息的按需去查询就是延迟加载。
验证步骤
需求：查询订单并且关联查询用户信息，使用association实现延迟加载

第0步：在SqlMapConfig.xml中开启延迟加载
mybatis默认没有开启延迟加载，需要在SqlMapConfig.xml中setting配置
<settings>   <setting name=
"lazyLoadingEnabled" value="true"/>  <setting name=
"aggressiveLazyLoading" value="false"/> </settings>
第一步：创建pojo—->Orders.java（同上一对一查询）

第二步：在OrdersMapperCustom.xml中添加如下配置语句

先去执行findOrdersUserLazyLoading，当需要去查询用户信息的时候再去执行findUserById，通过resultMap的定义将延迟加载执行配置起来。
<resultMap type="cn.itcast.mybatis.pojo.Orders" id=
"OrdersUserLazyLoadingResultMap">  <id column="id" property=
"id"/> <result column="user_id" property="userId"/> <result column="number"
property="number"/> <result column="createtime" property="createtime"/> <result
column="note" property="note"/>   <
association property="user" javaType="cn.itcast.mybatis.pojo.User" select=
"cn.itcast.mybatis.mapper.UserMapper.findUserById" column="user_id"> </
association> </resultMap> <select id="findOrdersUserLazyLoading" resultMap=
"OrdersUserLazyLoadingResultMap"> SELECT *FROM orders </select>
* 关联查询用户信息
通过上边查询到的订单信息中user_id去关联查询用户信息
使用UserMapper.xml中的findUserById <select id="findUserById" parameterType="int"
resultType="cn.itcast.mybatis.pojo.User"> SELECT*FROM USER WHERE id=#{id} </
select>
第三步：在接口OrdersMapperCustom.java中添加
//查询订单关联查询用户，用户信息是延迟加载 public List<Orders>findOrdersUserLazyLoading()throws
Exception;
第四步：测试
//实现订单查询用户，用户信息的延迟加载 @Test public void testFindOrdersUserLazyLoading() throws
Exception {//得到会话sqlSession SqlSession
sqlSession=sqlSessionFactory.openSession();//创建代理对象 OrdersMapperCustom
ordersMapperCustom=sqlSession.getMapper(OrdersMapperCustom.class);//查询订单信息（单表）
List<Orders>list=ordersMapperCustom.findOrdersUserLazyLoading();//遍历订单列表 for
(Orders orders:list){//执行Orders里面的getUser()时才去查询用户信息，这里实现按需加载了 User
user=orders.getUser(); System.out.println(user); } }
测试思路：

1、执行上边mapper方法（findOrdersUserLazyLoading），内部去调用cn.itcast.mybatis.mapper.OrdersMapperCustom中的findOrdersUserLazyLoading只查询orders信息（单表）。

2、在程序中去遍历上一步骤查询出的List<Orders>，当我们调用Orders中的getUser方法时，开始进行延迟加载。

3、延迟加载，去调用UserMapper.xml中findUserbyId这个方法获取用户信息。

热门工具换一换