• 转：Mybatis系列之集合映射

    转：Mybatis系列之集合映射

    上篇文章我们讲了关联映射，实现了销售与登录用户之间的关联。本文我们接着来讲一讲集合映射，实现销售与客户的多对多关系。

    实现销售与客户多对多关系

    本文中仍延用《Mybatis系列之关联映射》中的映射接口和测试用例，这里仅对增加和修改的内容进行讲解。

    第一步，在动手编写映射文件之前，我们需要对Sales类增加一个List属性，用以保存销售员对应的客户列表。

    [java] view plain copy
    1. /** 
    2.  *  
    3.  */  
    4.    private List<Customer> customers;  
    5.   
    6. public Sales() {  
    7.     super();  
    8.     this.setCustomers(new ArrayList<Customer>());  
    9. }  
    10.   
    11. public List<Customer> getCustomers() {  
    12.     return customers;  
    13. }  
    14.   
    15. protected void setCustomers(List<Customer> customers) {  
    16.     this.customers = customers;  
    17. }  

    同时增加一个客户类。

    [java] view plain copy
    1. package com.emerson.learning.pojo;  
    2.   
    3. import java.sql.Timestamp;  
    4.   
    5. public class Customer {  
    6.   
    7.     /** 
    8.      *  
    9.      */  
    10.     private int customerId;  
    11.   
    12.     /** 
    13.      *  
    14.      */  
    15.     private String customerName;  
    16.   
    17.     /** 
    18.      *  
    19.      */  
    20.     private int isValid;  
    21.   
    22.     /** 
    23.      *  
    24.      */  
    25.     private Timestamp createdTime;  
    26.   
    27.     /** 
    28.      *  
    29.      */  
    30.     private Timestamp updateTime;  
    31.   
    32.     /** 
    33.      *  
    34.      */  
    35.     private User userInfo;  
    36.   
    37.     @Override  
    38.     public String toString() {  
    39.         return "Customer [customerId=" + customerId + ", customerName=" + customerName + ", isValid=" + isValid  
    40.                 + ", createdTime=" + createdTime + ", updateTime=" + updateTime + ", userInfo=" + userInfo + "]";  
    41.     }  
    42.   
    43.     public int getCustomerId() {  
    44.         return customerId;  
    45.     }  
    46.   
    47.     public void setCustomerId(int customerId) {  
    48.         this.customerId = customerId;  
    49.     }  
    50.   
    51.     public String getCustomerName() {  
    52.         return customerName;  
    53.     }  
    54.   
    55.     public void setCustomerName(String customerName) {  
    56.         this.customerName = customerName;  
    57.     }  
    58.   
    59.     public int getIsValid() {  
    60.         return isValid;  
    61.     }  
    62.   
    63.     public void setIsValid(int isValid) {  
    64.         this.isValid = isValid;  
    65.     }  
    66.   
    67.     public Timestamp getCreatedTime() {  
    68.         return createdTime;  
    69.     }  
    70.   
    71.     public void setCreatedTime(Timestamp createdTime) {  
    72.         this.createdTime = createdTime;  
    73.     }  
    74.   
    75.     public Timestamp getUpdateTime() {  
    76.         return updateTime;  
    77.     }  
    78.   
    79.     public void setUpdateTime(Timestamp updateTime) {  
    80.         this.updateTime = updateTime;  
    81.     }  
    82.   
    83.     public User getUserInfo() {  
    84.         return userInfo;  
    85.     }  
    86.   
    87.     public void setUserInfo(User userInfo) {  
    88.         this.userInfo = userInfo;  
    89.     }  
    90. }  

     

     第二步，修改映射文件。我们先使用嵌套查询方式来实现为销售加载客户列表。首先在resultMap中增加客户集合映射的定义。

    嵌套查询 

    [xml] view plain copy
    1. <!-- 定义一对多集合信息（每个销售人员对应多个客户） -->  
    2. <collection property="customers" javaType="ArrayList" column="sales_id" ofType="Customer" select="getCustomerForSales" />  

    集合映射的定义与关联映射定义很相似，除了关键字不同外，还多了两个属性JavaType和ofType。

    property用于指定在Java实体类是保存集合关系的属性名称

    JavaType用于指定在Java实体类中使用什么类型来保存集合数据，多数情况下这个属性可以省略的。

    column用于指定数据表中的外键字段名称。

    ofType用于指定集合中包含的类型。

    select用于指定查询语句。

     

    然后再定义查询客户的查询语句。

    [xml] view plain copy
    1. <select id="getCustomerForSales" resultType="com.emerson.learning.pojo.Customer">  
    2.     SELECT c.customer_id, c.customer_name, c.user_id, c.is_valid,  
    3.     c.created_time, c.update_time  
    4.     FROM customer c INNER JOIN customer_sales s USING(customer_id)  
    5.     WHERE s.sales_id = #{id}  
    6. </select>  

    需 要注意的是，无论是关联还是集合，在嵌套查询的时候，查询语句的定义都不需要使用parameterType属性定义传入的参数类型，因为通常作为外键 的，都是简单数据类型，查询语句会自动使用定义在association或是collection元素上column属性作为传入参数的。

     

    运行测试用例，看到如下结果就说明我们的映射文件是正确的了。
    [html] view plain copy
    1. Opening JDBC Connection  
    2. Created connection 632249781.  
    3. Setting autocommit to false on JDBC Connection [com.mysql.jdbc.JDBC4Connection@25af5db5]  
    4. ==>  Preparing: SELECT sales_id, sales_name, sales_phone, sales_fax, sales_email, salesman.is_valid, salesman.created_time, salesman.update_time, sys_user.user_id as user_id, user_name, user_password, nick_name, email as user_email, sys_user.is_valid as user_is_valid, sys_user.created_time as user_created_time, sys_user.update_time as user_update_time FROM salesman left outer join sys_user using(user_id) WHERE sales_id=?   
    5. ==> Parameters: 2(Integer)  
    6. <==    Columns: sales_id, sales_name, sales_phone, sales_fax, sales_email, is_valid, created_time, update_time, user_id, user_name, user_password, nick_name, user_email, user_is_valid, user_created_time, user_update_time  
    7. <==        Row: 2, Bing Gu, 021-3418 1999, null, Bing.Gu@emerson.com, 1, 2015-10-01 20:21:26.0, 2015-10-01 21:56:40.0, 25, binggu, 5f4dcc3b5aa765d61d8327deb882cf99, Bing Gu, null, 1, 2015-09-30 22:04:34.0, 2015-09-30 22:04:34.0  
    8. ====>  Preparing: SELECT c.customer_id, c.customer_name, c.user_id, c.is_valid, c.created_time, c.update_time FROM customer c INNER JOIN customer_sales s USING(customer_id) WHERE s.sales_id = ?   
    9. ====> Parameters: 2(Integer)  
    10. <====    Columns: customer_id, customer_name, user_id, is_valid, created_time, update_time  
    11. <====        Row: 161, 客户1, null, 1, 2015-10-01 20:24:05.0, 2015-10-01 20:24:05.0  
    12. <====        Row: 163, 客户2, null, 1, 2015-10-01 20:24:05.0, 2015-10-01 20:24:05.0  
    13. <====        Row: 164, 客户3, null, 1, 2015-10-01 20:24:05.0, 2015-10-01 20:24:05.0  
    14. <====      Total: 3  
    15. <==      Total: 1  

    我们看到这里与数据库进行了两查询交互，说明这里仍然存在着“Ｎ＋1”的问题。下面，我们改用嵌套结果的方式来实现销售与客户的映射关系。

    嵌套结果

    [xml] view plain copy
    1. <resultMap id="salesResultMap" type="com.emerson.learning.pojo.Sales">  
    2.     <id property="salesId" column="sales_id" />  
    3.     <result property="salesName" column="sales_name" />  
    4.     <result property="phone" column="sales_phone" />  
    5.     <result property="fax" column="sales_fax" />  
    6.     <result property="email" column="sales_email" />  
    7.     <result property="isValid" column="is_valid" />  
    8.     <result property="createdTime" column="created_time" />  
    9.     <result property="updateTime" column="update_time" />  
    10.   
    11.     <!-- 定义多对一关联信息（嵌套结果方式） -->  
    12.     <association property="userInfo" resultMap="userResult" />  
    13.   
    14.     <!-- 定义一对多集合信息（每个销售人员对应多个客户） -->  
    15.     <!-- <collection property="customers" column="sales_id" select="getCustomerForSales" /> -->  
    16.   
    17.     <collection property="customers" ofType="com.emerson.learning.pojo.Customer">  
    18.         <id property="customerId" column="customer_id" />  
    19.         <result property="customerName" column="customer_name" />  
    20.         <result property="isValid" column="is_valid" />  
    21.         <result property="createdTime" column="created_time" />  
    22.         <result property="updateTime" column="update_time" />  
    23.         <!-- 映射客户与登录用户的关联关系，请注意columnPrefix属性 -->  
    24.         <association property="userInfo" resultMap="userResult" columnPrefix="cu_" />  
    25.     </collection>  
    26. </resultMap>  

    这里将客户的映射关系直接写在了销售的resultMap中。上述代码与关联映射十分相似，只是有一点需要朋友们留心，那就是在对客户数据进行映射的时候，我们使用了association元素的一个新的属性columnPrefix。这个属性是做什么用的呢？从名字上理解，就是给每个栏位之前加上前缀。Bingo！答对了，那么什么情况下会使用到这个属性呢？后面我们会结合着修改后的查询语句来说明这个属性的使用场景。请耐心的往下看。：）

    映射结果修改好了，紧接着我们就要修改查询语句了。

    [xml] view plain copy
    1. <select id="getById" parameterType="int" resultMap="salesResultMap">  
    2.     SELECT  
    3.         s.sales_id, s.sales_name, s.sales_phone, s.sales_fax, s.sales_email,  
    4.         s.is_valid, s.created_time, s.update_time,  
    5.         su.user_id as user_id, su.user_name, su.user_password, su.nick_name,  
    6.         su.email as user_email,  
    7.         su.is_valid as user_is_valid,  
    8.         su.created_time as user_created_time,  
    9.         su.update_time as user_update_time,  
    10.         c.customer_id, c.customer_name, c.is_valid as customer_is_valid,  
    11.         c.created_time as customer_created_time,  
    12.         c.update_time as customer_update_time,  
    13.         cu.user_id as cu_user_id, cu.user_name as cu_user_name, cu.user_password as cu_user_password,   
    14.         cu.nick_name as cu_nick_name, cu.email as cu_user_email, cu.is_valid as cu_user_is_valid,  
    15.         cu.created_time as cu_user_created_time, cu.update_time as cu_user_update_time  
    16.     FROM  
    17.         salesman s LEFT OUTER JOIN sys_user su ON s.user_id = su.user_id  
    18.         INNER JOIN customer_sales cs USING(sales_id)  
    19.         LEFT OUTER JOIN customer c USING(customer_id)  
    20.         LEFT OUTER JOIN sys_user cu ON c.user_id = cu.user_id  
    21.     WHERE sales_id=#{id}  
    22. </select>  

    这 个语句乍看起来有些复杂，其实很容易理解。这里用到了四张数据表，销售、客户、客房销售关系表和登录用户表。具体的字段我就不说了，主要说一下这个登录用 户表。这张数据表在查询语句中出现了两次，为什么呢？因为销售与登录用户有关联关系，同样地，客户也与登录用户表有关联关系，所以我们需要对用户表进行两 次Join操作。

    那么问题来了，销售要用户有关联，客户也要与用户有关联，这种映射语句应该如何写呢？难道要对用户表写两次映射？聪明的朋友一定会说，我们可以复用之前写过的用户映射结果集呀！答案是肯定的。我们不妨在这里再次贴出这段代码，一起回忆一下。

    [xml] view plain copy
    1. <resultMap id="userResult" type="User">  
    2.     <id property="userId" column="user_id" />  
    3.     <result property="userName" column="user_name" />  
    4.     <result property="userPassword" column="user_password" />  
    5.     <result property="nickName" column="nick_name" />  
    6.     <result property="email" column="user_email" />  
    7.     <result property="isValid" column="user_is_valid" />  
    8.     <result property="createdTime" column="user_created_time" />  
    9.     <result property="updateTime" column="user_update_time" />  
    10. </resultMap>  

    数据表中的字段与Java实体类中的属性的映射关系是一一对应的，Mybatis会根据我们定义的映射关系，将数据表中字段的映射到Java实体类属性上。

    可 是我们的查询语句中对用户表进行了两次Join操作，第一次是销售与用户的Join，第二次是客户与用户的Join。而SQL语句是不允许在同一条查询语 句中出现相同字段名的（虽然我们有时候会这样写，但是数据库会自动帮我们为重名的字段名起个别名的，比如在字段名后添加数字）。如果我们为第二次Join 进来的用户表中的字段使用别名方式，那么就会导致映射的到客户类中的用户信息缺失，因为字段名与我们在映射文件中的定义不一致。如何解决这个问题呢？这时 候该columnPrefix属性出场了。

    Mybatis也考虑到这种情况的出现，她允许我们在重复出现的字段名前加上一个统一的字符前缀，这样就可以有效的避免字段重名，又可以复用之前定义的映射结果集。

    在 上述的查询语句中，我们为第二次Join进来的用户表中的字段都加上了“cu_”做为区分重名字段的前缀，同时使用columnPrefix属性告诉 Mybatis在第二次对用户表映射的时候，将字段名是以“cu_”打头的字段值映射到Java实体类属性当中。这样就可以正确的把客户与用户的关联信息 映射到Customer对象当中了。

    [xml] view plain copy
    1. <association property="userInfo" resultMap="userResult" columnPrefix="cu_" />  

    上述的表达可能有些臃肿，不知道小伙朋友们明白了没有。理工男的写作水平，你们懂的。

     

    彩蛋奉上（共享不同映射文件中的结果集）

    我 们之前在User.xml文件中定义过用户表的映射结果集，现在在Sales.xml中也需要使用到同样的结果集，是否可以直接跨文件引用呢？答案是肯定 的了，不然对于同一个映射结果集，我们要多处编写，多处维护，这样不仅工作量大，对日后的维护也带来了一定的麻烦。我们只需要在引用处使用结果集的全限定 名就可以了。

    [xml] view plain copy
    1. <resultMap id="salesResultMap" type="com.emerson.learning.pojo.Sales">  
    2.     <id property="salesId" column="sales_id" />  
    3.     <result property="salesName" column="sales_name" />  
    4.     <result property="phone" column="sales_phone" />  
    5.     <result property="fax" column="sales_fax" />  
    6.     <result property="email" column="sales_email" />  
    7.     <result property="isValid" column="is_valid" />  
    8.     <result property="createdTime" column="created_time" />  
    9.     <result property="updateTime" column="update_time" />  
    10.   
    11.     <!-- 定义多对一关联信息（嵌套查询方式） -->  
    12.     <!-- <association property="userInfo" column="user_id" javaType="User"   
    13.         select="selectUser" fetchType="lazy"> </association> -->  
    14.   
    15.     <!-- 定义多对一关联信息（嵌套结果方式） -->  
    16.     <association property="userInfo" resultMap="com.emerson.learning.xml.user.userResult" />  
    17.   
    18.     <!-- 定义一对多集合信息（每个销售人员对应多个客户） -->  
    19.     <!-- <collection property="customers" column="sales_id" select="getCustomerForSales"   
    20.         /> -->  
    21.   
    22.     <collection property="customers" ofType="com.emerson.learning.pojo.Customer">  
    23.         <id property="customerId" column="customer_id" />  
    24.         <result property="customerName" column="customer_name" />  
    25.         <result property="isValid" column="is_valid" />  
    26.         <result property="createdTime" column="created_time" />  
    27.         <result property="updateTime" column="update_time" />  
    28.         <association property="userInfo" resultMap="com.emerson.learning.xml.user.userResult" columnPrefix="cu_" />  
    29.     </collection>  
    30. </resultMap>  

     

     

    附录

    《Mybatis系列（一）入门》

    《Mybatis系列（二）配置》

    《Mybatis系列（三）简单示例》

    《Mybatis系列（四）映射文件》

    《Mybatis系列（五）动态SQL》

    《Mybatis系列（六）接口式编程》

    《Mybatis系列（七）关联映射》

    《Mybatis系列（九）Spring & Mybatis整合》
  • 相关阅读:
    程序员是怎么炼成的---OC题集--练习答案与题目(3)
    程序员是怎么炼成的---OC题集--练习答案与题目(2)
    152. Maximum Product Subarray
    151. Reverse Words in a String
    150. Evaluate Reverse Polish Notation
    148. Sort List
    147. Insertion Sort List
    145. Binary Tree Postorder Traversal
    144. Binary Tree Preorder Traversal
    140. Word Break II
  • 原文地址：https://www.cnblogs.com/1995hxt/p/5895958.html
Copyright © 2020-2023  润新知