MyBatis - XML映射文件（7） - 集合（一对多、多对多关系映射）

最新推荐文章于 2021-09-04 22:24:57 发布

mytt_10566

最新推荐文章于 2021-09-04 22:24:57 发布

阅读量935

点赞数

分类专栏： mybatis 文章标签： mybatis mybatis多对多关系映射

本文链接：https://blog.csdn.net/mytt_10566/article/details/56840474

版权

mybatis 专栏收录该内容

19 篇文章 3 订阅

订阅专栏

官方文档：http://www.mybatis.org/mybatis-3/zh/sqlmap-xml.html#Result_Maps

一、<collection>标签

集合元素处理“有多个”类型的关系，如一对多、多对多的情况。例如一位作者有多篇博客，集合映射工作于这种结果之上。示例：

<resultMap type="User" id="userMap">
    ...
    <!-- 关联blogs，嵌套查询-->
    <collection property="blogs" column="id" ofType="Blog" select="findBlogByUserId"/>
</resultMap>

<collection>元素中需要告诉 MyBatis 如何加载关联。两种不同的方式可以实现:

嵌套查询：通过执行另外一个 SQL 映射语句来返回预期的复杂类型（可以执行本命名空间或其他命名空间的SQL映射语句）
嵌套结果：使用嵌套结果映射来处理重复的联合结果的子集

<collection>元素属性（和<assocation>元素属性类似，除了ofType）：

属性	描述
column	来自数据库的列名,或重命名的列标签。这和通常传递给 resultSet.getString(columnName)方法的字符串是相同的。 column 注意 : 要处理复合主键 , 你可以指定多个列名通过 column= ” {prop1=col1,prop2=col2} ” 这种语法来传递给嵌套查询语句。这会引起 prop1 和 prop2 以参数对象形式来设置给目标嵌套查询语句
ofType	指定集合包含的类型。用来区分 JavaBean(或字段)属性类型和集合包含的类型
select	另外一个映射语句的 ID,可以加载这个属性映射需要的复杂类型。获取的在列属性中指定的列的值将被传递给目标 select 语句作为参数。表格后面有一个详细的示例。 select 注意 : 要处理复合主键 , 你可以指定多个列名通过 column= ” {prop1=col1,prop2=col2} ” 这种语法来传递给嵌套查询语句。这会引起 prop1 和 prop2 以参数对象形式来设置给目标嵌套查询语句
fetchType	可选的。有效值为 lazy和eager。如果使用了，它将取代全局配置参数lazyLoadingEnabled
resultMap	这是结果映射的 ID,可以映射关联的嵌套结果到一个合适的对象图中。这是一种替代方法来调用另外一个查询语句。这允许你联合多个表来合成到 resultMap 一个单独的结果集。这样的结果集可能包含重复,数据的重复组需要被分解,合理映射到一个嵌套的对象图。为了使它变得容易,MyBatis 让你“链接”结果映射,来处理嵌套结果。一个例子会很容易来仿照,这个表格后面也有一个示例。
columnPrefix	当连接多表时，你将不得不使用列别名来避免ResultSet中的重复列名。指定columnPrefix允许你映射列名到一个外部的结果集中。请看后面的例子。
notNullColumn	默认情况下，子对象仅在至少一个列映射到其属性非空时才创建。通过对这个属性指定非空的列将改变默认行为，这样做之后Mybatis将仅在这些列非空时才创建一个子对象。可以指定多个列名，使用逗号分隔。默认值：未设置(unset)。
autoMapping	如果使用了，当映射结果到当前属性时，Mybatis将启用或者禁用自动映射。该属性覆盖全局的自动映射行为。注意它对外部结果集无影响，所以在select or resultMap属性中这个是毫无意义的。默认值：未设置(unset)。

二、示例

以商品和订单为例，一个订单有多件商品，一件商品可以属于多个订单；商品表为t_goods，订单表为t_order，中间表为t_order_goods；

1. 准备

（1）订单表t_order

CREATE TABLE `t_order` (
  `id` int(11) NOT NULL AUTO_INCREMENT,
  `order_code` varchar(100) DEFAULT NULL,
  `order_total` double DEFAULT NULL,
  PRIMARY KEY (`id`)
)
insert  into `t_order`(`id`,`order_code`,`order_total`) values (1,'1123456789',30),(2,'2123456789',30);

（2）商品表t_goods

CREATE TABLE `t_goods` (
  `id` int(11) NOT NULL AUTO_INCREMENT,
  `goods_name` varchar(100) DEFAULT NULL,
  `goods_price` double DEFAULT NULL,
  `goods_remark` varchar(100) DEFAULT NULL,
  PRIMARY KEY (`id`)
)
insert  into `t_goods`(`id`,`goods_name`,`goods_price`,`goods_remark`) values (1,'JAVA编程思想',80,'JAVA'),(2,'HEAD FIRST设计模式',60,'JAVA'),(3,'数据库原理及应用',40,'数据库');

（3）中间表t_order_goods

CREATE TABLE `t_order_goods` (
  `goods_id` int(11) DEFAULT NULL,
  `order_id` int(11) DEFAULT NULL,
  KEY `FK_t_order_goods_order_id_t_order_id` (`order_id`),
  KEY `FK_t_order_goods_goods_id_t_goods_id` (`goods_id`),
  CONSTRAINT `FK_t_order_goods_goods_id_t_goods_id` FOREIGN KEY (`goods_id`) REFERENCES `t_goods` (`id`),
  CONSTRAINT `FK_t_order_goods_order_id_t_order_id` FOREIGN KEY (`order_id`) REFERENCES `t_order` (`id`)
)
insert  into `t_order_goods`(`goods_id`,`order_id`) values (1,1),(2,1),(1,2),(3,2);

（4）pojo（简单java类）

Order.java

public class Order {
    private Integer id;
    private String orderCode;
    private Double orderTotal;
    private List<Goods> goodsList;
    //getter、setter略
}

Goods.java

public class Goods {
    private Integer id;
    private String goodsName;
    private Double goodsPrice;
    private String goodsRemark;
    private List<Order> orderList;
    //getter、setter略
}

2. mybatis配置

mybatis配置文件，全局配置懒加载（延迟加载）

<!-- 打开延迟加载的开关 -->
<setting name="lazyLoadingEnabled" value="true"/>
<!-- 将积极加载改为消息加载即按需加载 -->  
<setting name="aggressiveLazyLoading" value="false"/>

3. 映射文件

方式一：（嵌套查询）

column、select：column属性指定列作为参数传递给select属性指定的查询语句（关联的查询语句可以是本命名空间或其他命名空间）
javaType：该属性可以不指定，因为 MyBatis 在很多情况下会为自动推导出来
ofType：指定集合包含的类型。用来区分 JavaBean(或字段)属性类型和集合包含的类型

（1）OrderMapper.xml

<?xml version="1.0" encoding="UTF-8" ?>
<!DOCTYPE mapper PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN"
"http://mybatis.org/dtd/mybatis-3-mapper.dtd">
<mapper namespace="com.my.mybatis.mapper.OrderMapper">	
    <resultMap type="com.my.mybatis.pojo.Order" id="orderMap">
        <id property="id" column="id"/>
        <result property="orderCode" column="order_code"/>
        <result property="orderTotal" column="order_total"/>
        <!-- 关联商品，配置成一对多 -->
        <collection property="goodsList" javaType="java.util.ArrayList" ofType="com.my.mybatis.pojo.Goods" column="id" select="com.my.mybatis.mapper.GoodsMapper.findByOrderId"/>
    </resultMap>
	
    <sql id="Base_Column_List">
        id, order_code, order_total
    </sql>
    <select id="findById" parameterType="int" resultMap="orderMap">
        select
        <include refid="Base_Column_List"/>
        from t_order
        where id = #{id}
    </select>
</mapper>

（2）GoodsMapper.xml

<?xml version="1.0" encoding="UTF-8" ?>
<!DOCTYPE mapper PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN"
"http://mybatis.org/dtd/mybatis-3-mapper.dtd">
<mapper namespace="com.my.mybatis.mapper.GoodsMapper">	
    <resultMap type="com.my.mybatis.pojo.Goods" id="goodsMap">
        <id property="id" column="id"/>
        <result property="goodsName" column="goods_name"/>
        <result property="goodsPrice" column="goods_price"/>
        <result property="goodsRemark" column="goods_remark"/>
        <!-- 关联订单（与订单关联商品类似），此处略 -->
    </resultMap>
	
    <sql id="Base_Column_List">
        id, goods_name, goods_price, goods_remark
    </sql>
    <select id="findByOrderId" parameterType="int" resultMap="goodsMap">
        select
        <include refid="Base_Column_List"/>
        from t_goods
        where id in (select goods_id from t_order_goods where order_id = #{orderId})
    </select>
</mapper>

方式二：嵌套结果

（1）直接嵌套

通过多表查询的方式查询关联信息，可在某些场景下代替方式一，属性如下：

property：映射到列结果的字段或属性
javaType：该属性可以不指定，因为 MyBatis 在很多情况下会为自动推导出来
ofType：指定集合包含的类型。用来区分 JavaBean(或字段)属性类型和集合包含的类型
columnPrefix：指定列前缀。多表连接时，通过列别名ResultSet避免重复。在此处，将带有指定前缀的列与关联的属性进行映射，如columnPrefix="c_"，那么只会将带有c_前缀的列与goods_name、goods_price等进行映射。
嵌套的结果映射直接写在<collection>标签内，无法重复使用

映射文件：

OrderMapper.xml

<?xml version="1.0" encoding="UTF-8" ?>
<!DOCTYPE mapper PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN"
"http://mybatis.org/dtd/mybatis-3-mapper.dtd">
<mapper namespace="com.my.mybatis.mapper.OrderMapper">	
    <resultMap type="com.my.mybatis.pojo.Order" id="orderMap">
        <id property="id" column="id"/>
        <result property="orderCode" column="order_code"/>
        <result property="orderTotal" column="order_total"/>
        <!-- 关联商品，配置成一对多 -->
        <collection property="goodsList" ofType="com.my.mybatis.pojo.Goods" column="id" columnPrefix="c_">
            <id property="id" column="id"/>
            <result property="goodsName" column="goods_name"/>
            <result property="goodsPrice" column="goods_price"/>
            <result property="goodsRemark" column="goods_remark"/>
        </collection>
    </resultMap>
	
    <select id="findById" parameterType="int" resultMap="orderMap">
        select 
        t.id, 
        t.order_code, 
        t.order_total
        c.id            as c_id, 
        c.goods_name 	as c_goods_name,
        c.goods_price	as c_goods_price,
        c.goods_remark  as c_goods_remark
        from t_order t left join t_order_goods og on t.id = og.order_id left join t_goods c on c.id = og.goods_id
        where t.id = #{id}        
    </select>
</mapper>

（2）嵌套结果使用resultMap

属性同上，resultMap属性：将查询的结果与GoodsMapper命名空间的resultMap进行映射

示例：

OrderMapper.xml

<?xml version="1.0" encoding="UTF-8" ?>
<!DOCTYPE mapper PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN"
"http://mybatis.org/dtd/mybatis-3-mapper.dtd">
<mapper namespace="com.my.mybatis.mapper.OrderMapper">	
    <resultMap type="com.my.mybatis.pojo.Order" id="orderMap">
        <id property="id" column="id"/>
        <result property="orderCode" column="order_code"/>
        <result property="orderTotal" column="order_total"/>
        <!-- 关联商品，配置成一对多 -->
        <collection property="goodsList" ofType="com.my.mybatis.pojo.Goods" column="id" columnPrefix="c_" resultMap="com.my.mybatis.mapper.GoodsMapper.goodsMap"/>
    </resultMap>
	
    <select id="findById" parameterType="int" resultMap="orderMap">
        select 
        t.id, 
        t.order_code, 
        t.order_total
        c.id            as c_id, 
        c.goods_name 	as c_goods_name,
        c.goods_price	as c_goods_price,
        c.goods_remark  as c_goods_remark
        from t_order t left join t_order_goods og on t.id = og.order_id left join t_goods c on c.id = og.goods_id
        where t.id = #{id}        
    </select>
</mapper>

4. 测试

（1）OrderMapper

public interface OrderMapper {
    Order findById(Integer id);
}

（2）GoodsMapper

public interface GoodsMapper {
    List<Goods> findByOrderId(Integer orderId);
}

（3）测试

@Test
public void testMantToMany() throws Exception {
    InputStream inputStream = Resources.getResourceAsStream("mybatis.xml");	
    SqlSessionFactory sqlSessionFactory = new SqlSessionFactoryBuilder().build(inputStream);
    SqlSession session = sqlSessionFactory.openSession();
		
    // 获取mapper接口的代理对象
    OrderMapper orderMapper = session.getMapper(OrderMapper.class);
    Order order = orderMapper.findById(1);
    System.out.println(order.getOrderTotal());
    // 商品信息
//	List<Goods> goodsList = order.getGoodsList();
//	for (Goods goods : goodsList) {
//		System.out.println(goods.getGoodsName());
//	}
		
    session.commit();
    session.close();
}

（4）测试结果及说明

嵌套查询：

对于多对多，可以看为两个一对多。当查询时，一般设置懒加载（延迟加载），不是直接加载多方数据。
懒加载（延迟加载）时，通过设置全局开关

<!-- 打开延迟加载的开关 -->
<setting name="lazyLoadingEnabled" value="true"/>
<!-- 将积极加载改为消息加载即按需加载 -->  
<setting name="aggressiveLazyLoading" value="false"/>

也可以在assocation、collection等标签中设置fetchType属性

fetchType="lazy"<!-- 懒加载 -->
fetchType="eager"<!-- 立即加载 -->

以订单为例，多方为goodsList，通过设置column=“id” select="findByOrderId "，此时在查询出订单时，若用到商品信息，此时再生成根据订单id查询商品信息的sql，订单id由column属性值提供，查询语句调用select中指向的sql

（2）嵌套结果

多表联合查询出所有数据，在进行结果映射

mytt_10566

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
MyBatis - XML映射文件（7） - 集合（一对多、多对多关系映射）

官方文档：http://www.mybatis.org/mybatis-3/zh/sqlmap-xml.html#Result_Maps 一、&lt;collection&gt;标签集合元素处理“有多个”类型的关系，如一对多、多对多的情况。例如一位作者有多篇博客，集合映射工作于这种结果之上。示例：&lt;resultMap type="User" id="userMap"&gt;...
复制链接

扫一扫