Spring中使用Hibernate
Hibernate是最流行的ORM框架之一，而Spring提供了对Hibernate的出色集成支持。
本文介绍如何在传统Spring框架(非Spring Boot)中集成Hibernate。
项目搭建结构
我们先写一个例子，来看看 Spring 中如何使用和体现 Hibernate
项目结构
典型的Spring框架集成Hibernate的项目目录结构（Maven项目）：
1 | src/ |
但是本次演示，还是打算写成简单一些的方式
添加依赖
1 | <dependencies> |
配置 Spring 配置文件
创建Spring配置文件applicationContext.xml，application.properties，或者使用Java配置类：
1 |
|
properties 貌似是给 spring boot 用的，纯framework貌似都用xml 我感觉这个更方便
1 | # 数据源配置 |
确保主应用类上有 @SpringBootApplication 注解，它包含了 @ComponentScan 功能
Java 配置方式
1 | import org.springframework.context.annotation.Bean; |
创建实体类
使用Hibernate注解定义实体类
1 | import javax.persistence.*; |
创建DAO层
传统Hibernate DAO实现
这里使用了大量 session 的方法和 query 等常用 api 的方法，体现了 Hibernate 的使用
1 | import org.hibernate.Session; |
主要注解解析
@Repository
- 作用
- 声明该类为 Spring 的数据访问组件（DAO），是
@Component的特殊化版本。 - 自动将 DAO 类注册为 Spring Bean，并支持 Spring
的数据访问异常转换（将 Hibernate/JPA 异常转换为 Spring 的
DataAccessException体系）。
- 声明该类为 Spring 的数据访问组件（DAO），是
@Transactional
- 作用
- 声明该类的所有公共方法都在事务管理下执行。
- 默认配置下：
- 事务传播行为为
PROPAGATION_REQUIRED（若当前无事务，则创建新事务；否则加入当前事务）。 - 事务隔离级别为数据库默认级别。
- 所有
RuntimeException会触发事务回滚，受检异常（如IOException）不会触发回滚。
- 事务传播行为为
@Autowired
- 作用
- 通过类型自动注入依赖的 Bean（此处注入
SessionFactory）。 - Spring 会在容器中查找
SessionFactory类型的 Bean 并注入。
- 通过类型自动注入依赖的 Bean（此处注入
方法解析
getCurrentSession()
- 功能：获取当前线程绑定的
Session。 - 关键点
- 在
@Transactional注解的事务上下文中，Session由 Spring 自动管理，无需手动关闭。 - 若不在事务中调用此方法，会抛出异常。
- 在
findById(Long id)
- 功能：根据 ID 查询员工。
- Hibernate 方法
Session.get(Class, id)：立即查询数据库，若记录不存在返回null。
save(Employee employee)
功能：保存或更新员工。
Hibernate 方法
- ``` Session.saveOrUpdate(Object)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
- 若对象的 ID 为 `null` 或未持久化状态，执行 `INSERT`。
- 若对象的 ID 已存在，执行 `UPDATE`。
4. `delete(Employee employee)`
- **功能**：删除员工记录。
- Hibernate 方法
- `Session.delete(Object)`：将对象从持久化状态变为删除状态，事务提交时执行 `DELETE` 语句。
5. `findAll()`
- **功能**：查询所有员工。
- Hibernate 查询
- `Session.createQuery("from Employee")`：使用 HQL（Hibernate Query Language）查询，等价于 SQL 的 `SELECT * FROM employees`。
- `@SuppressWarnings("unchecked")`：抑制原始类型警告（Hibernate 5.2 前的 `createQuery()` 返回未泛型化的 `Query` 对象）。
6. `findByLastName(String lastName)`
- **功能**：根据姓氏查询员工。
- Hibernate 查询
- `createQuery("from Employee where lastName = :lastName", Employee.class)`：使用具名参数的 HQL 查询，防止 SQL 注入。
- `setParameter("lastName", lastName)`：绑定参数值。
### 服务层实现
```java
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;
import java.util.List;
/**
* 员工服务层
* 处理员工相关的业务逻辑，调用 DAO 层完成数据持久化操作
*/
@Service
public class EmployeeService {
/**
* 员工数据访问对象
* 由 Spring 容器自动注入，用于执行数据库操作
*/
@Autowired
private EmployeeDao employeeDao;
/**
* 根据 ID 获取员工信息
* @param id 员工 ID
* @return 对应的员工对象，若不存在则返回 null
*/
@Transactional(readOnly = true)
public Employee getEmployeeById(Long id) {
return employeeDao.findById(id);
}
/**
* 保存或更新员工信息
* - 新增员工：当员工对象 ID 为空时
* - 更新员工：当员工对象 ID 已存在时
* @param employee 员工对象
*/
@Transactional
public void saveEmployee(Employee employee) {
employeeDao.save(employee);
}
/**
* 删除员工信息
* @param employee 要删除的员工对象
*/
@Transactional
public void deleteEmployee(Employee employee) {
employeeDao.delete(employee);
}
/**
* 获取所有员工列表
* @return 包含所有员工的列表
*/
@Transactional(readOnly = true)
public List<Employee> getAllEmployees() {
return employeeDao.findAll();
}
/**
* 根据姓氏搜索员工
* @param lastName 姓氏
* @return 匹配的员工列表
*/
@Transactional(readOnly = true)
public List<Employee> searchByLastName(String lastName) {
return employeeDao.findByLastName(lastName);
}
}
- ``` Session.saveOrUpdate(Object)
主要注解解析
@Service
- 作用
- 声明该类为 Spring 的服务层组件，是
@Component的特殊化版本。 - 用于标识业务逻辑层，提高代码可读性和可维护性。
- 声明该类为 Spring 的服务层组件，是
- Spring 容器行为
- 自动扫描并注册为 Bean，可通过依赖注入使用。
@Autowired
- 作用
- 通过类型自动注入依赖的 Bean（此处注入
EmployeeDao）。
- 通过类型自动注入依赖的 Bean（此处注入
- 依赖注入方式
- 字段注入：简洁但不利于单元测试（建议使用构造器注入，Spring 4.3+
支持单参构造器省略
@Autowired）。
- 字段注入：简洁但不利于单元测试（建议使用构造器注入，Spring 4.3+
支持单参构造器省略
@Transactional
作用
- 声明方法在事务管理下执行，确保数据操作的原子性、一致性、隔离性和持久性（ACID）。
关键属性
- ```java readOnly = true
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
- 标记为只读事务，优化查询性能（如禁用缓存刷新、数据库优化等）。
- 仅用于查询方法，不可用于增删改操作。
- 默认配置
- 传播行为：`PROPAGATION_REQUIRED`（若当前无事务，则创建新事务；否则加入当前事务）。
- 隔离级别：使用数据库默认级别（如 MySQL 的 `REPEATABLE READ`）。
- 回滚规则：默认对 `RuntimeException` 和 `Error` 回滚，对受检异常（如 `IOException`）不回滚。
#### **方法解析**
1. `getEmployeeById(Long id)`
- **功能**：根据 ID 查询员工。
- 事务特性
- `readOnly = true`：优化查询性能。
- 业务逻辑
- 直接委派给 DAO 层执行数据库查询。
2. `saveEmployee(Employee employee)`
- **功能**：保存或更新员工信息。
- 事务特性
- 读写事务，确保操作的原子性。
- 业务逻辑
- 调用 DAO 层的 `save` 方法，可能触发 `INSERT` 或 `UPDATE`。
3. `deleteEmployee(Employee employee)`
- **功能**：删除员工信息。
- 事务特性
- 读写事务，确保操作的原子性。
- 业务逻辑
- 调用 DAO 层的 `delete` 方法执行物理删除。
4. `getAllEmployees()`
- **功能**：获取所有员工列表。
- 事务特性
- `readOnly = true`：优化查询性能。
- 业务逻辑
- 直接委派给 DAO 层查询所有记录。
5. `searchByLastName(String lastName)`
- **功能**：根据姓氏搜索员工。
- 事务特性
- `readOnly = true`：优化查询性能。
- 业务逻辑
- 直接委派给 DAO 层执行条件查询。
#### **服务层设计原则**
1. **单一职责**：
- 专注业务逻辑处理，不涉及数据访问细节（由 DAO 负责）。
2. **事务边界**：
- 在服务层控制事务边界，确保业务操作的原子性（如转账需同时更新两个账户）。
3. **数据校验**：
- 可在此层添加参数校验逻辑（示例中未体现，实际项目需添加）。
4. **异常处理**：
- 可捕获 DAO 层异常并转换为业务异常（示例中未体现，实际项目需添加）。
5. **事务传播**：
- 若方法间存在调用关系，需注意事务传播行为（默认 `REQUIRED` 可满足多数场景）。
#### **注意事项**
1. **事务嵌套**：
- 若服务层方法相互调用，需注意事务传播行为可能导致的意外结果（如内层方法异常导致整个事务回滚）。
2. **只读事务**：
- 确保 `readOnly = true` 仅用于纯查询方法，否则可能导致数据无法持久化。
3. **异常类型**：
- 业务异常建议继承 `RuntimeException`，确保事务自动回滚。
### 事务管理
Spring提供了声明式事务管理，可以通过注解轻松配置：
```java
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;
import org.hibernate.Hibernate; // Hibernate 特定 API
@Service
@Transactional
public class DepartmentService {
@Autowired
private DepartmentDao departmentDao;
@Autowired
private EmployeeDao employeeDao;
/**
* 获取部门及其所有员工（包含延迟加载的员工集合）
* @param deptId 部门 ID
* @return 包含完整员工列表的部门对象
*/
@Transactional(readOnly = true)
public Department getDepartmentWithEmployees(Long deptId) {
// 1. 通过 DAO 查询部门（此时员工集合为延迟加载的代理对象）
Department dept = departmentDao.findById(deptId);
// 2. 强制初始化延迟加载的员工集合
// Hibernate 特定方法，在事务未关闭前触发 SQL 查询
Hibernate.initialize(dept.getEmployees());
// 3. 返回已初始化员工集合的部门对象
return dept;
}
/**
* 批量转移员工到新部门
* @param fromDeptId 源部门 ID
* @param toDeptId 目标部门 ID
* @param employeeIds 待转移员工 ID 列表
*/
@Transactional(rollbackFor = Exception.class)
public void transferEmployees(Long fromDeptId, Long toDeptId, List<Long> employeeIds) {
// 1. 获取源部门和目标部门
Department fromDept = departmentDao.findById(fromDeptId);
Department toDept = departmentDao.findById(toDeptId);
// 2. 遍历员工 ID 列表，逐个转移
for (Long empId : employeeIds) {
Employee emp = employeeDao.findById(empId);
// 3. 从源部门移除员工（业务逻辑由实体类方法实现）
fromDept.removeEmployee(emp);
// 4. 添加到目标部门（业务逻辑由实体类方法实现）
toDept.addEmployee(emp);
// 5. 保存员工（更新部门关联）
employeeDao.save(emp);
}
// 6. 保存部门变更（可选，取决于实体关系配置）
departmentDao.save(fromDept);
departmentDao.save(toDept);
}
}
- ```java readOnly = true
主要注解解析
@Service
- 作用
- 声明该类为 Spring 的服务层组件，负责业务逻辑处理。
- Spring 容器行为
- 自动扫描并注册为 Bean，支持依赖注入。
@Transactional（类级别）
- 作用
- 为所有公共方法提供默认事务配置。
- 默认配置
- 传播行为：
PROPAGATION_REQUIRED（必要时创建新事务）。 - 隔离级别：使用数据库默认级别。
- 回滚规则：仅对
RuntimeException和Error回滚。
- 传播行为：
@Transactional(readOnly = true)（方法级别）
- 作用
- 覆盖类级别的事务配置，标记方法为只读事务。
- 优化点
- Hibernate 会优化查询执行（如禁用脏检查）。
- 数据库可优化只读事务的锁策略。
@Transactional(rollbackFor = Exception.class)（方法级别）
- 作用
- 覆盖类级别的回滚规则，指定所有异常（包括受检异常）都触发事务回滚。
- 适用场景
- 确保业务异常（如
ValidationException）也能触发回滚。
- 确保业务异常（如
方法解析
getDepartmentWithEmployees(Long deptId)
- 功能：获取部门及其所有员工。
- Hibernate 集成点
- 延迟加载处理
departmentDao.findById(deptId)返回的Department对象中，employees集合是 Hibernate 代理对象（未初始化）。Hibernate.initialize(dept.getEmployees())强制触发 SQL 查询，在事务未关闭前加载员工数据。
- Session 生命周期
- 方法在事务内执行，Session 保持打开状态，允许延迟加载初始化。
- 延迟加载处理
transferEmployees(...)
- 功能：批量转移员工到新部门。
- Hibernate 集成点
- 实体状态管理
- 通过 DAO 获取的
Department和Employee对象处于持久化状态。 - 修改持久化对象的关联关系（如
removeEmployee、addEmployee）会被 Hibernate 自动跟踪。
- 通过 DAO 获取的
- 级联操作
employeeDao.save(emp)可能无需调用（取决于实体类的cascade配置）。- 若
Department实体配置了cascade = CascadeType.ALL，则直接保存部门即可同步员工关联。
- 事务一致性
- 整个方法在单个事务中执行，确保数据一致性（要么全部转移成功，要么全部失败）。
- 实体状态管理
Hibernate 集成关键点
- 延迟加载（Lazy Loading）处理：
- 通过
Hibernate.initialize()强制初始化延迟集合，避免在事务外访问时抛出LazyInitializationException。 - 依赖
@Transactional保持 Session 打开状态。
- 通过
- 实体状态管理：
- Hibernate 跟踪持久化对象的状态变化，事务提交时自动生成 SQL。
- 示例中通过
removeEmployee和addEmployee修改实体关系，无需手动编写 SQL。
- 级联操作：
- 实体类的
@OneToMany或@ManyToOne注解可能配置了cascade属性（如CascadeType.PERSIST、CascadeType.MERGE），决定关联对象的自动持久化行为。
- 实体类的
- Session 生命周期：
- Spring 的
@Transactional管理 Hibernate Session 的打开、关闭和刷新。 - 方法执行期间 Session 保持打开，允许多次数据库操作。
- Spring 的
注意事项
- N+1 查询问题：
getDepartmentWithEmployees方法通过Hibernate.initialize()解决了 N+1 查询问题（先查部门，再查所有员工）。- 更优方案：使用
JOIN FETCH优化查询（如SELECT d FROM Department d JOIN FETCH d.employees WHERE d.id = :id）。
- 事务边界：
transferEmployees方法必须在单个事务内执行，否则可能导致数据不一致（如部分员工转移成功，部分失败）。
- 异常处理：
rollbackFor = Exception.class确保所有异常都触发回滚，但需谨慎使用，避免掩盖业务问题。
- 实体关系维护：
- 示例假设
Department实体的removeEmployee和addEmployee方法同时维护双向关联（即更新Employee的department字段）。 - 若未正确维护双向关联，可能导致数据库与对象状态不一致。
- 示例假设
高级配置
二级缓存配置
为什么配置二级缓存，什么时候配置
- 减少数据库访问压力
- 原理：将常用数据存储在应用服务器内存或分布式缓存中（如 Ehcache），避免重复查询数据库。
- 场景：高并发读场景（如商品详情、字典表），减少数据库 I/O 负载，提升系统吞吐量。
- 提升查询性能
- 原理：直接从缓存中读取数据，响应速度远快于数据库查询（内存访问速度比磁盘快 10 万倍以上）。
- 场景：频繁查询但不常更新的数据（如用户档案、配置信息），降低延迟，改善用户体验。
- 减轻应用层压力
- 原理：缓存分担了应用层的数据处理压力，尤其在复杂关联查询（如
Department关联Employee）时，避免重复执行 Hibernate 的对象关系映射（ORM）操作。
- 降低资源消耗
- 原理：减少数据库连接的创建和释放频率，降低 JDBC 操作的资源开销（如连接池压力）。
添加Ehcache依赖
1 | <dependency> |
在Hibernate配置中添加
1 | private Properties hibernateProperties() { |
在实体类上添加缓存注解
1 |
|
延迟加载与缓存
1 | public Department getDepartmentWithEmployees(Long deptId) { |
若Department的employees集合使用二级缓存，初始化时会直接从缓存加载数据，避免执行SELECT * FROM employees WHERE department_id = ?的
SQL 查询
集成测试
1 | import org.junit.jupiter.api.Test; |
与传统Hibernate的区别
在纯Hibernate应用中，你需要手动管理：
- SessionFactory的创建和关闭
- Session的生命周期
- 事务边界
- 异常处理
而在Spring集成Hibernate中：
- Spring管理SessionFactory的生命周期
- 通过
HibernateTemplate或@Transactional自动管理Session - 声明式事务管理
- Spring的统一异常体系转换Hibernate异常
关于配置 SessionFactory
本部分感谢 https://www.cnblogs.com/jwen1994/p/11299355.html，个人做出完善和修改
使用 Hibernate 框架的首要工作是编写Hibernate的配置文件，其次是如何使用这些配置文件实例化 SessionFactory，创建 Hibernate 的基础设施。
Spring 为创建 SessionFactory 提供了一个好用的 FactoryBean
工厂类：org.springframework.orm.hibernateX.LocalSessionFactoryBean，通过配置一些必要的属性，就可以获取一个SessionFactoryBean。
LocalSessionFactoryBean配置灵活度很高，支持开发者的不同习惯，让开发者拥有充分的选择权——这是Spring一贯的风格。
贴合Hibernate的配置方式
使用 HibernateAPI 创建一个 SessionFactory 的过程
首先编写好对象关系的映射文件 xxx.hbm.xml；
然后通过 Hibernate 的配置文件 hibernate.cfg.xml 将所有的 xxx.hbm.xml 映射文件组装起来；
最后通过以下经典的代码得到 SessionFactory 的实例：
1
2Configuration cfg = new Configuration().configure("hibernate.cfg.xml")：
SessionFactory sessionFactory = cfg.buildSessionFactory()；
hibernate.cfg.xml 配置文件拥有创建 Hibernate 基础设施所需的配置信息，来看一个最简单的 Hibernate 配置文件
1 |
|
这个配置文件定义了3个方面的信息：数据源、映射文件及 Hibernate 控制属性。
既然在 Hibernate 中可以使用一个配置文件创建一个
SessionFactory 实例，在 Spring
中也可以顺理成章地通过指定一个Hibernate配置文件，利用
LocalSessionFactoryBean 来达到相同的目的。
1 | <!-- 直接使用hibernate配置 --> |
如①处所示，通过 configLocation
属性指定了一个Hibernate 配置文件。如果有多个
Hibernate 配置文件，则可以通过 configLocations
属性指定，多个文件之间用逗号分隔。
LocalSessionFactoryBean 将利用 Hibernate
配置文件创建一个 SessionFactory 代理对象，以便和 Spring
的事务管理机制配合工作：当数据访问代码使用 SessionFactory
时，可以获取线程绑定的
Session，不管工作在本地或全局的事务，都能正确参与到当前的
Spring 事务管理中去。
更具 Spring 风格的配置
Spring 对 ORM 技术的一个重要支持就是提供统一的数据源管理机制，也许更多的开发者更愿意使用 Spring 配置数据源，即在 Spring 容器中定义数据源、指定映射文件、设置 Hibernate 控制属性等信息，完成集成组装的工作，完全抛开 hibernate.cfg.xml 配置文件，如下面代码所示。
1 |
|
数据源、映射文件及 Hibernate 控制属性这三方面的信息在
LocalSessionFactoryBean 中得到了完美集成，完全替代了
hibernate.cfg.xml 的作用，但这种配置对于 Spring 开发者而言更加亲切。
首先
1 | <bean id="sessionFactory" |
处指定的数据源是 Spring 容器中的数据源，不管是直接在 Spring
容器中配置，还是通过
其次，凭借 Spring 资源处理的强大功能，指定 Hibernate
映射文件变得相当灵活。在②<property name="mappingLocations">处采用了逐个指定映射文件的方法，其实这个方法是最笨拙的。由于
mappingLocations 属性的类型是
Resource[]，因此它还支持以下简洁的配置方式：
通过 Ant 风格的通配符 批量加载指定包下的所有映射文件，避免逐个罗列。 示例配置：
1 | <property name="mappingLocations"> |
若使用 JPA 注解（如 @Entity） 替代传统
.hbm.xml 映射文件，可通过 packagesToScan
属性自动扫描实体类所在包，彻底摆脱手动配置映射路径的繁琐。
1 | <bean id="sessionFactory" class="org.springframework.orm.hibernate4.LocalSessionFactoryBean"> |
- Spring 会扫描
packagesToScan指定的包，自动识别标注@Entity、@MappedSuperclass等注解的类。 - 无需手动维护映射文件列表，完全契合 “约定优于配置” 原则。
若厌倦 XML 配置，可改用纯 Java 代码配置 SessionFactory：
1 |
|
对应了我上面java配置类配置 SessionFactory 的部分
使用 HibernateTemplate
基于模板类使用 Hibernate 是最简单的方式，它可以在不牺牲 Hibernate
强大功能的前提下，以一种更简洁的方式使用 Hibernate，极大地降低了
Hibernate 的使用难度。按照 Spring 的风格，它提供了使用模板的支持类
HibernateDaoSupport，并通过
getHibernateTemplate()方法向子类开放模板类实例的调用。
把我的Dao类拿过来作为分析
1 | import org.hibernate.Session; |
HibernateTemplate 代理了 HibernateSession 的大多数持久化操作，并以一种更简洁的方式提供调用。 HibernateTemplate 所提供的大部分方法对于 Hibernate 开发者来说都是熟悉亲切的，模板类的方法大都可以在 Session 接口中找到镜像。
基于 HibernateTemplate 的 DAO 重构
传统方式通过 SessionFactory.getCurrentSession() 获取
Session，而使用 HibernateTemplate 时，需继承
HibernateDaoSupport 类，该类提供模板实例
hibernateTemplate，并自动管理 Session
的生命周期（包括事务和异常处理）。
1 | import org.springframework.orm.hibernate5.support.HibernateDaoSupport; |
- 继承
HibernateDaoSupport：- 父类提供
hibernateTemplate模板实例，通过getHibernateTemplate()访问。 - 自动处理
Session的打开、关闭和异常转换（如将 Hibernate 异常转为 SpringDataAccessException）。
- 父类提供
- 简化的 API 调用：
getHibernateTemplate().get(...)替代sessionFactory.getCurrentSession().get(...)。findByNamedParam(...)方法直接处理命名参数，无需手动创建Query对象。
- 无需手动管理事务：
- 事务由 Spring 的
@Transactional注解统一管理（需在 Service 层或 DAO 层方法上声明）。
- 事务由 Spring 的
常用的API方法
| 方法 | 说明 |
|---|---|
get(Class entityClass, Serializable id) |
根据 ID 获取实体（等效 Session.get()）。 |
load(Class entityClass, Serializable id) |
根据 ID 加载实体（支持延迟加载，等效
Session.load()）。 |
save(Object entity) |
保存新实体（等效 Session.save()）。 |
update(Object entity) |
更新现有实体（等效 Session.update()）。 |
saveOrUpdate(Object entity) |
自动判断保存或更新（等效
Session.saveOrUpdate()）。 |
delete(Object entity) |
删除实体（等效 Session.delete()）。 |
find(String hql) |
执行 HQL 查询，返回结果列表（等效
Session.createQuery(...).list()）。 |
findByNamedParam(String hql, String paramName, Object value) |
使用命名参数的 HQL 查询，防止 SQL 注入。 |
execute(HibernateCallback action) |
执行自定义回调逻辑，支持原生 Session 操作。 |
使用回调接口（HibernateCallback）
一般情况下，使用模板类的简单代理方法就可以满足要求了，如果希望使用更多
Hibernate 底层的功能，则可以使用回调接口。Spring
定义了一个回调接口org.springframework.orm.hibernate5.HibernateCallback
1 | T dolnHibernate(org.hibernate.Session session) throws HibernateException,SQLException |
该接口配合 HibernateTemplate 进行工作，它无须关心 HibernateSession 的打开/关闭等操作，仅需定义数据访问逻辑即可。可以通过该接口返回结果，结果可以是一个实体对象或一个实体对象的 List。回调接口中抛出的异常将传播到模板类中并被转换成 Spring DAO 异常体系的对应类。
HibernateTemplate 定义了两个使用 HibernateCallback 回调接口的方法。
<T>T execute(HibernateCallbackaction)：一般使用该方法执行数据更新、新增等操作。 - List executeFind(HibernateCallback<?> action)：一般使用该方法执行数据查询操作，返回的结果是一个List。
1 | public long getEmployeeNum() { |
当需要执行模板类未封装的原生操作（如分页查询、存储过程调用）时，可通过
execute 方法传入 HibernateCallback
回调接口，在其中使用原生 Session API。
1 | public List<Employee> findByPage(int pageNum, int pageSize) { |
关键点：
- 回调接口中的
session是当前事务绑定的Session，无需手动关闭。 - 可直接使用原生
Query对象，实现复杂查询逻辑（如setParameter()、setLockMode()等）。
在 Spring 中配置 DAO
在编写好基于 HibernateTemplate的DAO 类后，接下来要做的就是在 Spring 中进行具体配置，使该 DAO 生效
为 HibernateDaoSupport 注入
SessionFactory HibernateDaoSupport
父类需要 SessionFactory 来创建
HibernateTemplate，可通过 XML 中
`的sessionFactory` 属性注入。
1 | <!-- 启用注解驱动和组件扫描 --> |
<bean id="employeeDao">中的sessionFactory属性： 必须为HibernateDaoSupport子类注入SessionFactory，否则hibernateTemplate无法初始化。组件扫描：
context:component-scan会自动扫描标注@Repository的EmployeeDao，无需手动注册 Bean（若 XML 中显式声明 Bean，则以 XML 配置为准）。这样 Dao 类的 @Repository 及 @Autowired 注解就可以起作用，将 ForumHibernateDao 装配为 Spring 容器中的 Bean。
注解配置的详解
和 Spring 类似，Hibernate 不但可以使用 XML 提供 ORM 的配置信息，也可以直接在领域对象类中通过注解定义 ORM 映射信息。Hibernate 不但自已定义了一套注解，还支持 JPA 注解。这种方式比传统的 XML 映射文件更加直观、简洁，并且将映射信息直接与实体类关联在一起。
1 | import javax.persistence.*; |
Hibemate 通过 AnnotationConfiguration 的
addAnnotatedClass()或 addPackage()方法加载使用
JPA 注解的实体类，获取映射的元数据信息，并在此基础上创建
SessionFactory 实例。
需要特别注意的是，使用 addPackage 并不是加载类包下所有标注了 ORM 注解的实体类，而是加载类包下 package-info.java 文件中定义的 Annotation，而该类包下的所有持久化类仍然需要通过 addAnnotatedClass() 方法加载。
Spring 专门提供了一个配套的 AnnotationSessionFactoryBean，用于创建基于 JPA 注解的 SessionFactory。
1 | <bean id="sessionFactory" |
AnnotationSessionFactoryBean 扩展了 LocalSessionFactoryBean 类，增强的功能是：可以根据实体类的注解获取 ORM 的配置信息。也可以混合使用 XML 配置和注解配置对象关系映射，Hibernate 内部自动将这些元数据信息进行整合，并不会产生冲突。
annotatedCIasses 属性指定使用 JPA
注解的实体类名，如②处所示。如果实体类比较多，不要想当然地以为通过annotatedPackages
属性指定实体类所在包名就可以了，annotatedPackages
在内部通过调用 Hibernate 的 AnnotationConfiguration 的
addPackage() 方法加载包中package-info.java
文件定义的 Annotation，而非包中标注注解的实体类。
Spring 为了通过扫描方式加载带注解的实体类，提供了一个易用的 packagesToScan 属性，可以指定一系列包名，Spring 将扫描并加载这些包路径（包括子包）的所有带注解实体类。
packagesToScan 属性可接收多个类包路径，用逗号分隔即可，例如：
1 | <property name="packagesToScan" value="com.yourpackage.model"/> |
事务处理
Spring 的通用事务管理模型对 Hibernate 是完全适用的，包括编程式事务、基于 TransactionProxyFactoryBean、基于 aop/tx 及基于 @Transaction 注解的事务管理。在这里，仅给出基于 @Transaction 注解的事务管理。
1 |
|
其次，在 Spring 配置文件中配置 Hibernate 事务管理器，并启用注解驱动事务。
1 | <!-- 配置事务管理器 --> |
Hibernate 的事务管理器需要注入一个 sessionFactory
实例，将其命名为 transactionManager 后，在
<tx:annotation-driven/> 中就无须通过
transaction-manager 默认显式指定了。不管
DepartmentServiceImpl所用的 DAO 是基于 HibernateTemplate
还是基于 Hibernate 原生的API，DepartmentServiceImpl
中的所有方法都具有事务性。
本博客所有文章除特别声明外，均采用 CC BY-NC-SA 4.0 许可协议。转载请注明来源 ErgouTree's Blog！
相关推荐
2025-04-19
Spring Framework part2--IoC容器之IoC原理
Spring...
2025-05-16
Spring Boot中使用Hibernate框架
在Spring
Boot项目中使用Hibernate
Spring Data JPA是Spring框架提供的简化JPA(Java Persistence
API)操作的模块，而Hibernate是最流行的JPA实现之一
Hibernate是一个流行的ORM（对象关系映射）框架，它可以将Java对象映射到数据库表，从而方便地进行持久化操作。
在Spring
Boot项目中，集成Hibernate可以帮助我们更轻松地进行数据库操作。
在Spring
Boot项目中如何使用这两者，先写一个例子，我会在项目中，边写边用详细的注释来分析
项目示例
依赖导入
1234567891011121314151617181920<dependencies> <!-- Spring Boot Starter Data JPA (包含Hibernate) --> <dependency> <groupId>org.springframework.boot</groupId> ...
2025-05-16
Hibernate,JPA 和 Spring Data JPA 之间的关系
Hibernate， JPA 和 Spring Data
JPA
我们都知道Java 持久层框架访问数据库的方式大致分为两种。
一种以 SQL 核心，封装一定程度的 JDBC 操作，比如： MyBatis。
另一种是以 Java
实体类为核心，将实体类的和数据库表之间建立映射关系，也就是我们说的
ORM框架，如：Hibernate、Spring Data JPA。
JPA
JPA的全称是Java Persistence...
评论
FPS: 60