分享

mybatis“集合嵌套查询”和“集合嵌套结果”两种方法实现数据库一对多关系

 chopinli 2017-06-16

两个实体类分别如下:User用户类和Goods商品类。一个用户对应多个商品(一对多)

  1. package com.leo.entity;  
  2.   
  3. import java.util.List;  
  4. public class User {  
  5.     private Integer id;  
  6.     private String username;  
  7.     private Integer age;  
  8.     private String address;  
  9.     private List<Goods> goodsList;  
  10.   
  11.     public List<Goods> getGoodsList() {  
  12.         return goodsList;  
  13.     }  
  14.     public void setGoodsList(List<Goods> goodsList) {  
  15.         this.goodsList = goodsList;  
  16.     }  
  17.     public Integer getId() {  
  18.         return id;  
  19.     }  
  20.     public void setId(Integer id) {  
  21.         this.id = id;  
  22.     }  
  23.     public String getUsername() {  
  24.         return username;  
  25.     }  
  26.     public void setUsername(String username) {  
  27.         this.username = username;  
  28.     }  
  29.     public Integer getAge() {  
  30.         return age;  
  31.     }  
  32.     public void setAge(Integer age) {  
  33.         this.age = age;  
  34.     }  
  35.     public String getAddress() {  
  36.         return address;  
  37.     }  
  38.     public void setAddress(String address) {  
  39.         this.address = address;  
  40.     }  
  41.     public User() {  
  42.         super();  
  43.         // TODO Auto-generated constructor stub  
  44.     }  
  45.     @Override  
  46.     public String toString() {  
  47.         return "User [id=" + id + ", username=" + username + ", age=" + age  
  48.                 + ", address=" + address + ", goodsList=" + goodsList + "]";  
  49.     }  
  50.       
  51.       
  52.       
  53.       
  54.       
  55. }  
Goods商品类

  1. package com.leo.entity;  
  2.   
  3. public class Goods {  
  4.     private Integer id;  
  5.     private String goodsName;  
  6.     private Integer goodsNumber;  
  7.     private Integer user_id;  
  8.       
  9.       
  10.       
  11.     public Integer getId() {  
  12.         return id;  
  13.     }  
  14.     public void setId(Integer id) {  
  15.         this.id = id;  
  16.     }  
  17.     public String getGoodsName() {  
  18.         return goodsName;  
  19.     }  
  20.     public void setGoodsName(String goodsName) {  
  21.         this.goodsName = goodsName;  
  22.     }  
  23.     public Integer getGoodsNumber() {  
  24.         return goodsNumber;  
  25.     }  
  26.     public void setGoodsNumber(Integer goodsNumber) {  
  27.         this.goodsNumber = goodsNumber;  
  28.     }  
  29.     public Integer getUser_id() {  
  30.         return user_id;  
  31.     }  
  32.     public void setUser_id(Integer user_id) {  
  33.         this.user_id = user_id;  
  34.     }  
  35.       
  36.       
  37.       
  38.       
  39. }  

User实体类的mapper映射文件:UserDao.xml 

  1. <?xml version="1.0" encoding="UTF-8" ?>     
  2. <!DOCTYPE mapper PUBLIC "-////DTD Mapper 3.0//EN"   
  3.     "http:///dtd/mybatis-3-mapper.dtd">     
  4.     <mapper namespace="com.leo.mapper.UserDao">         
  5.         <resultMap type="User"  id="userMap">  
  6.             <id column="u_id" property="id" />  
  7.             <result column="username" property="username" />  
  8.             <result column="age" property="age" />  
  9.             <result column="address" property="address" />  
  10.             <!--当表之间的关系是一对多时,用 collection-->          <!-- 这里的 column="u_id"是为了传参数到嵌套的查询select="....."-->  
  11.             <collection property="goodsList" ofType="Goods" column="u_id" select="com.leo.mapper.GoodsDao.selectGoodsForUser" />  
  12.         </resultMap>      <!--goodsList是User实体类中的 私有属性集合 -->                                                      
  13.         <select id="getUserinfoById" parameterType="int"  resultMap="userMap">  
  14.             select   
  15.                 u.id as u_id,  
  16.                 u.username,  
  17.                 u.age,   
  18.                 u.address   
  19.             from  
  20.                 user u  
  21.              where   
  22.                 u.id =${value};  
  23.         </select>  
  24.     </mapper>   

Goods实体类的mapper映射文件:GoodsDao.xml 

  1. <?xml version="1.0" encoding="UTF-8" ?>     
  2. <!DOCTYPE mapper PUBLIC "-////DTD Mapper 3.0//EN"   
  3.     "http:///dtd/mybatis-3-mapper.dtd">  
  4.     <!-- 这就是那个嵌套的查询映射 -->     
  5.     <mapper namespace="com.leo.mapper.GoodsDao">  
  6.         <select id="selectGoodsForUser" parameterType="int" resultType="Goods">  
  7.           SELECT id,goodsName,goodsNumber,user_id FROM Goods WHERE user_id = #{value}  
  8.         </select>  
  9.     </mapper>    


mabatis的环境配置文件mabatis-config.xml
  1. <?xml version="1.0" encoding="UTF-8"?>     
  2. <!DOCTYPE configuration    
  3.   PUBLIC "-////DTD Config 3.0//EN"    
  4.   "http:///dtd/mybatis-3-config.dtd">       
  5. <configuration>  
  6.     <!-- 我把数据源的内容放在db.properties文件中 -->  
  7.     <properties resource="com/leo/resources/db.properties" />  
  8.       
  9.     <!--start-类型别名 :为mapper.xml中resultType取一个别名,看着不会很冗余-->  
  10.     <typeAliases>  
  11.       <typeAlias alias="User" type="com.leo.entity.User"/>  
  12.       <typeAlias alias="Goods" type="com.leo.entity.Goods"/>  
  13.     </typeAliases>  
  14.     <!-- end- 类型别名-->  
  15.       
  16.     <!-- start- environments配置 -->  
  17.     <environments default="development">     
  18.        <environment id="development">     
  19.            <transactionManager type="JDBC"/>     
  20.            <dataSource type="POOLED">     
  21.                <property name="driver" value="${driverClass}"/><!-- 数据源配置 -->   
  22.                <property name="url" value="${url}"/>     
  23.                <property name="username" value="${username}"/>     
  24.                <property name="password" value="${password}"/>     
  25.            </dataSource>     
  26.        </environment>     
  27.     </environments>  
  28.     <!-- end- environments配置 -->     
  29.       
  30.     <!-- 连接到实体类的映射文件资源-->  
  31.     <mappers>     
  32.         <mapper resource="com/leo/entity/UserDao.xml" />  
  33.         <mapper resource="com/leo/entity/GoodsDao.xml" />  
  34.     </mappers>     
  35. </configuration>  
测试的servlet(也可以用main函数测试)

  1. package com.leo.servlet;  
  2.   
  3. import java.io.IOException;  
  4. import java.io.InputStream;  
  5. import java.util.List;  
  6.   
  7. import javax.servlet.ServletException;  
  8. import javax.servlet.annotation.WebServlet;  
  9. import javax.servlet.http.HttpServlet;  
  10. import javax.servlet.http.HttpServletRequest;  
  11. import javax.servlet.http.HttpServletResponse;  
  12.   
  13. import org.apache.ibatis.io.Resources;  
  14. import org.apache.ibatis.session.ResultHandler;  
  15. import org.apache.ibatis.session.SqlSession;  
  16. import org.apache.ibatis.session.SqlSessionFactory;  
  17. import org.apache.ibatis.session.SqlSessionFactoryBuilder;  
  18.   
  19. import com.leo.entity.Goods;  
  20. import com.leo.entity.User;  
  21. import com.leo.mapper.GoodsDao;  
  22. import com.leo.mapper.UserDao;  
  23.   
  24.   
  25.   
  26. /**  
  27.  * Servlet implementation class MybatisServlet  
  28.  */  
  29. @WebServlet("/MybatisServlet")  
  30. public class MybatisServlet extends HttpServlet {  
  31.     private static final long serialVersionUID = 1L;  
  32.   
  33.     protected void doGet(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {  
  34.         InputStream is = Resources.getResourceAsStream("com/leo/resources/mybatis-config.xml");  
  35.         SqlSessionFactory factory = new SqlSessionFactoryBuilder().build(is);  
  36.         SqlSession session = factory.openSession();  
  37.           
  38. //      UserDao ud = session.getMapper(UserDao.class);  
  39.         GoodsDao gd = session.getMapper(GoodsDao.class);  
  40.   
  41.         List<Goods> goodsList= gd.selectGoodsForUser(1);  
  42.           
  43. //      User user = ud.getUserinfoById(1);        
  44. //      System.out.println(user);  
  45. //      List<Goods> goodsList  =  user.getGoodsList();  
  46.         for (Goods goods : goodsList) {  
  47.             System.out.println(goods.getId()+"   "+ goods.getGoodsName()+"   "+goods.getGoodsNumber()+ "  "+ goods.getUser_id());  
  48.         }  
  49.         session.commit();  
  50.         session.close();  
  51.           
  52.     }  
  53.       
  54.     protected void doPost(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {  
  55.         doGet(request, response);  
  56.           
  57.     }  
  58.   
  59. }  

以上是集合嵌套查询,还有一种方式是集合嵌套结果,这种方式只需要一个实体类文件即可,它是一种级联查询,自动完成的

下面用集合嵌套结果这种方式:

只需要改动UserDao.xml,且只是用这一个映射文件就可以完成

  1. <?xml version="1.0" encoding="UTF-8" ?>     
  2. <!DOCTYPE mapper PUBLIC "-////DTD Mapper 3.0//EN"   
  3.     "http:///dtd/mybatis-3-mapper.dtd">     
  4.     <mapper namespace="com.leo.mapper.UserDao">  
  5.           
  6.           
  7.         <resultMap type="Goods" id="goodsMap">  
  8.             <id column="g_id" property="id"/>  
  9.             <result column="goodsName" property="goodsName"/>  
  10.             <result column="goodsNumber" property="goodsNumber"/>  
  11.             <result column="user_id" property="user_id"/>  
  12.         </resultMap>  
  13.           
  14.         <resultMap type="User"  id="userMap">  
  15.             <id column="u_id" property="id" />  
  16.             <result column="username" property="username" />  
  17.             <result column="age" property="age" />  
  18.             <result column="address" property="address" />  
  19.             <collection property="goodsList" ofType="Goods" resultMap="goodsMap" /><!--两种方式的不同之处在这里,自己分析就可以知道-->  
  20.         </resultMap>  
  21.         <select id="getUserinfoById" parameterType="int" resultMap="userMap">  
  22.             select   
  23.                 u.id as u_id,  
  24.                 u.username,  
  25.                 u.age,  
  26.                 u.address,  
  27.                 g.id as g_id,   <!--嵌套结果这种方式是使用了一次连接查询,而嵌套查询使用了两次 -->  
  28.                 g.goodsName,  
  29.                 g.goodsNumber,  
  30.                 g.user_id  
  31.              from  
  32.                 user u  
  33.                 inner join goods g on u.id = g.user_id  
  34.              where   
  35.                 u.id =${value};  
  36.         </select>   
  37.     </mapper>    


希望可以帮到大家,有什么措辞不正确,希望得到指正,希望进步


    本站是提供个人知识管理的网络存储空间,所有内容均由用户发布,不代表本站观点。请注意甄别内容中的联系方式、诱导购买等信息,谨防诈骗。如发现有害或侵权内容,请点击一键举报。
    转藏 分享 献花(0

    0条评论

    发表

    请遵守用户 评论公约

    类似文章 更多