Hibernate -- 检索

蔚落 2022-05-30 02:15 242阅读 0赞

# Hibernate 的检索方式 #

在实际开发项目时，对数据进行最多的操作就是查询，数据的查询在所有 ORM 框架中都占有极其重要的地位。那么，如何利用 Hibernate 查询数据呢?

## Hibernate 检索方式的分类 ##

Hibernate 的检索方式主要有5种，分别为导航对像图检索方式、OID 检索方式、HQL 检索方式、QBC 检索方式和 SQL 检索方式

# 对象图导航检索 #

对象图导航检索方式是根据已经加载的对象，导航到他的关联对象。它利用类与类之间的关系来检索对象。譬如要查找B对应的A，就可以由B对象自动导航找到B所属的A对象。当然前提是必须在对象关系映射文件上皮质了多对一的关系。

B b = session.get(B.class, 1l);
    A a = b.getA();

# OID 检索方式 #

OID 检索方式主要指用 Session 的 get() 和 load() 方法加载某条记录对应的对象。如下面两种加载方式，就是 OID 检索方式。

A a = (A)session.get(A.class, 1);
    A a = (A)session.load(A.class, 1);

# HQL 检索 #

HQL (Hibernate Query Language)是面向对象的查询语言，它和 SQL 查询语言有些相似，但它使用的是类、对象和属性的概念，而没有表和字段的概念。在Hibernate提供的各种检索方式中，HQL 是官方推荐的查询语言，也是使用最广泛的一种检索方式。它具有如下功能。

*  在查询语句中设定各种查询条件。
 *  支持投影查询，即仅检索出对象的部分属性。
 *  支持分页查询。
 *  支持分组查询，允许使用group by和having关键字。
 *  提供内置聚集函数，如sumO、minO和maxO。
 *  能够调用用户定义的SQL函数。
 *  支持子查询，即嵌套查询。
 *  支持动态绑定参数。

Hibernate 提供的 Query 接口是专门的 HQL 查询接口，它能够执行各种复杂的HQL查询语句。  
完整的HQL语句结构如下。  
···  
select…from…where…group by…having…order by…asc/desc  
···

可见 HQL 查询非常类似于标准 SQL 查询。通常情况下，当检索数据表中的所有记录时，查询语句中可以省略 select 关键字，示例如下所示。

String hql = "from A";

如果执行该查询语句，则会返回应用程序中的所有 Customer 对象，需要注意的是 Customer 是类名，而不是表名，类名需要区分大小写，而关键字 from 不区分大小写。  
我们己经对 HQL 有了基本的了解，那么我们具体的来使用一下HQL。

## 基本检索 ##

// 基本查询
    Query query = session.createQuery("from A");
    List<A> aList = query.list();
    // 起别名
    //Query query = session.createQuery("from A a");
    //Query query = session.createQuery("select a from A a");
    List<A> aList = query.list();

## 排序检索 ##

Query query = session.createQuery("from A order by id desc");
    List<A> aList = query.list();

## 条件检索 ##

// 按位置绑定参数
    Query query = session.createQuery("from A where name = ?");
    //query.setString(0,"张三")；
    query.setParameter(0,"张三")；
    List<A> aList = query.list();
    
    // 按名称绑定参数
    Query query = session.createQuery("from A where name = :name");
    //query.setString(name,"张三")；
    query.setParameter(name,"张三")；
    List<A> aList = query.list();

## 分页检索 ##

Query query = session.createQuery("from A order by id desc");
    query.setFirstResult(5);
    query.setMaxResult(5);
    List<A> aList = query.list();

## 统计检索 ##

Query query = session.createQuery("select count(*) from A");
    Long num = (Long)query.uniqueResult();

## 投影检索 ##

// 一列
    List<String> list = session.createQuery("select name form A").list();
    
    // 多列
    List<Object[]> list = session.createQuery("select id, name from A").list();
    
    // 投影的构造的方式查询
    List<A> aList = session.createQuery("select new A(id, name) form A").list();

# QBC 检索 #

QBC(Query By Criteria)是Hibernate提供的另一种检索对象的方式，它主要由Criteria接口、Criterion 接口和 Expression 类组成。Criteria 接口是 Hibernate API中的一个查询接口，它需要由 session 进行创建。Criterion 是 Criteria的查询条件，在Criteria 中提供了 add(Criterion criterion) 方法来添加查询条件。

// 创建 Criteria 对象
    Criteria criteria = session.createCriteria(A.class);
    // 设定查询条件
    Criterion criterion = Restrictions.eq("id", 1);
    // 添加查询条件
    criteria.add(criterion);
    // 执行查询，返回查询结果
    List<A> aList = criteria.list();

Restrictions 的方法如下：

<table> 
 <thead> 
  <tr> 
   <th>方法名</th> 
   <th>说明</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>Restrictions.eq</td> 
   <td>等于</td> 
  </tr> 
  <tr> 
   <td>Restrictions.allEq</td> 
   <td>使用 Map，使用 k/v 进行多个等于的比较</td> 
  </tr> 
  <tr> 
   <td>Restrictions.gt</td> 
   <td>大于&gt;</td> 
  </tr> 
  <tr> 
   <td>Restrictions.ge</td> 
   <td>大于等于&gt;=</td> 
  </tr> 
  <tr> 
   <td>Restrictions.lt</td> 
   <td>小于&lt;</td> 
  </tr> 
  <tr> 
   <td>Restrictions.le</td> 
   <td>小于等于&lt;=</td> 
  </tr> 
  <tr> 
   <td>Restrictions.between</td> 
   <td>对应 SQL 的 between 字句</td> 
  </tr> 
  <tr> 
   <td>Restrictions.like</td> 
   <td>对应 SQL 的 like 字句</td> 
  </tr> 
  <tr> 
   <td>Restrictions.in</td> 
   <td>对应 SQL 的 IN 子句</td> 
  </tr> 
  <tr> 
   <td>Restrictions.and</td> 
   <td>and 关系</td> 
  </tr> 
  <tr> 
   <td>Restrictions.or</td> 
   <td>or 关系</td> 
  </tr> 
  <tr> 
   <td>Restrictions.sqlRestriction</td> 
   <td>SQL 限定查询</td> 
  </tr> 
 </tbody> 
</table>

## 基本检索 ##

Criteria criteria = session.createCriteria(A.class);
    List<A> aList = criteria.list();

## 条件检索 ##

Criteria criteria = session.createCriteria(A.class);
    //criteria.add(Restrictions.eq("name","张三"))；
    criteria.add(Restrictions.like("name","三"))；
    List<A> aList = criteria.list();

## 分页检索 ##

Criteria criteria = session.createCriteria(A.class);
    criteria.setFirstResult(5);
    criteria.setMaxResult(5);
    List<A> aList = criteria.list();

## 排序检索 ##

Criteria criteria = session.createCriteria(A.class);
    criteria.addOrder(Oder.desc("id"));
    List<A> aList = criteria.list();

## 统计检索 ##

Criteria criteria = session.createCriteria(A.class);
    criteria.setProjection(Projections.rowCount());
    Long count = (Long)criteria.uniqueResult();

## 离线条件检索 ##

DetachedCriteria 翻译为离线条件查询，因为它是可以脱离 Session 来使用的一种条件查询对象，我们都知道 Criteria 对象必须由 Session 对象来创建。那么也就是说必须先有 Session 才可以生成 Criteria 对象。而 DetachedCriteria 对象可以在其他层对条件进行封装。这个对象也是比较有用的，尤其在 SSH 整合以后这个对象经常会使用。它的主要优点是做一些特别复杂的条件查询的时候，往往会在 WEB 层向业务层传递很多的参数，业务层又会将这些参数传递给 DAO 层。最后在 DAO中拼接 SQL 完成查询。有了离线条件查询对象后，那么这些工作都可以不用关心了，我们可以在 WEB 层将数据封装好，传递到业务层，再由业务层传递给DAO完成查询。

我们可以先简单的测试一下离线条件查询对象，然后具体的使用我们会在后期整合中使用。到那时会更加体会出它的优势。

// 获得一个离线条件查询的对象
    DetachedCriteria detachedCriteria = DetachedCriteria.forClass(A.class);
    detachedCriteria.add(Restrictions.eq("name","张三"));
    Session session = HibernateUtils.getCurrentSession();
    session.beginTransaction();
    List<A> aList = detachedCriteria.getExecutableCriteria(session).list();

# 本地 SQL 检索方式 #

釆用 HQL 或 QBC 检索方式时，Hibernate 生成标准的 SQL 查询语句，适用于所有的数据库平台，因此这两种检索方式都是跨平台的。但有的应用程序可能需要根据底层数据库的 SQL 方言，来生成一些特殊的查询语句。在这种情况下，可以利用 Hibernate 提供的 SQL 检索方式。使用 SQL 检索方式检索对象的示例代码，如下所示：

SQLQuery sqlQuery = session.createSQLQuery("select id,name,age from A");

在这，SQL 的检索方式我们不做太多的介绍。之前无论我们使用的是 HQL 或是QBC 或是 SQL 其实都是单表的查询，而实际的开发中我们往往需要多个表的联合查询才可以获得我们想要的数据。那么接下来我们就来学习一下多表的查询吧。

# Hibernate 的多表查询 #

在做多表查询之前，我们需要先来回顾下使用SQL是如何完成多表的查询的。在学习SQL语句的时候进行多表联合查询一般都会采用连接查询，那么我们就来回顾一下SQL中的多表的联合查询。

## SQL 多表联合查询： ##

连接查询：

**交叉连接**

交叉连接返回的结果是被连接的两个表中所有数据行的笛卡尔积，也就是返回第一个表中符合查询条件的数据行数乘以第二个表中符合查询条件的数据行数，例如 department 表中有 4 个部门，employee 表中有 4 个员工，那么交叉连接的结果就有 4\*4=16 条数据。  
交叉连接的语法格式如下：

SELECT * FROM 表1 CROSS JOIN 表2；

也可以写为如下格式：

SELECT * FROM 表1, 表2；

从上述描述可以看出，交叉连接的记过就是两个表种所有数据的组合。需要注意的是，在实际开发种这种业务需求是很少见的，一般不会使用交叉连接，而是使用具体的田间对数据进行有目的的查询。

**内连接**

内连接（INNERJOIN)又称简单连接或自然连接，是一种常见的连接查询。内连接使用比较运算符对两个表中的数据进行比较，并列出与连接条件匹配的数据行，组合成新的记录,也就是说在内连接查询中，只有满足条件的记录才能出现在查询结果中。内连接查询的语

法格式如下所示：

SELECT 查询字段 FROM 表1 [inner] JOIN 表2 ON 表1.关系字段 = 表2.关系字段

在上述语法格式中，INNER JOIN 用于连接两个表，ON 来指定连接条件，其中 INNER 可以省略。内连接其实还可以细分为如下两类

*  隐式内连接：顾名思义隐式的就是我们看不到 INNER JOIN 的关键字。而使用 WHERE 关键字代替。

SELECT * FROM 表1，表2 WHERE 表1.关系字段 = 表2.关系字段

*  显式内连接：显示的就是在语句中明显的调用了 INNER JOIN 的关键字

SELECT * FROM 表1 INNER JOIN 表2 on 表1.关系字段 = 表2.关系字段 SELECT * FROM 表1 JOIN 表2 on 表1.关系字段 = 表2.关系字段；

**外连接**

前面讲解的内连接查询中，返回的结果只包含符合查询条件和连接条件的数据，然而有时还需要包含没有关联的数据，即返回查询结果中不仅包含符合条件的数据，而且还包括左表（左连接或左外连接）、右表（右连接或右外连接）或两个表（全外连接）中的所有数据，此时就需要使用外连接查询，外连接分为左连接和右连接。

外连接的语法格式如下：

SELECT 所查字段 FROM 表1 LEFT|RIGHT [OUTER] JOIN 表2 ON 表1.关系字段 = 表2.关系字段 WHERE 条件

外连接的语法格式和内连接类似，只不过使用的是LEFT JOIN、 RIGHT JOIN关键字，其中关键字左边的表被称为左表，关键字右边的表被称为右表。  
在使用左连接和右连接查询时，查询结果是不一致的，具体如下：

*  LEFT JOIN（左连接）：返回包括左表种的所欲记录和右表种符合连接条件的记录。

SELECT * FROM 表1 LEFT OUTER JOIN 表2 ON 表1.关系字段 = 表2.关系字段； SELECT * FROM A LEFT JOIN 表2 on 表1.关系字段 = 表2.关系字段；

*  RIGHT JOIN（右连接）：返回包括右表种的所欲记录和左表种符合连接条件的记录。

SELECT * FROM 表1 RIGHT OUTER JOIN 表2 ON 表1.关系字段 = 表2.关系字段； SELECT * FROM A RIGHTJOIN 表2 on 表1.关系字段 = 表2.关系字段；

## HQL 连接查询 ##

Hibernate进行多表查询与SQL其实是很相似的，但是HQL会在原来SQL分类的基础上又多出来一些操作。  
HQL的多表连接查询的分类如下：

*  交叉连接
 *  内连接  
    
    
     *  显示内连接
     *  隐式内连接
     *  **迫切内连接**
 *  外连接  
    
    
     *  左外连接
     *  **迫切左外连接**
     *  右外连接

其实这些连接查询语法大致都是一致的，就是 HQL 查询的是对象而 SQL 查询的是表。那么我们来比较一下 SQL 和 HQL 的连接查询。

SQL 连接查询：

SELECT 1 FROM cst_customer c INNER JOIN cst_linkman l ON c.cust_id = l.lkm_cust_id;

HQL 连接查询：

FROM Customer c INNER JOIN c.linkMans

在 HQL 中，我们不用写关联字段了，因为客户中的联系人的集合其实对应的就是外键，所以我们在 INNER JOIN 的后面直接可以写 c.linkMans。

我们发现如果这样写HQL语句的话，生成的底层的 SQL 语句就是使用 INNER JOIN 进行连接，而连接的条件就是 customer0\_.cust\_id = linkmans1\_.lkm\_cust\_id。就是两个表的关联的字段。所以 HQL 的连接不用写具体的的 ON 条件。直接写关联属性即可。那么我们己经知道了 HQL 的内连接的具体的写法了，那么迫切内连接和内连接写法和使用上有什么区别呢？  
迫切内连接其实就是在内连接的 INNER JOIN 后添加一个 FETCH 关键字。我们来比对一下：  
内连接：

session.createQuery("FROM Customer c INNER JOIN c.linkMans").list();

迫切内连接

session.createQuery("FROM Customer c INNER JOIN FETCH c.linkMans").list();

我们会发现无论是内连接或是迫切内连接发送的底层SQL都是一样的，而且在生成的 SQL 语句中也没有 FETCH 关键字，当然 FETCH 本身就不是 SQL 语句的关键字。所以一定要注意，FETCH 只能在 HQL 中使用的，生成了 SQL 语句以后，FETCH 就消失了。那么fetch到底有什么作用呢？

其实我们知道HQL内连接查询的和SQL的内连接查询到的结果集是一样的，都是两个表的交集部分的数据。

然后在封装数据的时候，普通内连接会将属于客户的数据封装到Customer对象中，会将属于联系人的数据封装到 LinkMan 对象中，所以每条记录都会是装有两个对象的集合，所以封装以后的数据是List

List<Object[]> list = session createQuery("FROM Customer c INNER JOIN c.linkMans").list();

那么加了 FETCH 以后，虽然我们查询到的数据是一样的，但是 Hibernate 发现HQL 中有 FETCH 就会将数据封装到一个对象中，把属于客户的数据封装到Customer 对象中，将属于联系人的部分封装到 Customer 中的联系人的集合中，这样最后封装完成以后是一个`List<Customer>`中。所以使用迫切内连接的时候可以如下编写代码：

List<Customer> list = session createQuery("FROM Customer c INNER JOIN FETCH c.linkMans").list();

其实内连接和迫切内连接的主要区别就在与封装数据，因为他们查询的结果集都是一样的，生成底层的SQL语句也是一样的。

*  内连接：发送就是内连接的语句，封装的时候将属于各自对象的数据封装到各自的对象中，最后得到一个`List<Object[]>`。
 *  迫切内连接：发送的是内连接的语句，需要在编写HQL的时候在join后添加一个 FETCH 关键字，Hibernate 会发送 HQL 中的 FETCH 关键字，从而将每条数据封装到对象中，最后得到一个`List<Customer>`

但是迫切内连接封装以后会出现重复的数据，因为我们查询到目前有三条记录，就会被封装到三个对象中，其实我们真正的客户对象只有两个所以往往自己在手动编写迫切内连接的时候会使用 DISTINCT 去掉重复值。