Mybatis学习系列（五）关联查询
前面几节的示例基本都是一些单表查询，实际项目中，经常用到关联表的查询，比如一对一，一对多等情况。在Java实体对象中，一对一和一对多可是使用包装对象解决，属性使用List或者Set来实现，在mybatis中一对一和一对多可是使用association或者collection标签来配合实现。
在MyBatis中有两种方式实现关联查询：
1. 嵌套结果:使用嵌套结果映射来处理重复的联合结果的子集。首先,然让我们来查看这个元素的属性。所有的你都会看到,它和普通的只由 select 和resultMap 属性的结果映射不同
2. 嵌套查询:通过执行另外一个 SQL 映射语句来返回预期的复杂类型
一对一查询
示例：商品表products 和 商品分类category 一个商品对应一种分类，所以products->category是一对一的关系
1.嵌套结果实现（resultMap）：
通过resultMap将查询结果中商品信息映射到Product对象中，在Product类中添加属性category，将关联结果映射到Product.category属性上。
<!-- 一对一查询 关联查询 使用resultMap映射结果集 --> <select id="oneToOneTestMap" parameterType="int" resultMap="productInfoMap"> select p.*,c.id categoryId,c.name categoryName,c.remark categoryRemark from products p join category c on p.categoryId= c.Id where p.id =#{value} </select> <resultMap id="productInfoMap" type="com.sl.po.Product"> <id column="id" property="Id" /> <result column="name" property="Name" /> <result column="description" property="Description" /> <result column="unitprice" property="UnitPrice" /> <result column="imageUrl" property="ImageUrl" /> <result column="isnew" property="IsNew" /> <result column="citycode" property="cityCode" /> <!-- association:用于映射关联查询单个对象的信息 property:要将关联查询的分类信息映射到属性category上 --> <association property="category" javaType="com.sl.po.Category"> <id column="categoryId" property="Id" /> <result column="categoryName" property="Name" /> <result column="categoryRemark" property="Remark" /> </association> </resultMap>
注：也可以使用resultType配置实现，需要定义一个包装类含有product和category两个对象的属性即可。
2.嵌套查询实现
<!-- 关联嵌套查询 --> <select id="oneToOneTestAssociationSelect" parameterType="int" resultMap="productInfoMap2"> select p.* from products p where p.id =#{value} </select> <resultMap id="productInfoMap2" type="com.sl.po.Product" > <id column="id" property="Id" /> <result column="name" property="Name" /> <result column="description" property="Description" /> <result column="unitprice" property="UnitPrice" /> <result column="imageUrl" property="ImageUrl" /> <result column="isnew" property="IsNew" /> <result column="citycode" property="cityCode" /> <!-- column：传递子查询参数，如果要处理符复合主键，使用column= "{prop1=col1,prop2=col2}" --> <!-- select：子查询语句id --> <association property="category" javaType="com.sl.po.Category" column="categoryId" select="selectCategoryInfo"> </association> </resultMap> <!-- 子查询 --> <select id="selectCategoryInfo" parameterType="int" resultType="com.sl.po.Category"> select * from category where id=#{id} </select>
使用resultType、resultMap和嵌套查询对比分析：
resultType：使用resultType只需要将查询结果集中的列名与定义的pojo属性一一对应即可完成映射，缺点:resultType无法将查询结果映射到包装类的pojo属性中
resultMap：需要额外定义resultMap，在resultMap中将结果集列名与pojo对象属性一一配置。
嵌套查询：需要定义多个查询，上面示例定义两个查询，一个用于查询products表，一个用于查询category表。由于使用的是嵌套查询，当操作大型数据集合和列表时将会带来频繁操作数据库问题。即执行一条sql获取结果集（oneToOneTestAssociationSelect），根据该结果集，循环执行嵌套查询获取具体信息（selectCategoryInfo），与上面的嵌套结果查询相比，这种情况显然有明显不足。
3. 测试代码
定义Product和Category实体，添加Mapper接口
package com.sl.po; import java.math.BigDecimal; public class Product { private int Id; private String Name; private String Description; private BigDecimal UnitPrice; private String ImageUrl; private Boolean IsNew; private String cityCode; private int categoryId; private Category category; public Category getCategory() { return category; } public void setCategory(Category category) { this.category = category; } public int getCategoryId() { return categoryId; } public void setCategoryId(int categoryId) { this.categoryId = categoryId; } public String getCityCode() { return cityCode; } public void setCityCode(String cityCode) { this.cityCode = cityCode; } public int getId() { return Id; } public void setId(int id) { this.Id = id; } public String getName() { return Name; } public void setName(String name) { this.Name = name; } public String getDescription() { return Description; } public void setDescription(String description) { this.Description = description; } public BigDecimal getUnitPrice() { return UnitPrice; } public void setUnitPrice(BigDecimal unitprice) { this.UnitPrice = unitprice; } public String getImageUrl() { return Name; } public void setImageUrl(String imageurl) { this.ImageUrl = imageurl; } public boolean getIsNew() { return IsNew; } public void setIsNew(boolean isnew) { this.IsNew = isnew; } @Override public String toString() { return "Product [Id=" + Id + ", Name=" + Name + ", Description=" + Description + ", UnitPrice=" + UnitPrice + ", ImageUrl=" + ImageUrl + ", IsNew=" + IsNew + ", cityCode=" + cityCode + ", categoryId=" + categoryId + ", category=" + category + "]"; } }
package com.sl.po; import java.util.List; public class Category { private int Id; private String Name; private String Remark; private List<Product> productList; public int getId() { return Id; } public List<Product> getProductList() { return productList; } public void setProductList(List<Product> productList) { this.productList = productList; } public void setId(int id) { Id = id; } public String getName() { return Name; } public void setName(String name) { Name = name; } public String getRemark() { return Remark; } public void setRemark(String remark) { Remark = remark; } @Override public String toString() { return "Category [Id=" + Id + ", Name=" + Name + ", Remark=" + Remark + ", productList=" + productList + "]"; } }
View Code
// 一对一 使用resultType映射结果集 // @Test public void testSelectProduct() { // 获取mapper接口的代理对象 UnitMapper unitMapper = session.getMapper(UnitMapper.class); ProductDetailInfo detailInfo = unitMapper.oneToOneTest(1); System.out.println(detailInfo); // 关闭会话 session.close(); } // 一对一 使用resultMap映射结果集 // @Test public void testSelectProduct2() { // 获取mapper接口的代理对象 UnitMapper unitMapper = session.getMapper(UnitMapper.class); Product product = unitMapper.oneToOneTestMap(2); System.out.println(product); System.out.println(product.getCategory().toString()); // 关闭会话 session.close(); } //嵌套查询 //一对一 //@Test public void testSelectProductTest() { // 获取mapper接口的代理对象 UnitMapper unitMapper = session.getMapper(UnitMapper.class); Product product = unitMapper.oneToOneTestAssociationSelect(2); System.out.println(product); System.out.println(product.getCategory().toString()); // 关闭会话 session.close(); }
一对多查询
将上面一对一的示例倒过来看，一种类别下有多个商品，所以category->products是一对多的关系
mybatis中可以通过使用resultMap的collection标签将关联查询的多条记录映射到一个list集合属性中。
1.嵌套结果实现
<!-- 一对多映射 --> <select id="oneToManyTest" resultMap="categoryInfo"> select c.id cid,c.`name` cname,c.remark, p.* from category c join products p on p.categoryId= c.Id where c.id= #{cid} </select> <resultMap type="com.sl.po.Category" id="categoryInfo"> <id column="cid" property="id" /> <result column="cname" property="name" /> <result column="remark" property="remark" /> <!-- collection标签，一对多映射，关联当前分类下产品信息 property映射集合结果，ofType结果集类型 --> <collection property="productList" ofType="com.sl.po.Product"> <id property="id" column="id" javaType="int" jdbcType="INTEGER" /> <result column="name" property="Name" /> <result column="description" property="Description" /> <result column="unitprice" property="UnitPrice" /> <result column="imageUrl" property="ImageUrl" /> <result column="isnew" property="IsNew" /> <result column="citycode" property="cityCode" /> </collection> </resultMap>
2.嵌套查询实现
<!-- 集合嵌套查询 --> <select id="oneToManyTestCollectionSelect" resultMap="categoryInfo2"> select * from category c where c.id= #{id} </select> <resultMap id="categoryInfo2" type="com.sl.po.Category"> <id column="id" property="id" /> <result column="name" property="name" /> <result column="remark" property="remark" /> <!--collection 映射一对多结果集 column：传递嵌套查询参数 select：嵌套查询id--> <collection property="productList" ofType="com.sl.po.Product" column="id" select="selectProductByCategoryId"> </collection> </resultMap> <!-- 嵌套子查询 --> <select id="selectProductByCategoryId" resultType="com.sl.po.Product"> select * from products where categoryId= #{id} </select>
测试代码：
定义Product和Category实体同上，添加Mapper接口
public interface UnitMapper { Category oneToManyTest(int cId); Product oneToOneTestAssociationSelect(int id); //嵌套查询中的子查询也需要定义接口 Category selectCategoryInfo(int id); }
//一对多 @Test public void oneToManyTest() { UnitMapper unitMapper = session.getMapper(UnitMapper.class); Category catrgoryInfo = unitMapper.oneToManyTest(1); System.out.println(catrgoryInfo); if (catrgoryInfo.getProductList().size() > 0) { for (Product pro : catrgoryInfo.getProductList()) { System.out.println(pro); } } // 关闭会话 session.close(); } //嵌套查询 一对多 @Test public void testoneToManyTestCollectionSelect() { // 获取mapper接口的代理对象 UnitMapper unitMapper = session.getMapper(UnitMapper.class); Category category = unitMapper.oneToManyTestCollectionSelect(1); System.out.println(category); if (category.getProductList().size() > 0) { for (Product pro : category.getProductList()) { System.out.println(pro); } } // 关闭会话 session.close(); }
多对多查询
示例：一个订单包含多个商品，一个商品也可以对应多个订单，这个示例查询稍微扩展一下，增加用户信息，一个用户对应多个订单
实体对象定义：定义User实体，增加orders属性，用于映射当前用户的订单； 定义Order对象，增加orderItems属性，映射当前订单有哪些内容(产品)；定义OrderItem实体，增加product属性，映射具体产品信息
<!-- 多对多映射 查询用户信息及对应订单信息，订单详情 --> <!-- select * from orders o join `user` u on o.userId = u.id join orderItem i on o.Id = i.orderid join products p on i.productid = p.Id --> <select id="manyToManyTest" resultMap="userAndOrderInfo"> select u.*, o.id oid, o.createtime ocreatetime, o.userid ouserid, o.amount oamount, o.remark oremark, i.id iid, i.orderid iorderid, i.productid iproductid, i.createtime icreatetime, i.number inumber, i.price iprice, p.id pid, p.`name` pname, p.Description pdescription from orders o join `user` u on o.userId = u.id join orderItem i on o.Id = i.orderid join products p on i.productid = p.Id where u.id=#{id} </select> <resultMap type="com.sl.po.User" id="userAndOrderInfo"> <id column="id" property="id" /> <result column="sex" property="sex" /> <result column="birthday" property="birthday" /> <result column="address" property="address" /> <result column="username" property="userName" /> <!-- 映射用户对应的订单信息,一个用户可以有多个订单 --> <collection property="orders" ofType="com.sl.po.Order"> <id column="oid" property="id" /> <result column="ocreatetime" property="createTime" /> <result column="ouserid" property="userId" /> <result column="oamount" property="amount" /> <result column="oremark" property="remark" /> <!-- 订单对应的商品信息，一个订单可以有多个商品 --> <collection property="orderItems" ofType="com.sl.po.OrderItem"> <id column="iid" property="id" /> <result column="iorderid" property="orderId" /> <result column="iproductid" property="productId" /> <result column="icreatetime" property="createTime" /> <result column="inumber" property="number" /> <result column="iprice" property="price" /> <!-- 映射商品信息 （OrderItem与商品product 一一对应）--> <association property="product" javaType="com.sl.po.Product"> <id column="pid" property="Id" /> <result column="pname" property="Name" /> <result column="pdescription" property="Description" /> </association> </collection> </collection> </resultMap>
测试代码
package com.sl.po; import java.sql.Date; import java.util.List; public class User { private int id; private String sex; private Date birthday; private String address; private String userName; //映射当前用户订单列表 private List<Order> orders; public List<Order> getOrders() { return orders; } public void setOrders(List<Order> orders) { this.orders = orders; } public int getId() { return id; } public void setId(int id) { this.id = id; } public String getSex() { return sex; } public void setSex(String sex) { this.sex = sex; } public Date getBirthday() { return birthday; } public void setBirthday(Date birthday) { this.birthday = birthday; } public String getAddress() { return address; } public void setAddress(String address) { this.address = address; } public String getUserName() { return userName; } public void setUserName(String userName) { this.userName = userName; } @Override public String toString() { return "User [id=" + id + ", sex=" + sex + ", birthday=" + birthday + ", address=" + address + ", userName=" + userName + ", orders=" + orders + "]"; } }
package com.sl.po; import java.sql.Date; import java.util.List; public class Order { private int id; private int userId; private Date createTime; private int amount; private String remark; private User user; //映射订单内容（产品信息） private List<OrderItem> orderItems; public Date getCreateTime() { return createTime; } public void setCreateTime(Date createTime) { this.createTime = createTime; } public int getId() { return id; } public void setId(int id) { this.id = id; } public int getUserId() { return userId; } public void setUserId(int userId) { this.userId = userId; } public int getAmount() { return amount; } public void setAmount(int amount) { this.amount = amount; } public String getRemark() { return remark; } public void setRemark(String remark) { this.remark = remark; } public User getUser() { return user; } public void setUser(User user) { this.user = user; } public List<OrderItem> getOrderItems() { return orderItems; } public void setOrderItems(List<OrderItem> orderItems) { this.orderItems = orderItems; } }
package com.sl.po; public class OrderItem { private int id; private int orderId; private int productId; private int createTime; private int number; private int price; //订单项对应的具体产品 private Product product; public Product getProduct() { return product; } public void setProduct(Product product) { this.product = product; } public int getId() { return id; } public void setId(int id) { this.id = id; } public int getOrderId() { return orderId; } public void setOrderId(int orderId) { this.orderId = orderId; } public int getProductId() { return productId; } public void setProductId(int productId) { this.productId = productId; } public int getCreateTime() { return createTime; } public void setCreateTime(int createTime) { this.createTime = createTime; } public int getNumber() { return number; } public void setNumber(int number) { this.number = number; } public int getPrice() { return price; } public void setPrice(int price) { this.price = price; } }
package com.sl.mapper; import java.util.List; import com.sl.po.Category; import com.sl.po.Product; import com.sl.po.ProductDetailInfo; import com.sl.po.User; public interface UnitMapper { User manyToManyTest(int id); }
//多对多 @Test public void manyToManyTest() { UnitMapper unitMapper = session.getMapper(UnitMapper.class); User userOrder = unitMapper.manyToManyTest(1); System.out.println(userOrder); // 关闭会话 session.close(); }
标签即属性说明
Association标签: 作用是可以将关联查询信息映射到一个pojo对象中
collection标签: 作用是可以将关联查询信息映射到一个集合中
Association和collection标签常用到的属性：
Property属性： 指定当前association标签内容映射到pojo对象中哪个属性。
javaType：映射属性的类型
typeHandler：类型处理器，使用这个属性,你可以覆盖默认的 typeHandler 类型处理器。 这个属性值是类的完全限定名或者是一个类型处理器的实现, 或者是类型别名
column：sql结果集列名，用在嵌套查询时传递参数，要 处 理 复 合 主 键 , 你 可 以 指 定 多 个 列 名 通 过 column= ” {prop1=col1,prop2=col2} ” 这种语法来传递给嵌套查询语 句。prop1 和 prop2 以参数对象形式来设置给目标嵌套查询语句。
select：嵌套查询映射语句的ID
fetchType：可选的。有效值为 lazy和eager。 如果使用了，它将取代全局配置参数lazyLoadingEnabled
columnPrefix：将含有指定前缀的结果集映射到当前标签下 例如：<association property="productInfo" columnPrefix="p_" /> 将结果集中以“p_”开头的列映射到productInfo属性上
