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. （idea maven）mybatis-generator步骤
			
    1.新建一个maven项目,选择maven-archetype-webapp 点击next 2.项目名称,点击next 3.选择项目存放路径,然后点击finish 4.在main包下 添加包java和 ...
    
			
    2. 
						
  2. Java开发笔记（一百零八）JSON串的定义和解析
			
    前面提到URL尾巴支持添加请求参数,具体格式形如“参数A名称=A参数值&参数B名称=B参数值”,可是这种格式只能传递简单的键值对信息,不能传递结构化数据,也无法传递数组形式的参数,因而它不适用 ...
    
			
    3. 
						
  3. Python规范:用用assert
			
    什么是assert assert的语法: assert_stmt ::= "assert" expression ["," expression] 例: ass ...
    
			
    4. 
						
  4. 【flask】登陆后返回之前重定向跳转的页面
			
    登陆后返回之前重定向跳转的页面 一.前言 实现强制跳转到登陆页面,登陆后返回之前的页面的功能.网上跳登陆页面的很多:返回之前页面功能没多少.这里我只是用了自己的方法,有缺点和其他方法也请指点!(´ε｀ ...
    
			
    5. 
						
  5. 面试4 --- constructor必须与class同名,但方法不能与class同名?
			
    选 C “constructor必须与class同名,但方法不能与class同名”这句话是错误的,方法是可以和class同名的:方法可以和类名同名的,和构造方法唯一的区别就是,构造方法没有返回值.
    
			
    6. 
						
  6. 利用ime-mode设置文本框只能输入正整数
			
    html: <input type="text" id="packageratio"style="ime-mode: disabled;&quo ...
    
			
    7. 
						
  7. 树莓派Raspbian系统格式化挂载硬盘
			
    1.查看树莓派系统挂载的储存设备 使用工具查看系统识别到的硬盘设备,命令: fdisk -l /dev/sda 和 /dev/sdb  分别是两块硬盘. 2.修改硬盘分区 Linux和windows一 ...
    
			
    8. 
						
  8. Java调用WebService方法总结(4)--Axis调用WebService
			
    Axis是比较常用的WebService框架,该项目在2006实现了最终版,后面就没有更新了.文中demo所使用到的软件版本:Java 1.8.0_191.Axis 1.4. 1.准备 参考Java调 ...
    
			
    9. 
						
  9. 5_PHP数组_3_数组处理函数及其应用_1_快速创建数组的函数
			
    以下为学习孔祥盛主编的<PHP编程基础与实例教程>(第二版)所做的笔记. 一.快速创建数组的函数 1. range() 函数 程序: <?php $numbers = range(1 ...
    
			
    10. 
						
  10. python3基础之“小练习（2）”
			
    (十三)创建一个你最喜欢歌手的列表. # singer=list() # singer=['a','b','c'] # print(singer) (十四)创建一个由元组构成的列表,每个元组包含居住过 ...
    
			
    11.