Mybatis关联关系映射

1、一对多

首先先用逆向生成工具生成t_hibernate_order、t_hibernate_order_item
这两张表对应的model与mapper

OrderVo
 package com.yuan.model.vo;

 import com.yuan.model.Order;

 import com.yuan.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;

     }

 }


OrderItemVo




 package com.yuan.model.vo;

 import com.yuan.model.Order;

 import com.yuan.model.OrderItem;

 public class OrderItemVo extends OrderItem {

     private Order order;

     public Order getOrder() {

         return order;

     }

     public void setOrder(Order order) {

         this.order = order;

     }

 }




OrderMapper.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.yuan.mapper.OrderMapper">

     <resultMap id="BaseResultMap" type="com.yuan.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.yuan.model.vo.OrderVo">

         <result property="orderId" column="order_id"></result>

         <result property="orderNo" column="order_no"></result>

         <!--<result property="orderItems" column=""></result>-->

         <collection property="orderItems" ofType="com.yuan.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>

     <delete id="deleteByPrimaryKey" parameterType="java.lang.Integer">

     delete from t_hibernate_order

     where order_id = #{orderId,jdbcType=INTEGER}

   </delete>

     <insert id="insert" parameterType="com.yuan.model.Order">

     insert into t_hibernate_order (order_id, order_no)

     values (#{orderId,jdbcType=INTEGER}, #{orderNo,jdbcType=VARCHAR})

   </insert>

     <insert id="insertSelective" parameterType="com.yuan.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.yuan.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.yuan.model.Order">

     update t_hibernate_order

     set order_no = #{orderNo,jdbcType=VARCHAR}

     where order_id = #{orderId,jdbcType=INTEGER}

   </update>

     <!--通过一个订单id，查询出订单信息的同时，查询所有的订单项-->

     <select id="selectByOrderId" 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.oid=#{orderId}

   </select>

 </mapper>




OrderMapper.java




 package com.yuan.mapper;

 import com.yuan.model.Order;

 import com.yuan.model.vo.OrderVo;

 import org.apache.ibatis.annotations.Param;

 import org.springframework.stereotype.Repository;

 import java.util.List;

 @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);

      //通过一个订单id，查询出订单信息的同时，查询所有的订单项

     List<OrderVo> selectByOrderId(@Param("orderId") Integer orderId);

 }




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.yuan.mapper.OrderItemMapper" >

   <resultMap id="BaseResultMap" type="com.yuan.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.yuan.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>

     <collection property="order" javaType="com.yuan.model.Order">

       <result property="orderId" column="order_id"></result>

       <result property="orderNo" column="order_no"></result>

     </collection>

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

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

   <!--通过一个订单项id，查询出订单项信息的同时，查询所所属的订单-->

   <select id="selectByOrderItemId" 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>

 </mapper>




OrderItemMapper.java




 package com.yuan.mapper;

 import com.yuan.model.OrderItem;

 import com.yuan.model.vo.OrderItemVo;

 import org.apache.ibatis.annotations.Param;

 import org.springframework.stereotype.Repository;

 import java.util.List;

 @Repository

 public interface OrderItemMapper {

     int deleteByPrimaryKey(Integer orderItemId);

     int insert(OrderItem record);

     int insertSelective(OrderItem record);

     OrderItem selectByPrimaryKey(Integer orderItemId);

     int updateByPrimaryKeySelective(OrderItem record);

     int updateByPrimaryKey(OrderItem record);

     //通过一个订单项id，查询出订单项信息的同时，查询所所属的订单

     List<OrderItemVo> selectByOrderItemId(@Param("orderItemId") Integer orderItemId);

 }




Service层


OneToManyService.java




 package com.yuan.service;

 import com.yuan.model.vo.OrderItemVo;

 import com.yuan.model.vo.OrderVo;

 import org.apache.ibatis.annotations.Param;

 import java.util.List;

 public interface OneToManyService {

     //通过一个订单项id，查询出订单项信息的同时，查询所所属的订单

     List<OrderItemVo> selectByOrderItemId(Integer orderItemId);

     //通过一个订单id，查询出订单信息的同时，查询所有的订单项

     List<OrderVo> selectByOrderId( Integer orderId);

 }




Service实现类


OneToManyServiceImpl.java




 package com.yuan.service.impl;

 import com.yuan.mapper.OrderItemMapper;

 import com.yuan.mapper.OrderMapper;

 import com.yuan.model.vo.OrderItemVo;

 import com.yuan.model.vo.OrderVo;

 import com.yuan.service.OneToManyService;

 import org.springframework.beans.factory.annotation.Autowired;

 import org.springframework.stereotype.Service;

 import java.util.List;

 @Service

 public class OneToManyServiceImpl implements OneToManyService {

     @Autowired

     private OrderMapper orderMapper;

     @Autowired

     private OrderItemMapper orderItemMapper;

     @Override

     public List<OrderItemVo> selectByOrderItemId(Integer orderItemId) {

         return orderItemMapper.selectByOrderItemId(orderItemId);

     }

     @Override

     public List<OrderVo> selectByOrderId(Integer orderId) {

         return orderMapper.selectByOrderId(orderId);

     }

 }




Test测试层代码


OneToManyServiceImplTest




 package com.yuan.service.impl;

 import com.yuan.SpringBaseTest;

 import com.yuan.model.OrderItem;

 import com.yuan.model.vo.OrderItemVo;

 import com.yuan.model.vo.OrderVo;

 import com.yuan.service.OneToManyService;

 import org.junit.Test;

 import org.junit.runner.RunWith;

 import org.springframework.beans.factory.annotation.Autowired;

 import java.util.List;

 import static org.junit.Assert.*;

 public class OneToManyServiceImplTest extends SpringBaseTest {

     @Autowired

     private OneToManyService oneToManyService;

     @Test

     public void selectByOrderItemId() {

         List<OrderItemVo> orderItemVos = oneToManyService.selectByOrderItemId(36);

         OrderItemVo orderItemVo = orderItemVos.get(0);

         //此订单项的信息

         System.out.println(orderItemVo);

         //此订单项所对应的订单

         System.out.println(orderItemVo.getOrder());

     }

     @Test

     public void selectByOrderId() {

         List<OrderVo> orderVos = oneToManyService.selectByOrderId(8);

         OrderVo orderVo = orderVos.get(0);

         System.out.println(orderVo);

         System.out.println(orderVos.size());

         for (OrderItem orderItem : orderVo.getOrderItems()) {

             System.out.println(orderItem);

         }

     }

 }




测试结果






2、多对多


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


HbookVo




 package com.yuan.model.vo;

 import com.yuan.model.Category;

 import com.yuan.model.HBook;

 import java.util.ArrayList;

 import java.util.List;

 public class HbookVo extends HBook {

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

     public List<Category> getCategories() {

         return categories;

     }

     public void setCategories(List<Category> categories) {

         this.categories = categories;

     }

 }




CategoryVo




package com.yuan.model.vo;

import com.yuan.model.Category;

import com.yuan.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;

    }

}




CategoryMapper.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.yuan.mapper.CategoryMapper" >

   <resultMap id="BaseResultMap" type="com.yuan.model.Category" >

     <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="CategoryVoMap" type="com.yuan.model.vo.CategoryVo">

     <result property="categoryId" column="category_id"></result>

     <result property="categoryName" column="category_name"></result>

     <!--<result property="orderItems" column=""></result>-->

     <collection property="hBooks" ofType="com.yuan.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>

   <delete id="deleteByPrimaryKey" parameterType="java.lang.Integer" >

     delete from t_hibernate_category

     where category_id = #{categoryId,jdbcType=INTEGER}

   </delete>

   <insert id="insert" parameterType="com.yuan.model.Category" >

     insert into t_hibernate_category (category_id, category_name)

     values (#{categoryId,jdbcType=INTEGER}, #{categoryName,jdbcType=VARCHAR})

   </insert>

   <insert id="insertSelective" parameterType="com.yuan.model.Category" >

     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.yuan.model.Category" >

     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.yuan.model.Category" >

     update t_hibernate_category

     set category_name = #{categoryName,jdbcType=VARCHAR}

     where category_id = #{categoryId,jdbcType=INTEGER}

   </update>

   <!--通过一个类别的id，查询出类别信息的同时，还查询出各个类别对应的书籍-->

   <select id="selectByCid" 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>

 </mapper>




CategoryMapper




package com.yuan.mapper;

import com.yuan.model.Category;

import com.yuan.model.vo.CategoryVo;

import org.apache.ibatis.annotations.Param;

import org.springframework.stereotype.Repository;

@Repository

public interface CategoryMapper {

    int deleteByPrimaryKey(Integer categoryId);

    int insert(Category record);

    int insertSelective(Category record);

    Category selectByPrimaryKey(Integer categoryId);

    int updateByPrimaryKeySelective(Category record);

    int updateByPrimaryKey(Category record);

//    通过一个类别的id，查询出类别信息的同时，还查询出各个类别对应的书籍

    CategoryVo selectByCid(@Param("cid") Integer cid);

}




HBookMapper.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.yuan.mapper.HBookMapper" >

   <resultMap id="BaseResultMap" type="com.yuan.model.HBook" >

     <constructor >

       <idArg column="book_id" jdbcType="INTEGER" javaType="java.lang.Integer" />

       <arg column="book_name" jdbcType="VARCHAR" javaType="java.lang.String" />

       <arg column="price" jdbcType="REAL" javaType="java.lang.Float" />

     </constructor>

   </resultMap>

   <resultMap id="HbookVoMap" type="com.yuan.model.vo.HbookVo">

     <result property="bookId" column="book_id"></result>

     <result property="bookName" column="book_name"></result>

     <result property="price" column="price"></result>

     <!--<result property="orderItems" column=""></result>-->

     <collection property="categories" ofType="com.yuan.model.Category">

       <result property="categoryId" column="category_id"></result>

       <result property="categoryName" column="category_name"></result>

     </collection>

   </resultMap>

   <sql id="Base_Column_List" >

     book_id, book_name, price

   </sql>

   <select id="selectByPrimaryKey" resultMap="BaseResultMap" parameterType="java.lang.Integer" >

     select

     <include refid="Base_Column_List" />

     from t_hibernate_book

     where book_id = #{bookId,jdbcType=INTEGER}

   </select>

   <delete id="deleteByPrimaryKey" parameterType="java.lang.Integer" >

     delete from t_hibernate_book

     where book_id = #{bookId,jdbcType=INTEGER}

   </delete>

   <insert id="insert" parameterType="com.yuan.model.HBook" >

     insert into t_hibernate_book (book_id, book_name, price

       )

     values (#{bookId,jdbcType=INTEGER}, #{bookName,jdbcType=VARCHAR}, #{price,jdbcType=REAL}

       )

   </insert>

   <insert id="insertSelective" parameterType="com.yuan.model.HBook" >

     insert into t_hibernate_book

     <trim prefix="(" suffix=")" suffixOverrides="," >

       <if test="bookId != null" >

         book_id,

       </if>

       <if test="bookName != null" >

         book_name,

       </if>

       <if test="price != null" >

         price,

       </if>

     </trim>

     <trim prefix="values (" suffix=")" suffixOverrides="," >

       <if test="bookId != null" >

         #{bookId,jdbcType=INTEGER},

       </if>

       <if test="bookName != null" >

         #{bookName,jdbcType=VARCHAR},

       </if>

       <if test="price != null" >

         #{price,jdbcType=REAL},

       </if>

     </trim>

   </insert>

   <update id="updateByPrimaryKeySelective" parameterType="com.yuan.model.HBook" >

     update t_hibernate_book

     <set >

       <if test="bookName != null" >

         book_name = #{bookName,jdbcType=VARCHAR},

       </if>

       <if test="price != null" >

         price = #{price,jdbcType=REAL},

       </if>

     </set>

     where book_id = #{bookId,jdbcType=INTEGER}

   </update>

   <update id="updateByPrimaryKey" parameterType="com.yuan.model.HBook" >

     update t_hibernate_book

     set book_name = #{bookName,jdbcType=VARCHAR},

       price = #{price,jdbcType=REAL}

     where book_id = #{bookId,jdbcType=INTEGER}

   </update>

   <!--通过一个书籍id，查询出书籍的信息的同时，还查询出这本书对应的类别-->

   <select id="selectByBid" 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=#{bid}

   </select>

 </mapper>




HBookMapper




 package com.yuan.mapper;

 import com.yuan.model.HBook;

 import com.yuan.model.vo.HbookVo;

 import org.apache.ibatis.annotations.Param;

 import org.springframework.stereotype.Repository;

 @Repository

 public interface HBookMapper {

     int deleteByPrimaryKey(Integer bookId);

     int insert(HBook record);

     int insertSelective(HBook record);

     HBook selectByPrimaryKey(Integer bookId);

     int updateByPrimaryKeySelective(HBook record);

     int updateByPrimaryKey(HBook record);

 //    通过一个书籍id，查询出书籍的信息的同时，还查询出这本书对应的类别

     HbookVo selectByBid(@Param("bid") Integer bid);

 }




Service层相关代码


ManyToManyService




 package com.yuan.service;

 import com.yuan.model.vo.CategoryVo;

 import com.yuan.model.vo.HbookVo;

 import org.apache.ibatis.annotations.Param;

 public interface ManyToManyService {

 //   通过一个书籍id，查询出书籍的信息的同时，还查询出这本书对应的类别

     HbookVo selectByBid(Integer bid);

 //    通过一个类别的id，查询出类别信息的同时，还查询出各个类别对应的书籍

     CategoryVo selectByCid(Integer cid);

 }




Service层实现类代码


ManyToManyServiceImpl




 package com.yuan.service.impl;

 import com.yuan.mapper.CategoryMapper;

 import com.yuan.mapper.HBookMapper;

 import com.yuan.model.vo.CategoryVo;

 import com.yuan.model.vo.HbookVo;

 import com.yuan.service.ManyToManyService;

 import org.springframework.beans.factory.annotation.Autowired;

 import org.springframework.stereotype.Service;

 @Service

 public class ManyToManyServiceImpl implements ManyToManyService {

     @Autowired

     private CategoryMapper categoryMapper;

     @Autowired

     private HBookMapper hBookMapper;

     @Override

     public HbookVo selectByBid(Integer bid) {

         return hBookMapper.selectByBid(bid);

     }

     @Override

     public CategoryVo selectByCid(Integer cid) {

         return categoryMapper.selectByCid(cid);

     }

 }




Test测试类


ManyToManyServiceImplTest




 package com.yuan.service.impl;

 import com.yuan.SpringBaseTest;

 import com.yuan.model.Category;

 import com.yuan.model.HBook;

 import com.yuan.model.vo.CategoryVo;

 import com.yuan.model.vo.HbookVo;

 import org.junit.Test;

 import org.junit.runner.RunWith;

 import org.springframework.beans.factory.annotation.Autowired;

 import static org.junit.Assert.*;

 public class ManyToManyServiceImplTest extends SpringBaseTest {

     @Autowired

     private ManyToManyServiceImpl manyToManyService;

 //    通过一个书籍id，查询出书籍的信息的同时，还查询出这本书对应的类别

     @Test

     public void selectByBid() {

         HbookVo hbookVo = manyToManyService.selectByBid(8);

         System.out.println(hbookVo);

         for (Category category : hbookVo.getCategories()) {

             System.out.println(category);

         }

     }

 //    通过一个类别的id，查询出类别信息的同时，还查询出各个类别对应的书籍

     @Test

     public void selectByCid() {

         CategoryVo categoryVo = manyToManyService.selectByCid(8);

         System.out.println(categoryVo);

         for (HBook gethBook : categoryVo.gethBooks()) {

             System.out.println(gethBook);

         }

     }

 }




测试方法一：selectByBid




测试方法二：selectByCid




谢谢观看！！！
												


											
mybatis之关联关系映射的更多相关文章
	

    
						
  1. mybatis一对一关联关系映射
		
    mybatis一对一关联关系映射 在关联关系中,有一对一,一对多,多对多三种关联关系. 一对一关系:在操作上,任意一方引入对方的主键作为外键. 一对多关系:在"多"的一方添加&qu ...
    
		
    2. 
								
  2. mybatis多对多关联关系映射
		
    mybatis多对多关联关系映射 多对多关系在java类实体中表示为,一个类中包含了集合为另一个类的属性.而这连个实体都需要包含对方的集合类的属性. 例如:订单和商品,一个订单包含多个商品,一个商品又 ...
    
		
    3. 
						
  3. mybatis一对多关联关系映射
		
    mybatis一对多关联关系映射 一对多关联关系只需要在多的一方引入少的一方的主键作为外键即可.在实体类中就是反过来,在少的一方添加多的一方,声明一个List 属性名 作为少的一方的属性. 用户和订单 ...
    
		
    4. 
						
  4. Hibernate（6）—— 一对多 和 多对多关联关系映射（xml和注解）总结
		
    俗话说,自己写的代码,6个月后也是别人的代码……复习!复习!复习!涉及的知识点总结如下: One to Many 映射关系 多对一单向外键关联(XML/Annotation) 一对多单向外键关联(XM ...
    
		
    5. 
						
  5. Hibernate—— 一对多 和 多对多关联关系映射（xml和注解）总结（转载）
		
    One to Many 映射关系 多对一单向外键关联(XML/Annotation) 一对多单向外键关联(XML/Annotation) 懒加载和积极加载 一对多双向外键关联(XML/Annotati ...
    
		
    6. 
						
  6. Mybatis的关联映射案例
		
    主要是对之前学习的关联映射做一个案例,自己动手实践一下,可以理解的更好一点. 开发环境 开发工具:idea Java环境: jdk1.8.0_121 数据库:SQLServer 项目结构,里面包含了三 ...
    
		
    7. 
						
  7. mybatis之关联关系
		
    前言:在我们之前的hibernate中我们是学过了关联关系的,所以我们在本章给讲一讲mybatis的关联关系. mybatis的关联关系一对多的测试1.通过逆向工程生成Hbook,HbookCateg ...
    
		
    8. 
						
  8. Mybatis(二) SQL映射文件
		
    SQL映射文件 单条件查询 1. 在UserMapper接口添加抽象方法 //根据用户名模糊查询 List<User> getUserListByName(); 2. 在UserMappe ...
    
		
    9. 
						
  9. MyBatis加强（1）~myBatis对象关系映射（多对一关系、一对多关系）、延迟/懒加载
		
    一.myBatis对象关系映射(多对一关系.一对多关系) 1.多对一关系: ---例子:多个员工同属于一个部门. (1)myBatis发送 额外SQL: ■ 案例:员工表通过 dept_id 关联 部 ...
    
		
    10. 
		

	


随机推荐
	

    
									
  1. 19 IO流（十六）——Commons工具包，FileUtils（一）
			
    Commons包的API:自己查吧懒得传云 Commons包的导入方法 Commons是一个java的IO开源工具,导入方法: 从apache.org下载commons包 解压 copy其中的comm ...
    
			
    2. 
						
  2. 基于OpenCV制作道路车辆计数应用程序
			
    基于OpenCV制作道路车辆计数应用程序 发展前景 随着科学技术的进步和工业的发展,城市中交通量激增,原始的交通方式已不能满足要求:同时,由于工业发展为城市交通提供的各种交通工具越来越多,从而加速了城 ...
    
			
    3. 
						
  3. Android--Facebook Login without LoginButton
			
    1.引入facebook 工程lib,在Manifest中声明com.facebook.LoginActivity,facebook_app_id <activity android:name= ...
    
			
    4. 
						
  4. GC收集器
			
    新生代收集器 Serial New 单线程收集器,工作时必须暂停其他线程: 简单高效,没有线程交互开销: 基于复制算法: Parallel New 对Serial的改进,多线程: CPU数量<4 ...
    
			
    5. 
						
  5. Java初学心得（二）
			
    数组概述 一,数组基本操作 ①一维数组的创建:数组元素类型[] 数组名字=new 数组类型[数组元素个数] 例:int []arr=new int[5];数组长度为5 ②初始化一维数组:第一种:int ...
    
			
    6. 
						
  6. Springboot 之 静态资源路径配置
			
    1.静态资源路径是指系统可以直接访问的路径,且路径下的所有文件均可被用户通过浏览器直接读取. 2.在Springboot中默认的静态资源路径有:classpath:/META-INF/resource ...
    
			
    7. 
						
  7. oracle中的CURRVAL和NEXTVAL用法
			
    原文:https://blog.csdn.net/qianyiyiding/article/details/51592689  1.什么是sequence?其作用是什么? 在Oracle数据库中,什么 ...
    
			
    8. 
						
  8. 使用jQuery开发dialog对话框插件
			
    1.插件使用 首先引入 jquery 库,然后引入 dialog.js.dialog.css,如下: <script type="text/javascript" src=& ...
    
			
    9. 
						
  9. stack + positioned
			
    stack 下套container, 发现最大的显示,小的都没显示, 把所有都套个POSITIONED, 都正常显示了.
    
			
    10. 
						
  10. dubbo源码阅读之自适应扩展
			
    自适应扩展机制 刚开始看代码,其实并不能很好地理解dubbo的自适应扩展机制的作用,我们不妨先把代码的主要逻辑过一遍,梳理一下,在了解了代码细节之后,回过头再来思考自适应扩展的作用,dubbo为什么要 ...
    
			
    11.