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

其他 2018-07-01 20:42:13 阅读次数: 0

本节主要对订单商品数据模型进行分析。并分析以下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），通过外键关联查询用户表只能查询出一条记录，可以使用内链接。

<!-- 第一种：resultType:查询订单关联查询用户信息 -->
    <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,订单查询 关联 用户的 ,将整个查询的结果映射到cn.itcast.mybatis.pojo.Orders中-->
<resultMap type="cn.itcast.mybatis.pojo.Orders" id="OrdersUserResultMap">

<!-- (1) 配置订单信息 -->
        <!--  数据库表orders对应 pojo中的Orders.java -->
<!--  id:唯一标识
         column：订单信息的唯 一标识 列
         property：订单信息的唯 一标识 列所映射到Orders中哪个属性
      result:普通标识   -->

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

<!-- (2)配置关联用户信息 -->
      <!--   数据库表user对应 pojo中的User.java -->
<!-- association：用于映射关联查询单个对象的信息
            property：要将关联查询的用户信息映射到Orders中哪个属性
            javaType：映射到user的哪个属性-->

  <association property="user"  javaType="cn.itcast.mybatis.pojo.User">
            <!-- id：关联查询用户的唯 一标识
                   column：指定唯 一标识用户信息的列
                 result:普通标识
             -->
            <id column="user_id" property="id"/> 
            <result column="username" property="username"/>
            <result column="sex" property="sex"/>
            <result column="address" property="address"/>   
  </association> 
</resultMap>

 <!--第二种：举例一对一： 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，其中(1)(2)和上面一样，可以采用继承 -->
<resultMap type="cn.itcast.mybatis.pojo.Orders" id="OrdersAndOrderDetailResultMap"
extends="OrdersUserResultMap">
<!-- (1) 配置订单信息 -->
         <!--  数据库表orders对应 pojo中的Orders.java -->
<!-- (2) 配置关联用户信息 -->     
        <!--  数据库表user对应 pojo中的User.java -->
<!-- (3) 配置订单明细信息 -->
         <!-- 数据库表orderdetail对应 pojo中的Orderdetail.java -->

    <!-- 由于一条订单关联查询多个订单明细，因此采用collection集合映射 
    collection:将关联查询到的多条记录映射到集合对象中
    property:将关联查询到的多条记录映射到cn.itcast.mybatis.pojo.Orders中那个属性中
    ofType:指定映射到list集合属性中pojo的类型-->

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


<!--举例一对多： 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 -->
<resultMap type="cn.itcast.mybatis.pojo.User" id="UserAndItemsResultMap">
<!-- (1) 配置用户信息 --> 
        <id column="user_id" property="id"/>
        <result column="username" property="username"/>
        <result column="sex" property="sex"/>
        <result column="address" property="address"/>       
<!-- (2) 配置订单信息
        一个用户对应多个订单，使用collection映射 -->     
 <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"/>
    <!-- (3) 配置订单明细信息  
                                     一个订单包括 多个订单明细 -->       
    <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"/>        
            <!-- (4) 配置商品信息
                                                  一个订单明细对应一个商品-->
            <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>


<!-- 举例多对多：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">
<!-- (1) 配置订单信息 -->
        <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"/>
<!-- (2) 实现用户信息延迟加载 -->  
<!-- select:指定延迟加载需要执行的statement的id(是根据user_id查询用户信息的statement),
                                要使用userMapper.xml中findUserById完成根据用户id(user_id)用户信息的查询，
                                如果findUserById不在本mapper中，则需要加上所在的namespace
           <select id="findUserById" parameterType="int" resultType="cn.itcast.mybatis.pojo.User">
                SELECT*FROM USER WHERE id=#{id}
           </select>                          
     column:订单信息中关联用户信息查询的列，是user_id

             关联查询的sql理解为：子查询
     select 
           orders.*,
          (select username from user where orders.user_id=user.id)username,
          (select sex from user where orders.user_id=user.id)sex
     from 
          orders 
 -->

       <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这个方法获取用户信息。

猜你喜欢

转载自blog.csdn.net/hefenglian/article/details/80699723
今日推荐
《美国对全球网络空间安全与发展的威胁和破坏》报告发布
火速冲上 GitHub 热榜 —— 开源编程语言、框架哪有这么可爱？
北京人形机器人创新中心发布全球首个纯电驱拟人奔跑的全尺寸人形机器人“天工”
LFOSSA 源来如此公开课 | 掌握云原生未来：CNCF 认证全面攻略与备考秘籍
周排行
让自己的头脑极度开放
CentOS 6.5(x64) 和Redhat6.5操作系误删libc
高可用注册中心
【日记】12.28/【题解】AtCoder AGC041
XML（5）_XML 约束_DTD
Java集合Map（四）
树梅派安装桌面环境教程
pipenv 的 使用和安装
小程序白屏问题和内存研究
C语言简单选择排序
每日归档
更多
2024-05-02(0)
2024-05-01(4)
2024-04-30(1)
2024-04-29(40)
2024-04-28(0)
2024-04-27(56)
2024-04-26(39)
2024-04-25(22)
2024-04-24(36)
2024-04-23(26)

代码天地 © 2018 codetd.com

境外服务器   最新电视剧2022