【mybatis之关联关系】

最新推荐文章于 2022-06-21 19:11:46 发布

原创最新推荐文章于 2022-06-21 19:11:46 发布 · 629 阅读

CC 4.0 BY-SA版权

本文介绍了mybatis中关联关系的三种方式：一对一、一对多和多对多。通过OrderVo和OrderItemVo示例解释了一对多关系的配置，包括在OrderMapper和OrderItemMapper.xml中的映射设置，以及服务层和测试的实现。对于多对多关系，涉及到了t_hibernate_book、t_hibernate_book_category和t_hibernate_category三个表，中间表t_hibernate_book_category的配置，并展示了服务和测试的编写。

mybatis之关联关系的三种关联方式

数据库表的关联关系有三种，一对一，一对多，多对多
一对一   是通过在任意一方的主键，引入对方主键作为外键来实现的，就是说主键与外键为同一字段
一对多   是通过在“多”的一方，添加“一”的一方的主键作为外键
多对多   是通过一张中间关系表，引入两张表的主键作为外键，两个主键成为联合主键或使用新的字段作为主键

*在java类中关联关系也有三种，一对一，一对多，多对多
一对一   在本类中定义对方类型的对象,如A类中定义B类类型的属性b,B类中定义A类类型的属性a
一对多   一个A类类型对应多个B类类型的情况,需要在A类中以集合的方式引入B类类型的对象,在B类中定义A类类型的属性a
多对多   在A类中定义B类类型的集合,在B类中定义A类类型的集合

下文大致思路如下

1.将数据表导入数据库中

2.通过mybatis-generator插件生成dao、mapper、model

   1）配置mybatis-generator插件生成文件位置
   2）修改generatorConfig.xml配置文件的生成目录(mapper和model)及对应生成关系

3.修改Customer、Order实体类
   1）实现序列化接口
   2）建立实体映射关联关系（一对多、多对一）
   #一对多：一个客户对应多个订单
   private List<Order> orders=new ArrayList<Order>();

   #多对一：多个订单对应一个客户（一个订单对应一个客户）
   private Customer customer;

一对多关联关系

OrderVo

package com.xyx.model;

public class Order {
    private Integer orderId;

    private String orderNo;

    public Order(Integer orderId, String orderNo) {
        this.orderId = orderId;
        this.orderNo = orderNo;
    }


    @Override
    public String toString() {
        return "Order{" +
                "orderId=" + orderId +
                ", orderNo='" + orderNo + '\'' +
                '}';
    }

    public Order() {
        super();
    }

    public Integer getOrderId() {
        return orderId;
    }

    public void setOrderId(Integer orderId) {
        this.orderId = orderId;
    }

    public String getOrderNo() {
        return orderNo;
    }

    public void setOrderNo(String orderNo) {
        this.orderNo = orderNo;
    }
}

OrderItemVo

package com.xyx.model.vo;

import com.xyx.model.Order;
import com.xyx.model.OrderItem;

public class OrderItemVo extends OrderItem {

    private Order order;

    public Order getOrder() {
        return order;
    }

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

然后再Mapper中写一个查询订单的方法
OrderMapper

package com.xyx.mapper;

import com.xyx.model.Order;
import com.xyx.model.vo.OrderVo;
import org.apache.ibatis.annotations.Param;
import org.springframework.stereotype.Repository;

@Repository
public interface OrderMapper {
    int deleteByPrimaryKey(Integer orderId);

    int insert(Order record);

    int insertSelective(Order record);

    Order selectByPrimaryKey(Integer orderId);

    int updateByPrimaryKeySelective(Order record);

    int updateByPrimaryKey(Order record);

    OrderVo selectByOid(@Param("oid") Integer oid);

}

先在rderMapper.xml中配置好一对多关联关系的映射

<?xml version="1.0" encoding="UTF-8" ?>
<!DOCTYPE mapper PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN" "http://mybatis.org/dtd/mybatis-3-mapper.dtd" >
<mapper namespace="com.xyx.mapper.OrderMapper" >
  <resultMap id="BaseResultMap" type="com.xyx.model.Order" >
    <constructor >
      <idArg column="order_id" jdbcType="INTEGER" javaType="java.lang.Integer" />
      <arg column="order_no" jdbcType="VARCHAR" javaType="java.lang.String" />
    </constructor>
  </resultMap>

<!-- 描述一对多 -->
  <resultMap id="OrderVoMap" type="com.xyx.model.vo.OrderVo" >
    <result property="orderId" column="order_id"></result>
    <result property="orderNo" column="order_no"></result>
    <collection property="orderItems" ofType="com.xyx.model.OrderItem">
      <result property="orderItemId" column="order_item_id"></result>
      <result property="productId" column="product_id"></result>
      <result property="quantity" column="quantity"></result>
      <result property="oid" column="oid"></result>
    </collection>
  </resultMap>

  <sql id="Base_Column_List" >
    order_id, order_no
  </sql>
  <select id="selectByPrimaryKey" resultMap="BaseResultMap" parameterType="java.lang.Integer" >
    select 
    <include refid="Base_Column_List" />
    from t_hibernate_order
    where order_id = #{orderId,jdbcType=INTEGER}
  </select>
  <select id="selectByOid" 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 = #{oid}
  </select>
  <delete id="deleteByPrimaryKey" parameterType="java.lang.Integer" >
    delete from t_hibernate_order
    where order_id = #{orderId,jdbcType=INTEGER}
  </delete>
  <insert id="insert" parameterType="com.xyx.model.Order" >
    insert into t_hibernate_order (order_id, order_no)
    values (#{orderId,jdbcType=INTEGER}, #{orderNo,jdbcType=VARCHAR})
  </insert>
  <insert id="insertSelective" parameterType="com.xyx.model.Order" >
    insert into t_hibernate_order
    <trim prefix="(" suffix=")" suffixOverrides="," >
      <if test="orderId != null" >
        order_id,
      </if>
      <if test="orderNo != null" >
        order_no,
      </if>
    </trim>
    <trim prefix="values (" suffix=")" suffixOverrides="," >
      <if test="orderId != null" >
        #{orderId,jdbcType=INTEGER},
      </if>
      <if test="orderNo != null" >
        #{orderNo,jdbcType=VARCHAR},
      </if>
    </trim>
  </insert>
  <update id="updateByPrimaryKeySelective" parameterType="com.xyx.model.Order" >
    update t_hibernate_order
    <set >
      <if test="orderNo != null" >
        order_no = #{orderNo,jdbcType=VARCHAR},
      </if>
    </set>
    where order_id = #{orderId,jdbcType=INTEGER}
  </update>
  <update id="updateByPrimaryKey" parameterType="com.xyx.model.Order" >
    update t_hibernate_order
    set order_no = #{orderNo,jdbcType=VARCHAR}
    where order_id = #{orderId,jdbcType=INTEGER}
  </update>
</mapper>

然后在OrderItemMapper.xml中配置好多个订单项对应一个订单的关系

<?xml version="1.0" encoding="UTF-8" ?>
<!DOCTYPE mapper PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN" "http://mybatis.org/dtd/mybatis-3-mapper.dtd" >
<mapper namespace="com.xyx.mapper.OrderItemMapper" >
  <resultMap id="BaseResultMap" type="com.xyx.model.OrderItem" >
    <constructor >
      <idArg column="order_item_id" jdbcType="INTEGER" javaType="java.lang.Integer" />
      <arg column="product_id" jdbcType="INTEGER" javaType="java.lang.Integer" />
      <arg column="quantity" jdbcType="INTEGER" javaType="java.lang.Integer" />
      <arg column="oid" jdbcType="INTEGER" javaType="java.lang.Integer" />
    </constructor>
  </resultMap>

  <!-- 描述一对多 -->
  <resultMap id="OrderItemVoMap" type="com.xyx.model.vo.OrderItemVo" >
    <result property="orderItemId" column="order_item_id"></result>
    <result property="productId" column="product_id"></result>
    <result property="quantity" column="quantity"></result>
    <result property="oid" column="oid"></result>
    <association property="order" javaType="com.xyx.model.Order">
      <result property="orderId" column="order_id"></result>
      <result property="orderNo" column="order_no"></result>
    </association>
  </resultMap>

  <sql id="Base_Column_List" >
    order_item_id, product_id, quantity, oid
  </sql>
  <select id="selectByPrimaryKey" resultMap="BaseResultMap" parameterType="java.lang.Integer" >
    select 
    <include refid="Base_Column_List" />
    from t_hibernate_order_item
    where order_item_id = #{orderItemId,jdbcType=INTEGER}
  </select>
  <select id="selectByIrderItemId" resultMap="OrderItemVoMap" 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>
  <delete id="deleteByPrimaryKey" parameterType="java.lang.Integer" >
    delete from t_hibernate_order_item
    where order_item_id = #{orderItemId,jdbcType=INTEGER}
  </delete>
  <insert id="insert" parameterType="com.xyx.model.OrderItem" >
    insert into t_hibernate_order_item (order_item_id, product_id, quantity, 
      oid)
    values (#{orderItemId,jdbcType=INTEGER}, #{productId,jdbcType=INTEGER}, #{quantity,jdbcType=INTEGER}, 
      #{oid,jdbcType=INTEGER})
  </insert>
  <insert id="insertSelective" parameterType="com.xyx.model.OrderItem" >
    insert into t_hibernate_order_item
    <trim prefix="(" suffix=")" suffixOverrides="," >
      <if test="orderItemId != null" >
        order_item_id,
      </if>
      <if test="productId != null" >
        product_id,
      </if>
      <if test="quantity != null" >
        quantity,
      </if>
      <if test="oid != null" >
        oid,
      </if>
    </trim>
    <trim prefix="values (" suffix=")" suffixOverrides="," >
      <if test="orderItemId != null" >
        #{orderItemId,jdbcType=INTEGER},
      </if>
      <if test="productId != null" >
        #{productId,jdbcType=INTEGER},
      </if>
      <if test="quantity != null" >
        #{quantity,jdbcType=INTEGER},
      </if>
      <if test="oid != null" >
        #{oid,jdbcType=INTEGER},
      </if>
    </trim>
  </insert>
  <update id="updateByPrimaryKeySelective" parameterType="com.xyx.model.OrderItem" >
    update t_hibernate_order_item
    <set >
      <if test="productId != null" >
        product_id = #{productId,jdbcType=INTEGER},
      </if>
      <if test="quantity != null" >
        quantity = #{quantity,jdbcType=INTEGER},
      </if>
      <if test="oid != null" >
        oid = #{oid,jdbcType=INTEGER},
      </if>
    </set>
    where order_item_id = #{orderItemId,jdbcType=INTEGER}
  </update>
  <update id="updateByPrimaryKey" parameterType="com.xyx.model.OrderItem" >
    update t_hibernate_order_item
    set product_id = #{productId,jdbcType=INTEGER},
      quantity = #{quantity,jdbcType=INTEGER},
      oid = #{oid,jdbcType=INTEGER}
    where order_item_id = #{orderItemId,jdbcType=INTEGER}
  </update>
</mapper>

在这里我们需要写好service测试
OneToManyService

package com.xyx.service;

import com.xyx.model.vo.OrderItemVo;
import com.xyx.model.vo.OrderVo;


public interface OneToManyService {

    OrderVo selectByOid(Integer oid);
    OrderItemVo selectByOrderItemId(Integer orderItemId);

}

OneToManyServiceImpl

package com.xyx.service.impl;

import com.xyx.mapper.OrderItemMapper;
import com.xyx.mapper.OrderMapper;
import com.xyx.model.vo.OrderItemVo;
import com.xyx.model.vo.OrderVo;
import com.xyx.service.OneToManyService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;


@Service
public class OneToManyServiceImpl implements OneToManyService {
    @Autowired
    private OrderMapper orderMapper;
    @Autowired
    private OrderItemMapper orderItemMapper;

    @Override
    public OrderVo selectByOid(Integer oid) {
        return orderMapper.selectByOid(oid);
    }

    @Override
    public OrderItemVo selectByOrderItemId(Integer orderItemId) {
        return orderItemMapper.selectByIrderItemId(orderItemId);
    }
}

测试

package com.xyx.service;

import com.xyx.SpringBaseTest;
import com.xyx.model.OrderItem;
import com.xyx.model.vo.OrderVo;
import org.junit.Test;
import org.springframework.beans.factory.annotation.Autowired;


public class OneToManyServiceImplTest extends SpringBaseTest {
    @Autowired
    private  OneToManyService oneToManyService;

    @Test
    public void selectByOid() {
        OrderVo orderVo = oneToManyService.selectByOid(1);
        System.out.println(orderVo);
        for (OrderItem item : orderVo.getOrderItems()) {
            System.out.println(item);
        }
    }

}

查询结果
在这里插入图片描述

多对多关联关系

在这里多对多的关系就是两个一对多在，这里我们需要三个表，t_hibernate_book、t_hibernate_book_category、t_hibernate_category
其中t_hibernate_book_category中间表我们一般把自己写的多表查的其他sql语句放进中间表中的mapper中

HbookVo

package com.xyx.model.vo;

import com.xyx.model.Category;
import com.xyx.model.Hbook;

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


public class HbookVo extends Hbook {

    private List categorys = new ArrayList<Category>();

    public List getCategorys() {
        return categorys;
    }

    public void setCategorys(List categorys) {
        this.categorys = categorys;
    }


}

CategoryVo

package com.xyx.model.vo;

import com.xyx.model.Category;
import com.xyx.model.Hbook;

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


public class CategoryVo extends Category {
    private List<Hbook> hbooks = new ArrayList<>();

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

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

中间表配置文件，HbookCategoryMapper.xml 这个表基本不改

<?xml version="1.0" encoding="UTF-8" ?>
<!DOCTYPE mapper PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN" "http://mybatis.org/dtd/mybatis-3-mapper.dtd" >
<mapper namespace="com.xyx.mapper.HbookCategoryMapper" >
  <resultMap id="BaseResultMap" type="com.xyx.model.HbookCategory" >
    <constructor >
      <idArg column="category_id" jdbcType="INTEGER" javaType="java.lang.Integer" />
      <arg column="category_name" jdbcType="VARCHAR" javaType="java.lang.String" />
    </constructor>
  </resultMap>

  <!--多对多：多个一对多-->
  <!-- 描述一对多 -->
  <resultMap id="HbookVoMap" type="com.xyx.model.vo.HbookVo" >
    <result property="bookId" column="book_id"></result>
    <result property="bookName" column="book_name"></result>
    <result property="price" column="price"></result>
    <collection property="categorys" ofType="com.xyx.model.Category">
      <result property="categoryId" column="category_id"></result>
      <result property="categoryName" column="category_name"></result>
    </collection>
  </resultMap>

  <!-- 描述一对多 -->
  <resultMap id="CategoryVoMap" type="com.xyx.model.vo.CategoryVo" >
    <result property="categoryId" column="category_id"></result>
    <result property="categoryName" column="category_name"></result>
    <collection property="hbooks" ofType="com.xyx.model.Hbook">
      <result property="bookId" column="book_id"></result>
      <result property="bookName" column="book_name"></result>
      <result property="price" column="price"></result>
    </collection>
  </resultMap>

  <sql id="Base_Column_List" >
    category_id, category_name
  </sql>
  <select id="selectByPrimaryKey" resultMap="BaseResultMap" parameterType="java.lang.Integer" >
    select 
    <include refid="Base_Column_List" />
    from t_hibernate_category
    where category_id = #{categoryId,jdbcType=INTEGER}
  </select>
  <select id="queryByBid" 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">
    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>
  <delete id="deleteByPrimaryKey" parameterType="java.lang.Integer" >
    delete from t_hibernate_category
    where category_id = #{categoryId,jdbcType=INTEGER}
  </delete>
  <insert id="insert" parameterType="com.xyx.model.HbookCategory" >
    insert into t_hibernate_category (category_id, category_name)
    values (#{categoryId,jdbcType=INTEGER}, #{categoryName,jdbcType=VARCHAR})
  </insert>
  <insert id="insertSelective" parameterType="com.xyx.model.HbookCategory" >
    insert into t_hibernate_category
    <trim prefix="(" suffix=")" suffixOverrides="," >
      <if test="categoryId != null" >
        category_id,
      </if>
      <if test="categoryName != null" >
        category_name,
      </if>
    </trim>
    <trim prefix="values (" suffix=")" suffixOverrides="," >
      <if test="categoryId != null" >
        #{categoryId,jdbcType=INTEGER},
      </if>
      <if test="categoryName != null" >
        #{categoryName,jdbcType=VARCHAR},
      </if>
    </trim>
  </insert>
  <update id="updateByPrimaryKeySelective" parameterType="com.xyx.model.HbookCategory" >
    update t_hibernate_category
    <set >
      <if test="categoryName != null" >
        category_name = #{categoryName,jdbcType=VARCHAR},
      </if>
    </set>
    where category_id = #{categoryId,jdbcType=INTEGER}
  </update>
  <update id="updateByPrimaryKey" parameterType="com.xyx.model.HbookCategory" >
    update t_hibernate_category
    set category_name = #{categoryName,jdbcType=VARCHAR}
    where category_id = #{categoryId,jdbcType=INTEGER}
  </update>
</mapper>

HbookCategoryService

package com.xyx.service;

import com.xyx.model.vo.CategoryVo;
import com.xyx.model.vo.HbookVo;


public interface HbookCategoryService {

    HbookVo queryByBid(Integer bid);

    CategoryVo queryByCid( Integer cid);
}

HbookCategoryServiceImpl

package com.xyx.service.impl;

import com.xyx.mapper.HbookCategoryMapper;
import com.xyx.model.vo.CategoryVo;
import com.xyx.model.vo.HbookVo;
import com.xyx.service.HbookCategoryService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;

@Service
public class HbookCategoryServiceImpl implements HbookCategoryService {
    @Autowired
    private HbookCategoryMapper hbookCategoryMapper;

    @Override
    public HbookVo queryByBid(Integer bid) {
        return hbookCategoryMapper.queryByBid(bid);
    }

    @Override
    public CategoryVo queryByCid(Integer cid) {
        return hbookCategoryMapper.queryByCid(cid);
    }
}

测试HbookCategoryServiceImplTest

package com.xyx.service.impl;

import com.xyx.SpringBaseTest;
import com.xyx.model.Hbook;
import com.xyx.model.vo.CategoryVo;
import com.xyx.model.vo.HbookVo;
import com.xyx.service.HbookCategoryService;
import org.junit.Test;
import org.springframework.beans.factory.annotation.Autowired;

public class HbookCategoryServiceImplTest extends SpringBaseTest {
    @Autowired
    private HbookCategoryService hbookCategoryService;

    @Test
    public void queryByBid() {
        HbookVo hbookVo = hbookCategoryService.queryByBid(1);
        System.out.println(hbookVo);
        for (Object category : hbookVo.getCategorys()) {
            System.out.println(category);
        }
    }

    @Test
    public void queryByCid() {
        CategoryVo categoryVo = hbookCategoryService.queryByCid(1);
        System.out.println(categoryVo);
        for (Hbook hbook : categoryVo.getHbooks()) {
            System.out.println(hbook);
        }
    }
}

在这里插入图片描述