Hibernate初学者课程件：从基础到实战

于 2025-03-11 10:15:38 发布
阅读量692 收藏 21
点赞数 14
CC 4.0 BY-SA版权
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_29323977/article/details/146203719

本文还有配套的精品资源，点击获取 menu-r.4af5f7ec.gif

简介：Hibernate是一个流行的Java ORM框架，它通过对象-关系映射简化了数据库操作，无需编写直接SQL语句。本课件专为初学者设计，涵盖Hibernate的核心概念、架构、配置、实体类映射、对象持久化、查询操作、懒加载、级联操作、缓存机制以及实体关系映射等关键技术点。学习本课件，初学者能全面掌握Hibernate的基本用法，并在实际项目中提升数据库操作效率和代码可维护性。 hibernate课件

1. Hibernate简介和数据持久化工具介绍

Hibernate 是一个开源的对象关系映射（ORM）框架，它使得开发者能够使用 Java 对象来表示数据库表中的数据。Hibernate 在 Java 持久化领域中扮演着关键角色，因其强大的功能和社区支持而广受欢迎。它简化了数据库操作，减少了样板代码，允许开发者更专注于业务逻辑而非数据库细节。

与其它数据持久化工具如JPA（Java Persistence API）、MyBatis 或者 JDO（Java Data Objects）相比，Hibernate 提供了一种更为全面和深入的方式来处理对象与数据库之间的映射。它支持全面的延迟加载、级联操作、缓存策略，并为开发者提供了丰富的配置选项来优化性能。

数据持久化是指将程序中的数据保存到数据库或其他存储介质中，并且能够从这些存储介质中恢复数据的过程。Hibernate 通过映射机制将 Java 对象的状态保存到数据库中，同时管理对象与数据库之间的交互，从而实现数据持久化。这种抽象层次不仅简化了数据库编程，还允许程序能够适应多种数据库系统，实现数据库无关性。下一章我们将深入解析 Hibernate 的核心架构组件，为理解其高级特性打下坚实的基础。

2.1 Session的生命周期与操作

2.1.1 Session接口详解

Session是Hibernate中一个非常核心的接口，它提供了操作数据库的入口。Session可以看作是与数据库进行交互的一个持久化层的会话。当应用程序需要执行数据访问时，首先需要打开一个Session对象，通过该对象提供的方法，我们可以完成所有的数据操作任务，包括对数据的查询、更新、插入和删除等。

Session内部通过维护一个持久化上下文来管理所有的持久化实例，即处于持久化状态的Java对象。Session对于数据库的访问，是通过Hibernate底层的SQL会话来完成的，所以它的操作可以看作是懒惰的，在必要时才会生成并执行SQL语句。

2.1.2 Session的打开、关闭和事务管理

当需要进行数据库操作时，必须先创建并打开一个Session。典型的代码示例如下： 

Session session = null;
try {
    session = sessionFactory.openSession();
    // 执行持久化操作...
    session.save(new User("tom", "Tom's Password"));
    // 提交事务
    session.getTransaction().commit();
} catch (Exception e) {
    if (session.getTransaction().isActive()) {
        session.getTransaction().rollback();
    }
    e.printStackTrace();
} finally {
    // 关闭Session
    if (session != null) {
        session.close();
    }
}

在上面的示例代码中，我们首先通过调用 sessionFactory.openSession() 方法打开了一个Session。需要注意的是，在完成所有的持久化操作后，我们需要提交事务，即调用 session.getTransaction().commit() 方法。在提交事务之前，如果操作过程中发生异常，应该进行事务的回滚操作，以保证数据的一致性。最后，不管操作是否成功，都应该确保Session被关闭，以释放资源。

在多线程环境下，Session对象不是线程安全的，因此，必须避免在一个线程中多次打开同一个Session，或者让Session对象在多个线程之间共享。

在理解了Session的基本操作后，开发者可以更有效地管理数据库连接和事务，确保应用程序的性能和稳定性。

3. Hibernate配置与数据库连接设置

3.1 Hibernate配置文件解析

3.1.1 hibernate.cfg.xml的作用和结构

Hibernate的配置文件 hibernate.cfg.xml 是Hibernate配置的核心，它包含了一系列配置属性，这些属性定义了Hibernate的运行时行为。Hibernate通过读取此文件来配置和初始化其内部组件，如连接池、方言、映射文件等。这个文件通常位于项目的根目录或者资源目录中，确保Hibernate能够正确加载。

配置文件的结构主要分为以下几个部分：

  • <hibernate-configuration> ：这是文件的根元素，包含了Hibernate配置的总体信息。
  • <session-factory> ：这是一个用于配置Session工厂的元素，所有的会话（Session）都将由此工厂产生。
  • <property> ：用于定义各种配置属性，如数据库连接信息、方言、缓存等。
  • <mapping> ：用于指定映射文件的位置，Hibernate将根据这些映射文件来构建实体和数据库表之间的关系。

3.1.2 配置属性的详细解析

下面是一些关键的 <property> 配置项和它们的作用：

  • hibernate.connection.driver_class ：指定JDBC驱动类。
  • hibernate.connection.url ：数据库连接URL。
  • hibernate.connection.username ：数据库连接用户名。
  • hibernate.connection.password ：数据库连接密码。
  • hibernate.dialect ：数据库方言，Hibernate会根据方言来生成特定数据库的SQL语句。
  • hibernate.show_sql ：设置为true时，Hibernate会在控制台输出生成的SQL语句。
  • hibernate.hbm2ddl.auto ：这个属性允许在启动时自动创建或更新数据库结构，如 update 、 create-drop 等。

示例代码： 

<hibernate-configuration>
    <session-factory>
        <property name="hibernate.connection.driver_class">com.mysql.jdbc.Driver</property>
        <property name="hibernate.connection.url">jdbc:mysql://localhost:3306/mydatabase</property>
        <property name="hibernate.connection.username">username</property>
        <property name="hibernate.connection.password">password</property>
        <property name="hibernate.dialect">org.hibernate.dialect.MySQLDialect</property>
        <property name="hibernate.show_sql">true</property>
        <property name="hibernate.hbm2ddl.auto">update</property>
        <mapping class="com.example.MyEntity" />
    </session-factory>
</hibernate-configuration>

3.2 数据库连接和方言配置

3.2.1 JDBC和数据库连接设置

在Hibernate配置中，指定数据库连接是必不可少的步骤。为了实现这一点，通常需要引入JDBC驱动，使得Hibernate可以通过Java代码与数据库进行交互。在配置文件中，我们设置了数据库连接的URL、用户名和密码等关键信息，这些信息由 <property> 标签的属性定义。

为了让Hibernate知道如何与特定类型的数据库交互，我们需要指定对应的数据库方言。例如，如果你使用的是MySQL数据库，你将需要指定MySQL的方言类。数据库方言使得Hibernate能够生成针对特定数据库优化的SQL语句。

3.2.2 针对不同数据库的方言配置

Hibernate支持多种数据库，每种数据库都有其特定的方言类。在配置文件中，通过 hibernate.dialect 属性来指定使用的方言。例如： 

<property name="hibernate.dialect">org.hibernate.dialect.MySQLDialect</property>

对于Oracle数据库，你可能会使用如下配置： 

<property name="hibernate.dialect">org.hibernate.dialect.OracleDialect</property>

每种方言类都实现了 Dialect 接口，Hibernate通过这个接口来获取数据库特有的信息，如最大标识符长度、是否支持排序的限制等。

3.3 连接池的配置与优化

3.3.1 常用连接池的介绍和配置

连接池是一种重要的性能优化手段，它可以有效地管理数据库连接的生命周期，提高数据库操作的效率。Hibernate提供了内置的支持，可以通过配置来使用各种连接池策略。

Hibernate常用的连接池配置有：

  • C3P0：Hibernate推荐的连接池之一，它提供了简单的配置和优秀的性能。
  • HikariCP：相对较新的连接池，它提供了非常优秀的性能，是许多现代框架和应用程序的首选。
  • Proxool：一个更加灵活的连接池解决方案，但是较其他方案性能稍差。

配置连接池时，需要在Hibernate配置文件中设置相关的连接池属性。以C3P0为例，配置示例如下： 

<property name="hibernate.connection.provider_class">org.hibernate.connection.C3P0ConnectionProvider</property>
<property name="hibernate.c3p0.min_size">5</property>
<property name="hibernate.c3p0.max_size">20</property>
<property name="hibernate.c3p0.timeout">1800</property>
<property name="hibernate.c3p0.max_statements">50</property>

3.3.2 性能优化的实践方法

连接池的配置对应用性能有着直接的影响。一些实践方法包括：

  • 预先测试，找到最优的连接池参数设置。
  • 根据应用的负载模式，调整连接池大小，避免资源浪费或者连接超时。
  • 合理设置连接的超时时间，确保过期的连接能够及时释放。
  • 监控连接池的使用情况，注意是否有连接泄露等问题。

在实际使用中，可能需要根据应用的实际需要和数据库的特性，不断调整这些参数来达到最佳性能。

4. 实体类与映射文件的创建与关系描述

4.1 实体类的创建与映射

4.1.1 实体类的基本规则和注解

在Hibernate中，实体类通常代表数据库中的一个表，每个实体类的实例对应表中的一行数据。实体类的基本规则包括：

  1. 实体类需使用 @Entity 注解进行标记。
  2. 实体类的属性应当使用 @Id 注解指定主键字段。
  3. @Column 注解可以用来指定数据库表的列名和属性之间的映射关系。

例如，以下是一个简单的实体类定义： 

import javax.persistence.*;
import java.util.Date;

@Entity
@Table(name = "user")
public class User {
    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    @Column(name = "id")
    private Long id;
    @Column(name = "username")
    private String username;
    @Column(name = "password")
    private String password;
    @Column(name = "register_date")
    private Date registerDate;
    // Getters and setters
}

在这个例子中，我们定义了一个 User 实体类，它映射到一个名为 user 的数据库表，并且有四个字段： id , username , password , 和 register_date 。

4.1.2 使用映射文件进行映射配置

虽然使用注解是映射实体类的首选方法，但在某些情况下，如遗留代码维护或复杂的映射关系，使用XML映射文件仍然是一个可行的选择。下面是一个简单的XML映射文件例子： 

<?xml version="1.0"?>
<!DOCTYPE hibernate-mapping PUBLIC "-//Hibernate/Hibernate Mapping DTD 3.0//EN" "http://www.hibernate.org/dtd/hibernate-mapping-3.0.dtd">
<hibernate-mapping package="com.example.model">
    <class name="User" table="user">
        <id name="id" column="id" type="long">
            <generator class="native"/>
        </id>
        <property name="username" type="string" column="username"/>
        <property name="password" type="string" column="password"/>
        <property name="registerDate" type="date" column="register_date"/>
    </class>
</hibernate-mapping>

在Hibernate配置文件中（通常是 hibernate.cfg.xml ），需要指定该XML映射文件的位置： 

<mapping resource="com/example/model/User.hbm.xml"/>

通过映射文件，Hibernate可以了解如何将实体类的属性映射到数据库表的列。

4.2 实体间关系的映射

4.2.1 一对多和多对一关系的映射

在关系型数据库中，一对多或多对一的关系是常见的。在Hibernate中，可以通过注解来映射这些关系。

  • 一对多关系：使用 @OneToMany 注解。
  • 多对一关系：使用 @ManyToOne 注解。 
import javax.persistence.*;
import java.util.Set;

@Entity
@Table(name = "user")
public class User {
    // ...

    @OneToMany(mappedBy = "user")
    private Set<Order> orders;
    // ...
}

@Entity
@Table(name = "order")
public class Order {
    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    private Long id;
    @ManyToOne
    @JoinColumn(name = "user_id")
    private User user;
    // ...
}

在这个例子中， User 类中的 orders 集合代表一个用户可以有多个订单，而每个 Order 实例都通过一个外键 user_id 关联到特定的用户。

4.2.2 复杂关系的映射策略和方法

对于包含多个字段的复杂关系，如一对一和多对多，Hibernate也提供了相应的注解来处理。

  • 一对一关系：使用 @OneToOne 注解。
  • 多对多关系：使用 @ManyToMany 注解。

对于一对一关系，通常需要在两个相关的表中都定义一个外键，指向前一个表的主键。映射代码如下： 

@Entity
@Table(name = "person")
public class Person {
    // ...

    @OneToOne(mappedBy = "person")
    private Passport passport;
    // ...
}

@Entity
@Table(name = "passport")
public class Passport {
    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    private Long id;
    @OneToOne
    @JoinColumn(name = "person_id")
    private Person person;
    // ...
}

对于多对多关系，需要创建一个额外的关联表来存储两个实体之间的关联信息。映射代码如下： 

@Entity
@Table(name = "student")
public class Student {
    // ...

    @ManyToMany
    @JoinTable(
        name = "student_course",
        joinColumns = @JoinColumn(name = "student_id"),
        inverseJoinColumns = @JoinColumn(name = "course_id")
    )
    private Set<Course> courses;
    // ...
}

@Entity
@Table(name = "course")
public class Course {
    // ...

    @ManyToMany(mappedBy = "courses")
    private Set<Student> students;
    // ...
}

请注意，这些注解可以进一步结合 @JoinTable 、 @JoinColumns 等注解进行更细致的控制，以满足复杂业务逻辑下对关系映射的需求。

5. Hibernate对象持久化操作详解

5.1 基本的CRUD操作

5.1.1 Session中的持久化操作方法

在Hibernate中，CRUD操作是通过Session接口提供的方法来实现的。Session对象扮演了与数据库交互的桥梁角色，所有的持久化操作都要通过Session来完成。以下是Session接口中用于执行CRUD操作的几个核心方法：

  • save(Object entity) ：创建新记录，将一个临时状态的对象保存为持久状态。
  • get(Class<T> entityClass, Serializable id) ：通过ID读取一个持久化对象，如果对象不存在则返回null。
  • update(Object entity) ：更新对象状态，将一个脱管状态的对象重新关联到Session中。
  • delete(Object entity) ：删除对象记录，将一个持久化状态的对象转变为脱管状态，并删除数据库中对应的记录。

CRUD操作是任何持久化框架中不可或缺的部分，为了演示如何使用这些方法，我们考虑有一个简单的用户信息持久化场景，其中有一个用户实体 User ，它被映射到一个名为 users 的数据库表。 

Session session = sessionFactory.openSession();
Transaction tx = session.beginTransaction();

// 创建用户并保存
User newUser = new User("Alice", "alice@example.com");
session.save(newUser);
tx.commit();
session.close();

上述代码展示了如何创建一个新的用户对象并使用Hibernate将其保存到数据库。这个过程首先打开了一个新的Session，开始了一个事务，然后创建了一个 User 对象并将其保存，最后提交了事务并关闭了Session。

5.1.2 缓存的作用和使用策略

Hibernate提供了一级缓存（Session级别）和二级缓存（SessionFactory级别）两种类型的缓存，这些缓存用于提高数据访问的性能。当应用程序执行CRUD操作时，Hibernate会自动利用这些缓存，但开发者也可以通过配置来优化缓存的行为。

  • 一级缓存 ：每个Session拥有自己的缓存区域，用来保存该Session加载的实体对象，直到Session关闭。一级缓存的最大好处是保证了对象状态的一致性，因为所有的持久化操作都会直接影响到缓存中的数据。

  • 二级缓存 ：整个SessionFactory共享的缓存，可以跨多个Session使用。通过在配置文件中声明哪些类或者表使用二级缓存，可以显著提高数据访问速度。但需要注意的是，只有那些被声明为"可缓存"的实体类或集合才能使用二级缓存。

Hibernate缓存使用的关键策略包括： - 确保读操作尽可能地从缓存中读取数据，减少数据库的访问次数。 - 在事务提交或Session关闭时，同步更新缓存和数据库的状态。 - 使用合适的缓存策略和缓存区域，例如，可以对频繁访问但不常变更的数据使用只读缓存。

开发者可以通过调整缓存的大小、过期策略、并发读写策略来优化应用性能，同时需要在确保数据一致性与系统性能之间找到平衡点。

5.2 懒加载与延迟加载

5.2.1 懒加载的概念及其优缺点

懒加载（Lazy Loading）是Hibernate中一个重要的性能优化机制，它是指在应用程序首次访问一个关联对象时，才从数据库加载该对象数据。这种机制可以减少不必要的数据库访问和提高应用程序的性能。

懒加载可以应用于实体类之间的关联关系，如一对多、多对一等。通常情况下，可以通过在映射文件或注解中设置 fetch 属性为 FetchType.LAZY 来启用懒加载。

懒加载的优点包括： - 减少数据库访问次数 ：只有在实际需要访问关联对象时，Hibernate才会从数据库加载它们，避免了不必要的数据加载。 - 优化应用性能 ：通过延迟加载可以显著减少内存消耗，提高应用的响应速度。

然而，懒加载也有其缺点，尤其是当开发者不理解其工作原理时： - 可能引发性能问题 ：如果对大量关联对象进行懒加载，那么在首次访问这些对象时，可能会引起大量的数据库访问，造成性能瓶颈。 - 需要谨慎管理 ：在事务提交之后，懒加载的关联对象可能无法正常加载，导致 LazyInitializationException 异常。

5.2.2 在实际应用中的最佳实践

为了最大限度地利用懒加载的优势并避免潜在的问题，以下是几种在实际应用中可以遵循的最佳实践：

  • 理解懒加载的范围和限制 ：开发者应该清楚哪些关联关系启用了懒加载，并理解懒加载如何影响实体对象的生命周期。
  • 避免在视图层中直接访问懒加载的关联对象 ：在Web层或表示层中直接访问懒加载对象可能导致异常，最佳实践是尽量在服务层中加载这些对象。
  • 使用合适的缓存策略配合懒加载 ：通过配置合适的缓存级别和策略，可以在需要时加载关联数据，而不会对性能产生太大影响。

开发者需要深入理解业务场景，合理配置懒加载策略，才能发挥其最大的优势。

5.3 事务的高级管理

5.3.1 事务的隔离级别和传播机制

在Hibernate中，事务管理是保证数据一致性的关键。 Transaction 接口提供了控制事务边界的方法。为了处理并发访问和保证数据完整性，Hibernate支持多种事务隔离级别，它们在性能和数据一致性之间提供了不同级别的平衡。

  • Transaction.ISOLATION_READ_UNCOMMITTED ：读未提交，这是最低的隔离级别，允许读取未提交的数据变更，可能会导致脏读、不可重复读和幻读。
  • Transaction.ISOLATION_READ_COMMITTED ：读已提交，允许读取并发事务已经提交的数据，可以防止脏读，但不可重复读和幻读可能发生。
  • Transaction.ISOLATION_REPEATABLE_READ ：可重复读，确保同一查询在事务中多次读取一致的结果，除非数据是本事务自己所更改，可以防止脏读和不可重复读，但幻读可能发生。
  • Transaction.ISOLATION_SERIALIZABLE ：串行化，最高的隔离级别，强制事务串行执行，可以防止脏读、不可重复读和幻读。

事务传播机制定义了当一个事务方法被另一个事务方法调用时，事务应该如何传播。Hibernate提供了以下传播行为：

  • Transaction.PROPAGATION_REQUIRED ：如果当前没有事务，就新建一个事务，如果已存在一个事务中，加入到这个事务中。
  • Transaction.PROPAGATION_SUPPORTS ：支持当前事务，如果当前没有事务，就以非事务方式执行。
  • Transaction.PROPAGATION_MANDATORY ：支持当前事务，如果当前没有事务，就抛出异常。
  • Transaction.PROPAGATION_REQUIRES_NEW ：新建事务，如果当前存在事务，把当前事务挂起。
  • Transaction.PROPAGATION_NOT_SUPPORTED ：以非事务方式执行操作，如果当前存在事务，就把当前事务挂起。
  • Transaction.PROPAGATION_NEVER ：以非事务方式执行，如果当前存在事务，则抛出异常。

开发者需要根据具体的业务逻辑来选择合适的隔离级别和事务传播行为。这不仅涉及到应用的性能，还关系到数据的一致性和完整性。

5.3.2 分布式事务的处理方法

在分布式系统中，跨越多个资源管理器（如数据库、消息队列）的事务被称为分布式事务。处理分布式事务要比本地事务复杂得多，因为它们需要跨多个节点进行数据一致性管理。

Hibernate自身并不直接支持分布式事务，通常需要与支持两阶段提交协议（2PC）的事务管理器（如JTA）结合来处理分布式事务。在Java EE环境中，JTA和JNDI资源被用来管理分布式事务。

一个分布式事务处理的简单例子可能包括：

  • 应用程序在一个JTA事务中执行对数据库的操作。
  • 同时，应用程序还可能需要向消息队列发送消息。
  • 这些操作要么全部成功，要么全部失败，以保持数据的一致性。

在实现分布式事务时，需要特别注意性能问题和死锁的可能性。在设计系统时，应尽量减少分布式事务的使用，利用补偿事务（SAGA模式）来解决业务连续性问题，这通常需要领域驱动设计（DDD）来实现。通过将业务逻辑划分成独立的小事务，并设计事务之间的回滚和补偿策略，可以有效地减少分布式事务所带来的性能负担。

6. Hibernate查询操作：HQL与Criteria API

6.1 HQL查询语言详解

HQL（Hibernate Query Language）是Hibernate中用于数据库查询的专用语言。它的设计与SQL类似，但不是直接与数据库表交互，而是与持久化对象及其属性进行交互。HQL能够理解类名和属性名，因此可以进行面向对象的查询。

6.1.1 HQL的基本语法和使用场景

HQL查询通常包括以下部分：

  • FROM 子句：指定查询的类或实体。
  • SELECT 子句：列出要返回的字段或对象。
  • WHERE 子句：设置查询的条件。
  • ORDER BY 子句：定义返回结果的排序方式。
  • 分页语法： LIMIT 和 OFFSET 。

一个基本的HQL查询示例如下： 

String hql = "FROM Employee e WHERE e.salary > :minSalary ORDER BY e.salary";
Query query = session.createQuery(hql);
query.setParameter("minSalary", 50000);
List<Employee> highPaidEmployees = query.list();

在此示例中，我们从 Employee 类中选择工资高于50000的员工，并按工资排序。

6.1.2 HQL与SQL的比较及转换技巧

HQL与SQL的主要区别在于HQL是面向对象的，而SQL是面向关系的。HQL需要映射到数据库表，但HQL中的类和属性需要通过Hibernate的映射文件来对应到实际的数据库表和字段。

例如，HQL查询可能看起来像这样： 

"SELECT e FROM Employee e WHERE e.department.name = :departmentName"

在底层，Hibernate会将其转换为类似以下的SQL查询（假设 Employee 和 Department 有合适的映射关系）： 

SELECT employee.*
FROM employees employee
JOIN departments department ON employee.department_id = department.id
WHERE department.name = :departmentName

为了更有效地将HQL转换为SQL，开发者应当了解HQL的语义和Hibernate的映射机制。HQL查询的性能优化也可以参考其对应的SQL查询优化方法。

6.2 Criteria API的构建与应用

Criteria API提供了一种面向对象的查询方式，它允许开发者以类型安全的方式构建查询，使用起来更类似于Java代码而非字符串。它允许动态地构建查询，并且可以保证编译时的类型检查。

6.2.1 Criteria API的构建过程

Criteria API查询的构建过程通常遵循以下步骤：

  1. 创建一个 Criteria 实例，通常与特定的类或表相对应。
  2. 使用 add 方法添加各种限制条件。
  3. 设置排序（如果有需要）。
  4. 执行查询并获取结果。

例如，使用Criteria API来查询工资高于50000的员工，代码如下： 

Criteria criteria = session.createCriteria(Employee.class);
criteria.add(Restrictions.gt("salary", 50000));
criteria.addOrder(Order.desc("salary"));

List<Employee> highPaidEmployees = criteria.list();

6.2.2 动态查询和复合条件查询的实现

Criteria API非常适合实现动态查询。可以在运行时根据不同的条件动态构建查询。例如，根据用户输入动态添加查询条件： 

String departmentName = ...;
if (departmentName != null) {
    criteria.add(Restrictions.eq("department.name", departmentName));
}

复合条件查询也十分直观，可以链式调用 add 方法添加多个条件： 

criteria.add(Restrictions.eq("salary", salary));
criteria.add(Restrictions.eq("department.id", departmentId));

6.3 查询性能优化

Hibernate查询性能优化是确保应用稳定运行的关键。优化可以通过减少数据加载范围、使用查询缓存和调整Hibernate缓存策略等方式实现。

6.3.1 优化查询的常见策略

  • 使用 setFetchSize 方法减少一次性加载的数据量。
  • 使用 setTimeout 方法避免查询超时。
  • 利用 scroll 和 setFetchSize 实现分批加载大量数据。
  • 确保查询时使用的索引已经创建好，并且优化了SQL语句。

6.3.2 Hibernate查询缓存的应用及配置

Hibernate查询缓存可以存储查询结果，减少对数据库的访问次数。要启用查询缓存，需要在配置文件中设置： 

<property name="hibernate.cache.use_query_cache">true</property>

然后，在创建查询时，可以指定缓存使用： 

Query query = session.createQuery("FROM Employee e");
query.setCacheable(true);

结合实际情况，可以进一步调整查询缓存的过期策略和容量限制，以及如何处理缓存同步问题。

在下一章节，我们将探讨Hibernate中的懒加载与级联操作的优化策略，进一步提高应用的性能和稳定。

本文还有配套的精品资源，点击获取 menu-r.4af5f7ec.gif

简介：Hibernate是一个流行的Java ORM框架，它通过对象-关系映射简化了数据库操作，无需编写直接SQL语句。本课件专为初学者设计，涵盖Hibernate的核心概念、架构、配置、实体类映射、对象持久化、查询操作、懒加载、级联操作、缓存机制以及实体关系映射等关键技术点。学习本课件，初学者能全面掌握Hibernate的基本用法，并在实际项目中提升数据库操作效率和代码可维护性。

本文还有配套的精品资源，点击获取 menu-r.4af5f7ec.gif

带虾条酱
关注
hibernate session生命周期示例
05-25
NULL 博文链接：https://selvemen.iteye.com/blog/457225
[Hibernate] Hibernate配制项之hibernate.show_sql, hibernate.show_sql和hibernate.use_sql_comments
weixin_36210698的博客
05-18 9566
Hibernate配制项之hibernate.show_sql, hibernate.show_sql和hibernate.use_sql_comments 前言 在本地开发时，我们经常有查看执行的SQL语句的需求。 本次介绍输出和统计SQL语句相关的三个配制项。 本文测试使用的实体如下： @Entity public class Event { @Id @Gene...
springboot-hibernate-show_sql无效 sql日志打印
非常暴躁的程序猿博客
03-28 2128
springboot中hibernate的show_sql配置无效的解决办法
Hibernate中的show_sql和Spring中的hibernate.show_sql的区别
热门推荐
小熊Leo的专栏
12-08 1万+
Hibernate中的show_sql和Spring中的hibernate.show_sql的区别Hibernate配置文件的属性是show_sql 而Spring配置文件中的属性是hibernate.show_sql其实Hiberante中用的也是hibernate.show_sql， 只不过hibernate这段字符串是在org.hibernate.cfg.Configuration类的ad
hibernate输出sql语句参数配置
lsh0118的专栏
11-09 547
关键字: 让hibernate输出sql语句参数配置 在J2ee应用中，如果采用Hibernate框架，可以自动建立数据库实体与Java实体类的映射关系，大大方便Java程序进行持久化对象访问和操作，从而明显提高企业应用开发效率，减轻Java程序与后台数据库的依赖性。 但是，有时候如果操作不慎，可能造成映射关系不完整（特别是存在外键链接的时候），造成访问数据库对象时程序有Bug。这时，可以通过参数...
hibernate基本配置show_sql、sql_format
weixin_30575309的博客
09-29 407
show_sql是否打印生成的sql语句： <property name="show_sql">false</property> sql_format，格式化生成的sql语句： <property name="format_sql">true</property> 转载于:https://www.cnblog...
Java全套视频教程：从基础到实战应用
这份Java视频教程提供了一个完整的路径，从基础语法到高级框架和企业级应用开发，无论你是初学者还是进阶开发者，都能从中受益匪浅。通过跟随教程，你将获得扎实的Java编程技能，并掌握一系列与之相关的前端和后端...
JAVA基础教程PPT课程：从初识到项目实战
资源摘要信息:"本资源为一套完整的Java基础教程PPT，涵盖了Java编程语言的基础知识，适合初学者使用。教程内容从基础概念讲起，逐步深入至项目开发实战，包含25个章节，内容丰富，包括但不限于基本语法、程序结构、...
J2EE全攻略：从基础到实战教程
本教程分为八个主要章节，共计36个学时，适合初学者和有一定基础的开发者深入学习。 首先，第2页的目录列出了教学大纲，涵盖了从基础概念到高级技术的广泛内容。从互联网基础知识开始，包括Internet的起源与发展，...
Java全栈学习指南：从基础到实战
Java学习大纲是一个全面指导Java初学者入门至高级的系统性课程，它涵盖了Java语言的各个方面，旨在帮助学习者掌握这门强大的编程语言。该大纲由以下几个主要部分组成： 1. **Java简介**：这部分首先介绍Java的历史...
hibernate---配置属性
墨笙弘一
01-31 468
1.hibernate.show_sql (1)在hibernate.cfg.xml中配置 true(2)作用：在控制台输出所有的sql语句声明，这个在日志目录中是一个可选择的属性，它的值有两个true或者false。 true:在控制台打印sql日志信息 false:在控制台部打印sql日志信息 2.hibernate.format_sql (1)在hibernate.cfg.x
灵活控制 Hibernate 的日志或 SQL 输出，以便于诊断
03-29 1167
我们在使用 Hibernate 时一般只会关注是否显示生成的 SQL 语句，不过有些时候还不够。默认时 Hibernate 执行的 SQL 语句是打印在控制台上的，它也可以配置为输出给 Log4J 或是 Log4Back，还能显示出更详细的参数和取值信息。这里简单讲来。 Hibernate 的配置文件 hibernate.cfg.xml 里提供有三个有关显示 SQL 的配置项，如果是与 Spri
JAVAWEB开发之Hibernate详解（一）——Hibernate的框架概述、开发流程、CURD操作和核心配置与API以及Hibernate日志的使用...
iteye_18817的博客
03-26 980
Hibernate框架概述 什么是Hibernate？ 框架：软件的半成品，完成部分代码的功能。 Hibernate：Hibernate是一个开放源代码的对象关系映射框架，它对JDBC进行了非常轻量级的对象封装，使得Java程序员可以随心所欲的使用对象编程思想来操作数据库。Hibernate可以应用在任何使用JDBC的场合，既可以在Java的客户端程序中使用，也可以在Servlet/JSP的web...
hibernate 核心配置
qq_40435621的博客
02-18 136
必须的配置 连接数据库的基本的参数 驱动类 url路径 用户名 密码 方言 可选的配置 显示SQL ：hibernate.show_sql 格式化SQL ：hibernate.format_sql 自动建表 ：hibernate.hbm2ddl.auto none ：不使用hibernate的自动建表 create ：如果数据库中已经有表，删除原有表，重新创建，如果没有表，新建表。...
让Hibernate输出SQL语句参数配置
weixin_33895016的博客
06-04 201
2019独角兽企业重金招聘Python工程师标准>>> ...
测试Hibernate中session的生命周期以及CRUD
家很远,心很近.....
04-21 2593
由于这册测试使用的是JUnit，所以在开始之前，先说一下JUnit 的注意事项：Junit简介：  * 编写类XXXXTest，需要继承TestCase  * 编写单元测试方法，测试方法必须以test开头，测试方法不能含有参数和返回值，如：    public void testHello( ) { }  * 最好单独建立source目录存放测试类下面开始：1.新建了一个Hiberna
spring中延长hibernate中session的生命周期：OpenSessionInViewFilter
mafly008的专栏
08-29 2072
在HIBERNATE中,如果我们要访问到某个类的集合属性,那我们一般在类的的映射文件里SET节点启用LAZE=FALSE; 那么在S2SH中怎么解决呢? 1.OpenSessionInViewFilter是Spring提供的一个针对Hibernate的一个支持类，其主要意思是在发起一个页面请求时打开Hibernate的Session， 一直保持这个Session，直到这个请求结束，具体是
Hibernate快速入门—新手Hibernate详细配置步骤介绍
J.Jian博客
10-27 967
一、准备jar包创建好javaweb以后在lib下复制准备好了的Hibernate的jar包，会自动导入Web App Libraries下 下载jar包地址：http://hibernate.org/orm/ 二、创建User实体类：在com.hibernate包下package com.hibernate;/** * 实体User */ public class User { p
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值