iBatis查询复杂集合

程序员文章站 2022-05-17 15:11:36

...

    本文系iBatis开发详解系列文章之在iBatis查询复杂集合
    通常我们使用iBatis的select查询都是映射的简单对象，即便在一个查询中连接多个表也是如此，那么既然iBatis是SQL Mapper，也就是说它可以映射复杂集合，我们来看看如何让对象模型向数据模型（关系型数据模型）靠拢。
    假设在在线购物应用中，我们有用户表User，订单表Order和订单项表OrderItem，它们之间存在的关联是显而易见的。用户可以下订单，而订单中可以包含多个项。
    我们的数据库设计如下：

CREATE TABLE `user` (
`userId`  int(11) NOT NULL AUTO_INCREMENT ,
`userName`  varchar(50) NULL DEFAULT NULL ,
`password`  varchar(32) NULL DEFAULT NULL ,
`mobile`  varchar(11) NULL DEFAULT NULL ,
`email`  varchar(50) NULL DEFAULT NULL ,
`age`  int(3) NULL DEFAULT NULL ,
PRIMARY KEY (`userId`)
)

订单表为：

CREATE TABLE `order` (
`orderId`  int(11) NOT NULL AUTO_INCREMENT ,
`orderName`  varchar(50) NULL DEFAULT NULL ,
`generateTime`  datetime NULL DEFAULT NULL ,
`userId`  int(11) NULL DEFAULT NULL ,
PRIMARY KEY (`orderId`)
)

订单项表为：

CREATE TABLE `orderItem` (
`orderItemId`  int(11) NOT NULL AUTO_INCREMENT ,
`itemName`  varchar(50) NULL DEFAULT NULL ,
`quantity`  int(3) NULL DEFAULT NULL ,
`price`  float NULL DEFAULT NULL ,
`orderId`  int(11) NOT NULL ,
PRIMARY KEY (`orderItemId`)
)

三个表之前通过userId和orderId进行关联，这里仅做示例性说明，并没有添加物理外键关联。
下面我们设计POJO来描述这三个对象：

package ibatis.model;
public class OrderItem implements java.io.Serializable {
	private Integer orderItemId;
	private String itemName;
	private int quantity;
	private float price;
	private Integer orderId;
	public OrderItem() {
	}
	public OrderItem(Integer orderItemId, String itemName, int quantity,
			float price, Integer orderId) {
		super();
		this.orderItemId = orderItemId;
		this.itemName = itemName;
		this.quantity = quantity;
		this.price = price;
		this.orderId = orderId;
	}
	//Setters And Getters
	public String toString() {
		return "OrderItem [itemName=" + itemName + ", orderItemId=" + orderItemId+ ", orderId=" + orderId + ", price=" + price + ", quantity="
				+ quantity + "]";
	}
}

我们使用各个属性连描述orderItem表的字段，下面是order对象：

package ibatis.model;
import java.util.Arrays;
public class OrderInfo {
	private Order order;
	private OrderItem[] orderItemList;
	public Order getOrder() {
		return order;
	}
	public void setOrder(Order order) {
		this.order = order;
	}
	public OrderItem[] getOrderItemList() {
		return orderItemList;
	}
	public void setOrderItemList(OrderItem[] orderItemList) {
		this.orderItemList = orderItemList;
	}
	public String toString() {
		return "OrderInfo [order=" + order + ", orderItemList="
				+ Arrays.toString(orderItemList) + "]";
	}
}

使用数组来存放每个订单的订单项，分别给出setter和getter方法。下面是user对象：

package ibatis.model;
import java.util.Arrays;
public class UserInfo {
	private User user;
	private OrderInfo[] orderList;
	public User getUser() {
		return user;
	}
	public void setUser(User user) {
		this.user = user;
	}
	public OrderInfo[] getOrderList() {
		return orderList;
	}
	public void setOrderList(OrderInfo[] orderList) {
		this.orderList = orderList;
	}
	public String toString() {
		return "UserInfo [orderList=" + Arrays.toString(orderList) + ", user="+ user + "]";
	}
}

和OrderInfo类似，我们也使用数组来存放用户所下的订单。
那么实体对象和数据表我们就都有了，下面来编写iBatis的sqlMap文件来描述它们之间的关系，我们自定义resultMap来说明：

	<resultMap class="ibatis.model.OrderItem" id="ResultOrderItemMap">
		<result property="orderId" column="orderId" />
		<result property="orderItemId" column="orderItemId" />
		<result property="itemName" column="itemName" />
		<result property="quantity" column="quantity" />
		<result property="price" column="price" />
	</resultMap>

描述OrderItem则是最简单的了，就是刻画各个属性即可。

	<resultMap class="ibatis.model.OrderInfo" id="ResultOrderInfoMap">
		<result property="order.orderId" column="orderId" />
		<result property="order.orderName" column="orderName" />
		<result property="order.generateTime" column="generateTime" />
		<result property="orderItemList" select="pioneer.getOrderItemList"
			column="orderId" />
	</resultMap>
	<select id="getOrderItemList" resultMap="ResultOrderItemMap">
		select
			orderId,
			orderItemId,
			itemName,
			quantity,
			price
		from
			orderItem
		where
			orderId = #orderId#
	</select>

在刻画OrderInfo时，我们加入了一个select查询，就是查到该订单下的所有订单项，并使用数组保存起来，那么上面这段XML代码就好理解了。

	<resultMap class="ibatis.model.UserInfo" id="ResultUserInfoMap">
		<result property="user.userId" column="userId" />
		<result property="user.userName" column="userName"/>
		<result property="orderList" select="pioneer.getOrderInfoList"
			column="userId" />
	</resultMap>
	<select id="getOrderInfoList" resultMap="ResultOrderInfoMap">
		select
			orderId,
			orderName,
			generateTime
		from
			test.order
		where
			userId = #userId#
	</select>

和上面的订单项是类似的，我们在查询用户时，也把用户所下的订单都给查出来。最后我们是要获取内系统的所有用户，那么使用下面的这个SQL：

	<select id="getUserInfoList" resultMap="ResultUserInfoMap">
		select
			userId,
			userName
		from
			user
	</select>

综上的XML表述了这么一个需求，就是查询系统的内的所有用户，以及它们所下的所有订单，并还要查出每个订单项。
那么示例程序就很简单了：

package ibatis;
import ibatis.model.UserInfo;
import java.io.IOException;
import java.io.Reader;
import java.util.ArrayList;
import com.ibatis.common.resources.Resources;
import com.ibatis.sqlmap.client.SqlMapClient;
import com.ibatis.sqlmap.client.SqlMapClientBuilder;
public class UserInfoDemo {
	private static String config = "ibatis/SqlMapConfig.xml";
	private static Reader reader;
	private static SqlMapClient sqlMap;
	static {
		try {
			reader = Resources.getResourceAsReader(config);
		} catch (IOException e) {
			e.printStackTrace();
		}
		sqlMap = SqlMapClientBuilder.buildSqlMapClient(reader);
	}
	public static void main(String[] args) throws Exception {
		long start = System.currentTimeMillis();
		ArrayList<UserInfo> userInfoList = (ArrayList<UserInfo>) sqlMap
				.queryForList("pioneer.getUserInfoList");
		long end = System.currentTimeMillis();
		System.out.println(userInfoList);
		System.out.println((end - start) + " ms");
	}}

运行程序，我们可以得到如下输出：
iBatis查询复杂集合

博客分类：框架技术 ibatis企业应用

    查询得到的内容为：
    [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 version="1.0" encoding="UTF-8" ?>
<!DOCTYPE sqlMapConfig      
    PUBLIC "-//ibatis.apache.org//DTD SQL Map Config 2.0//EN"      
    "http://ibatis.apache.org/dtd/sql-map-config-2.dtd">
<sqlMapConfig>
	......
	<settings useStatementNamespaces="true" lazyLoadingEnabled="true" />
	......
</sqlMapConfig>

也就是在settings中设置了lazyLoadingEnabled为true，如果想开启cglib的增强版，需要在类路径下添加相关jar包，并设置enhancementEnabled为true即可。但是要清楚一点，这些设置都是全局的设置，也就是说项目中的其它iBatis查询都将应用延迟加载特性。下面我们来测试一下代码：
iBatis查询复杂集合

博客分类：框架技术 ibatis企业应用

可以看到，在仅有的几条数据时，所消耗的时间也大幅减少，说明延迟加载特性已经启用。
下面我们来看针对N+1查询问题的解决方案，那就是使用iBatis在resultMap中为我们提供的groupBy属性。我们将上面的XML文件修改如下：

	<resultMap class="ibatis.model.UserInfo" id="ResultUserInfoMapN" groupBy="user.userId">
		<result property="user.userId" column="userId" />
		<result property="user.userName" column="userName"/>
		<result property="orderList" resultMap="pioneer.ResultOrderInfoMapN" />
	</resultMap>
	<resultMap class="ibatis.model.OrderInfo" id="ResultOrderInfoMapN" groupBy="order.orderId">
		<result property="order.orderId" column="orderId" />
		<result property="order.orderName" column="orderName" />
		<result property="order.generateTime" column="generateTime" />
		<result property="orderItemList" resultMap="pioneer.ResultOrderItemMapN" />
	</resultMap>
	<resultMap class="ibatis.model.OrderItem" id="ResultOrderItemMapN">
		<result property="orderId" column="orderId" />
		<result property="orderItemId" column="orderItemId" />
		<result property="itemName" column="itemName" />
		<result property="quantity" column="quantity" />
		<result property="price" column="price" />
	</resultMap>
	<select id="getUserInfoListN" resultMap="ResultUserInfoMapN">
		select
			user.userId as userId,
			user.userName as userName,
			test.order.orderId as orderId,
			test.order.orderName as orderName,
			test.order.generateTime as generateTime,
			orderItem.*
		from
			user join test.order on user.userId=test.order.userId join orderItem on test.order.orderId=orderItem.orderId
		order by
			userId,test.order.orderId,orderItemId
	</select>

resultMap的配置使用了groupBy属性，其余和上面配置类似，而这次我们的查询语句就合并成一个连接查询，测试时，需要修改POJO中的数组变量为单对象变量，那么执行程序后，我们得到如下效果：
iBatis查询复杂集合

博客分类：框架技术 ibatis企业应用