程式師世界 >> 編程語言 >> JAVA編程 >> JAVA綜合教程 >> MyBatis學習--高級映射，mybatis--映射

MyBatis學習--高級映射，mybatis--映射

編輯：JAVA綜合教程

MyBatis學習--高級映射，mybatis--映射

簡介

　　前面說過了簡單的數據庫查詢和管理查詢，在開發需求中有一些一對一、一對多和多對多的需求開發，如在開發購物車的時候，訂單和用戶是一對一，用戶和訂單是一對多，用戶和商品是多對多。這些在Hibernate開發中也是常見的，Hibernate中是通過數據映射來實現的，在MyBatis中也是通過配置文件的數據映射來實現。

一對一查詢

　　如果我們要查詢訂單信息，關聯查詢創建訂單的用戶信息，那麼這就是典型的一對一查詢。實現一對一查詢有兩種實現方式：使用resultType和resultMap。resultType需要額外定義POJO，然後把查詢的字段和新定義的POJO一一對應。resultMap則需要通過配置文件來實現兩個POJO的一對一關聯。下面我們就這兩種方式來分別實現。

　　resultType：

　　1、創建POJO，將需要映射的新的屬性加入到新的POJO中。

 1 public class OrderCustom extends Orders{
 2     //添加用戶信息
 3     private String username;
 4     private String sex;
 5     private String address;
 6     public String getUsername() {
 7         return username;
 8     }
 9     public void setUsername(String username) {
10         this.username = username;
11     }
12     public String getSex() {
13         return sex;
14     }
15     public void setSex(String sex) {
16         this.sex = sex;
17     }
18     public String getAddress() {
19         return address;
20     }
21     public void setAddress(String address) {
22         this.address = address;
23     }
24     
25     
26 }

　　2、映射文件：

 1 <select id="findOrderUser" resultType="com.luchao.mybatis.first.po.OrderCustom">
 2         select
 3         orders.*,
 4         user.username,
 5         user.sex,
 6         user.address
 7         from orders,user
 8         where
 9         orders.user_id = user.id
10 </select>

　　3、Mapper接口的實現：

1 //查詢訂單和用戶信息
2 public List<OrderCustom> findOrderUser() throws Exception;

　　4、測試代碼：

1 public void findOrdersUser() throws Exception {
2         // 獲取sqlSession對象
3         SqlSession sqlSession = sqlSessionFactory.openSession();
4         // 創建OrderMapper對象，MyBatis自動生成mapper代理
5         OrderMapper orderMapper = sqlSession.getMapper(OrderMapper.class);
6         // 調用orderMapper的方法，查詢訂單和用戶信息
7         List<OrderCustom> orderCustoms = orderMapper.findOrderUser();
8         System.out.println(orderCustoms.size());
9 }

　　resultMap實現：

　　resultMap將查詢結果中的訂單信息映射到Orders對象中，在orders類中添加User屬性，將關聯查詢出來的用戶信息映射到orders對象中的user屬性中。

　　1、創建POJO，在Order類中加入User屬性。

 1 public class Orders {
 2     private Integer id;
 3     private Integer userId;
 4     private String number;
 5     private Date createtime;
 6     private String note;
 7     //用戶信息
 8     private User user;
 9     //訂單條目
10     private List<Orderdetail> orderdetails;
11     public Integer getId() {
12         return id;
13     }
14     public void setId(Integer id) {
15         this.id = id;
16     }
17     public Integer getUserId() {
18         return userId;
19     }
20     public void setUserId(Integer userId) {
21         this.userId = userId;
22     }
23     public String getNumber() {
24         return number;
25     }
26     public void setNumber(String number) {
27         this.number = number == null ? null : number.trim();
28     }
29     public Date getCreatetime() {
30         return createtime;
31     }
32     public void setCreatetime(Date createtime) {
33         this.createtime = createtime;
34     }
35     public String getNote() {
36         return note;
37     }
38     public void setNote(String note) {
39         this.note = note == null ? null : note.trim();
40     }
41     public User getUser() {
42         return user;
43     }
44     public void setUser(User user) {
45         this.user = user;
46     }
47     public List<Orderdetail> getOrderdetails() {
48         return orderdetails;
49     }
50     public void setOrderdetails(List<Orderdetail> orderdetails) {
51         this.orderdetails = orderdetails;
52     }   
53 }

　　2、映射文件：

 1 <!-- 訂單查詢關聯用戶的resultMap,將整個查詢結果映射到orders中 -->
 2     <resultMap type="com.luchao.mybatis.first.po.Orders" id="ordersUserResultMap">
 3         <id column="id" property="id" />
 4         <result column="user_id" property="userId" />
 5         <result column="number" property="number" />
 6         <result column="createtime" property="createtime" />
 7         <result column="note" property="note" />
 8         <!-- 配置映射的關聯的用戶信息 -->
 9         <!-- association：用於映射關聯查詢單個對象的信息 property：要將關聯查詢的用戶信息映射到Orders中哪個屬性 -->
10         <association property="user" javaType="com.luchao.mybatis.first.po.User">
11             <!-- id：關聯查詢用戶的唯 一標識 column：指定唯 一標識用戶信息的列 javaType：映射到user的哪個屬性 -->
12             <id column="user_id" property="id" />
13             <result column="username" property="username" />
14             <result column="sex" property="sex" />
15             <result column="address" property="address" />
16 
17         </association>
18     </resultMap>
19 <select id="findOrderUserMap" resultMap="ordersUserResultMap">
20         select
21         orders.*,
22         user.username,
23         user.sex,
24         user.address
25         from orders,user
26         where
27         orders.user_id = user.id
28     </select>

　　association：用於映射關聯查詢單個對象的信息，property：要將關聯查詢的用戶信息映射到Orders中哪個屬性。

　　3、Mapper接口

1 //查詢訂單和用戶信息通過resultMap
2 public List<Orders> findOrderUserMap() throws Exception;

　　4、測試代碼：

1 public void findOrdersUserMap() throws Exception {
2         // 獲取sqlSession對象
3         SqlSession sqlSession = sqlSessionFactory.openSession();
4         // 創建OrderMapper對象，MyBatis自動生成mapper代理
5         OrderMapper orderMapper = sqlSession.getMapper(OrderMapper.class);
6         // 調用orderMapper的方法，查詢訂單和用戶信息
7         List<Orders> orders = orderMapper.findOrderUserMap();
8         System.out.println(orders.size());
9 }

　　resultType和resultMap實現一對一查詢總結：

　　resultType：使用resultType實現較為簡單，如果pojo中沒有包括查詢出來的列名，需要增加列名對應的屬性，即可完成映射。如果沒有查詢結果的特殊要求建議使用resultType。

　　resultMap：需要單獨定義resultMap，實現有點麻煩，如果對查詢結果有特殊的要求，使用resultMap可以完成將關聯查詢映射pojo的屬性中。resultMap可以實現延遲加載，resultType無法實現延遲加載。

一對多查詢

　　如果需要查詢訂單及訂單明細的信息，那麼這就是一對多的查詢需求。

　　1、POJO和上面resultMap的Order的POJO相同，將訂單明細設為List作為Order的屬性。

　　2、映射文件：

 1 <!-- 訂單及訂單明細和用戶信息的map 使用繼承不用在配置訂單和用戶信息 -->
 2     <resultMap type="com.luchao.mybatis.first.po.Orders" id="ordersOrderdetailResultMap"
 3         extends="ordersUserResultMap">
 4         <collection property="orderdetails"
 5             ofType="com.luchao.mybatis.first.po.Orderdetail">
 6             <result column="orderdetail_id" property="id" />
 7             <result column="items_id" property="itemsId" />
 8             <result column="items_num" property="itemsNum" />
 9             <result column="orders_id" property="ordersId" />
10         </collection>
11     </resultMap>
12 <select id="findOrderAndOrderdetailMap" resultMap="ordersOrderdetailResultMap">
13         select
14         orders.*,
15         user.username,
16         user.sex,
17         user.address,
18         orderdetail.id orderdetail_id,
19         orderdetail.items_id,
20         orderdetail.items_num,
21         orderdetail.orders_id
22         from
23         orders,user,orderdetail
24         where orders.user_id = user.id and
25         orderdetail.orders_id = orders.id
26     </select>

　　訂單及訂單明細的resultMap，使用extends繼承，不用在中配置訂單信息和用戶信息的映射。

　　collection：對關聯查詢到多條記錄映射到集合對象中，property：將關聯查詢到多條記錄映射到Orders哪個屬性。

　　ofType：指定映射到list集合屬性中pojo的類型，注意這裡是ofType與一對一還是有區別的。

　　3、Mapper接口：

1 //查詢訂單、訂單明細和用戶信息通過resultMap
2 public List<Orders> findOrderAndOrderdetailMap() throws Exception;

　　4、測試代碼：

 1 public void findOrderAndOrderdetailMap() throws Exception {
 2         // 獲取sqlSession對象
 3         SqlSession sqlSession = sqlSessionFactory.openSession();
 4         // 創建OrderMapper對象，MyBatis自動生成mapper代理
 5         OrderMapper orderMapper = sqlSession.getMapper(OrderMapper.class);
 6         // 調用orderMapper的方法，查詢訂單和用戶信息
 7         List<Orders> orders = orderMapper.findOrderAndOrderdetailMap();
 8         System.out.println(orders.get(0).getOrderdetails().size());
 9         System.out.println(orders.size());
10     }

　　一對多小結：

　　mybatis使用resultMap的collection對關聯查詢的多條記錄映射到一個list集合屬性中。

　　使用resultType實現：

　　將訂單明細映射到orders中的orderdetails中，需要自己處理，使用雙重循環遍歷，去掉重復記錄，將訂單明細放在orderdetails中。這樣會比較麻煩。

多對多

　　如果我們查詢用戶及用戶購買商品信息，這個就是多對多，可以使用MyBatis的多對多映射。

　　將用戶信息映射到user中。在user類中添加訂單列表屬性List<Orders> orderslist，將用戶創建的訂單映射到orderslist，在Orders中添加訂單明細列表屬性List<OrderDetail>orderdetials，將訂單的明細映射到orderdetials，在OrderDetail中添加Items屬性，將訂單明細所對應的商品映射到Items。

　　1、POJO

 1 public class Orderdetail {
 2     private Integer id;
 3     private Integer ordersId;
 4     private Integer itemsId;
 5     private Integer itemsNum;
 6     //商品信息
 7     private Items items;
 8     public Integer getId() {
 9         return id;
10     }
11     public void setId(Integer id) {
12         this.id = id;
13     }
14     public Integer getOrdersId() {
15         return ordersId;
16     }
17     public void setOrdersId(Integer ordersId) {
18         this.ordersId = ordersId;
19     }
20     public Integer getItemsId() {
21         return itemsId;
22     }
23     public void setItemsId(Integer itemsId) {
24         this.itemsId = itemsId;
25     }
26     public Integer getItemsNum() {
27         return itemsNum;
28     }
29     public void setItemsNum(Integer itemsNum) {
30         this.itemsNum = itemsNum;
31     }
32     public Items getItems() {
33         return items;
34     }
35     public void setItems(Items items) {
36         this.items = items;
37     }
38     @Override
39     public String toString() {
40         return "Orderdetail [id=" + id + ", ordersId=" + ordersId
41                 + ", itemsId=" + itemsId + ", itemsNum=" + itemsNum + "]";
42     }  
43 }

　　2、映射文件：

 1 <!-- 查詢用戶及購買的商品 -->
 2     <resultMap type="com.luchao.mybatis.first.po.User" id="ordersItemsResultMap">
 3         <!-- 用戶信息 -->
 4         <id column="user_id" property="id" />
 5         <result column="username" property="username" />
 6         <result column="sex" property="sex" />
 7         <result column="address" property="address" />
 8         <!-- 訂單信息 一個用戶對應多個訂單，使用collection映射 -->
 9         <collection property="ordersList" ofType="com.luchao.mybatis.first.po.Orders">
10             <id column="id" property="id" />
11             <result column="user_id" property="userId" />
12             <result column="number" property="number" />
13             <result column="createtime" property="createtime" />
14             <result column="note" property="note" />
15             <!-- 訂單明細 一個訂單包括 多個明細 -->
16             <collection property="orderdetails"
17                 ofType="com.luchao.mybatis.first.po.Orderdetail">
18                 <id column="id" property="id" />
19                 <result column="items_id" property="itemsId" />
20                 <result column="items_num" property="itemsNum" />
21                 <result column="orders_id" property="ordersId" />
22                 <!-- 商品信息 一個訂單明細對應一個商品 -->
23                 <association property="items"
24                     javaType="com.luchao.mybatis.first.po.Items">
25                     <id column="items_id" property="id" />
26                     <result column="items_name" property="name" />
27                     <result column="items_detail" property="detail" />
28                     <result column="items_price" property="price" />
29                 </association>
30             </collection>
31         </collection>
32     </resultMap>
33 <select id="findOrderAndItemMap" resultMap="ordersItemsResultMap">
34         select
35         orders.*,
36         user.username,
37         user.sex,
38         user.address,
39         orderdetail.id orderdetail_id,
40         orderdetail.items_id,
41         orderdetail.items_num,
42         orderdetail.orders_id,
43         items.id items_id,
44         items.name items_name,
45         items.detail items_detail,
46         items.price items_price
47         from orders,user,orderdetail,items
48         where orders.user_id =
49         user.id and orderdetail.orders_id = orders.id AND orderdetail.items_id
50         = items.id
51     </select>

　　可以看出，多對多基本上就是一對多和一對一的組合，所有復雜問題基本都是簡單問題的組合，只要細細分析，理清楚其原理。

　　3、Mapper接口：

1 //查詢訂單、訂單明細和用戶信息通過resultMap
2 public List<User> findOrderAndItemMap() throws Exception;

　　4、測試代碼：

 1 public void findOrderAndItemMap() throws Exception {
 2         // 獲取sqlSession對象
 3         SqlSession sqlSession = sqlSessionFactory.openSession();
 4         // 創建OrderMapper對象，MyBatis自動生成mapper代理
 5         OrderMapper orderMapper = sqlSession.getMapper(OrderMapper.class);
 6         // 調用orderMapper的方法，查詢訂單和用戶信息
 7         List<User> users = orderMapper.findOrderAndItemMap();
 8         System.out.println(users.get(0).getOrdersList().get(0)
 9                 .getOrderdetails().get(0).getId());
10         // System.out.println(orders.size());
11 }

　　多對多查詢總結：

　　上邊的需求就使用resultType將查詢到的記錄映射到一個擴展的pojo中，很簡單實現明細清單的功能，但是這種不能實現延遲加載。使用resultMap將用戶購買的商品明細列表映射到對象中，可以實現延遲加載。使用resultMap是針對那些對查詢結果映射有特殊要求的功能，，比如特殊要求映射成list中包括多個list。