JavaWeb 之 Hibernate 查询方式与策略优化

Posted on 2018-06-05 Edited on 2023-12-08 In JavaWeb

Hibernate 查询方式与策略优化

Hibernate 框架的查询方式

唯一标识 OID 的检索方式

1
2
3

session.get(对象.class,OID);
// 例如：
Customer customer = session.get(Customer.class, 1L);

对象的导航的方式

比如，查询客户下的联系人：

1	Customer.getLinkmans();

HQL 的检索方式

（Hibernate Query Language） – Hibernate 的查询语言

QBC 的检索方式

（Query By Criteria） – 条件查询

SQL 检索方式（了解）

本地的SQL检索

HQL 查询

HQL 概述**

HQL 的介绍

HQL (Hibernate Query Language) 是面向对象的查询语言, 它和 SQL 查询语言有些相似。
在 Hibernate 提供的各种检索方式中, HQL 是使用最广的一种检索方式

HQL 与 SQL 的关系

HQL 查询语句是面向对象的，Hibernate 负责解析 HQL 查询语句，然后根据对象-关系映射文件中的映射信息，把 HQL 查询语句翻译成相应的 SQL 语句。
HQL 查询语句中的主体是域模型中的类及类的属性；
SQL 查询语句是与关系数据库绑定在一起的。SQL 查询语句中的主体是数据库表及表的字段。

HQL 的基本查询

HQL 基本的查询格式

支持 方法链 的编程，即直接调用 list() 方法
简单的代码如下

1	session.createQuery("from Customer").list();

/**
 * 基本查询的演示
 */
@Test
public void run1() {
    Session session = HibernateUtils.getCurrentSession();
    Transaction tr = session.beginTransaction();

    Query query = session.createQuery("from Customer");
    List<Customer> list = query.list();
    for (Customer customer : list) {
        System.out.println(customer);
    }

    tr.commit();
}

使用别名的方式

可以使用别名的方式

不能出现 *，即不能 select * from Customer c ✖

1 2	session.createQuery("from Customer c").list(); session.createQuery("select c from Customer c").list();

排序查询

排序查询和 SQL 语句中的排序的语法是一样的：

升序

1	session.createQuery("from Customer order by cust_id").list();

降序

1	session.createQuery("from Customer order by cust_id desc").list();

分页查询

不论使用的是 MySQL 还是 Oracle，都可以使用 Hibernate 框架提供的分页方法。

两个方法如下：

1 2	setFirstResult(a); // 从哪条记录开始，如果查询是从第一条开始，值是 0 setMaxResults(b); // 每页查询的记录条数

演示代码如下

1	List<LinkMan> list = session.createQuery("from LinkMan").setFirstResult(0).setMaxResults().list();

/**
 * 分页查询
 */
@Test
public void run2() {
    Session session = HibernateUtils.getCurrentSession();
    Transaction tr = session.beginTransaction();
    // 查询联系人
    Query query = session.createQuery("from Linkman l order by l.lkm_id");
    // 分页查询，调用方法，查询第一页的数据 1-3 条
    query.setFirstResult(0);
    query.setMaxResults(3);

    List<Linkman> list = query.list();
    for(Linkman linkman:list){
        System.out.println(linkman);
    }
    tr.commit();
}

条件查询

setParameter("?号的位置，默认从0开始","参数的值"); 不用考虑参数的具体类型
按位置绑定参数的条件查询（指定下标值，默认从 0 开始）
按名称绑定参数的条件查询（HQL语句中的 ? 号换成 :名称的方式）

例如代码如下：

/**
 * 按条件查询
 */
@Test
public void run3() {
    Session session = HibernateUtils.getCurrentSession();
    Transaction tr = session.beginTransaction();
    // 查询联系人
    Query query = session.createQuery("from Linkman l where l.lkm_gender = ?");
    // 传入值
    // query.setString(0, "男");

    // Query query = session.createQuery("from Linkman l where l.lkm_id > 2");
    // query.setLong(0, 2L);

    // 通用的方法，不用判断具体的类型
    query.setParameter(0, "男");
    List<Linkman> list = query.list();
    for (Linkman linkman : list) {
        System.out.println(linkman);
    }
    tr.commit();
}

HQL 的投影查询

投影查询就是想查询某一字段的值或者某几个字段的值。

投影查询的案例：

如果查询多个字段，例如下面这种方式

List<Object[]> list = session.createQuery("select c.cust_name,c.cust_level from Customer c").list();
for (Object[] objects : list) {
    System.out.println(Arrays.toString(objects));
}

如果查询两个字段，也可以把这两个字段封装到对象中

先在持久化类中 提供对应字段的构造方法（不要忘了空的构造方法）
语句也要像下面一样发生改变

List<Customer> list = session.createQuery("select new Customer(c.cust_name,c.cust_level) from Customer c").list();
for (Customer customer : list) {
    System.out.println(customer);
}

聚合函数查询

count()、sum()、avg()、max()、min()等。

获取总的记录数

Session session = HibernateUtils.getCurrentSession();
Transaction tr = session.beginTransaction();
// 也可以是 select count(*) from Customer
List<Number> list = session.createQuery("select count(c) from Customer c").list();
// 通过下标取值
Long count = list.get(0).longValue();
System.out.println(count);
tr.commit();

获取某一列数据的和

Session session = HibernateUtils.getCurrentSession();
Transaction tr = session.beginTransaction();
List<Number> list = session.createQuery("select sum(c.cust_id) from Customer c").list();
Long count = list.get(0).longValue();
System.out.println(count);
tr.commit();

HQL 多表查询

多表的查询

HQL 语句和 SQL 语句的查询语法比较类似。

内连接查询

显示内连接

1	select * from customers c inner join orders o on c.cid = o.cno;

隐式内连接

1	select * from customers c,orders o where c.cid = o.cno;

外连接查询

左外连接

1	select * from customers c left join orders o on c.cid = o.cno;

右外连接

1	select * from customers c right join orders o on c.cid = o.cno;

迫切和非迫切

非迫切返回结果是 Object[]
迫切连接返回的结果是对象，把客户的信息封装到客户的对象中，把订单的信息封装到客户的 Set 集合中。

内连接查询

内连接使用 inner join ，默认返回的是 Object 数组

/**
 * 内连接，数据默认返回的是数组
 */
@Test
public void run1() {
	Session session = HibernateUtils.getCurrentSession();
	Transaction tr = session.beginTransaction();

	// 默认返回数组
	Query query = session.createQuery("from Customer c inner join c.linkmans");
	List<Object[]> list = query.list();
	for (Object[] objects : list) {
		System.out.println(Arrays.toString(objects));
	}

	tr.commit();
}

迫切内连接: inner join fetch ，返回的是实体对象

/**
 * 内连接，数据默认返回的是数组
 * 把数据封装到对象中
 * 使用关键字：fetch 迫切连接，这样就会把数据封装到对象中
 * 此时数据会重复
 */
@Test
public void run1() {
	Session session = HibernateUtils.getCurrentSession();
	Transaction tr = session.beginTransaction();

	// 使用 fetch 迫切连接，封装数据
	Query query = session.createQuery("from Customer c inner join fetch c.linkmans");
	List<Customer> list = query.list();
	for (Customer customer : list) {
		System.out.println(customer);
	}

	tr.commit();
}

解决数据重复：

/**
 * 解决数据的重复问题
 */
@Test
public void run2() {
	Session session = HibernateUtils.getCurrentSession();
	Transaction tr = session.beginTransaction();

	Query query = session.createQuery("from Customer c inner join fetch c.linkmans");
	List<Customer> list = query.list();
	// 手动解决数据重复问题，编程中都使用这种方式来解决重复的问题
	Set<Customer> set=new HashSet<>(list);
	for (Customer customer : set) {
		System.out.println(customer);
	}

	tr.commit();
}

左外连接查询

左外连接: 封装成 List<Object[]>
迫切左外连接

Session session = HibernateUtils.getCurrentSession();
Transaction tr = session.beginTransaction();
List<Customer> list = session.createQuery("from Customer c left join fetch c.linkmans").list();
Set<Customer> set = new HashSet<Customer>(list);
for (Customer customer : set) {
	System.out.println(customer);
}
tr.commit();

QBC 查询

QBC：Query By Criteria，按条件进行查询。

Criteria：代表一次查询；
Criterion：代表一个查询条件；
Restrictions：产生查询条件的工具类。

简单查询

使用的是 Criteria 接口：

List<Customer> list = session.createCriteria(Customer.class).list();
for (Customer customer : list) {
    System.out.println(customer);
}

排序查询

需要使用 addOrder() 的方法来设置参数，参数使用 org.hibernate.criterion.Order 对象。
具体代码如下：

Session session = HibernateUtils.getCurrentSession();
Transaction tr = session.beginTransaction();
Criteria criteria = session.createCriteria(Linkman.class);
// 设置排序
// criteria.addOrder(Order.asc("lkm_id"));
criteria.addOrder(Order.desc("lkm_id"));
List<Linkman> list = criteria.list();
for (Linkman linkman : list) {
    System.out.println(linkman);
}
tr.commit();

分页查询

QBC 的分页查询也是使用两个方法:

setFirstResult();
setMaxResults();
代码如下;

Session session = HibernateUtils.getCurrentSession();
Transaction tr = session.beginTransaction();
Criteria criteria = session.createCriteria(Linkman.class);
// 设置排序
criteria.addOrder(Order.desc("lkm_id"));
criteria.setFirstResult(0);
criteria.setMaxResults(3);
List<Linkman> list = criteria.list();
for (Linkman linkman : list) {
    System.out.println(linkman);
}
tr.commit();

条件查询

Criterion 是查询条件的接口，Restrictions 类是 Hibernate 框架提供的工具类，使用该工具类来设置查询条件。

条件查询使用 Criteria 接口的 add 方法，用来传入条件。
使用 Restrictions 的添加条件的方法，来添加条件，例如：

方法	含义
Restrictions.eq	相等
Restrictions.gt	大于号
Restrictions.ge	大于等于
Restrictions.lt	小于
Restrictions.le	小于等于
Restrictions.between	在之间
Restrictions.like	模糊查询
Restrictions.in	范围
Restrictions.and	并且
Restrictions.or	或者
Restrictions.isNull	查询某属性为空的值

测试代码如下

Session session = HibernateUtils.getCurrentSession();
Transaction tr = session.beginTransaction();
Criteria criteria = session.createCriteria(Linkman.class);
// 设置排序
criteria.addOrder(Order.desc("lkm_id"));
// 设置查询条件
// Restrictions 提供静态的方法，拼接查询的条件
criteria.add(Restrictions.or(Restrictions.eq("lkm_gender", "男"), Restrictions.gt("lkm_id", 3L)));
List<Linkman> list = criteria.list();
for (Linkman linkman : list) {
    System.out.println(linkman);
}
tr.commit();

聚合函数查询

Projection 的聚合函数的接口，而 Projections 是 Hibernate 提供的工具类，使用该工具类设置聚合函数查询。

使用 QBC 的聚合函数查询，需要使用 criteria.setProjection() 方法
具体的代码如下：

Session session = HibernateUtils.getCurrentSession();
Transaction tr = session.beginTransaction();
Criteria criteria = session.createCriteria(Linkman.class);
criteria.setProjection(Projections.rowCount());
List<Number> list = criteria.list();
Long count = list.get(0).longValue();
System.out.println(count);
tr.commit();

离线条件查询

脱离 session，可以不使用 session 来创建。而是在 web 层创建对象。

离线条件查询使用的是 DetachedCriteria 接口进行查询，离线条件查询对象在创建的时候，不需要使用 Session 对象，只是在查询的时候使用 Session 对象即可。

创建离线条件查询对象

1	DetachedCriteria criteria = DetachedCriteria.forClass(Linkman.class);

具体的代码如下

Session session = HibernateUtils.getCurrentSession();
Transaction tr = session.beginTransaction();

DetachedCriteria criteria = DetachedCriteria.forClass(Linkman.class);
// 设置查询条件
criteria.add(Restrictions.eq("lkm_gender", "男"));
// 查询数据
List<Linkman> list = criteria.getExecutableCriteria(session).list();
for (Linkman linkman : list) {
    System.out.println(linkman);
}
tr.commit();

SQL 查询方式（了解）

使用 Hibernate 框架一般不会使用 SQL 查询。

基本语法：

Session session = HibernateUtils.getCurrentSession();
Transaction tr = session.beginTransaction();

SQLQuery sqlQuery = session.createSQLQuery("select * from cst_linkman where lkm_gender = ?");
sqlQuery.setParameter(0,"男");
// 通过方法设置，封装数据
sqlQuery.addEntity(Linkman.class);
List<Linkman> list = sqlQuery.list();
System.out.println(list);
tr.commit();

查询功能优化

没有好与坏之分，只有适合不适合，可根据需求自行优化。但一般都会使用默认的，除非有特殊需求。

延迟加载

延迟加载先获取到代理对象，当真正使用到该对象中的属性的时候，才会发送 SQL 语句，是 Hibernate 框架提升性能的方式。

类级别的延迟加载

Session 对象的 get 方法是没有延迟加载；
Session 对象的 load 方法默认就是 延迟加载；
Customer c1 = session.load(Customer.class, 1L); 没有发送 SQL 语句，当使用该对象的属性时，才发送 SQL 语句。

使类级别的延迟加载失效：

在 <class> 标签上配置 lazy="false"

或者：

Hibernate.initialize(Object proxy); 把对象先初始化一下。

1	Hibernate.initialize(c1);

关联级别的延迟加载

（查询某个客户，当查看该客户下的所有联系人是否是延迟加载）

默认是延迟加载

Session session = HibernateUtils.getCurrentSession();
Transaction tr = session.beginTransaction();
Customer c = session.get(Customer.class, 1L);
System.out.println("=============");
System.out.println(c.getLinkmans().size()); // 当查询客户下的联系人的时候才发送语句进行查询
tr.commit();

关联级别延迟加载的策略

查询策略：使用 Hibernate 查询一个对象的时候，查询其关联对象，应该如何查询，是 Hibernate 的一种优化手段！！

Hibernate 框架的检索策略解决的问题

查询的时机

1 2	Customer c1 = (Customer) session.get(Customer.class, 1); System.out.println(c1.getLinkmans().size());

lazy 属性解决查询的时机的问题，需要配置 是否采用延迟加载！！

查询的语句格式

List<Customer> list = session.createQuery("from Customer").list();
for(Customer c : list){
	System.out.println(c.getLinkmans());
}

fetch 属性就可以解决 查询语句的格式 的问题！！

set 标签配置策略

在 <set> 标签上使用 fetch 和 lazy 属性：

fetch 的取值 – 控制 SQL 语句生成的格式

select – 默认值。发送查询语句

join – 连接查询。发送的是一条迫切左外连接！配置了 join，lazy 就失效了

subselect – 子查询。发送一条子查询查询其关联对象。（需要使用 list() 方法进行测试）

lazy 的取值 – 查找关联对象的时候是否采用延迟!

true – 默认。延迟

false – 不延迟

extra – 及其懒惰

set 标签上的默认值是 fetch="select" 和 lazy="true"

总结：Hibernate 框架都采用了默认值，开发中基本上使用的都是默认值。特殊情况再进行设置。

many-to-one 标签配置策略

在 <many-to-one> 标签上使用 fetch 和 lazy 属性

fetch的取值 – 控制SQL的格式.

select – 默认。发送基本select语句查询

join – 发送迫切左外连接查询

lazy的取值 – 控制加载关联对象是否采用延迟

false – 不采用延迟加载。

proxy – 默认值。代理。现在是否采用延迟

由另一端的 <class> 上的 lazy 确定.如果这端的 class 上的 lazy="true"。proxy 的值就是 true(延迟加载)。
如果 class 上 lazy="false" ，proxy 的值就是 false(不采用延迟)

在 <many-to-one> 标签上的默认值是 fetch="select" 和 proxy