hibernate 通过子查询预抓取集合 fetch subselect join (最后遗留疑问)

最新推荐文章于 2021-10-30 10:27:33 发布
最新推荐文章于 2021-10-30 10:27:33 发布
阅读量4.2k 收藏 1
点赞数
分类专栏： hibernate 文章标签： hibernate join session jpa query iterator
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/partner4java/article/details/6938854
版权
（总结在后面） 
通过子查询预抓取集合：
view plain copy to clipboard print ?
  1. <set fetch="subselect" ..>  
  2.   
  3. @org.hibernate.annotations.Fetch(org.hibernate.annotations.FetchMode.SUBSELECT)  

配置文件：
view plain copy to clipboard print ?
  1.   <class name="Item" table="ITEM">  
  2.       <id name="itemId" column="ITEM_ID" type="integer">  
  3.           <generator class="native"/>  
  4.       </id>  
  5.       <property name="itemName" type="string" column="ITEM_NAME"/>  
  6.         
  7. <bag name="bids" inverse="true" cascade="save-update" fetch="subselect">  
  8.     <key column="ITEM_ID_M"></key>  
  9.     <one-to-many class="Bid"/>  
  10. </bag>  
  11.           
  12.   </class>  

测试代码：
view plain copy to clipboard print ?
  1.     private static void select() {  
  2.         Configuration configuration = new Configuration().configure();  
  3.         SessionFactory sessionFactory = configuration.buildSessionFactory();  
  4.         Session session = sessionFactory.openSession();  
  5.           
  6.         Item item = (Item) session.get(Item.class, 1);  
  7.           
  8.         System.out.println("-----");  
  9.           
  10.         Collection<Bid> bids = item.getBids();  
  11.           
  12.         System.out.println("+++++");  
  13.           
  14.         for(Iterator it = bids.iterator();it.hasNext();){  
  15.             Bid bid = (Bid) it.next();  
  16.             System.out.println(bid);  
  17.         }  
  18.           
  19. //      hibernate打印：  
  20. //      Hibernate: select item0_.ITEM_ID as ITEM1_1_0_, item0_.ITEM_NAME as ITEM2_1_0_ from ITEM item0_ where item0_.ITEM_ID=?  
  21. //      -----  
  22. //      +++++  
  23. //      Hibernate: select bids0_.ITEM_ID_M as ITEM3_1_, bids0_.BID_ID as BID1_1_, bids0_.BID_ID as BID1_0_0_, bids0_.bidMoeny as bidMoeny0_0_, bids0_.ITEM_ID_M as ITEM3_0_0_ from BID bids0_ where bids0_.ITEM_ID_M=?  
  24. //      Bid [bidId=1, bidMoeny=12.0]  
  25. //      Bid [bidId=2, bidMoeny=13.0]  
  26.           
  27.   
  28. //如果是多条就会变成：  
  29. //Hibernate: select bids0_.ITEM_ID_M as ITEM3_1_1_, bids0_.BID_ID as BID1_1_, bids0_.BID_ID as BID1_0_0_, bids0_.bidMoeny as bidMoeny0_0_, bids0_.ITEM_ID_M as ITEM3_0_0_ from BID bids0_ where bids0_.ITEM_ID_M in (select item0_.ITEM_ID from ITEM item0_)  
  30.   
  31.   
  32.         session.close();  
  33.           
  34.         sessionFactory.close();  
  35.     }  






通过联结即时抓取： 
view plain copy to clipboard print ?
  1. <set fetch="join" ..>  
  2.   
  3. @org.hibernate.annotations.Fetch(org.hibernate.annotations.FetchMode.JOIN)  


配置文件：
view plain copy to clipboard print ?
  1.   <class name="Item" table="ITEM">  
  2.       <id name="itemId" column="ITEM_ID" type="integer">  
  3.           <generator class="native"/>  
  4.       </id>  
  5.       <property name="itemName" type="string" column="ITEM_NAME"/>  
  6.         
  7. <set name="bids" inverse="true" cascade="save-update" fetch="join">  
  8.     <key column="ITEM_ID_M"></key>  
  9.     <one-to-many class="Bid"/>  
  10. </set>  
  11.           
  12.   </class>  

测试代码： 
很奇怪，不解，难道我这个版本的hibernate有bug？把session.close();放在获取之前就会报no session的错误，那么肯定就是采用的懒加载的方式 
view plain copy to clipboard print ?
  1.     /** 
  2.      * 前提是我Item有三条数据，两条没有Bid 
  3.      */  
  4.     private static void select() {  
  5.         Configuration configuration = new Configuration().configure();  
  6.         SessionFactory sessionFactory = configuration.buildSessionFactory();  
  7.         Session session = sessionFactory.openSession();  
  8.           
  9.         Query query = session.createQuery("select o from Item o");  
  10.         List<Item> items = query.list();  
  11.           
  12.         System.out.println(items.size());  
  13.           
  14.         for(int i=0;i<items.size();i++){  
  15.             Item item = items.get(i);  
  16.             System.out.println(item.getBids());  
  17.         }  
  18. //      后台打印：  
  19. //      Hibernate: select item0_.ITEM_ID as ITEM1_1_, item0_.ITEM_NAME as ITEM2_1_ from ITEM item0_  
  20. //      3  
  21. //      Hibernate: select bids0_.ITEM_ID_M as ITEM3_1_, bids0_.BID_ID as BID1_1_, bids0_.BID_ID as BID1_0_0_, bids0_.bidMoeny as bidMoeny0_0_, bids0_.ITEM_ID_M as ITEM3_0_0_ from BID bids0_ where bids0_.ITEM_ID_M=?  
  22. //      [Bid [bidId=2, bidMoeny=12.0], Bid [bidId=1, bidMoeny=13.0]]  
  23. //      Hibernate: select bids0_.ITEM_ID_M as ITEM3_1_, bids0_.BID_ID as BID1_1_, bids0_.BID_ID as BID1_0_0_, bids0_.bidMoeny as bidMoeny0_0_, bids0_.ITEM_ID_M as ITEM3_0_0_ from BID bids0_ where bids0_.ITEM_ID_M=?  
  24. //      []  
  25. //      Hibernate: select bids0_.ITEM_ID_M as ITEM3_1_, bids0_.BID_ID as BID1_1_, bids0_.BID_ID as BID1_0_0_, bids0_.bidMoeny as bidMoeny0_0_, bids0_.ITEM_ID_M as ITEM3_0_0_ from BID bids0_ where bids0_.ITEM_ID_M=?  
  26. //      []  
  27.           
  28.           
  29. //      很奇怪，不解，难道我这个版本的hibernate有bug？把session.close();放在获取之前就会报no session的错误，那么肯定就是采用的懒加载的方式  
  30.   
  31.           
  32.           
  33.         session.close();  
  34.           
  35.         sessionFactory.close();  
  36.     }  
  37.       


换个版本（hibernate-distribution-3.6.4.Final）： 
还是这样。 
突然明白过来，他在你指定的HQL中，如何生效呢？呵呵 
view plain copy to clipboard print ?
  1.     /** 
  2.      * 前提是我Item有三条数据，两条没有Bid 
  3.      */  
  4.     private static void select2() {  
  5.         Configuration configuration = new Configuration().configure();  
  6.         SessionFactory sessionFactory = configuration.buildSessionFactory();  
  7.         Session session = sessionFactory.openSession();  
  8.           
  9.         Item item = (Item) session.get(Item.class, 1);  
  10. //      打印：  
  11. //      Hibernate: select item0_.ITEM_ID as ITEM1_1_1_, item0_.ITEM_NAME as ITEM2_1_1_, bids1_.ITEM_ID_M as ITEM3_1_3_, bids1_.BID_ID as BID1_3_, bids1_.BID_ID as BID1_0_0_, bids1_.bidMoeny as bidMoeny0_0_, bids1_.ITEM_ID_M as ITEM3_0_0_ from ITEM item0_ left outer join BID bids1_ on item0_.ITEM_ID=bids1_.ITEM_ID_M where item0_.ITEM_ID=?  
  12.   
  13.           
  14.         session.close();  
  15.           
  16.         sessionFactory.close();  
  17.     }  
  18.       


JPA：
view plain copy to clipboard print ?
  1. @Entity  
  2. public class Item implements Serializable {  
  3.     @Id  
  4.     @GeneratedValue  
  5.     @Column(name="ITEM_ID")  
  6.     private Integer itemId;  
  7.     @Column(name="ITEM_NAME")  
  8.     private String itemName;  
  9.       
  10.     @OneToMany(mappedBy="item",cascade=CascadeType.ALL)  
  11.     @Fetch(value=FetchMode.JOIN)  
  12.     private Set<Bid> bids = new HashSet<Bid>();  
  13.   
  14. .....  

调用： 
执行了查询集合数据 
view plain copy to clipboard print ?
  1.     private static void select() {  
  2.         EntityManagerFactory factory = Persistence.createEntityManagerFactory("partner4java");  
  3.         EntityManager em = factory.createEntityManager();  
  4.           
  5.         Query query = em.createQuery("select o from Item o ");  
  6.         List<Item> items = query.getResultList();  
  7.           
  8. //      后台打印：  
  9. //      Hibernate: select item0_.ITEM_ID as ITEM1_1_, item0_.ITEM_NAME as ITEM2_1_ from Item item0_  
  10. //      Hibernate: select bids0_.ITEM_ID as ITEM3_1_1_, bids0_.BID_ID as BID1_1_, bids0_.BID_ID as BID1_0_0_, bids0_.BID_MONEY as BID2_0_0_, bids0_.ITEM_ID as ITEM3_0_0_ from Bid bids0_ where bids0_.ITEM_ID=?  
  11. //      Hibernate: select bids0_.ITEM_ID as ITEM3_1_1_, bids0_.BID_ID as BID1_1_, bids0_.BID_ID as BID1_0_0_, bids0_.BID_MONEY as BID2_0_0_, bids0_.ITEM_ID as ITEM3_0_0_ from Bid bids0_ where bids0_.ITEM_ID=?  
  12.   
  13.           
  14.         em.close();  
  15.         factory.close();  
  16.     }     
  17.   
  18.       
  19.   
  20.     private static void select2() {  
  21.         EntityManagerFactory factory = Persistence.createEntityManagerFactory("partner4java");  
  22.         EntityManager em = factory.createEntityManager();  
  23.           
  24.         Item item = em.find(Item.class, 1);  
  25.         System.out.println("----");  
  26.         System.out.println(item.getBids());  
  27.           
  28. //      后台打印：  
  29. //      Hibernate: select item0_.ITEM_ID as ITEM1_0_1_, item0_.ITEM_NAME as ITEM2_0_1_, bids1_.ITEM_ID as ITEM3_0_3_, bids1_.BID_ID as BID1_3_, bids1_.BID_ID as BID1_1_0_, bids1_.BID_MONEY as BID2_1_0_, bids1_.ITEM_ID as ITEM3_1_0_ from Item item0_ left outer join Bid bids1_ on item0_.ITEM_ID=bids1_.ITEM_ID where item0_.ITEM_ID=?  
  30. //      ----  
  31. //      [Bid [bidId=1, bidMoeny=12.0], Bid [bidId=2, bidMoeny=13.0]]  
  32.           
  33.         //但是，我们是三条数据，一条Item没有Bid，所以出问题了  
  34.           
  35.         em.close();  
  36.         factory.close();  
  37.     }  
  38.   
  39.       
  40.   
  41.       


上面这样就生效了。看来fetch方式如此不堪。 
##总结：## 

JPA使用下面代码测试（前提是有三条Item，一条没有Bid数据）：
view plain copy to clipboard print ?
  1. private static void select() {  
  2.     EntityManagerFactory factory = Persistence.createEntityManagerFactory("partner4java");  
  3.     EntityManager em = factory.createEntityManager();  
  4.       
  5.     Query query = em.createQuery("select o from Item o ");  
  6.     List<Item> items = query.getResultList();  
  7.       
  8.     em.close();  
  9.     factory.close();  
  10. }  


join： 
1、无论使用hibernate和jpa使用HQL或者QL语句，是不生效的。 
2、区别在于JPA： 
@OneToMany(mappedBy="item",cascade=CascadeType.ALL,fetch=FetchType.LAZY) 
@Fetch(value=FetchMode.JOIN) 
后台打印： 
Hibernate: select item0_.ITEM_ID as ITEM1_0_, item0_.ITEM_NAME as ITEM2_0_ from Item item0_ 
Hibernate: select bids0_.ITEM_ID as ITEM3_0_1_, bids0_.BID_ID as BID1_1_, bids0_.BID_ID as BID1_1_0_, bids0_.BID_MONEY as BID2_1_0_, bids0_.ITEM_ID as ITEM3_1_0_ from Bid bids0_ where bids0_.ITEM_ID=? 
Hibernate: select bids0_.ITEM_ID as ITEM3_0_1_, bids0_.BID_ID as BID1_1_, bids0_.BID_ID as BID1_1_0_, bids0_.BID_MONEY as BID2_1_0_, bids0_.ITEM_ID as ITEM3_1_0_ from Bid bids0_ where bids0_.ITEM_ID=? 
Hibernate: select bids0_.ITEM_ID as ITEM3_0_1_, bids0_.BID_ID as BID1_1_, bids0_.BID_ID as BID1_1_0_, bids0_.BID_MONEY as BID2_1_0_, bids0_.ITEM_ID as ITEM3_1_0_ from Bid bids0_ where bids0_.ITEM_ID=? 
像这样，无论，JPA中你是否指明了懒加载，只要生命了fetch=join方式，就会变成立即加载。 

Hibernate不会，hibernate始终就是默认就是把返回代理放在最优先考虑的方式。 
3、如果使用非HQL或QL的查询方式，如get之类的，JOIN就会出现问题，因为使用的left outer join方式，就只会查询出有关联数据的Item。 


SUBSELECT： 
1、JPA和hibernate是相同的： 
@OneToMany(mappedBy="item",cascade=CascadeType.ALL,fetch=FetchType.LAZY) 
@Fetch(value=FetchMode.SUBSELECT) 
就是，默认是懒加载模式 
后台打印： 
Hibernate: select item0_.ITEM_ID as ITEM1_1_, item0_.ITEM_NAME as ITEM2_1_ from Item item0_ 

2、但是，如果修改为： 
@OneToMany(mappedBy="item",cascade=CascadeType.ALL,fetch=FetchType.EAGER) 
@Fetch(value=FetchMode.SUBSELECT) 
后台就会打印： 
Hibernate: select item0_.ITEM_ID as ITEM1_1_, item0_.ITEM_NAME as ITEM2_1_ from Item item0_ 
Hibernate: select bids0_.ITEM_ID as ITEM3_1_1_, bids0_.BID_ID as BID1_1_, bids0_.BID_ID as BID1_0_0_, bids0_.BID_MONEY as BID2_0_0_, bids0_.ITEM_ID as ITEM3_0_0_ from Bid bids0_ where bids0_.ITEM_ID in (select item0_.ITEM_ID from Item item0_) 
就是JPA中QL语句也会生效SUBSELECT设置。Hibernate也会生效。



所以，综上所述，当时使用HQL或QL查询的时候，而且需要获取脱管对象的关联对象时，建议使用SUBSELECT方式，但是，还需要额外指明即时加载。且，JPA的JOIN方式的QL查询还存在bug。 



但是，我们如果想在第一个select的HQL方式中也用join该如何呢？ 
partner4java
关注
专栏目录
Hibernate--fetch抓取策略
nupt_Wang的专栏
01-08 6026
有几个需要注意的地方： 1 在xml配置中 是默认懒加载的（fetch=select），也就是在使用到懒加载对象的属性时候  才会发出SQL语句，不使用的话就发一个SQL即可，若遍历时使用关联对象的属性，那么会发出大量SQL，而这是我们不希望看见的 很多情况下 我们是要希望能使用fetch=Join 也就是实现全部加载 只发出一条SQL，即使没有显示的使用关联对象属性仍然全部加载，此SQL使用
day36 08-Hibernate抓取策略：批量抓取
04-26
除此之外，Hibernate还提供了子查询和多级抓取等高级策略，以适应更复杂的场景。在使用这些策略时，我们需要考虑数据库的性能、内存消耗以及应用程序的需求，以找到最佳的平衡点。 总的来说，理解并熟练运用...
hibernate抓取策略fetch=select /join/subselect
smile725775的专栏
11-07 631
一、hibernate抓取策略（单端代理的批量抓取fetch=select(默认）/join） 测试用例： Student student = (Student)session.get(Student.class, 1);     System.out.println(student.getName());     System.out.println(student.getClasses
hibernate抓取策略
l_feilong的博客
03-03 304
出处：http://blog.csdn.net/ychatou1220/article/details/6489881 一、hibernate抓取策略（单端代理的批量抓取fetch=select(默认）/join） 测试用例： Student student = (Student)session.get(Student.class, 1);     System.out.println(s
hibernate的fetch=“subselect"碰上SQLQuery
sorphi
08-13 241
会变成fetch="select"   List&lt;User&gt; users = sesson.createSQLQuery("select {u.*} from user_table u where ...") .addEntity("u", User.class).list(); for(User u ...
Hibernate中FetchMode.JOIN FetchMode.SELECT FetchMode.SUBSELECT介绍
淘技术
06-30 2291
@Fetch(FetchMode.JOIN) 会使用left join查询 只产生一条sql语句 @Fetch(FetchMode.SELECT) 会产生N+1条sql语句 @Fetch(FetchMode.SUBSELECT) 产生两条sql语句 第二条语句使用id in (…..)查询出所有关联的数据
Hibernate中的多表查询及抓取策略
08-31
- **批量抓取**：通过设置`batch-size`属性，例如在`<set>`标签中配置`batch-size="n"`，可以在查询多个主对象时，批量获取其关联的子对象，减少数据库访问次数。 综上所述，Hibernate的多表查询和抓取策略提供了...
day36 06-Hibernate抓取策略：set集合上的抓取策略
04-26
2. **子查询抓取（Subselect Fetching）**：这种方式会先执行一个子查询来获取关联集合的ID，然后根据这些ID加载集合。使用`@Fetch(FetchMode.SUBSELECT)`可以开启此策略，适用于大数据量的关联，因为它能减少内存...
Hibernate-HQL查询（2）子查询、连接查询
叶为正的博客
06-03 1127
package junit.test;import hibch05.dao.HibernateSessionFactory; import hibch05.pojo.Dept; import hibch05.pojo.Emp;import java.util.Iterator; import java.util.List; import java.util.Set;import org.hibern
hibernate一对多关系 在一方查询会获得重复数据，重复数量就是多端数据数量用@Fetch(FetchMode.SUBSELECT)解决...
weixin_30347335的博客
08-24 794
先来看数据表 版块表只有两个数据 板块1是推荐，下边没有子栏目 板块2下边有14个子栏目 在1的一端来查询，发现结果有16条 也就是板块1+版块2+版块2和他的14个子集都列出来了，这明显不对 板块对象的配置 @OneToMany(cascade = {CascadeType.ALL}, fetch = FetchType.EAGER) ...
@Fetch FetchMode=select/join/subselect
邹浩阳的专栏
08-26 6521
最近看到了hibernate的fetch mode ，想着以前用的是fetch=fetchType.LAZY/EAGER 。就去网上查了一下，发现都是设定关联对象的加载策略。 FetchType.LAZY: 懒加载，在访问关联对象的时候加载(即从数据库读入内存) FetchType.EAGER:立刻加载，在查询主对象的时候同时加载关联对象。 @Fetch(FetchMode.JO
@Fetch
qq_45055165的博客
10-30 349
@Fetch(FetchMode.JOIN) 会使用left join查询 只产生一条sql语句 @Fetch(FetchMode.SELECT) 会产生N+1条sql语句 @Fetch(FetchMode.SUBSELECT) 产生两条sql语句 第二条语句使用id in (……)查询出所有关联的数据
FetchMode.JOIN FetchMode.SELECT FetchMode.SUBSELECT 的区别
iteye_5075的博客
12-04 223
@Fetch(FetchMode.JOIN) 会使用left join查询 只产生一条sql语句 @Fetch(FetchMode.SELECT) 会产生N+1条sql语句 @Fetch(FetchMode.SUBSELECT) 产生两条sql语句 第二条语句使用id in (.....)查询出所有关联的数据...
FetchMode.JOIN FetchMode.SELECT FetchMode.SUBSELECT 的区别
ssyan的专栏
01-19 6341
@Fetch(FetchMode.JOIN) 会使用left join查询  只产生一条sql语句 @Fetch(FetchMode.SELECT)   会产生N+1条sql语句 @Fetch(FetchMode.SUBSELECT)  产生两条sql语句 第二条语句使用id in (.....)查询出所有关联的数据
hibernate 一对多 取多方数据重复问题，FetchMode.JOIN、FetchMode.SELECT、FetchMode.SUBSELECT区别
azhegps的博客
08-08 792
问题描述：稿件附件表数据时出现多条重复数据。 介绍： 表：稿件实体Manuscripts （数据库表MANUSCRIPTS），稿件附件实体ManuscriptsAtt（表MANUSCRIPTS_ATT），稿件审核实体：ManuscriptsQuotes 表关系：稿件与稿件附件 一对多；稿件与稿件审核一对多； 代码： 稿件实体 Manuscripts： @Entit...
hibernate 一对多 取多方数据重复问题，FetchMode.JOIN、FetchMode.SELECT、FetchMode.SUBSELECT区别...
weixin_30355437的博客
06-28 275
问题描述：稿件附件表数据时出现多条重复数据。 介绍： 表：稿件实体Manuscripts （数据库表MANUSCRIPTS），稿件附件实体ManuscriptsAtt（表MANUSCRIPTS_ATT），稿件审核实体：ManuscriptsQuotes 表关系：稿件与稿件附件 一对多；稿件与稿件审核一对多； 代码： 稿件实体 Manuscripts： @Ent...
FetchType与FetchMode的区别
绿茶_白开水
07-21 304
使用例： @OneToMany(mappedBy="item",cascade=CascadeType.ALL,fetch=FetchType.EAGER)  @Fetch(value=FetchMode.SUBSELECT)  两者比较： 两者都是设定关联对象的加载策略。前者是JPA标准的通用加载策略注解属性， 后者是Hibernate自有加载策略注解属性。 FetchType可选值...
Hibernate HQL：内连接查询与fetch机制详解
本篇文章主要讨论的是迫切内连接（Inner Join Fetch），这是Hibernate中用于检索包含关联对象的查询方式。 首先，我们来看一下"inner join fetch"关键字。在Hibernate的SQL查询语句中，"inner join fetch"命令表示...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值