程序博客网 > 编程的双引号怎么打

iBatis开发详解（9）-----------查询复杂集合

来源：互联网 发布：编程的双引号怎么打 编辑：程序博客网 时间：2024/05/16 17:41
  通常我们使用iBatis的select查询都是映射的简单对象，即便在一个查询中连接多个表也是如此，那么既然iBatis是SQL Mapper，也就是说它可以映射复杂集合，我们来看看如何让对象模型向数据模型（关系型数据模型）靠拢。 
    假设在在线购物应用中，我们有用户表User，订单表Order和订单项表OrderItem，它们之间存在的关联是显而易见的。用户可以下订单，而订单中可以包含多个项。 
    我们的数据库设计如下： 
Sql代码  收藏代码
  1. CREATE TABLE `user` (  
  2. `userId`  int(11) NOT NULL AUTO_INCREMENT ,  
  3. `userName`  varchar(50) NULL DEFAULT NULL ,  
  4. `password`  varchar(32) NULL DEFAULT NULL ,  
  5. `mobile`  varchar(11) NULL DEFAULT NULL ,  
  6. `email`  varchar(50) NULL DEFAULT NULL ,  
  7. `age`  int(3) NULL DEFAULT NULL ,  
  8. PRIMARY KEY (`userId`)  
  9. )  

    订单表为： 
Sql代码  收藏代码
  1. CREATE TABLE `order` (  
  2. `orderId`  int(11) NOT NULL AUTO_INCREMENT ,  
  3. `orderName`  varchar(50) NULL DEFAULT NULL ,  
  4. `generateTime`  datetime NULL DEFAULT NULL ,  
  5. `userId`  int(11) NULL DEFAULT NULL ,  
  6. PRIMARY KEY (`orderId`)  
  7. )  

    订单项表为： 
Sql代码  收藏代码
  1. CREATE TABLE `orderItem` (  
  2. `orderItemId`  int(11) NOT NULL AUTO_INCREMENT ,  
  3. `itemName`  varchar(50) NULL DEFAULT NULL ,  
  4. `quantity`  int(3) NULL DEFAULT NULL ,  
  5. `price`  float NULL DEFAULT NULL ,  
  6. `orderId`  int(11) NOT NULL ,  
  7. PRIMARY KEY (`orderItemId`)  
  8. )  

    三个表之前通过userId和orderId进行关联，这里仅做示例性说明，并没有添加物理外键关联。 
    下面我们设计POJO来描述这三个对象： 
Java代码  收藏代码
  1. package ibatis.model;  
  2. public class OrderItem implements java.io.Serializable {  
  3.     private Integer orderItemId;  
  4.     private String itemName;  
  5.     private int quantity;  
  6.     private float price;  
  7.     private Integer orderId;  
  8.     public OrderItem() {  
  9.     }  
  10.     public OrderItem(Integer orderItemId, String itemName, int quantity,  
  11.             float price, Integer orderId) {  
  12.         super();  
  13.         this.orderItemId = orderItemId;  
  14.         this.itemName = itemName;  
  15.         this.quantity = quantity;  
  16.         this.price = price;  
  17.         this.orderId = orderId;  
  18.     }  
  19.     //Setters And Getters  
  20.     public String toString() {  
  21.         return "OrderItem [itemName=" + itemName + ", orderItemId=" + orderItemId+ ", orderId=" + orderId + ", price=" + price + ", quantity="  
  22.                 + quantity + "]";  
  23.     }  
  24. }  

    我们使用各个属性连描述orderItem表的字段，下面是order对象： 
Java代码  收藏代码
  1. package ibatis.model;  
  2. import java.util.Arrays;  
  3. public class OrderInfo {  
  4.     private Order order;  
  5.     private OrderItem[] orderItemList;  
  6.     public Order getOrder() {  
  7.         return order;  
  8.     }  
  9.     public void setOrder(Order order) {  
  10.         this.order = order;  
  11.     }  
  12.     public OrderItem[] getOrderItemList() {  
  13.         return orderItemList;  
  14.     }  
  15.     public void setOrderItemList(OrderItem[] orderItemList) {  
  16.         this.orderItemList = orderItemList;  
  17.     }  
  18.     public String toString() {  
  19.         return "OrderInfo [order=" + order + ", orderItemList="  
  20.                 + Arrays.toString(orderItemList) + "]";  
  21.     }  
  22. }  

    使用数组来存放每个订单的订单项，分别给出setter和getter方法。下面是user对象： 
Java代码  收藏代码
  1. package ibatis.model;  
  2. import java.util.Arrays;  
  3. public class UserInfo {  
  4.     private User user;  
  5.     private OrderInfo[] orderList;  
  6.     public User getUser() {  
  7.         return user;  
  8.     }  
  9.     public void setUser(User user) {  
  10.         this.user = user;  
  11.     }  
  12.     public OrderInfo[] getOrderList() {  
  13.         return orderList;  
  14.     }  
  15.     public void setOrderList(OrderInfo[] orderList) {  
  16.         this.orderList = orderList;  
  17.     }  
  18.     public String toString() {  
  19.         return "UserInfo [orderList=" + Arrays.toString(orderList) + ", user="+ user + "]";  
  20.     }  
  21. }  

    和OrderInfo类似，我们也使用数组来存放用户所下的订单。 
    那么实体对象和数据表我们就都有了，下面来编写iBatis的sqlMap文件来描述它们之间的关系，我们自定义resultMap来说明： 
Xml代码  收藏代码
  1. <resultMap class="ibatis.model.OrderItem" id="ResultOrderItemMap">  
  2.     <result property="orderId" column="orderId" />  
  3.     <result property="orderItemId" column="orderItemId" />  
  4.     <result property="itemName" column="itemName" />  
  5.     <result property="quantity" column="quantity" />  
  6.     <result property="price" column="price" />  
  7. </resultMap>  

    描述OrderItem则是最简单的了，就是刻画各个属性即可。 
Xml代码  收藏代码
  1. <resultMap class="ibatis.model.OrderInfo" id="ResultOrderInfoMap">  
  2.     <result property="order.orderId" column="orderId" />  
  3.     <result property="order.orderName" column="orderName" />  
  4.     <result property="order.generateTime" column="generateTime" />  
  5.     <result property="orderItemList" select="pioneer.getOrderItemList"  
  6.         column="orderId" />  
  7. </resultMap>  
  8. <select id="getOrderItemList" resultMap="ResultOrderItemMap">  
  9.     select  
  10.         orderId,  
  11.         orderItemId,  
  12.         itemName,  
  13.         quantity,  
  14.         price  
  15.     from  
  16.         orderItem  
  17.     where  
  18.         orderId = #orderId#  
  19. </select>  

    在刻画OrderInfo时，我们加入了一个select查询，就是查到该订单下的所有订单项，并使用数组保存起来，那么上面这段XML代码就好理解了。 
Xml代码  收藏代码
  1. <resultMap class="ibatis.model.UserInfo" id="ResultUserInfoMap">  
  2.     <result property="user.userId" column="userId" />  
  3.     <result property="user.userName" column="userName"/>  
  4.     <result property="orderList" select="pioneer.getOrderInfoList"  
  5.         column="userId" />  
  6. </resultMap>  
  7. <select id="getOrderInfoList" resultMap="ResultOrderInfoMap">  
  8.     select  
  9.         orderId,  
  10.         orderName,  
  11.         generateTime  
  12.     from  
  13.         test.order  
  14.     where  
  15.         userId = #userId#  
  16. </select>  

    和上面的订单项是类似的，我们在查询用户时，也把用户所下的订单都给查出来。最后我们是要获取内系统的所有用户，那么使用下面的这个SQL： 
Xml代码  收藏代码
  1. <select id="getUserInfoList" resultMap="ResultUserInfoMap">  
  2.     select  
  3.         userId,  
  4.         userName  
  5.     from  
  6.         user  
  7. </select>  

    综上的XML表述了这么一个需求，就是查询系统的内的所有用户，以及它们所下的所有订单，并还要查出每个订单项。 
    那么示例程序就很简单了： 
Java代码  收藏代码
  1. package ibatis;  
  2. import ibatis.model.UserInfo;  
  3. import java.io.IOException;  
  4. import java.io.Reader;  
  5. import java.util.ArrayList;  
  6. import com.ibatis.common.resources.Resources;  
  7. import com.ibatis.sqlmap.client.SqlMapClient;  
  8. import com.ibatis.sqlmap.client.SqlMapClientBuilder;  
  9. public class UserInfoDemo {  
  10.     private static String config = "ibatis/SqlMapConfig.xml";  
  11.     private static Reader reader;  
  12.     private static SqlMapClient sqlMap;  
  13.     static {  
  14.         try {  
  15.             reader = Resources.getResourceAsReader(config);  
  16.         } catch (IOException e) {  
  17.             e.printStackTrace();  
  18.         }  
  19.         sqlMap = SqlMapClientBuilder.buildSqlMapClient(reader);  
  20.     }  
  21.     public static void main(String[] args) throws Exception {  
  22.         long start = System.currentTimeMillis();  
  23.         ArrayList<UserInfo> userInfoList = (ArrayList<UserInfo>) sqlMap  
  24.                 .queryForList("pioneer.getUserInfoList");  
  25.         long end = System.currentTimeMillis();  
  26.         System.out.println(userInfoList);  
  27.         System.out.println((end - start) + " ms");  
  28.     }}  

    运行程序，我们可以得到如下输出： 
 
    查询得到的内容为： 
    [UserInfo [orderList=[OrderInfo [order=Order [generateTime=Mon Aug 27 21:35:27 CST 2012, orderId=1, orderItems=null, orderName=Mobile Phone], orderItemList=[OrderItem [itemName=Moto MB525, orderItemId=1, orderId=1, price=1000.0, quantity=1], OrderItem [itemName=Moto MB526, orderItemId=2, orderId=1, price=1200.0, quantity=1]]], OrderInfo [order=Order [generateTime=Mon Aug 27 22:28:38 CST 2012, orderId=2, orderItems=null, orderName=Laptop], orderItemList=[OrderItem [itemName=Lenovo X201, orderItemId=3, orderId=2, price=5000.0, quantity=1], OrderItem [itemName=Lenovo X220, orderItemId=4, orderId=2, price=7000.0, quantity=1]]]], user=User [age=0, email=null, mobile=null, password=null, userId=1, userName=Sarin]]] 
    他们都是以对象的形式来描述的，因为我们命没有查询user的email，mobile等信息，所以它们是null。 
    程序编写完了，但是问题随之而来。先看这么一大堆的输出，我们仅仅有1个用户的两个订单，每个订单仅包含2个项。如果我们的系统内有10000个用户，每个用户下了100个订单，每个订单有5项，那么一次查询结果就会生成500万个对象，显然在数据不是很多时，就已经带来了问题。首先这是一个数据库I/O的问题，大量数据库I/O和内存对象，降低了性能，消耗了资源。其次是N+1查询问题。 
    N+1问题也好理解，在本例中，我们要查询一个用户的N个订单，还要查询这N个订单中每个订单的N个订单项，就产生了N+1查询问题。 
    iBatis提供了针对每个问题的解决方案，但是却不能同时解决这两个问题。 
    针对数据库I/O，我们很容易想到延迟加载的特性，就是对于所有数据并不是一次全部查出，在需要的时候继续进行查询，那么就会大幅度减少数据库的I/O，开启iBatis的延迟加载特性非常简单，只需修改如下XML设置即可： 
Xml代码  收藏代码
  1. <?xml version="1.0" encoding="UTF-8" ?>  
  2. <!DOCTYPE sqlMapConfig        
  3.     PUBLIC "-//ibatis.apache.org//DTD SQL Map Config 2.0//EN"        
  4.     "http://ibatis.apache.org/dtd/sql-map-config-2.dtd">  
  5. <sqlMapConfig>  
  6.     ......  
  7.     <settings useStatementNamespaces="true" lazyLoadingEnabled="true" />  
  8.     ......  
  9. </sqlMapConfig>  

    也就是在settings中设置了lazyLoadingEnabled为true，如果想开启cglib的增强版，需要在类路径下添加相关jar包，并设置enhancementEnabled为true即可。但是要清楚一点，这些设置都是全局的设置，也就是说项目中的其它iBatis查询都将应用延迟加载特性。下面我们来测试一下代码： 
 
    可以看到，在仅有的几条数据时，所消耗的时间也大幅减少，说明延迟加载特性已经启用。 
    下面我们来看针对N+1查询问题的解决方案，那就是使用iBatis在resultMap中为我们提供的groupBy属性。我们将上面的XML文件修改如下： 
Xml代码  收藏代码
  1. <resultMap class="ibatis.model.UserInfo" id="ResultUserInfoMapN" groupBy="user.userId">  
  2.     <result property="user.userId" column="userId" />  
  3.     <result property="user.userName" column="userName"/>  
  4.     <result property="orderList" resultMap="pioneer.ResultOrderInfoMapN" />  
  5. </resultMap>  
  6. <resultMap class="ibatis.model.OrderInfo" id="ResultOrderInfoMapN" groupBy="order.orderId">  
  7.     <result property="order.orderId" column="orderId" />  
  8.     <result property="order.orderName" column="orderName" />  
  9.     <result property="order.generateTime" column="generateTime" />  
  10.     <result property="orderItemList" resultMap="pioneer.ResultOrderItemMapN" />  
  11. </resultMap>  
  12. <resultMap class="ibatis.model.OrderItem" id="ResultOrderItemMapN">  
  13.     <result property="orderId" column="orderId" />  
  14.     <result property="orderItemId" column="orderItemId" />  
  15.     <result property="itemName" column="itemName" />  
  16.     <result property="quantity" column="quantity" />  
  17.     <result property="price" column="price" />  
  18. </resultMap>  
  19. <select id="getUserInfoListN" resultMap="ResultUserInfoMapN">  
  20.     select  
  21.         user.userId as userId,  
  22.         user.userName as userName,  
  23.         test.order.orderId as orderId,  
  24.         test.order.orderName as orderName,  
  25.         test.order.generateTime as generateTime,  
  26.         orderItem.*  
  27.     from  
  28.         user join test.order on user.userId=test.order.userId join orderItem on test.order.orderId=orderItem.orderId  
  29.     order by  
  30.         userId,test.order.orderId,orderItemId  
  31. </select>  

    resultMap的配置使用了groupBy属性，其余和上面配置类似，而这次我们的查询语句就合并成一个连接查询，测试时，需要修改POJO中的数组变量为单对象变量，那么执行程序后，我们得到如下效果： 
 
    也可以看到查询效率的显著提升。 
    综上所述，延迟加载适用于大型数据集合，但是并非其中的每条记录都会被用到。此方法前期的性能大幅度提高，但是后期仍需加载所需数据。而N+1查询解决方案适用于小型数据集合或者是所有数据都肯定会被用到的数据集合，使得整体性能得到提高。 
0 0
编程的双引号怎么打 编程的双引号怎么打
原创粉丝点击
热门IT博客
淘宝客有什么要求淘宝客有什么要求
软件测试全程项目软件测试全程项目
深圳软件产业基地2栋
霸业传奇宝石升级数据
网络刷客
org.json jar包
阿里云cdn
优酷账号怎么解绑淘宝
ps移花接木软件
linux新建文档命令
淘宝网迪士尼书包
青岛阿里云数据中心
长虹电视无法连接网络
虚拟机安装mac系统
淘宝隐藏优惠券怎么找
义乌淘宝摄影工作室
物理其实很简单. 淘宝
医用软件采购申请报告
电信网络诈骗宣传总结
mac怎么查看无线密码
热门问题 老师的惩罚 人脸识别 我在镇武司摸鱼那些年 重生之率土为王 我在大康的咸鱼生活 盘龙之生命进化 天生仙种 凡人之先天五行 春回大明朝 姑娘不必设防，我是瞎子 a+ ~a a\' a+a a- \'a a淘宝 特级a丫 a罩杯 一极大黄a 一级a标准 京东方a 国产a 国产a2 维a酸乳膏 四溴双酚a 高级a a组 a总 日本a免费不卡 国产区a1区黄 日本一本a高清免费 日本高清不卡a免费网站 a++ a0图纸尺寸 a0尺寸 a0 0pp0a9 ppa z00p0rh1a opp0a9 0pp0a7x 0x0000007a 0pp0a9x 0pp0a9s多少钱 0pp0a9手机 0pp0a11x手机多少钱 0pp0a11x 0a a0纸尺寸 0pp0a5手机价格

程序博客网，程序员的互联网技术博客家园。csdn论坛精品 msdn技术资料都在这里