`

Hibernate关联表特殊查询(一方)inner join fetch,left join fet

阅读更多

inner join fetch
/**
* 一对多中的一方inner join fetch多方
* 这里不能用inner join on
* 查询结果是它把一方对多方的那个集合里面的对象都查询出来放到一方的集合中
*/
public List getallByinnerjoinTShop(){
   List list=null;
   try {
    Query query=this.GetSession().createQuery("from TType as t inner join fetch t.TShops");
    list=query.list();
   } catch (HibernateException e) {
    throw e;
   }finally{
    this.ColseSession();
   }
   return list;
}
测试:
List list=typedao.getallByinnerjoinTShop();
   Iterator iter=list.iterator();
   while(iter.hasNext()){
    TType type=(TType) iter.next();
    System.out.println(type.toString());
    Iterator<TShop> it=type.getTShops().iterator();
    while(it.hasNext()){
     TShop sh=it.next();
     System.out.println(sh.toString());
    }
   }

left join fetch
/**
* left join fetch 左外连接
*/
public List getallLeftjoinfetchTShop(){
   List list=null;
   try {
    Query query=this.GetSession().createQuery("from TType as t left join fetch t.TShops");
    list=query.list();
   } catch (HibernateException e) {
    throw e;
   }finally{
    this.ColseSession();
   }
   return list;  
}
测试:
List list=typedao.getallLeftjoinfetchTShop();
   Iterator iter=list.iterator();
   while(iter.hasNext()){
    TType type=(TType) iter.next();
    System.out.println(type.toString());
    Iterator<TShop> it=type.getTShops().iterator();
    while(it.hasNext()){
     TShop sh=it.next();
     System.out.println(sh.toString());
    }
   }

left join
/**
* left join 左外连接
*
*/
public List getallLeftjoinTShop(){
   List list=null;
   try {
    Query query=this.GetSession().createQuery("from TType as t left join t.TShops");
    list=query.list();
   } catch (HibernateException e) {
    throw e;
   }finally{
    this.ColseSession();
   }
   return list;  
}
测试:
List list=typedao.getallLeftjoinTShop();
   Iterator iter=list.iterator();
   while(iter.hasNext()){
    Object[] obj=(Object[]) iter.next();
    TType type=(TType) obj[0];
    TShop shop=(TShop) obj[1];
    System.out.println(type.toString());
    //访问type对象里面的TShops集合里的元素,有懒加载问题
    //Iterator<TShop> it=type.getTShops().iterator();
    //while(it.hasNext()){
    //TShop sh=it.next();
    //System.out.println(sh.toString());
    //}
    //from TType as t left join t.TShops shop可能为空
    if(shop!=null){
     System.out.println(shop.toString());
    }   
   }
隐式内连接
/**
* 隐式内连接
*/
public List getall(){
   List list=null;
   try {
    Query query=this.GetSession().createQuery("from TType as t,TShop as s where s.TType=t");
    list=query.list();
   } catch (HibernateException e) {
    throw e;
   }finally{
    this.ColseSession();
   }
   return list;
}
测试:
List list=typedao.getall();
   Iterator iter=list.iterator();
   while(iter.hasNext()){
    Object[] obj=(Object[]) iter.next();
    TType type=(TType) obj[0];
    TShop shop=(TShop) obj[1];
    System.out.println(type);
    System.out.println(shop);
   }


集合过滤
/**
* 集合过滤
*/
public List getallfilter(int price){
   List list=null;
   try {
    Query query=this.GetSession().createQuery("from TType");
    list=query.list();
    Iterator iter=list.iterator();
    while(iter.hasNext()){
     TType type=(TType) iter.next();
     Query que=this.GetSession().createFilter(type.getTShops(), "where SPrice>=?");
     que.setInteger(0, price);
     List arr=que.list();
     type.setTShops(new HashSet(arr));
    }
   } catch (HibernateException e) {
    throw e;
   }finally{
    this.ColseSession();
   }
   return list;
}
测试:
List list=typedao.getallfilter(10);
   Iterator iter=list.iterator();
   while(iter.hasNext()){
    TType type=(TType) iter.next();
    System.out.println(type.toString());
    Iterator<TShop> it=type.getTShops().iterator();
    while(it.hasNext()){
     TShop sh=it.next();
     System.out.println(sh.toString());
    }
   }

分享到:
评论
1 楼 huagaisheng 2011-12-17  
好文章,总结的很好

相关推荐

    Hibernate关联关系练习【全】

    在Hibernate中,这需要通过一个中间表(也称为关联表或连接表)来实现,对应的注解是@ManyToMany,同时需要定义@JoinTable,包括joinColumns和inverseJoinColumns来指定双方的引用。 在"HibernateSelect"这个文件名...

    hibernate关联查询

    在处理一对多关联查询时,我们可能会遇到内连接(JOIN)和左连接(LEFT JOIN)。`JOIN`会返回两个表中存在匹配的所有记录,而`LEFT JOIN`会返回所有左侧表的记录,即使右侧表没有匹配的记录。 在HQL中,我们可以...

    hibernate多表查询详解

    对象方式的查询是Hibernate的一大特色,它通过建立实体类间的关联关系来实现多表查询。这种方式更加面向对象,易于理解和维护。例如,如果Table1和Table2存在一对多关系,我们可以在Table1的实体类中定义一个Table2...

    hibernate 关联表问题

    - 使用`fetch="join"`进行联合查询,可以减少数据库的多次交互,提高性能。 - 考虑使用`@BatchSize`来控制一次加载多少关联对象,避免大数据量时的内存溢出。 - 当不需要完整关联数据时,可使用`@NotFound(action...

    Hibernate-基础联表模板

    "Hibernate-基础联表模板"是针对Hibernate中联表查询的一个实用工具,旨在帮助开发者快速地进行多表关联查询,而不必记住复杂的SQL语句。 1. **Hibernate简介** Hibernate是一种开源的ORM框架,它允许开发者将Java...

    hsql查询语法

    from Cat as cat inner join fetch cat.mate left join fetch cat.kittens 这个语句将Cat类的实例与其mate和kittens之间的关系进行关联和连接,并将相关联的对象随着父对象的初始化而被初始化。 需要注意的是,...

    hibernate关联关系总结

    在Hibernate中,使用@ManyToMany注解,同时定义@JoinTable注解来指定中间表的详细信息,包括joinColumns和inverseJoinColumns,分别表示本实体在中间表中的引用。 在实际应用中,为了确保数据一致性,我们还需要...

    HQL Hibernate查询语言

    HQL Hibernate 查询语言 HQL(Hibernate Query Language)是 Hibernate 中的一种强大的查询语言,它看起来很像 SQL,但是不要被...例如:from Cat as cat inner join fetch cat.mate left join fetch cat.kittens。

    Hibernate Fetch 的作用

    例如,在上面的代码片段中,通过`left outer join fetch parent.childs`语句,我们告诉Hibernate在加载`Parent`实体时,也一并加载所有相关的`Child`实体。这样,即使`Parent`实体的`childs`属性被标记为`lazy="true...

    hibernate代码优化基于配置的多表查询

    通过配置`@JoinTable`、`@JoinColumn`或`@ManyToMany`注解,我们可以指定实体间的关联关系,从而让Hibernate执行单个SQL联合查询,减少网络延迟。 2. **二级缓存配置**: Hibernate的二级缓存能存储已查询过的数据...

    Hibernate关联关系疑问

    它们支持复杂的关联查询和条件表达式,使得数据库操作更加灵活。 10. **缓存机制**:Hibernate支持一级缓存(Session级别)和二级缓存(SessionFactory级别),能够提高查询效率,减少对数据库的访问。但是,缓存...

    Hibernate关联关系总结

    多对一关联的一方通常会包含对另一方的引用,而在被引用的一方不需要做特殊处理,因为主键已经天然地形成了关联。同样,可以通过`fetch`属性控制加载策略,以及在关联字段上设置`@JoinColumn`来定义外键信息。 **多...

    hibernate 关联映射(二) one to one(单向)

    本篇文章将深入探讨Hibernate中的关联映射,特别是One-to-One(一对一)关联,这是一种表示两个实体之间一对一关系的映射方式。我们将通过源码分析和实际例子来理解其工作原理。 ### 一、One-to-One关联概述 在...

    Hibernate教程15_关联关系中的CRUD Cascade_Fetch

    在本教程中,我们将深入探讨Hibernate中的关联关系及其在CRUD操作中的应用,特别是关于Cascade和Fetch策略。Hibernate是Java领域广泛使用的对象关系映射(ORM)框架,它允许开发者用面向对象的方式来处理数据库交互...

    hibernate 关联例子

    在Java的持久化框架Hibernate中,关联映射是核心概念之一,它允许对象之间的关系在数据库层面得以体现。...在实际应用中,需根据业务需求选择合适的关联类型,并注意优化关联查询,避免N+1问题,以提高系统性能。

    hibernate关联关系实例

    在这个“hibernate关联关系实例”中,我们将深入探讨四种基本的关联关系:一对一(One-to-One)、一对多(One-to-Many)、多对一(Many-to-One)以及多对多(Many-to-Many),同时也会涉及Hibernate查询语言(HQL)...

    Hibernate HQL.doc

    `fetch`连接用于一次性初始化相关联的对象,避免延迟加载,例如`from Cat as cat inner join fetch cat.mate`。需要注意的是,`fetch`连接不应在使用`scroll()`或`iterate()`的查询中使用,且与`right join fetch`或...

    hibernate关联映射的作用和常用属性解释

    ### Hibernate关联映射的作用与常用属性详解 #### 关联映射概述 在对象关系映射(Object Relational Mapping,简称ORM)技术中,Hibernate作为Java领域内非常成熟且功能强大的框架之一,它允许开发者将Java类映射...

    Hibernate实体关联速查表

    **Hibernate实体关联速查表详解** Hibernate作为Java领域中的一款著名对象关系映射(ORM)框架,极大地简化了数据库操作,使得开发者可以使用面向对象的方式来处理数据库事务。本速查表旨在提供关于Hibernate实体...

    hibernate关联关系多对一实例

    6. **查询优化**:在处理多对一关联时,我们需要关注HQL(Hibernate Query Language)或JPA的Criteria API,以及JOIN fetch,以避免过多的数据库查询。例如,通过`join fetch`可以一次性获取学生和其关联的教师信息...

Global site tag (gtag.js) - Google Analytics