mybatis的嵌套查询和延迟加载分析

最新推荐文章于 2024-09-13 14:26:48 发布
最新推荐文章于 2024-09-13 14:26:48 发布
阅读量760 收藏
点赞数
分类专栏： Mybatis 文章标签： mybatis

本文我们研究mybatis的嵌套查询和延迟加载。 

1.预备知识 
resultMap是mybatis里的一个高级功能。通过利用association和collection，可以做到将多个表关联到到一起，但又不用写JOIN这种复杂SQL，有点类似于hibernate、JPA。 
如果不熟悉resultMap的话，可以读一下官方的文档。 

2.官方例子 
学习最好的方法就是看例子 
我这里下载了官方的mybatis3.3.0-SNAPSHOT源码，借用里面一个测试程序来跟踪一下嵌套查询和延迟加载这两个特性。 

找到org.apache.ibatis.submitted.cglib_lazy_error包，里面有两个测试程序， 
CglibNPETest是测试嵌套查询的，没有用延迟加载。 
CglibNPELazyTest则用了延迟加载。 

2.1 表结构和测试数据 
CreateDB.sql 

Sql代码   收藏代码
  1. create table person (  
  2.   id int,  
  3.   firstName varchar(100),  
  4.   lastName varchar(100),  
  5.   parent int DEFAULT NULL  
  6. );  
  7.   
  8. INSERT INTO person (id, firstName, lastName, parent) VALUES (1, 'John sr.', 'Smith', null);  
  9. INSERT INTO person (id, firstName, lastName, parent) VALUES (2, 'John', 'Smith', 1);  
  10. INSERT INTO person (id, firstName, lastName, parent) VALUES (3, 'John jr.', 'Smith', 2);  


表结构我们只要关心parent字段就可以了，是说这个人的父亲是谁。然后插入3条记录，3的父亲是2，2的父亲是1

2.2 Bean定义 
Person.java 
Java代码   收藏代码
  1. public class Person {  
  2.   
  3.   private Long id;  
  4.   private String firstName;  
  5.   private String lastName;  
  6.   private Person parent;  
  7. }  


2.3 Mapper定义 
Person.xml 

Xml代码   收藏代码
  1. <resultMap id="personMap" type="Person">  
  2.     <id property="id" column="Person_id"/>  
  3.     <result property="firstName" column="Person_firstName"/>  
  4.     <result property="lastName" column="Person_lastName"/>  
  5.     <association property="parent" column="Person_parent" select="selectById"/>  
  6. </resultMap>  
  7.   
  8. <select id="selectById" resultMap="personMap" parameterType="int">  
  9.     SELECT  
  10.     <include refid="columns"/>  
  11.     FROM Person  
  12.     WHERE id = #{id,jdbcType=INTEGER}  
  13. </select>  


可以看到要关联父子，没有采用写JOIN语句的方法，而是在resultMap里定义了一个association，然后最后的select="selectById"表明要用一个嵌套查询来查得父亲记录。 

3.测试准备 
为了看的清楚一点，我们打开DEBUG的log，最简单的可以采用STDOUT_LOGGING，将日志输出到控制台。 
两个文件，ibatisConfig.xml是CglibNPETest用的，ibatisConfigLazy.xml是CglibNPELazyTest用的。 

ibatisConfig.xml 
Xml代码   收藏代码
  1. <settings>  
  2.     <setting name="logImpl" value="STDOUT_LOGGING"/>  
  3. </settings>  


ibatisConfigLazy.xml 
Xml代码   收藏代码
  1. <settings>  
  2.     <setting name="proxyFactory" value="CGLIB"/>  
  3.     <setting name="lazyLoadingEnabled" value="true"/>  
  4.     <setting name="logImpl" value="STDOUT_LOGGING"/>  
  5. </settings>  



4.嵌套查询测试 
CglibNPETest.testAncestorAfterQueryingParents方法 
断点分别设在这2句话上 
Java代码   收藏代码
  1. Person expectedAncestor = personMapper.selectById(1);  
  2. Person person = personMapper.selectById(3);  


先运行selectById(1)，观察日志 
Txt代码   收藏代码
  1. ==>  Preparing: SELECT Person.id AS Person_id, Person.firstName AS Person_firstName, Person.lastName AS Person_lastName, Person.parent AS Person_parent FROM Person WHERE id = ?   
  2. ==> Parameters: 1(Integer)  
  3. <==    Columns: PERSON_ID, PERSON_FIRSTNAME, PERSON_LASTNAME, PERSON_PARENT  
  4. <==        Row: 1, John sr., Smith, null  
  5. <==      Total: 1  

mybatis发了1条SQL取得id为1的记录。 

然后运行selectById(3)，观察日志 

Txt代码   收藏代码
  1. ==>  Preparing: SELECT Person.id AS Person_id, Person.firstName AS Person_firstName, Person.lastName AS Person_lastName, Person.parent AS Person_parent FROM Person WHERE id = ?   
  2. ==> Parameters: 3(Integer)  
  3. <==    Columns: PERSON_ID, PERSON_FIRSTNAME, PERSON_LASTNAME, PERSON_PARENT  
  4. <==        Row: 3, John jr., Smith, 2  
  5. ====>  Preparing: SELECT Person.id AS Person_id, Person.firstName AS Person_firstName, Person.lastName AS Person_lastName, Person.parent AS Person_parent FROM Person WHERE id = ?   
  6. ====> Parameters: 2(Integer)  
  7. <====    Columns: PERSON_ID, PERSON_FIRSTNAME, PERSON_LASTNAME, PERSON_PARENT  
  8. <====        Row: 2, John, Smith, 1  
  9. <====      Total: 1  
  10. <==      Total: 1  

可以看到mybatis采用了发2条SQL的方法来实现这个嵌套查询的功能。先 select 3, 再 select 2，同时注意下图右上角person的类型的确是如假包换的Person型。 


进一步深入，一步步跟踪进去，调用堆栈如图所示，这张图大家不要看错，调用顺序是从下往上的，所以请从下往上看。 

最下面的$Proxy5.selectById想必大家一定都知道了，表明了personMapper是一个代理，这就是为什么我们只需要定义mapper的接口，而不需要实现的原因了，mybatis用JDK的动态代理帮我们实现了。 

接下来这段调用流程的入口点我们可以看到是CachingExecutor.query，目的是为了取得id=3的记录 

CachingExecutor.query 
-->SimpleExecutor.query 
-->SimpleExecutor.prepareStatement 
-->RoutingStatementHandler.query 
-->PreparedStatementHandler.query 

取得记录后，交给DefaultResultSetHandler处理，要做的事情是将Resultset转换成一个List 
----->DefaultResultSetHandler.<E> handleResultSets 
----->DefaultResultSetHandler.handleResultSet 
----->DefaultResultSetHandler.handleRowValues 
----->DefaultResultSetHandler.handleRowValuesForSimpleResultMap 
----->DefaultResultSetHandler.getRowValue 

怎么转，肯定先要创建bean，然后再把属性一个个设上去咯，这些都是用反射来做到的。 
-------->DefaultResultSetHandler.createResultObject 
-------->DefaultResultSetHandler.createResultObject 
        先用反射new一个Person对象 

但是如果是嵌套查询且要延迟加载，则用cglib或javassist生成一个代理，这个后文再说。 
-------->ProxyFactory.createProxy 

----->DefaultResultSetHandler.applyAutomaticMappings 
----->DefaultResultSetHandler.applyPropertyMappings 

开始把属性一个个设上去咯 
----->DefaultResultSetHandler.getPropertyMappingValue 
----->typeHandler.getResult 
      如果是普通的值就用相应的typeHandler来从resultset中取得值 

然后就是parent这种有嵌套查询的则调用此嵌套查询方法 
----->getNestedQueryMappingValue 
-------->lazyLoader.addLoader 
         有延迟加载则addLoader，这个后文再说。 
-------->ResultLoader.loadResult 
         没有延迟加载则立即加载 
----------->ResultLoader.selectList 
----------->CachingExecutor.query 

这里的CachingExecutor.query，目的是为了取得id=2的记录 
然后看到了没，这是一个递归调用，这样又转回去了，一个轮回。。。。。。这样就可以不断递归取到父亲、爷爷、曾祖父咯。。。。。。 
不过mybatis还是做了一点优化的，看到日志里只发了2条SQL取3和2两条记录，而1这条记录因为之前就取过了嘛，已经在缓存里了，所以没必要重复取了。当然这也是防死循环的一个方法了，我们看下官方文档的说明： 
引用
本地缓存机制（Local Cache）防止循环引用（circular references）和加速重复嵌套查询。默认值为 SESSION，这种情况下会缓存一个会话中执行的所有查询。

要注意的是这个本地缓存是一级缓存。而二级缓存的处理则是通过CachingExecutor处理的。 
不理解一级缓存、二级缓存的，可参考这篇文章  MyBatis  缓存机制深度解剖 / 自定义二级缓存  。 

5.延迟加载测试（cglib） 
CglibNPELazyTest.testAncestorAfterQueryingParents方法 
同样的断点分别设在这2句话上 
Java代码   收藏代码
  1. Person expectedAncestor = personMapper.selectById(1);  
  2. Person person = personMapper.selectById(3);  


我们略过第一句话，执行selectById(3)以后观察日志，发现mybatis只发了1条SQL取得3这条记录 
Txt代码   收藏代码
  1. ==>  Preparing: SELECT Person.id AS Person_id, Person.firstName AS Person_firstName, Person.lastName AS Person_lastName, Person.parent AS Person_parent FROM Person WHERE id = ?   
  2. ==> Parameters: 3(Integer)  
  3. <==    Columns: PERSON_ID, PERSON_FIRSTNAME, PERSON_LASTNAME, PERSON_PARENT  
  4. <==        Row: 3, John jr., Smith, 2  
  5. <==      Total: 1  


而当调用了下面的话person.getParent()以后，mybatis才去发另一条SQL取得2这条记录 

Txt代码   收藏代码
  1. ==>  Preparing: SELECT Person.id AS Person_id, Person.firstName AS Person_firstName, Person.lastName AS Person_lastName, Person.parent AS Person_parent FROM Person WHERE id = ?   
  2. ==> Parameters: 2(Integer)  
  3. <==    Columns: PERSON_ID, PERSON_FIRSTNAME, PERSON_LASTNAME, PERSON_PARENT  
  4. <==        Row: 2, John, Smith, 1  
  5. <==      Total: 1  


这便是延迟加载的效果了，和hibernate如出一辙啊。如何做到的呢，进一步跟踪。 
DefaultResultSetHandler.getRowValue 
-------->DefaultResultSetHandler.createResultObject 
但是如果是嵌套查询且要延迟加载，则用cglib或javassist生成一个代理。 
-------->ProxyFactory.createProxy 
看图，这次生成的person是一个冒牌的person，它的类型是Person
EnhancerByCGLIB 
bdd8787e类型的，是由cglib创建的一个代理 


然后就是parent这种有嵌套查询的则调用此嵌套查询方法 
----->getNestedQueryMappingValue 
-------->lazyLoader.addLoader 
         有延迟加载则addLoader,把要延迟加载的属性记到ResultLoaderMap里（一个哈希表） 

然后当我们调用person.getParent()以后，图中可清楚的看到这个方法被拦截啦! 


Person
EnhancerByCGLIB 
bdd8787e.getParent 
-->CglibProxyFactory$EnhancedResultObjectProxyImpl.intercept 
-->ResultLoaderMap.load 
-->ResultLoaderMap$LoadPair.load 
-------->ResultLoader.loadResult 
         立即加载 
----------->ResultLoader.selectList 
----------->CachingExecutor.query 

看到了没，又转回CachingExecutor.query这个入口点了，所以就可以发另1条SQL来取得id=2这条记录了 

6.延迟加载测试（javassist） 
这次我们把cglib换成javassist试一下 
ibatisConfigLazy.xml 
Xml代码   收藏代码
  1. <settings>  
  2.     <setting name="proxyFactory" value=""JAVASSIST""/>  
  3.     <setting name="lazyLoadingEnabled" value="true"/>  
  4.     <setting name="logImpl" value="STDOUT_LOGGING"/>  
  5. </settings>  

还是用和cglib相同的方法断点调试，看图，这次生成的person的类型是Person_$$_jvst844_0类型的，是由javassist创建的一个代理 


然后当我们调用person.getParent()以后，图中可清楚的看到这个方法被拦截啦! 


Person_$$_jvst844_0.getParent 
-->JavassistProxyFactory$EnhancedResultObjectProxyImpl.invoke 
然后后面就和cglib一模一样了。 

7.resultMap与resultType比较 
resultMap虽然强大，从设计上看很牛叉，但是笔者这里还是提一下自己的观点，笔者觉得一般情况下用用resultType足够了，没必要用resultMap 

resultMap 
优点：使用嵌套查询的话（association@select）多表不用写JOIN这种复杂SQL。 
缺点：“N+1 查询问题”，会导致成百上千的 SQL 语句被执行，不过可以通过延迟加载一部分解决这个性能问题。另一种根治的方法就是用嵌套的resultMap，不过这样写出来的resultMap就更复杂了。 

resultType 
优点：自己写多表关联的SQL比较踏实，可以做SQL的性能调优。 
缺点：导致大量的DTO需要创建，不过可以考虑将多个SQL的select出来的字段做一个最大的并集，这些SQL共用一个DTO 


8.总结 
mybatis的嵌套查询和延迟加载，虽然大家可能不会用到这个功能（至少笔者觉得不实用），但是设计思想是可以借鉴的。提供了cglib,javassist两种方法来实现延迟加载，这和hibernate的延迟加载如出一辙啊！另外一级缓存和二级缓存的使用，也是和hibernate思想一致!里面用到的一些技术，如反射，动态代理，字节码（cglib,javassist）则是java的基础，另加许多设计模式的运用，使得mybatis源码显得比较优雅，大家品读mybatis源码对自己一定是一个提高。 
零度anngle
关注
专栏目录
Mybatis-嵌套查询
hxy1625309592的博客
03-15 5787
1.1 项目目录 1.2 什么是嵌套查询 嵌套查询就是将原来多表查询中的联合查询语句拆成单个表的查询，再使用mybatis的语法嵌套在一起。 案例实现 -- 需求：查询一个订单，与此同时查询出该订单所属的用户 # 1. 联合查询 select * from orders o left join user u on o.oid =u.id #2. 嵌套查询 #2.1先查询订单 Select * from orders #2.2 再根据订单uid外键，查询用户 select * from use
MyBatis = MyBatis嵌套查询和缓存
人生起落，生活苦甜，坚持追求！
05-12 459
嵌套查询， 加载策略：立即加载，延迟加载 ； 缓存：一级缓存，二级缓存； mybatis配置文件核心标签 一.MyBatis 嵌套查询 嵌套查询就是将原来多表查询中的联合查询语句拆开成 多个单表的查询。 在使用mybatis的语法嵌套在一起。 将一次多表联合查询尽量使用多次单表查询来替代( 分步查询 ), 最后将多次查询的结果嵌套组装起来 优点: 每次都是简单的单表 缺点: 使用更加麻烦 demo： * 需求：查询一个订单，与此同时查询出该订单所属的用户 * 关联查询： s..
mybatis -- 嵌套查询
hc1428090104的博客
05-24 6659
嵌套查询
29. MyBatis中的嵌套查询如何实现？如何映射嵌套结果集？
最新发布
zhzjn的博客
09-13 623
在 MyBatis 中，嵌套查询是指在一个查询中包含另一个子查询，通常用于处理关联关系的数据查询，如一对一、一对多、多对多的关系。MyBatis 提供了多种方式来实现嵌套查询，并且支持将嵌套查询的结果映射到嵌套的 Java 对象中。嵌套查询可以通过在 SQL 中直接嵌套子查询实现，也可以通过在 MyBatis 配置中使用关联（association）或集合（collection）的方式实现。是映射嵌套结果集的关键，前者用于多对一或一对一关系，后者用于一对多或多对多关系。标签，用于映射嵌套的结果集。
Mybatis--嵌套查询
BtWangZhi的博客
08-24 1507
本文部分参考：https://blog.csdn.net/qq_34777858/article/details/79209392 http://www.mybatis.org/mybatis-3/zh/sqlmap-xml.html 翻了一下Mybatis官方文档，之前看得不是很懂的位置，现在看有种豁然开朗的感觉。看到嵌套查询，写了几个Demo，觉得不错，整理记录一下。 构造的三张表： ...
mybatis嵌套查询
weixin_43606738的博客
06-14 210
<!--单词选项，嵌套--> <resultMap id="wordAndOption" type="org.springblade.english.vo.WordAndOptionVO"> <result column="id" property="id"/> <result column="en_text" property="enText"/> <result column="ch_text"
Mybatis查询延迟加载详解及实例
09-09
Mybatis的查询延迟加载是一种优化策略，用于提高数据查询效率。在默认情况下，Mybatis不会自动启用延迟加载，而是会一次性加载所有关联的数据。这意味着，当你执行一个查询时，如果查询结果包含其他对象的引用，...
21、(知识篇)Mybatis02使用（嵌套结果/嵌套查询）
你的博客
12-25 5511
/** * MyBatis的嵌套结果/嵌套查询（网上有说这是叫延迟加载） *  * 1、一对一： * 1.1 一对一嵌套结果：实际就是将两个表join起来（参考userMapper.xml的selectUserById方法） * 得出多行数据，其中，需要用resultMap返回， * 配置resultMap * * type：返回的类型的全类名/配置别名  * autoMapp
Mybatis学习笔记之延迟加载和N+1问题
qq_34577182的博客
10-12 351
提示：文章写完后，目录可以自动生成，如何生成可参考右边的帮助文档 文章目录一、什么是延迟加载？二、延迟加载的分类N+1问题总结 一、什么是延迟加载？ MyBatis中的延迟加载，也称为懒加载 ，是指在进行关联查询时，按照设置延迟规则推迟对关联对象的select查询。延迟加载可以有效的减少数据库压力。 Mybatis的延迟加载，需要通过resultMap标签中的association和collection子标签才能演示成功。 Mybatis的延迟加载，也被称为是嵌套查询，对应的还有嵌套结果的概念，可以参考
Mybatis的嵌套查询
weixin_49689284的博客
11-01 254
嵌套查询是延迟加载的前提.之前的关联查询，是在一次查询中查询多个表。 嵌套查询就是把多个表拆成一个一个表，每次执行单表，执行多次查询 一对一 一个订单只对应一个用户。 需求:查询所有订单，并且显示出对应的用户信息 entity OrdersMapper接口 CustomerMapper接口 OrdersMapper.xml CustomerMapper.xml 一对多 从客户查询每个客户的所有订单信息 entity CustomerMapper接口 OrderMapper接口 Custome
Mybatis之嵌套查询
li-zhang-yu的博客
05-08 182
一：Mybatis之嵌套查询
2 - Mybatis 常用
wealth_gold的博客
12-12 1169
2 MyBatis 常用 2.1 ResultMap 如果实体的属性名与表中字段名不一致，可以使用ResutlMap实现手动封装到实体类中 resultType : 如果实体的属性名与表中字段名一致，将查询结果自动封装到实体类中 <!--id : 标签的唯一标识 type: 封装后实体类型--> <resultMap id="userResultMap" type="com.dy.domain.User"> <!--手动配置映射关系--> <
MyBatis嵌套结果查询
诉衷情の麻雀的博客
03-27 232
J2EE课老师让我们完成课后的练习，内容是分别使用嵌套结果的方式和嵌套查询的方式查询商品表和分类表。需要注意的是在xml文件中 以前映射的语句是resultType但映射为实体类时是ResultMap。如果你出现了以下的报错除了要检查mybatis_config配置外，那就是有可能这里出现了问题。在Resources下mapper编写xml文件。然后在测试类编写查询语句。首先我们建库建表嘛。
11.MyBatis的嵌套查询
程序员阿红的博客
02-24 9378
11.MyBatis的嵌套查询 1.什么事嵌套查询 嵌套查询就是将原来多表查询中的联合查询语句拆成单个表的查询，再使用mybatis的语法嵌套在一 起。 例子： * 需求：查询一个订单，与此同时查询出该订单所属的用户 1. 联合查询 SELECT * FROM orders o LEFT JOIN USER u ON o.`uid`=u.`id`; 2. 嵌套查询 2.1 先查询订单 SELECT * FROM orders 2.2 再根据订单uid外键，查询用户 SELECT * FROM `user
Mybatis嵌套查询（一对多）
Roc的博客
08-03 1876
【代码】Mybatis嵌套查询（一对多）
Mybatis延迟加载和查询缓存
dengduoya4019的博客
05-10 105
一、延迟加载 　　resultMap可以实现高级映射(使用association、collection实现一对一及一对多映射)，association、collection具备延迟加载功能。 　　延迟加载：先从单表查询，需要时再从关联表去关联查询，大大提高数据库性能，因为查询单表要比关联查询多张表速度要快。 在mybatis核心配置文件中配置： lazyLoadingEnable...
MyBatis（三） MyBatis复杂嵌套查询
Hello World!
05-01 4828
MyBatis（三） MyBatis复杂嵌套查询
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值