hibernate与Spring整合入门：配置步骤+实战案例教程

学过 Hibernate 和 Spring 的新手是不是都有这样的困惑？单独用 Hibernate 做 CRUD 还行，单独用 Spring 管理 Bean 也能搞定，可一到整合就犯懵；配置文件写了一堆，要么报 “SessionFactory 找不到”，要么事务不生效；依赖加了好几个，却因为版本不兼容启动就报错。别着急，兔子哥第一次整合时，光是搞懂 Spring 怎么管理 Hibernate 的 SessionFactory 就查了半天资料，还因为少加了 spring-orm 依赖，项目启动一直报类找不到的错误。今天就带零基础的朋友从配置步骤讲到实战案例，把整合的核心要点和避坑技巧讲透，跟着学，你也能轻松搞定 Hibernate 与 Spring 的整合！

一、为什么要整合？Spring 和 Hibernate 各有啥优势？

很多人不明白，单独用 Hibernate 和 Spring 挺好的，为啥要整合？其实整合能发挥两者的优势，让开发更高效。

1. Spring 的优势：管理对象和事务
   Spring 就像个 “大管家”，能帮我们管理对象（通过 IOC 容器），不用手动 new 对象；还能统一管理事务，不用在每个 Hibernate 操作里手动开启和提交事务，加个注解就能实现事务控制，减少重复代码。
   
2. Hibernate 的优势：简化数据库操作
   Hibernate 是 ORM 框架，能帮我们把 Java 对象和数据库表映射起来，不用写 SQL，直接用对象操作数据库，省去了手写 JDBC 代码的麻烦。
   
3. 整合的好处：1+1＞2
   整合后，Spring 负责管理 Hibernate 的核心对象（比如 SessionFactory）、事务和依赖注入，Hibernate 专注于数据库映射和 CRUD 操作，两者分工明确。你不用再手动创建 SessionFactory，不用在代码里处理事务，开发效率能提高一大截。
   

网友 “后端小白” 分享：“没整合前，每个方法里都要写开启事务、获取 Session 的代码，整合后用 Spring 管理，代码少了一半，事务还更稳定了！”

二、整合配置步骤：5 步搞定环境搭建，从依赖到配置文件

整合的核心是让 Spring 接管 Hibernate 的配置和对象管理，这 5 个步骤环环相扣，新手跟着做，环境很快就能搭好。

1. 第一步：加依赖，这几个 jar 包不能少
   用 Maven 管理的项目，pom.xml 里要加 Spring 核心依赖、Spring 与 Hibernate 整合依赖、Hibernate 核心依赖和数据库驱动，版本尽量统一（比如 Spring 5.x 搭配 Hibernate 5.x）：

xml

<dependency><groupId>org.springframeworkgroupId><artifactId>spring-contextartifactId><version>5.3.20version>dependency><dependency><groupId>org.springframeworkgroupId><artifactId>spring-ormartifactId><version>5.3.20version>dependency><dependency><groupId>org.hibernategroupId><artifactId>hibernate-coreartifactId><version>5.4.32.Finalversion>dependency><dependency><groupId>mysqlgroupId><artifactId>mysql-connector-javaartifactId><version>8.0.28version>dependency><dependency><groupId>com.alibabagroupId><artifactId>druidartifactId><version>1.2.8version>dependency>

少了 spring-orm 依赖，Spring 就无法识别 Hibernate 的 SessionFactory，这是新手最容易漏的。

1. 第二步：写 Spring 配置文件，管理数据源
   在 src/main/resources 下新建 applicationContext.xml，先配置数据库连接池（用 Druid 连接池，比 Hibernate 自带的好用）：

xml

<bean id="dataSource" class="com.alibaba.druid.pool.DruidDataSource"><property name="driverClassName" value="com.mysql.cj.jdbc.Driver"/><property name="url" value="jdbc:mysql://localhost:3306/spring_hibernate?serverTimezone=UTC"/><property name="username" value="root"/><property name="password" value="123456"/>bean>

数据源是连接数据库的基础，url 里的数据库名要先在 MySQL 里建好，账号密码填自己的。

1. 第三步：配置 Hibernate 相关属性，交给 Spring 管理
   在 applicationContext.xml 里加 Hibernate 的属性配置，替代原来的 hibernate.cfg.xml：

xml

<bean id="hibernateProperties" class="java.util.Properties"><property name="prop.keySet"><props><prop key="hibernate.dialect">org.hibernate.dialect.MySQL8Dialectprop><prop key="hibernate.show_sql">trueprop><prop key="hibernate.format_sql">trueprop>props>property>bean>

整合后，Hibernate 的核心配置通过 Spring 的 Properties bean 来设置，不用再单独写 hibernate.cfg.xml 了。

1. 第四步：配置 SessionFactory，Spring 创建和管理
   SessionFactory 是 Hibernate 的核心对象，整合后由 Spring 创建，需要指定数据源、Hibernate 属性和映射实体：

xml

<bean id="sessionFactory" class="org.springframework.orm.hibernate5.LocalSessionFactoryBean"><property name="dataSource" ref="dataSource"/><property name="hibernateProperties" ref="hibernateProperties"/><property name="packagesToScan" value="com.springhibernate.entity"/>bean>

packagesToScan指定实体类所在的包，Spring 会自动扫描带注解的实体类，不用再手动配置映射了。

1. 第五步：配置事务管理器，Spring 管控事务
   最后配置 Spring 的事务管理器，负责 Hibernate 的事务控制：

xml

<bean id="transactionManager" class="org.springframework.orm.hibernate5.HibernateTransactionManager"><property name="sessionFactory" ref="sessionFactory"/>bean><tx:annotation-driven transaction-manager="transactionManager"/>

加了，就能用@Transactional注解控制事务了，超方便。

三、实战案例：用户管理 CRUD，整合后代码更简洁

环境搭好后，用一个用户管理的 CRUD 案例看看整合后的效果，核心是通过 Spring 的 HibernateTemplate 简化操作，用注解控制事务。

1. 实体类：User.java（和之前一样用注解映射）

java

import javax.persistence.*;@Entity@Table(name = "user")public class User {@Id@GeneratedValue(strategy = GenerationType.IDENTITY)private Integer id;@Column(name = "name")private String name;@Column(name = "age")private Integer age;// getter和setter省略}

1. DAO 层：用 HibernateTemplate 简化数据库操作
   新建 UserDao 接口和实现类，通过 Spring 提供的 HibernateTemplate 操作数据库，不用手动获取 Session：

java

import org.springframework.orm.hibernate5.HibernateTemplate;import org.springframework.stereotype.Repository;import javax.annotation.Resource;import java.util.List;@Repository // 让Spring扫描到DAO层public class UserDaoImpl implements UserDao {// 注入HibernateTemplate，由Spring管理@Resourceprivate HibernateTemplate hibernateTemplate;// 添加用户@Overridepublic void add(User user) {hibernateTemplate.save(user); // 直接调用save方法}// 查询用户@Overridepublic User findById(Integer id) {return hibernateTemplate.get(User.class, id); // 查单个}// 查询所有@Overridepublic List<User> findAll() {return hibernateTemplate.loadAll(User.class); // 查所有}// 更新用户@Overridepublic void update(User user) {hibernateTemplate.update(user);}// 删除用户@Overridepublic void delete(Integer id) {User user = findById(id);if (user != null) {hibernateTemplate.delete(user);}}}

HibernateTemplate 封装了常用的 CRUD 方法，不用再写开启 Session、提交事务的代码，简洁多了。

1. Service 层：加事务注解，控制事务
   新建 UserService 接口和实现类，调用 DAO 层方法，用@Transactional注解开启事务：

java

import org.springframework.stereotype.Service;import org.springframework.transaction.annotation.Transactional;import javax.annotation.Resource;import java.util.List;@Service // 标记Service层@Transactional // 该类所有方法都受事务管控public class UserServiceImpl implements UserService {@Resourceprivate UserDao userDao;@Overridepublic void add(User user) {userDao.add(user);}@Overridepublic User findById(Integer id) {return userDao.findById(id);}@Overridepublic List<User> findAll() {return userDao.findAll();}@Overridepublic void update(User user) {userDao.update(user);}@Overridepublic void delete(Integer id) {userDao.delete(id);}}

加了@Transactional，方法执行出错会自动回滚，不用手动处理事务了。

1. 测试类：加载 Spring 配置，调用 Service

java

import org.springframework.context.ApplicationContext;import org.springframework.context.support.ClassPathXmlApplicationContext;public class Test {public static void main(String[] args) {// 加载Spring配置文件ApplicationContext context = new ClassPathXmlApplicationContext("applicationContext.xml");// 获取Service对象UserService userService = context.getBean(UserService.class);// 测试添加User user = new User();user.setName("李四");user.setAge(22);userService.add(user);System.out.println("添加成功！");// 测试查询User findUser = userService.findById(1);System.out.println("查询到：" + findUser.getName() + "，年龄：" + findUser.getAge());}}

运行后，数据库会新增记录，控制台能查询到数据，整合成功！

四、避坑指南：整合时最容易踩的 5 个坑

1. 坑 1：启动报 “ClassNotFoundException: org.springframework.orm.hibernate5.LocalSessionFactoryBean”
   原因：没加 spring-orm 依赖，这个依赖包含 Spring 与 Hibernate 整合的关键类。解决：在 pom.xml 里添加 spring-orm 依赖，版本和 Spring 核心一致。
   
2. 坑 2：SessionFactory 创建失败，报 “数据源找不到”
   检查 applicationContext.xml 里的数据源 id 是否和 SessionFactory 的dataSource属性引用一致，比如数据源 id 是 “dataSource”，SessionFactory 里必须写，ref 值错了就找不到。
   
3. 坑 3：事务不生效，增删改后数据库没变化
   没开启事务注解驱动！解决：在 applicationContext.xml 里加，确保事务管理器 id 和这里的一致。
   
4. 坑 4：依赖版本冲突，报 “方法找不到” 错误
   Spring 和 Hibernate 版本不兼容，比如 Spring 5.x 搭配 Hibernate 4.x 可能有问题。解决：尽量用配套版本，Spring 5.x 推荐搭配 Hibernate 5.x，Maven 会自动处理依赖冲突。
   
5. 坑 5：实体类扫描不到，报 “没有映射实体”
   SessionFactory 的packagesToScan属性值写错了，包路径不对。解决：检查实体类所在的包，确保和value值一致，比如实体在 “com.springhibernate.entity”，就写这个路径。
   

五、自问自答：整合入门常问的 3 个问题

1. “整合后还要写 hibernate.cfg.xml 吗？”
   不用！整合后 Hibernate 的核心配置（方言、显示 SQL 等）通过 Spring 的 Properties bean 来设置，实体类映射用注解，由 SessionFactory 的packagesToScan扫描，完全不用单独的 hibernate.cfg.xml，简化了配置。
   
2. “HibernateTemplate 和直接用 Session 有啥区别？”
   HibernateTemplate 是 Spring 封装的工具类，帮我们简化了获取 Session、处理异常、关闭资源的代码，直接调用 save、get 等方法就行；而直接用 Session 需要手动获取、开启事务、关闭，代码更繁琐。新手推荐用 HibernateTemplate，减少出错。
   
3. “事务注解加在 Service 层还是 DAO 层？”
   建议加在 Service 层！Service 层负责业务逻辑，一个 Service 方法可能调用多个 DAO 方法，事务加在 Service 层能保证这些操作在同一个事务里，要么全成功，要么全失败，数据更一致。
   

结尾心得

Hibernate 与 Spring 整合的核心是 “让 Spring 来管理 Hibernate”，把数据源、SessionFactory、事务这些复杂的配置交给 Spring，我们专注于业务逻辑就行。兔子哥的经验是，整合时配置文件一定要仔细核对，尤其是 id 和 ref 的引用关系，一个字母错了就可能启动失败；依赖版本要统一，避免版本冲突。刚开始可以从简单的 CRUD 案例做起，熟悉 HibernateTemplate 的用法和事务注解，慢慢就会发现整合后的开发效率真的高很多。坚持多练，遇到问题对照避坑指南排查，你会发现整合其实没那么难，加油！

标签： SessionFactory 环环相扣