重拾Hibernate框架——查询操作

最新推荐文章于 2020-07-08 01:18:59 发布
最新推荐文章于 2020-07-08 01:18:59 发布
阅读量669 收藏
点赞数
分类专栏： JavaEE 文章标签： hibernate HQL查询 QBC查询 SQL查询
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_15096707/article/details/72676180
版权

目录

前言

　　以下案例的项目上下文在《重拾Hibernate框架——一对多关联》、《重拾Hibernate框架——多对多关联》这两篇文章中提及，如无特殊说明，本文中提及的案例将基于上述项目进行运行测试。

OID查询

　　根据ID查询记录，调用session中的get方法进行实现。如：

User user = session.get(User.class, 1);

对象导航查询

　　查询某个公司中所有员工的过程，使用对象导航实现。对象导航查询适用于单向一对多关系下通过“一方”获取“多方”的信息记录。如：

// 获取ID为3的公司的所有员工
Company company = session.get(Company.class, 3);
Set<Employee> employees = company.getEmployees();
System.out.println(employees.size());

HQL查询

　　HQL（HQL，Hibernate Query Language），是Hibernate提供的一种查询语言，HQL语法类似于SQL，不同的是HQL是一种完全面向对象的语言，能够直接查询实体类及属性。而SQL语句操作的是数据库中的表和表中的字段。

查询所有

　　如查询所有公司记录：

Query query = session.createQuery("from Company");
List<Company> list = query.list();
for (Company company : list) {
    System.out.println(company.getId() + "=" + company.getName());
}

条件查询

　　where

// Query query = session.createQuery("from Company where id = ? and name = ?"); // 可以取别名，如下
Query query = session.createQuery("from Company as c where c.id = ? and c.name = ?");
// 设置占位符（?）的值，从位置0开始设置
query.setParameter(0, 1);
query.setParameter(1, "CSDN");
List<Company> list = query.list();

　　like

Query query = session.createQuery("from Company where name like ?");
query.setParameter(0, "%D%");
List<Company> list = query.list();

排序查询

// 升序（默认）
// Query query = session.createQuery("from Company order by id asc");
// 降序
Query query = session.createQuery("from Company order by id desc");
List<Company> list = query.list();

分页查询

（1）MySQL中实现分页：使用关键字limit实现
如：

SELECT * FROM t_company LIMIT 0, 3

（2）HQL中实现分页
　　在HQL语句中，不支持limit关键字（因为MySQL数据库支持limit关键字，但其他数据库不一定支持）。在Hibernate的Query对象中封装了两个方法实现了分页操作。如：

Query query = session.createQuery("from Company");
// 设置分页的开始位置
query.setFirstResult(0);
// 设置每页的记录数
query.setMaxResults(3);
List<Company> list = query.list();

投影查询

　　投影查询：查询部分字段的值，而不是查询所有字段的值，这就是投影查询。
　　注：在HQL语句中select语句后面不能写“*”，不支持这样查询所有数据。
（1）查询单个字段的值

// 查询单个字段的值
Query query = session.createQuery("select id from Company");
List<Object> list = query.list();
for (Object obj : list) {
    System.out.println(obj);
}

（2）查询多个字段的值

// 查询多个字段的值
Query query = session.createQuery("select id, name from Company");
List<Object[]> list = query.list();
for (Object[] obj : list) {
    System.out.println(obj[0] + "=" + obj[1]);
}

聚合函数的使用

　　常见的聚合函数：count、sum、avg、max、min。
　　这里以count为例，查询公司的总记录数，如：

Query query = session.createQuery("select count(*) from Company");
Object obj = query.uniqueResult();
// 直接输出总记录数
System.out.println(obj);
Query query = session.createQuery("select count(*) from Company");
Object obj = query.uniqueResult();
// 转成int输出
Long longObj = (Long) obj;
int count = longObj.intValue();
System.out.println(count);

　　这里需要注意的是，不能直接将obj转成int类型：

Query query = session.createQuery("select count(*) from Company");
Object obj = query.uniqueResult();
// 错误方式
int count = (int) obj;
System.out.println(count);

　　否则会报：java.lang.ClassCastException: java.lang.Long cannot be cast to java.lang.Integer 错误。

QBC查询

　　QBC查询，即Query By Criteria查询，使用Criteria对象进行实现。
　　使用QBC查询，一般需要以下三个步骤：
1. 使用Session实例 的createCriteria()方法创建Criteria对象；
2. 使用工具类Restrictions的方法为Criteria对象设置查询条件，Order工具类的方法设置排序方式，Projections工具类的方法进行统计和分组；
3. 使用Criteria对象的list()方法进行查询并返回结果。

查询所有

Criteria criteria = session.createCriteria(Company.class);
List<Company> list = criteria.list();
for (Company company : list) {
    System.out.println(company.getId() + "=" + company.getName());
}

条件查询

使用工具类Restrictions的方法为Criteria对象设置查询条件。

　　where

Criteria criteria = session.createCriteria(Company.class);
// 添加查询条件
// 在add方法中使用类的方法实现条件的设置
criteria.add(Restrictions.eq("id", 1));
criteria.add(Restrictions.eq("name", "CSDN"));
List<Company> list = criteria.list();
for (Company company : list) {
    System.out.println(company.getId() + "=" + company.getName());
}

　　like

Criteria criteria = session.createCriteria(Company.class);
// 添加查询条件
criteria.add(Restrictions.like("name", "%D%"));
List<Company> list = criteria.list();

Restrictions类的常用方法

方法名称描述
Restrictions.eq等于 =
Restrictions.allEq使用Map，使用key/value进行多个等于的判断
Restrictions.gt大于 >
Restrictions.ge大于等于 >=
Restrictions.lt小于 <
Restrictions.le小于等于 <=
Restrictions.between对应SQL的between子句
Restrictions.like对应SQL的like子句
Restrictions.in对应SQL的in子句
Restrictions.andand关系
Restrictions.oror关系
Restrictions.sqlRestrictionSQL限定查询

排序查询

　　调用addOrder设置排序规则，即对哪个属性采用升序还是降序排序，如：

// 升序（默认）
/*Criteria criteria = session.createCriteria(Company.class);
criteria.addOrder(Order.asc("id"));*/
// 降序
Criteria criteria = session.createCriteria(Company.class);
criteria.addOrder(Order.desc("id"));
List<Company> list = criteria.list();

Order类的常用方法

方法名称描述
Order.asc升序
Order.desc降序

分页查询

Criteria criteria = session.createCriteria(Company.class);
// 设置分页的开始位置
criteria.setFirstResult(0);
// 设置每页的记录数
criteria.setMaxResults(3);
List<Company> list = criteria.list();
for (Company company : list) {
    System.out.println(company.getId() + "=" + company.getName());
}

统计查询

使用Projections工具类的方法进行统计和分组。

Criteria criteria = session.createCriteria(Company.class);
criteria.setProjection(Projections.rowCount());
Object obj = criteria.uniqueResult();
Long longObj = (Long) obj;
int count = longObj.intValue();
System.out.println(count);

Projections类的常用方法

方法名称描述
Projections.avg求平均值
Projections.count统计某属性的数量
Projections.countDistinct统计某属性不同值的数量
Projections.groupProperty指定某个属性为分组属性
Projections.max求最大值
Projections.min求最小值
Projections.projectionList创建一个ProjectionList对象
Projections.rowCount查询结果集中的记录条数
Projections.sum求某属性的合计

离线查询

　　通常离线查询可以在表示层建立，然后传入业务层进行查询。

DetachedCriteria detachedCriteria = DetachedCriteria.forClass(Company.class);
// 最终执行时才需要到session对象
Criteria criteria = detachedCriteria.getExecutableCriteria(session);
List<Company> list = criteria.list();
for (Company company : list) {
    System.out.println(company.getId() + "=" + company.getName());
}

多表查询

MySQL中的多表查询

（1）内连接

/*内连接*/
SELECT * FROM t_company c, t_employee e WHERE c.id = e.cid

SELECT * FROM t_company c INNER JOIN t_employee e ON c.id = e.cid

（2）左外连接

/*左外连接*/
SELECT * FROM t_company c LEFT OUTER JOIN t_employee e ON c.id = e.cid

（3）右外连接

/*右外连接*/
SELECT * FROM t_company c RIGHT OUTER JOIN t_employee e ON c.id = e.cid

HQL中的多表查询

内连接

　　语法：from 实体类名称 别名 inner join 别名.存储另一个实体类对象的set属性名称。如：

Query query = session.createQuery("from Company c inner join c.employees");
List<Object[]> list = query.list();
for (Object[] objs: list) {
    Company company = (Company) objs[0];
    Employee employee = (Employee) objs[1];
    System.out.println(company.getId() + ": " + company.getName() + " " + employee.getId() + ": " + employee.getName());
}

　　调用query对象的list方法后，方法返回的是一个List集合，集合中的每个部分是数组形式。

迫切内连接

　　迫切内连接本质上也是内连接操作，不同的是使用内连接返回list中每部分是数组，而迫切内连接返回list中每部分是对象。
　　语法：from 实体类名称 别名 inner join fetch 别名.存储另一个实体类对象的set属性名称。如：

Query query = session.createQuery("from Company c inner join fetch c.employees");
List<Company> list = query.list();
for (Company c : list) {
    System.out.println(c.getId() + ": " + c.getName());
}

左外连接

　　语法：from 实体类名称 别名 left outer join 别名.存储另一个实体类对象的set属性名称。如：

Query query = session.createQuery("from Company c left outer join c.employees");
List<Object[]> list = query.list();
for (Object[] objs: list) {
    Company company = (Company) objs[0];
    if(objs[1] != null) {
        Employee employee = (Employee) objs[1];
        System.out.println(company.getId() + ": " + company.getName() + " " + employee.getId() + ": " + employee.getName());
    } else {
        System.out.println(company.getId() + ": " + company.getName() + " null : null");
    }
}

　　调用query对象的list方法后，方法返回的是一个List集合，集合中的每个部分是数组形式。

迫切左外连接

　　迫切左外连接本质上也是左外连接操作，不同的是使用左外连接返回list中每部分是数组，而迫切左外连接返回list中每部分是对象。
　　语法：from 实体类名称 别名 left outer join fetch 别名.存储另一个实体类对象的set属性名称。如：

Query query = session.createQuery("from Company c left outer join fetch c.employees");
List<Company> list = query.list();
for (Company c : list) {
    System.out.println(c.getId() + ": " + c.getName());
}

右外连接

　　语法：from 实体类名称 别名 right outer join 别名.存储另一个实体类对象的set属性名称。如：

Query query = session.createQuery("from Company c right outer join c.employees");
List<Object[]> list = query.list();
for (Object[] objs: list) {
    Employee employee = (Employee) objs[1];
    if(objs[0] != null) {
        Company company = (Company) objs[0];
        System.out.println(company.getId() + ": " + company.getName() + " " + employee.getId() + ": " + employee.getName());
    } else {
        System.out.println("null : null " + employee.getId() + ": " + employee.getName());
    }
}

注：没有迫切右外连接！！！

Hibernate检索策略

检索策略的概念

　　在Hibernate中检索策略分为两类：
第一类 立即查询：调用查询方式将立即发送查询语句到数据库进行查询，如根据ID调用get方法查询，会立即发送查询到数据库。如：

// 获取ID为3的公司的所有员工
// 调用get方法将立即发送SQL语句查询数据库
Company company = session.get(Company.class, 3);
System.out.println(company.getId() + ": " + company.getName());

第二类 延迟查询：调用方法时不会立即发送查询语句到数据库进行查询，而是在真正需要到数据时才发送语句查询数据库，如根据ID调用load方法查询，调用load方法不会马上发送语句查询数据库。如：

// 获取ID为3的公司的所有员工
// 调用load方法之后，不会立即发送SQL语句到数据库进行查询
Company company = session.load(Company.class, 3);
// 返回对象ID时，不会发送SQL语句进行查询
System.out.println(company.getId());
// 得到对象其他属性值时才发送查询语句
System.out.println(company.getName());

　　注：在以上代码测试过程中，发现没有延迟查询的效果，原因不明，待查明！！！
　　延迟查询又分为两类：
（1）类级别延迟：如根据ID查询返回实体类对象，调用load方法不会立即发送语句到数据库进行查询。
（2）关联级别延迟：如查询某个公司的所有员工记录的过程。查询到某公司后得到公司的实体类对象，该对象拥有包含所有员工信息的set集合属性，在未使用该属性内的数据时，并不会发送语句到数据库查询员工信息。如：

// 根据ID查询公司，这里并没有自动查询该公司的所有员工
Company company = session.get(Company.class, 3);

// 下面这一句将发送查询语句到数据库进行查询
Set<Employee> employees = company.getEmployees();

System.out.println("test");
System.out.println(employees.size());

关联级别延迟操作

<set>集合上的fetch和lazy

　　在映射文件中可以配置实现关联级别延迟的方式。如在Company.hbm.xml中配置：
在set标签上使用属性fetch和lazy：

  • fetch：控制的是查询其关联对象的时候采用的SQL语句的格式。
    • select：默认值。发送一条select语句查询其关联对象。
    • join：发送一条迫切做外连接查询关联对象。
    • subselect：发送一条子查询查询其关联对象。
  • lazy：控制的是查询其关联对象的时候是否采用延迟加载的策略。
    • true：默认值。默认查询关联对象的时候采用延迟加载。
    • false：查询关联对象的时候不采用延迟加载。
    • extra：极其懒惰，查询关联对象的时候，采用比延迟加载更懒惰的方式进行查询。如需要得到记录的总条数，其只会使用count聚合函数查询记录总数。

测试：配置Company.hbml映射文件的set标签
（1）<set name="employees" fetch="select" lazy="true">

// 根据ID查询公司，这里并没有自动查询该公司的所有员工
Company company = session.get(Company.class, 3);

// 下面这一句将发送select查询语句到数据库进行查询
Set<Employee> employees = company.getEmployees();

System.out.println("test");
System.out.println(employees.size());

（2）<set name="employees" fetch="select" lazy="false">

// 根据ID查询公司时也查询了该公司的所有员工信息
Company company = session.get(Company.class, 3);

Set<Employee> employees = company.getEmployees();

System.out.println("test");
System.out.println(employees.size());

（3）<set name="employees" fetch="select" lazy="extra">

// 根据ID查询公司，这里并没有自动查询该公司的所有员工
Company company = session.get(Company.class, 3);

// 只发送查询记录总数的语句到数据库，如下：
Set<Employee> employees = company.getEmployees();

System.out.println("test");
System.out.println(employees.size());

　　获取员工记录时，发送的SQL语句：

Hibernate: 
    select
        count(id) 
    from
        t_employee 
    where
        cid =?

批量抓取

　　如，默认情况下，查询所有公司下的所有员工信息。我们可以先查询所有公司记录再遍历每个公司获取公司下的所有员工信息。在关联级别延迟加载下，只有公司去获取员工信息时才会发送查询语句进行查询。在这样的情况下，Hibernate会根据公司记录逐条发送查询员工记录的语句到数据库，影响效率。如：

Criteria criteria = session.createCriteria(Company.class);
List<Company> list = criteria.list();
for (Company company : list) {
　　// 每次遍历才发送查询当前公司下的所有员工记录信息
    Set<Employee> employees = company.getEmployees();
    for (Employee employ : employees) {
        System.out.println(company.getId() + ": " + company.getName() + " " + employ.getId() + ": " + employ.getName());
    }
}

　　通过配置公司Company.hbm.xml中set标签的batch-size值，可以减少发送查询语句的次数，批量查询。如：

<set name="employees" batch-size="10">

　　这时遍历一次后，会发现类似如下查询，使用in帮我们查询了后续多条员工记录信息，而不是一条一条的查询：

Hibernate: 
    select
        employees0_.cid as cid5_1_1_,
        employees0_.id as id1_1_1_,
        employees0_.id as id1_1_0_,
        employees0_.name as name2_1_0_,
        employees0_.gender as gender3_1_0_,
        employees0_.phone as phone4_1_0_,
        employees0_.cid as cid5_1_0_ 
    from
        t_employee employees0_ 
    where
        employees0_.cid in (
            ?, ?, ?
        )
葡萄干是个程序员
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
mysql谓词下推_Filter(过滤)|Project(映射)|Pushdowns(谓词下推)
weixin_32099979的博客
02-19 698
1. Filter(过滤) 和 Project(映射)在传统的 OLAP 系统中，在进行 Join 的时候使用过滤和映射会极大的提高性能。同样的，在 Hadoop 中使用 Filter 和 Projection 同样可以提高效率，由于减少了一个管道需要处理的数据量。在Hadoop中减少处理的数据量是至关重要的，尤其当需要通过网络和本地磁盘进行处理的时候。我们都知道，MapReduce 的shuff...
Hibernate总结——课程管理
06-20
在Java开发中，Hibernate是一个非常重要的对象关系映射（ORM）框架，它简化了数据库操作，使得开发者可以使用面向对象的方式来处理数据。本教程将深入探讨如何使用Hibernate来实现一个简单的课程管理系统，涵盖多对...
Hibernate: select count(employee0_.id) as col_0_0_ from Employee employee0_ where 0=1
蔡茂的博客
04-27 2206
Hibernate: select count(employee0_.id) as col_0_0_ from Employee employee0_ where 0=1 高级查询除了为空无法查询出数据，看了Hibernate的底层sql语句有一个where 0=1 后来发现时定制规则的时候出错 原代码 @Override public Specification createSp...
hibernate学习（2）
weixin_30920091的博客
11-06 131
1 实体类编写规则 2 hibernate主键生成策略 3实体类操作 （1）crud操作 （2）实体对象状态 4 hibernate的一级缓存 5 hibernate事务操作 （1）事务代码规则写法 6 hibernate其他的api（查询） 实体类编写规则 1 实体类里面属性私有的 2 私有属性使用公开的set方法和get方法操作 3 要求实体类有属性作为唯一值...
hibernate详解（三）---对象的关系之关联关系
m0_46616045的博客
07-08 381
对象的关系 （1）依赖关系:如果A对象离开了B对象就不能编译,那么A对象依赖B对象; （2）关联关系:如果A对象依赖B对象,并且把B对象作为A对象的一个属性,我们就说,A对象和B对象是关联关系; 关联关系从多重性来讲: 一对多：一个A包含多个B; 多对一：多个A属于一个B;并且一个A只能属于一个B; 多对多：一个A属于多个B,一个B可以属于多个A; 一对一：一个A属于一个B,一个B属于一个A; 关联关系从导航性来讲(java代码):通过A的某一个属性能够访问到和这个属性关联的B对象,A能够在这个关系
Hibernate读书笔记---继承映射
hududumo
07-06 112
对于面向对象的程序设计语言，继承、多态是两个最基本的概念。Hibernate的继承映射可以理解两个持久化类之间的继承关系。 Hibernate支持几种继承映射策略，不管哪种继承映射策略，Hibernate的多态查询都可以很好的运行。 假设有四个对象：Department、Employee、Skiller、Sales。他们四个对象存在如下关系： 从上面的关系可知：Employee与...
重拾Hibernate框架——入门
梦空间
05-20 651
目录目录 Hibernate入门 第一个Hibernate程序 Session重点 Transaction Session重点 TransactionHibernate入门第一个Hibernate程序第一步 搭建Hibernate环境 （1）创建一个Java（或Java Web）工程项目； （2）导入Hibernate的jar包； 注：除此之外，在使用Hibernate的时候，有日志信息的输出
重拾Hibernate框架——多对多关联
梦空间
05-24 585
目录目录 前言 多对多映射配置 创建实体类 让两个实体类之间相互表示 配置映射关系 配置核心配置文件 多对多级联保存 多对多级联删除 维护第三张表关系前言　　这里将以用户和角色为例，其中用户与角色是多对多的关系。即一个用户可以拥有多个角色，一个角色可以分配给多个用户。以下将介绍如何使用hibernate框架配置这样一种多对多的映射关系。配置完成后，我们无需在数据库中手动建表，Hibernate框架将
重拾Hibernate框架——一对多关联
梦空间
05-23 566
目录目录 前言 一对多映射配置 创建实体类 让两个实体类之间相互表示 配置映射关系 配置核心配置文件 一对多关联操作前言　　这里将以公司和员工为例，其中公司与员工是一对多的关系。即一个公司拥有多个员工，一个员工属于一个公司。以下将介绍如何使用Hibernate框架配置这样一种一对多的映射关系。配置完成后，我们无需在数据库中手动建表，Hibernate框架将会为我们在对应的数据库中自动创建。一对多映射
重拾Hibernate框架——实体类、主键生成策略、session绑定本地线程
梦空间
05-20 792
目录目录 实体类持久化类的编写规则 Hibernate主键生成策略 实体类操作 案例准备 对实体类CRUD操作 添加操作 查询操作 修改操作 删除操作 saveOrUpdate方法 实体类对象状态实体类（持久化类）的编写规则 属性私有化，即private修饰； 属性提供getter和setter方法； 要求实体类提供一个属性，并作为唯一值（一般使用ID值）； 实体类属性建议使用基本数据类型对应的包装
Hibernate 4——Hello World
04-20
在本文中，我们将深入探讨如何使用Hibernate 4框架进行初步的“Hello World”实践。Hibernate是一个流行的开源对象关系映射（ORM）框架，它简化了Java应用程序与数据库之间的交互。通过将Java对象与数据库表之间的...
Hibernate框架技术文档资料汇总
07-22
资源名称：Hibernate框架技术文档资料汇总资源目录：【】EJB3.0实例教程【】HeadFirstHibernate【】Hibernate In Action【】Hibernate【】hibernate【】Hibernate【】Hibernate3.1.2中文文档【】Hibernate3.2官方...
Hibernate 框架总结
09-11
对 Hibernate 框架的学习总结 映射配置已详细描述，如还是不懂得可以留言，私发你代码，如有错误，欢迎各位大神指点
hibernate框架
03-31
Hibernate是一个强大的Java持久化框架，它简化了数据库操作，使开发者可以更专注于业务逻辑而不是数据库交互。在Java应用中，尤其是在企业级应用开发中，Hibernate扮演着至关重要的角色，它提供了对象关系映射（ORM...
Spring框架自学之路——简易入门
热门推荐
梦空间
06-01 11万+
目录 目录 介绍 Spring中的IoC操作 IoC入门案例 Spring的bean管理（配置文件） Bean实例化的方式 Bean标签的常用属性 属性注入 使用有参构造函数注入属性 使用set方法注入属性 注入对象类型属性 p名称空间注入属性 注入复杂类型属性 IoC和DI的区别 Spring的bean管理（注解） Spring注解开发准备 注解创建对象 注解注入属性 ...
Intellij IDEA下的第一个Hibernate项目
梦空间
05-15 2万+
参考：intellij配置hibernate自动生成hbm.xml文件     从零开始用Intellij idea14创建hibernate项目        下面我要讲的创建方式，可能更加原生态，更加类似于Eclipse下创建Hibernate项目的方式，我想这也有助于对在Intellij IDEA下创建Hibernate项目的理解。        首先需要在Intellij IDEA下创
Maven中source插件的使用及其注意问题
梦空间
05-20 1万+
使用source插件，可以使我们在package打包过程中也打包项目源码。使用source插件，需要我们在 pom.xml 中添加配置： org.apache.maven.plugins maven-source-plugin 2.4 packag
Hibernate中Blob对象类型的使用
梦空间
05-17 1万+
使用Intellij IDEA创建Hibernate项目，目录结构如下：        其中 assets/app.png 为将要存储的照片，src/hibernate.cfg.xml 为Hibernate的配置文件，Students为实体，Students.hbm.xml 为对象关系映射的配置文件，test目录下其中使用到的测试类为 StudentsTest 类，使用到junit进行测试。
Hibernate查询操作详解：HQL与Criteria
"这篇内容主要讨论了在Hibernate框架中进行查询操作的相关知识，特别是HQL（Hibernate Query Language）和Criteria API的使用。文章提到了在使用HQL进行查询时，`list()`方法返回数据的不同类型，并给出了如何优化...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值