mybatis之关联关系映射

一、

1、一对多

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

1.1 OrderVo

 

 1 package com.jy.model.vo;
 2 
 3 import com.jy.model.Order;
 4 import com.jy.model.OrderItem;
 5 
 6 import java.util.ArrayList;
 7 import java.util.List;
 8 
 9 public class OrderVo extends Order {
10 
11     private List orderItems = new ArrayList<>();
12 
13     public List getOrderItems() {
14         return orderItems;
15     }
16 
17     public void setOrderItems(List orderItems) {
18         this.orderItems = orderItems;
19     }
20 }

 

1.2 OrderItemVo

 

 1 package com.jy.model.vo;
 2 
 3 import com.jy.model.Order;
 4 import com.jy.model.OrderItem;
 5 
 6 public class OrderItemVo extends OrderItem {
 7     private Order order;
 8 
 9     public Order getOrder() {
10         return order;
11     }
12 
13     public void setOrder(Order order) {
14         this.order = order;
15     }
16 }

 

1.3 OrderMapper.xml

 

 1 
 2 
 3 
 4     
 5         
 6             
 7             
 8         
 9     
10 
11     
12         
13         
14         
15         
16             
17             
18             
19             
20         
21     
22 
23     
24     order_id, order_no
25   
26     
27         select
28         
29         from t_hibernate_order
30         where order_id = #{orderId,jdbcType=INTEGER}
31     
32     
33     delete from t_hibernate_order
34     where order_id = #{orderId,jdbcType=INTEGER}
35   
36     
37     insert into t_hibernate_order (order_id, order_no)
38     values (#{orderId,jdbcType=INTEGER}, #{orderNo,jdbcType=VARCHAR})
39   
40     
41         insert into t_hibernate_order
42         
43             
44                 order_id,
45             
46             
47                 order_no,
48             
49         
50         
51             
52                 #{orderId,jdbcType=INTEGER},
53             
54             
55                 #{orderNo,jdbcType=VARCHAR},
56             
57         
58     
59     
60         update t_hibernate_order
61         
62             
63                 order_no = #{orderNo,jdbcType=VARCHAR},
64             
65         
66         where order_id = #{orderId,jdbcType=INTEGER}
67     
68     
69     update t_hibernate_order
70     set order_no = #{orderNo,jdbcType=VARCHAR}
71     where order_id = #{orderId,jdbcType=INTEGER}
72   
73 
74     
75     
76     SELECT * FROM t_hibernate_order o,t_hibernate_order_item oi WHERE o.`order_id`=oi.`oid`
77 AND oi.oid=#{orderId}
78   
79 
80 
81 

 

1.4 OrderMapper

 1 package com.jy.mapper;
 2 
 3 import com.jy.model.Order;
 4 import com.jy.model.vo.OrderVo;
 5 import org.apache.ibatis.annotations.Param;
 6 import org.springframework.stereotype.Repository;
 7 
 8 import java.util.List;
 9 
10 @Repository
11 public interface OrderMapper {
12     int deleteByPrimaryKey(Integer orderId);
13 
14     int insert(Order record);
15 
16     int insertSelective(Order record);
17 
18     Order selectByPrimaryKey(Integer orderId);
19 
20     int updateByPrimaryKeySelective(Order record);
21 
22     int updateByPrimaryKey(Order record);
23 
24      //通过一个订单id，查询出订单信息的同时，查询所有的订单项
25     List selectByOrderId(@Param("orderId") Integer orderId);
26 
27 }

 

1.5 OrderItemMapper.xml

 

  1 
  2 
  3 
  4   
  5     
  6       
  7       
  8       
  9       
 10     
 11   
 12 
 13   
 14 
 15     
 16     
 17     
 18     
 19     
 20       
 21       
 22     
 23   
 24 
 25 
 26   
 27     order_item_id, product_id, quantity, oid
 28   
 29   
 30     select 
 31     
 32     from t_hibernate_order_item
 33     where order_item_id = #{orderItemId,jdbcType=INTEGER}
 34   
 35   
 36     delete from t_hibernate_order_item
 37     where order_item_id = #{orderItemId,jdbcType=INTEGER}
 38   
 39   
 40     insert into t_hibernate_order_item (order_item_id, product_id, quantity, 
 41       oid)
 42     values (#{orderItemId,jdbcType=INTEGER}, #{productId,jdbcType=INTEGER}, #{quantity,jdbcType=INTEGER}, 
 43       #{oid,jdbcType=INTEGER})
 44   
 45   
 46     insert into t_hibernate_order_item
 47     
 48       
 49         order_item_id,
 50       
 51       
 52         product_id,
 53       
 54       
 55         quantity,
 56       
 57       
 58         oid,
 59       
 60     
 61     
 62       
 63         #{orderItemId,jdbcType=INTEGER},
 64       
 65       
 66         #{productId,jdbcType=INTEGER},
 67       
 68       
 69         #{quantity,jdbcType=INTEGER},
 70       
 71       
 72         #{oid,jdbcType=INTEGER},
 73       
 74     
 75   
 76   
 77     update t_hibernate_order_item
 78     
 79       
 80         product_id = #{productId,jdbcType=INTEGER},
 81       
 82       
 83         quantity = #{quantity,jdbcType=INTEGER},
 84       
 85       
 86         oid = #{oid,jdbcType=INTEGER},
 87       
 88     
 89     where order_item_id = #{orderItemId,jdbcType=INTEGER}
 90   
 91   
 92     update t_hibernate_order_item
 93     set product_id = #{productId,jdbcType=INTEGER},
 94       quantity = #{quantity,jdbcType=INTEGER},
 95       oid = #{oid,jdbcType=INTEGER}
 96     where order_item_id = #{orderItemId,jdbcType=INTEGER}
 97   
 98 
 99   
100   
101     SELECT * FROM t_hibernate_order o,t_hibernate_order_item oi WHERE o.`order_id`=oi.`oid`
102 AND oi.order_item_id=#{orderItemId}
103   
104 
105 
106 
107 

 

1.6 OrderItemMapper

 1 package com.jy.mapper;
 2 
 3 import com.jy.model.OrderItem;
 4 import com.jy.model.vo.OrderItemVo;
 5 import org.apache.ibatis.annotations.Param;
 6 import org.springframework.stereotype.Repository;
 7 
 8 import java.util.List;
 9 
10 @Repository
11 public interface OrderItemMapper {
12     int deleteByPrimaryKey(Integer orderItemId);
13 
14     int insert(OrderItem record);
15 
16     int insertSelective(OrderItem record);
17 
18     OrderItem selectByPrimaryKey(Integer orderItemId);
19 
20     int updateByPrimaryKeySelective(OrderItem record);
21 
22     int updateByPrimaryKey(OrderItem record);
23 
24     //通过一个订单项id，查询出订单项信息的同时，查询所所属的订单
25     List selectByOrderItemId(@Param("orderItemId") Integer orderItemId);
26 
27 }

 

Service层

1.7 OneToManyService

 1 package com.jy.service;
 2 
 3 import com.jy.model.vo.OrderItemVo;
 4 import com.jy.model.vo.OrderVo;
 5 import org.apache.ibatis.annotations.Param;
 6 
 7 import java.util.List;
 8 
 9 public interface OneToManyService {
10 
11     //通过一个订单项id，查询出订单项信息的同时，查询所所属的订单
12     List selectByOrderItemId(Integer orderItemId);
13 
14     //通过一个订单id，查询出订单信息的同时，查询所有的订单项
15     List selectByOrderId( Integer orderId);
16 
17 }

 

Service实现类

1.8 OneToManyServiceImpl

 

 1 package com.jy.service.impl;
 2 
 3 import com.jy.mapper.OrderItemMapper;
 4 import com.jy.mapper.OrderMapper;
 5 import com.jy.model.vo.OrderItemVo;
 6 import com.jy.model.vo.OrderVo;
 7 import com.jy.service.OneToManyService;
 8 import org.springframework.beans.factory.annotation.Autowired;
 9 import org.springframework.stereotype.Service;
10 
11 import java.util.List;
12 
13 @Service
14 public class OneToManyServiceImpl implements OneToManyService {
15     @Autowired
16     private OrderMapper orderMapper;
17     @Autowired
18     private OrderItemMapper orderItemMapper;
19     @Override
20     public List selectByOrderItemId(Integer orderItemId) {
21         return orderItemMapper.selectByOrderItemId(orderItemId);
22     }
23 
24     @Override
25     public List selectByOrderId(Integer orderId) {
26         return orderMapper.selectByOrderId(orderId);
27     }
28 }

 

Test测试层代码

1.9 OneToManyServiceImplTest

 

 1 package com.jy.service.impl;
 2 
 3 import com.jy.SpringBaseTest;
 4 import com.jy.model.OrderItem;
 5 import com.jy.model.vo.OrderItemVo;
 6 import com.jy.model.vo.OrderVo;
 7 import com.jy.service.OneToManyService;
 8 import org.junit.Test;
 9 import org.junit.runner.RunWith;
10 import org.springframework.beans.factory.annotation.Autowired;
11 
12 import java.util.List;
13 
14 import static org.junit.Assert.*;
15 
16 public class OneToManyServiceImplTest extends SpringBaseTest {
17 
18     @Autowired
19     private OneToManyService oneToManyService;
20     @Test
21     public void selectByOrderItemId() {
22         List orderItemVos = oneToManyService.selectByOrderItemId(36);
23         OrderItemVo orderItemVo = orderItemVos.get(0);
24         //此订单项的信息
25         System.out.println(orderItemVo);
26         //此订单项所对应的订单
27         System.out.println(orderItemVo.getOrder());
28     }
29 
30     @Test
31     public void selectByOrderId() {
32 
33         List orderVos = oneToManyService.selectByOrderId(8);
34         OrderVo orderVo = orderVos.get(0);
35         System.out.println(orderVo);
36         System.out.println(orderVos.size());
37         for (OrderItem orderItem : orderVo.getOrderItems()) {
38             System.out.println(orderItem);
39         }
40 
41     }
42 }

 

 

 

二、多对多

使用逆向生成工具生成t_hibernate_book、t_hibernate_book_category、t_hibernate_category
这几张表对应的model与mapper　

2.1 HbookVo

 

 1 package com.jy.model.vo;
 2 
 3 import com.jy.model.Category;
 4 import com.jy.model.HBook;
 5 
 6 import java.util.ArrayList;
 7 import java.util.List;
 8 
 9 public class HbookVo extends HBook {
10     private List categories = new ArrayList<>();
11 
12     public List getCategories() {
13         return categories;
14     }
15 
16     public void setCategories(List categories) {
17         this.categories = categories;
18     }
19 }

 

2.2 CategoryVo

 

package com.jy.model.vo;

import com.jy.model.Category;
import com.jy.model.HBook;

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

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

    public List gethBooks() {
        return hBooks;
    }

    public void sethBooks(List hBooks) {
        this.hBooks = hBooks;
    }
}

 

2.3 CategoryMapper.xml

 1 
 2 
 3 
 4   
 5     
 6       
 7       
 8     
 9   
10 
11   
12     
13     
14 
15     
16     
17       
18       
19       
20     
21   
22 
23   
24     category_id, category_name
25   
26   
27     select 
28     
29     from t_hibernate_category
30     where category_id = #{categoryId,jdbcType=INTEGER}
31   
32   
33     delete from t_hibernate_category
34     where category_id = #{categoryId,jdbcType=INTEGER}
35   
36   
37     insert into t_hibernate_category (category_id, category_name)
38     values (#{categoryId,jdbcType=INTEGER}, #{categoryName,jdbcType=VARCHAR})
39   
40   
41     insert into t_hibernate_category
42     
43       
44         category_id,
45       
46       
47         category_name,
48       
49     
50     
51       
52         #{categoryId,jdbcType=INTEGER},
53       
54       
55         #{categoryName,jdbcType=VARCHAR},
56       
57     
58   
59   
60     update t_hibernate_category
61     
62       
63         category_name = #{categoryName,jdbcType=VARCHAR},
64       
65     
66     where category_id = #{categoryId,jdbcType=INTEGER}
67   
68   
69     update t_hibernate_category
70     set category_name = #{categoryName,jdbcType=VARCHAR}
71     where category_id = #{categoryId,jdbcType=INTEGER}
72   
73 
74   
75   
76    SELECT * FROM t_hibernate_book b,t_hibernate_book_category bc,t_hibernate_category c
77   WHERE b.book_id = bc.bid AND bc.cid = c.category_id
78   AND c.category_id = #{cid}
79   
80 
81 

 

2.4 CategoryMapper

 

package com.jy.mapper;

import com.jy.model.Category;
import com.jy.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);

}

 

2.5 HBookMapper.xml

 

 1 
 2 
 3 
 4   
 5     
 6       
 7       
 8       
 9     
10   
11 
12   
13     
14     
15     
16     
17     
18       
19       
20     
21   
22 
23   
24     book_id, book_name, price
25   
26   
27     select 
28     
29     from t_hibernate_book
30     where book_id = #{bookId,jdbcType=INTEGER}
31   
32   
33     delete from t_hibernate_book
34     where book_id = #{bookId,jdbcType=INTEGER}
35   
36   
37     insert into t_hibernate_book (book_id, book_name, price
38       )
39     values (#{bookId,jdbcType=INTEGER}, #{bookName,jdbcType=VARCHAR}, #{price,jdbcType=REAL}
40       )
41   
42   
43     insert into t_hibernate_book
44     
45       
46         book_id,
47       
48       
49         book_name,
50       
51       
52         price,
53       
54     
55     
56       
57         #{bookId,jdbcType=INTEGER},
58       
59       
60         #{bookName,jdbcType=VARCHAR},
61       
62       
63         #{price,jdbcType=REAL},
64       
65     
66   
67   
68     update t_hibernate_book
69     
70       
71         book_name = #{bookName,jdbcType=VARCHAR},
72       
73       
74         price = #{price,jdbcType=REAL},
75       
76     
77     where book_id = #{bookId,jdbcType=INTEGER}
78   
79   
80     update t_hibernate_book
81     set book_name = #{bookName,jdbcType=VARCHAR},
82       price = #{price,jdbcType=REAL}
83     where book_id = #{bookId,jdbcType=INTEGER}
84   
85 
86   
87   
88    SELECT * FROM t_hibernate_book b,t_hibernate_book_category bc,t_hibernate_category c
89   WHERE b.book_id = bc.bid AND bc.cid = c.category_id
90   AND b.book_id=#{bid}
91   
92 
93 
94 

 

2.6 HBookMapper

 

 1 package com.jy.mapper;
 2 
 3 import com.jy.model.HBook;
 4 import com.jy.model.vo.HbookVo;
 5 import org.apache.ibatis.annotations.Param;
 6 import org.springframework.stereotype.Repository;
 7 
 8 @Repository
 9 public interface HBookMapper {
10     int deleteByPrimaryKey(Integer bookId);
11 
12     int insert(HBook record);
13 
14     int insertSelective(HBook record);
15 
16     HBook selectByPrimaryKey(Integer bookId);
17 
18     int updateByPrimaryKeySelective(HBook record);
19 
20     int updateByPrimaryKey(HBook record);
21 
22 //    通过一个书籍id，查询出书籍的信息的同时，还查询出这本书对应的类别
23     HbookVo selectByBid(@Param("bid") Integer bid);
24 
25 }

 

 

Service层相关代码

2.7 ManyToManyService

 

 1 package com.jy.service;
 2 
 3 import com.jy.model.vo.CategoryVo;
 4 import com.jy.model.vo.HbookVo;
 5 import org.apache.ibatis.annotations.Param;
 6 
 7 public interface ManyToManyService {
 8 
 9 //   通过一个书籍id，查询出书籍的信息的同时，还查询出这本书对应的类别
10     HbookVo selectByBid(Integer bid);
11 
12 //    通过一个类别的id，查询出类别信息的同时，还查询出各个类别对应的书籍
13     CategoryVo selectByCid(Integer cid);
14 }

 

Service层实现类代码

2.8 ManyToManyServiceImpl

 

1 package com.jy.service.impl;
 2 
 3 import com.jy.mapper.CategoryMapper;
 4 import com.jy.mapper.HBookMapper;
 5 import com.jy.model.vo.CategoryVo;
 6 import com.jy.model.vo.HbookVo;
 7 import com.jy.service.ManyToManyService;
 8 import org.springframework.beans.factory.annotation.Autowired;
 9 import org.springframework.stereotype.Service;
10 
11 @Service
12 public class ManyToManyServiceImpl implements ManyToManyService {
13     @Autowired
14     private CategoryMapper categoryMapper;
15     @Autowired
16     private HBookMapper hBookMapper;
17 
18     @Override
19     public HbookVo selectByBid(Integer bid) {
20         return hBookMapper.selectByBid(bid);
21     }
22 
23     @Override
24     public CategoryVo selectByCid(Integer cid) {
25         return categoryMapper.selectByCid(cid);
26     }
27 }

 

Test测试类

2.9 ManyToManyServiceImplTest

 1 package com.jy.service.impl;
 2 
 3 import com.jy.SpringBaseTest;
 4 import com.jy.model.Category;
 5 import com.jy.model.HBook;
 6 import com.jy.model.vo.CategoryVo;
 7 import com.jy.model.vo.HbookVo;
 8 import org.junit.Test;
 9 import org.junit.runner.RunWith;
10 import org.springframework.beans.factory.annotation.Autowired;
11 
12 import static org.junit.Assert.*;
13 
14 public class ManyToManyServiceImplTest extends SpringBaseTest {
15 
16     @Autowired
17     private ManyToManyServiceImpl manyToManyService;
18 
19 //    通过一个书籍id，查询出书籍的信息的同时，还查询出这本书对应的类别
20     @Test
21     public void selectByBid() {
22         HbookVo hbookVo = manyToManyService.selectByBid(8);
23         System.out.println(hbookVo);
24         for (Category category : hbookVo.getCategories()) {
25             System.out.println(category);
26         }
27 
28     }
29 
30 //    通过一个类别的id，查询出类别信息的同时，还查询出各个类别对应的书籍
31     @Test
32     public void selectByCid() {
33         CategoryVo categoryVo = manyToManyService.selectByCid(8);
34         System.out.println(categoryVo);
35         for (HBook gethBook : categoryVo.gethBooks()) {
36             System.out.println(gethBook);
37         }
38 
39     }
40 }

测试：

方法一：selectByBid

 

方法二：selectByCid