Mybatis之关联关系映射

已于 2023-04-06 11:12:08 修改
阅读量1.3k 收藏 1
点赞数 1
分类专栏： Mybatis以及Mybatis-Plus 文章标签： spring java 后端
于 2021-12-17 19:08:30 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_53151031/article/details/121989802
版权

目录

一、一对多

          1、Mybatis的关联关系和Hibernate的关联关系大同小异。

          2、关于一对多的关系：

          3、关于Mybatis一对多的关系配置步骤：（以Order和OrderItem为例） 

               3.1：先将对应的表建立好，并且用代码生成器生成对应的mapper和model（注意不要生成重复的mapper和model）

               3.2：在对应的orderMpper.xml和orderItemMpper.xml中配置resultMap节点以及对应的方法：

               3.3:在对应的OrderMapper.java和OrderItemsMapper.java中配置出对应的方法：

               3.4:之后到service层中接口和实现类中写好方法：

               3.5:之后配置两个表之间的关系，建立vo类：

               3.6:建立实体类：

二、多对多

           1、多对多关系就是和一对多的关系的大同小异，只是多对多的关系可以看成两个一对多关系。

           2、多对多关系的配置的步骤和一对多关系配置是一样的：（以书籍表、类别表以及书籍类别表为例）

                 2.1:首先先用逆向生成工具生成t_hibernate_book、t_hibernate_book_category、t_hibernate_category，这两张表对应的model与mapper

                 2.2在对应的HbookCategoryMapper.xml配置resultMap节点以及对应的方法：（为什么只在HbookCategoryMapper.xml中进行配置，因为只是一个中间表，可以起到一个连接的动作）：

               2.3:在对应的HbookCategoryMapper.java文件中写好方法：

               2.4之后到service层中接口和实现类中写好方法

               2.5:之后配置两个表之间的关系，建立vo类：

               2.6：编写测试类:

三、总结：

一、一对多

          1、Mybatis的关联关系和Hibernate的关联关系大同小异。

               mybatis的Hibernate的不同就在于Hibernate代码是自动生成的，而Mybatis的代码可以手动写，可以手动改变。

          2、关于一对多的关系：

先来回归一下Hibernate中关联关系：在Hibernate中，一对多和多对多的关系处理如下：

1、一对多：（以订单表和订单详情表为例）

           一方order类，

               定义一个引用对象list<orderItems>  orderItems

               order.hbm.xml配置：

                                 one-to-many id=“orderItems”

                                  配置多方的实体类路径

           多方orderItem类：

               定义一个引用对象list<order>  order

                orderItem.hbm.xml配置：

                       many-to-one id=“order”

                        配置一方的实体类路径

2、多对多：（以书籍表和类别表为例，其中书籍类别表为中间表） 

                       1方Book：

               定义一个引用对象list<category>  categorys

               book.hbm.xml配置：

                                 many -to-many id=“categorys”

                                  配置多方的实体类路径

                       1方category：

               定义一个引用对象list<book>  books

                category.hbm.xml配置：

                       many-to-manyid=“books”

                        配置一方的实体类路径

                                               

          3、关于Mybatis一对多的关系配置步骤：（以Order和OrderItem为例） 

               3.1：先将对应的表建立好，并且用代码生成器生成对应的mapper和model（注意不要生成重复的mapper和model）

 <table schema="" tableName="t_hibernate_order" domainObjectName="Order"
               enableCountByExample="false" enableDeleteByExample="false"
               enableSelectByExample="false" enableUpdateByExample="false">
            <!-- 忽略列，不生成bean 字段 -->
            <!-- <ignoreColumn column="FRED" /> -->
            <!-- 指定列的java数据类型 -->
            <!-- <columnOverride column="LONG_VARCHAR_FIELD" jdbcType="VARCHAR" /> -->
        </table>

        <table schema="" tableName="t_hibernate_order_item" domainObjectName="OrderItem"
               enableCountByExample="false" enableDeleteByExample="false"
               enableSelectByExample="false" enableUpdateByExample="false">
            <!-- 忽略列，不生成bean 字段 -->
            <!-- <ignoreColumn column="FRED" /> -->
            <!-- 指定列的java数据类型 -->
            <!-- <columnOverride column="LONG_VARCHAR_FIELD" jdbcType="VARCHAR" /> -->
        </table>

               3.2：在对应的orderMpper.xml和orderItemMpper.xml中配置resultMap节点以及对应的方法：

orderMpper.xml：

<resultMap id="OrderVoMap" type="com.javaxl.ssm.model.vo.OrderVo" >
  <result property="orderId" column="order_id"></result>
  <result property="orderNo" column="order_no"></result>
  <collection property="orderItems" ofType="com.javaxl.ssm.model.OrderItem">
    <result property="orderItemId" column="order_item_id"></result>
    <result property="oid" column="oid"></result>
    <result property="productId" column="product_id"></result>
    <result property="quantity" column="quantity"></result>
  </collection>
</resultMap>

<select id="queryOrderVoByOrderId" resultMap="OrderVoMap" parameterType="java.lang.Integer">
   select * from t_hibernate_order o,t_hibernate_order_item oi
    where o.order_id = oi.oid
    and o.order_id = #{orderId}
</select>

orderItemMpper.xml：

<resultMap id="OrderVoMap" type="com.javaxl.ssm.model.vo.OrderItemVo" >
  <result property="orderItemId" column="order_item_id"></result>
  <result property="oid" column="oid"></result>
  <result property="productId" column="product_id"></result>
  <result property="quantity" column="quantity"></result>
  <association property="order" javaType="com.javaxl.ssm.model.Order">
    <result property="orderId" column="order_id"></result>
    <result property="orderNo" column="order_no"></result>
  </association>
</resultMap>

<select id="queryOrderItemVoByOrderItemId" resultMap="OrderVoMap" parameterType="java.lang.Integer">
   select * from t_hibernate_order o,t_hibernate_order_item oi
    where o.order_id = oi.oid
    and oi.order_item_id = #{orderItemId}
</select>

               3.3:在对应的OrderMapper.java和OrderItemsMapper.java中配置出对应的方法：

OrderMapper.java：

    OrderVo queryOrderVoByOrderId(@Param("orderId") Integer orderId);

OrderItemsMapper.java：

    OrderItemVo queryOrderItemVoByOrderItemId(@Param("orderItemId") Integer orderItemId);

               3.4:之后到service层中接口和实现类中写好方法：

One2ManyService.java：

package com.zj.www.service;

import com.zj.www.vo.OrderItemVo;
import com.zj.www.vo.OrderVo;

public interface One2ManyService {
    OrderVo queryOrderVoByOrderId(Integer orderId);
    OrderItemVo queryOrderItemVoByOrderItemId(Integer OrderItemId);
}

One2ManyServiceImpl：
package com.zj.www.service.impl;

import com.zj.www.mapper.OrderItemMapper;
import com.zj.www.mapper.OrderMapper;
import com.zj.www.service.One2ManyService;
import com.zj.www.vo.OrderItemVo;
import com.zj.www.vo.OrderVo;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;


@Service
public class One2ManyServiceImpl implements One2ManyService {
    @Autowired
    private OrderMapper orderMapper;

    @Autowired
    private OrderItemMapper orderItemMapper;



    @Override
    public OrderVo queryOrderVoByOrderId(Integer orderId) {
        return orderMapper.queryOrderVoByOrderId(orderId);
    }

    @Override
    public OrderItemVo queryOrderItemVoByOrderItemId(Integer OrderItemId) {
        return orderItemMapper.queryOrderItemVoByOrderItemId(OrderItemId);
    }
}

               3.5:之后配置两个表之间的关系，建立vo类：

两个表之间的关系：

             1、一个订单有多个订单详情表

             2、一个订单详情只有一个订单

ordervo：

package com.zj.www.vo;

import com.zj.www.model.Order;
import com.zj.www.model.OrderItem;

import java.util.ArrayList;
import java.util.List;

public class OrderVo extends Order {
    private List<OrderItem> orderItems = new ArrayList<>();

    public List<OrderItem> getOrderItems() {
        return orderItems;
    }

    public void setOrderItems(List<OrderItem> orderItems) {
        this.orderItems = orderItems;
    }


    @Override
    public String toString() {
        return "OrderVo{" +
                "orderItems=" + orderItems +
                '}';
    }
}

orderItemVo：

package com.zj.www.vo;

import com.zj.www.model.Order;
import com.zj.www.model.OrderItem;

public class OrderItemVo extends OrderItem {
    private Order order;

    public Order getOrder() {
        return order;
    }

    public void setOrder(Order order) {
        this.order = order;
    }


    @Override
    public String toString() {
        return "OrderItemVo{" +
                "order=" + order +
                '}';
    }
}

               3.6:建立实体类：

One2ManyService：
package com.zj.www.service.impl;

import com.zj.www.model.OrderItem;
import com.zj.www.service.One2ManyService;
import com.zj.www.vo.OrderItemVo;
import com.zj.www.vo.OrderVo;
import junit.framework.TestCase;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.test.context.ContextConfiguration;
import org.springframework.test.context.junit4.SpringJUnit4ClassRunner;

@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration(locations={"classpath:applicationContext.xml"})
public class One2ManyServiceImplTest extends TestCase {

    @Autowired
    private One2ManyService one2ManyService;

    @Test
    public void queryOrderVoByOrderId() {
        OrderVo orderVo = this.one2ManyService.queryOrderVoByOrderId(8);
        System.out.println(orderVo);
        for (OrderItem orderItem : orderVo.getOrderItems()) {
            System.out.println(orderItem);
        }
    }

    @Test
    public void queryOrderItemVoByOrderItemId() {
        OrderItemVo orderItemVo = this.one2ManyService.queryOrderItemVoByOrderItemId(49);
        System.out.println(orderItemVo);
        System.out.println(orderItemVo.getOrder());
    }
}

运行结果：

通过订单id产查找订单详情：

通过订单详情id查找对应的订单：

表结构：

订单详情表： 

订单表：

二、多对多

           1、多对多关系就是和一对多的关系的大同小异，只是多对多的关系可以看成两个一对多关系。

           2、多对多关系的配置的步骤和一对多关系配置是一样的：（以书籍表、类别表以及书籍类别表为例）

                 2.1:首先先用逆向生成工具生成t_hibernate_book、t_hibernate_book_category、t_hibernate_category，这两张表对应的model与mapper

     <table schema="" tableName="t_hibernate_book" domainObjectName="HBook"
               enableCountByExample="false" enableDeleteByExample="false"
               enableSelectByExample="false" enableUpdateByExample="false">
            <!-- 忽略列，不生成bean 字段 -->
            <!-- <ignoreColumn column="FRED" /> -->
            <!-- 指定列的java数据类型 -->
            <!-- <columnOverride column="LONG_VARCHAR_FIELD" jdbcType="VARCHAR" /> -->
        </table>


        <table schema="" tableName="t_hibernate_book_category" domainObjectName="HBookC"
               enableCountByExample="false" enableDeleteByExample="false"
               enableSelectByExample="false" enableUpdateByExample="false">
            <!-- 忽略列，不生成bean 字段 -->
            <!-- <ignoreColumn column="FRED" /> -->
            <!-- 指定列的java数据类型 -->
            <!-- <columnOverride column="LONG_VARCHAR_FIELD" jdbcType="VARCHAR" /> -->
        </table>



        <table schema="" tableName="t_hibernate_category" domainObjectName="HCate"
               enableCountByExample="false" enableDeleteByExample="false"
               enableSelectByExample="false" enableUpdateByExample="false">
            <!-- 忽略列，不生成bean 字段 -->
            <!-- <ignoreColumn column="FRED" /> -->
            <!-- 指定列的java数据类型 -->
            <!-- <columnOverride column="LONG_VARCHAR_FIELD" jdbcType="VARCHAR" /> -->
        </table>

                 2.2在对应的HbookCategoryMapper.xml配置resultMap节点以及对应的方法：（为什么只在HbookCategoryMapper.xml中进行配置，因为只是一个中间表，可以起到一个连接的动作）：

  <resultMap id="HbookVoMap" type="com.zj.www.vo.HBookVo">
    <result property="bookId" column="book_id"></result>
    <result property="bookName" column="book_name"></result>
    <collection property="categories" ofType="com.zj.www.model.HCate">
      <result property="categoryId" column="category_id"></result>
      <result property="categoryName" column="category_name"></result>
    </collection>
  </resultMap>


  <resultMap id="CategoryVoMap" type="com.zj.www.vo.HCateVo">
    <result property="categoryId" column="category_id"></result>
    <result property="categoryName" column="category_name"></result>
    <collection property="hbooks" ofType="com.zj.www.model.HBook">
      <result property="bookId" column="book_id"></result>
      <result property="bookName" column="book_name"></result>
    </collection>
  </resultMap>

 <select id="queryByBookId" resultMap="HbookVoMap" parameterType="java.lang.Integer">
    select * from t_hibernate_book b,t_hibernate_book_category bc,t_hibernate_category c
    where b.book_id = bc.bid and bc.cid = c.category_id and b.book_id = #{bookId}
  </select>
  <select id="queryByCid" resultMap="CategoryVoMap" parameterType="java.lang.Integer">
    select * from t_hibernate_book b,t_hibernate_book_category bc,t_hibernate_category c
    where b.book_id = bc.bid and bc.cid = c.category_id and c.category_id=#{cid}
  </select>

               2.3:在对应的HbookCategoryMapper.java文件中写好方法：

package com.zj.www.mapper;

import com.zj.www.model.HBookC;
import com.zj.www.vo.HBookVo;
import com.zj.www.vo.HCateVo;
import org.apache.ibatis.annotations.Param;

public interface HBookCMapper {
    int deleteByPrimaryKey(Integer bcid);

    int insert(HBookC record);

    int insertSelective(HBookC record);

    HBookC selectByPrimaryKey(Integer bcid);

    int updateByPrimaryKeySelective(HBookC record);

    int updateByPrimaryKey(HBookC record);


    HBookVo queryByBookId(@Param("bookId") Integer bookId);

    HCateVo queryByCid(@Param("cid") Integer cid);


}

               2.4之后到service层中接口和实现类中写好方法

Many2ManyService：
package com.zj.www.service;

import com.zj.www.vo.HBookVo;
import com.zj.www.vo.HCateVo;

public interface Many2ManyService {

    HBookVo queryByBookId(Integer bookId);

    HCateVo queryByCid(Integer cid);

}

Many2ManyServiceImpl：
package com.zj.www.service.impl;

import com.zj.www.mapper.HBookCMapper;
import com.zj.www.service.Many2ManyService;
import com.zj.www.vo.HBookVo;
import com.zj.www.vo.HCateVo;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;

@Service
public class Many2ManyServiceImpl implements Many2ManyService {
    @Autowired
    private HBookCMapper hBookCMapper;
    @Override
    public HBookVo queryByBookId(Integer bookId) {
        return hBookCMapper.queryByBookId(bookId);
    }

    @Override
    public HCateVo queryByCid(Integer cid) {
        return hBookCMapper.queryByCid(cid);
    }
}

               2.5:之后配置两个表之间的关系，建立vo类：

HBookVo：

package com.zj.www.vo;

import com.zj.www.model.HBook;
import com.zj.www.model.HBookC;
import com.zj.www.model.HCate;

import java.util.ArrayList;
import java.util.List;

public class HBookVo  extends HBook {


    private List<HCate> categories = new ArrayList<>();

    public List<HCate> getCategories() {
        return categories;
    }

    public void setCategories(List<HCate> categories) {
        this.categories = categories;
    }


}

HBookC：

package com.zj.www.vo;

import com.zj.www.model.HBook;
import com.zj.www.model.HCate;

import java.util.ArrayList;
import java.util.List;

public class HCateVo extends HCate {


    private List<HBook> hbooks = new ArrayList<>();

    public List<HBook> getHbooks() {
        return hbooks;
    }

    public void setHbooks(List<HBook> hbooks) {
        this.hbooks = hbooks;
    }


    @Override
    public String toString() {
        return "HCateVo{" +
                "hbooks=" + hbooks +
                '}';
    }
}

               2.6：编写测试类:

package com.zj.www.service.impl;

import com.zj.www.model.HBook;
import com.zj.www.model.HCate;
import com.zj.www.service.Many2ManyService;
import com.zj.www.vo.HBookVo;
import com.zj.www.vo.HCateVo;
import junit.framework.TestCase;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.test.context.ContextConfiguration;
import org.springframework.test.context.junit4.SpringJUnit4ClassRunner;

@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration(locations={"classpath:applicationContext.xml"})
public class Many2ManyServiceImplTest extends TestCase {

    @Autowired
    private Many2ManyService many2ManyService;

    @Test
    public void queryByBookId() {
        HBookVo hbookVo = many2ManyService.queryByBookId(8);
        System.out.println(hbookVo);
        for (HCate category : hbookVo.getCategories()) {
            System.out.println(category);
        }
    }

    @Test
    public void queryByCid() {
        HCateVo categoryVo = many2ManyService.queryByCid(8);
        System.out.println(categoryVo);
        for (HBook hbook : categoryVo.getHbooks()) {
            System.out.println(hbook);
        }

    }
}

运行结果：

1、通过书籍id找出对应的类别名称：

 sql语句：

select * from t_hibernate_book b,t_hibernate_book_category bc,t_hibernate_category c where b.book_id = bc.bid and bc.cid = c.category_id and b.book_id = ? 

书籍表： 

书籍类别表：

类别表：

2、通过类别id查找出对应的书籍名称：

运行结果：

 sql语句： 

 select * from t_hibernate_book b,t_hibernate_book_category bc,t_hibernate_category c where b.book_id = bc.bid and bc.cid = c.category_id and c.category_id=? 

逻辑推理：

类别表： 

 书籍类别表：

书籍表：

 

三、总结：

mybatis的关联关系和Hibernate的关联关系大同小异

其中要注意的是：配置关系Vo类和在xxxMap.xml中的配置：

里面用的是collection--->oftype

<collection property="categories" ofType="com.zj.www.model.HCate">

                   association--->javaType

<association property="order" javaType="com.zj.www.model.Order">

今天的分享就到这里了，希望能够帮助到你！

落日飞行
关注
专栏目录
Mybatis 快速入门之 关联关系映射
qq_61313896的博客
07-31 2033
Mybatis 中的简单关联关系映射讲解
MyBatis的关联映射
yandao的博客
04-21 1077
结果映射（resultMap）–主要使用这两个标签association – 一个复杂类型的关联；许多结果将包装成这种类型嵌套结果映射 – 关联可以是 resultMap 元素，或是对其它结果映射的引用collection – 一个复杂类型的集合嵌套结果映射 – 集合可以是 resultMap 元素，或是对其它结果映射的引用。
Mybatis关联映射
11-07
Mybatis关联映射 Mybatis关联映射 Mybatis关联映射 Mybatis关联映射 Mybatis关联映射
Mybatis关系映射
qq_40148886的博客
02-04 120
一、一对一关系映射 使用resultType+包装类实现 　　1、假设问题背景是要求在某一个购物平台的后台程序中添加一个这样的功能：查询某个订单的信息和下该订单的用户信息。首先我们可以知道，一般这样的平台上面，某一笔订单只属于某一个用户，从这个角度来看，可以作为一对一的参考模型 　　①首先创建数据表user（用户表） CREATE TABLE `user` ( `uid...
MyBatis关联映射
专业的计算机毕业设计指南
09-04 378
1.关联映射(多表查询) 数据库中多表之间存在着三种关系，如图所示。 多对多： 程序员<------>项目 用户--------->角色 一对多: 班级----->学生 学校------>班级 帅哥----->多个女朋友 一对一: 学生----->学位证 人------>DNA 从图可以看出，系统设...
MyBatis-映射关系
爱笑的boy的博客
07-09 651
MyBatis-映射关系
MyBatis的关联映射实践报告
12-04
了解数据表之间以及对象之间的三种关联关系 2.熟悉关联关系中的嵌套查询和 嵌套结果 3.掌握一对一，一对多，和多对多关联映射作用
SpringBoot中mybatis表关联映射关系(一对多嵌套：结果方式)
07-11
SpringBoot 中 MyBatis 表关联映射关系（一对多嵌套：结果方式） 在 SpringBoot 中，MyBatis 是一个非常流行的持久层框架，它提供了强大的持久化功能，能够将 Java 对象与数据库表进行映射。在实际开发中，我们经常...
Mybatis一对多关联关系映射实现过程解析
08-25
Mybatis的一对多关联关系映射实现过程解析 Mybatis是一款基于Java的持久层框架，它提供了对数据库的操作接口，包括数据的增删改查等操作。在实际开发中，我们经常会遇到一对多关联关系映射的问题，例如用户和订单...
MyBatis关系映射
TestXzing的博客
09-04 1460
在关系映射中，MyBatis提供了一些注解和XML配置来实现对象和数据库表之间的映射关系。例如，@Table注解可以用于指定Java对象对应的数据库表，@Column注解可以用于指定Java对象属性对应的数据库字段。
Mybatis中的关系映射
ChatYU的博客
09-04 1209
在 MyBatis 中，映射关系是指数据库表和 Java 对象之间的映射配置，用于将查询结果映射到 Java 对象或将 Java 对象的属性映射到数据库表的列使用元素配置结果集的映射关系，指定数据库列和 Java 对象属性之间的映射。可以使用元素将数据库列映射到 Java 对象的属性，并指定属性的类型、映射关系及相关配置。可以使用元素配置关联对象的映射关系，用于映射复杂对象之间的关系。可以使用元素配置集合类型对象的映射关系，用于映射一对多或多对多的关系。使用
【MyBatis】关系映射
学习 - 总结 - 分享 - Francis
10-18 675
一对一映射映射关系：一个员工对应一张员工卡 说明： 根据id查询Employee信息，因为Employee中有一个关联对象Card，所以返回对象是resultMap； 通过column的card_id值作为参数执行CardMapper.selectCardById，查询到的数据封装到Card对象<mapper namespace="com.mapper.CardMapper"> <se
MyBatis系列--关系映射
qq_43404873的博客
11-19 774
关联关系概述 在关系型数据库中，多表之间存在3种关联关系，分别为一对1、一对多和多对多。 一对一：在任意一方引入对方主键作为外键。 一对多：在"多"的一方添加"一"的一方的主键作为外键。 多对多: 产生中间关系表，引入两张表的主键作为外键，两个主键成为联合主键或使用新的字段作为主键。 对象之间也存在3种关联关系. 一对一的关系: 在本类中定义对方类型的对象，比如A类中定义B类类型的属性b、在B类中定义A类类型的属性a。 一对多的关系：一个A类类型对应多个B类类型的情况，需要在A类中以集合的方法引入B类
Mybatis关联关系映射
qq_65345936的博客
08-16 487
Mybatis关联关系映射
mybatis关系关联映射
最新发布
09-13
MyBatis是一种持久化框架，它可以通过配置文件或注解来进行关系关联映射。在MyBatis中，关系关联映射主要通过以下几种方式实现： 1. 一对一关联映射：通过在对象之间定义关联关系，可以使用嵌套查询或嵌套结果映射...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值