Hibernate

我们首先介绍 Hibernate 5 在 Spring 环境中的应用，以此演示 Spring 在集成 OR 映射器方面所采取的方法。本节详细讨论了许多问题，并展示了 DAO 实现和事务划分的不同变体。这些模式中的大多数都可以直接应用于所有其他受支持的 ORM 工具。本章后面的部分将介绍其他 ORM 技术并提供简短示例。

自 Spring Framework 6.0 起，Spring 要求 Hibernate ORM 5.5+ 用于 Spring 的 HibernateJpaVendorAdapter 以及原生的 Hibernate SessionFactory 配置。我们推荐将 Hibernate ORM 5.6 作为该 Hibernate 生成中的最后一个特性分支。

Hibernate ORM 6.x 仅作为 JPA 提供程序（HibernateJpaVendorAdapter）受支持。使用 orm.hibernate5 包的原生 SessionFactory 配置不再受支持。我们建议新开发项目使用 Hibernate ORM 6.1/6.2 及 JPA 风格的配置。

在 Spring 容器中配置 SessionFactory

为了避免将应用程序对象与硬编码的资源查找绑定，您可以将资源（如 JDBC DataSource 或 Hibernate SessionFactory）定义为 Spring 容器中的 bean。需要访问资源的应用程序对象通过 bean 引用接收对这些预定义实例的引用，如下一节的 DAO 定义所示。

以下 XML 应用上下文定义的片段显示了如何在 JDBC DataSource 之上设置 Hibernate SessionFactory

<beans>

	<bean id="myDataSource" class="org.apache.commons.dbcp.BasicDataSource" destroy-method="close">
		<property name="driverClassName" value="org.hsqldb.jdbcDriver"/>
		<property name="url" value="jdbc:hsqldb:hsql://localhost:9001"/>
		<property name="username" value="sa"/>
		<property name="password" value=""/>
	</bean>

	<bean id="mySessionFactory" class="org.springframework.orm.hibernate5.LocalSessionFactoryBean">
		<property name="dataSource" ref="myDataSource"/>
		<property name="mappingResources">
			<list>
				<value>product.hbm.xml</value>
			</list>
		</property>
		<property name="hibernateProperties">
			<value>
				hibernate.dialect=org.hibernate.dialect.HSQLDialect
			</value>
		</property>
	</bean>

</beans>

从本地 Jakarta Commons DBCP BasicDataSource 切换到 JNDI 定位的 DataSource（通常由应用服务器管理）仅仅是配置上的改变，如下例所示

<beans>
	<jee:jndi-lookup id="myDataSource" jndi-name="java:comp/env/jdbc/myds"/>
</beans>

您还可以通过 Spring 的 JndiObjectFactoryBean / <jee:jndi-lookup> 访问 JNDI 定位的 SessionFactory 并暴露它。然而，这通常在 EJB 环境之外并不常见。

Spring 还提供了一个 LocalSessionFactoryBuilder 变体，它与 @Bean 风格的配置和编程式设置（不涉及 FactoryBean）无缝集成。

LocalSessionFactoryBean 和 LocalSessionFactoryBuilder 都支持后台引导（bootstrapping），Hibernate 初始化在一个给定的引导执行器（例如 SimpleAsyncTaskExecutor）上与应用程序引导线程并行运行。在 LocalSessionFactoryBean 上，这通过 bootstrapExecutor 属性可用。在编程式的 LocalSessionFactoryBuilder 上，有一个重载的 buildSessionFactory 方法接受一个引导执行器参数。

这种原生的 Hibernate 设置也可以暴露一个 JPA EntityManagerFactory，用于标准的 JPA 交互以及原生的 Hibernate 访问。详情请参阅JPA 的原生 Hibernate 设置。

基于原生 Hibernate API 实现 DAO

Hibernate 有一个称为上下文会话（contextual sessions）的特性，其中 Hibernate 本身管理每个事务一个当前 Session。这大致等同于 Spring 的每个事务同步一个 Hibernate Session。相应的 DAO 实现类似于以下示例，它基于原生的 Hibernate API

  • Java

  • Kotlin

public class ProductDaoImpl implements ProductDao {

	private SessionFactory sessionFactory;

	public void setSessionFactory(SessionFactory sessionFactory) {
		this.sessionFactory = sessionFactory;
	}

	public Collection loadProductsByCategory(String category) {
		return this.sessionFactory.getCurrentSession()
				.createQuery("from test.Product product where product.category=?")
				.setParameter(0, category)
				.list();
	}
}
class ProductDaoImpl(private val sessionFactory: SessionFactory) : ProductDao {

	fun loadProductsByCategory(category: String): Collection<*> {
		return sessionFactory.currentSession
				.createQuery("from test.Product product where product.category=?")
				.setParameter(0, category)
				.list()
	}
}

这种风格类似于 Hibernate 参考文档和示例中的风格，只是将 SessionFactory 保存在实例变量中。我们强烈推荐这种基于实例的设置，而不是 Hibernate 的 CaveatEmptor 示例应用程序中老式的 static HibernateUtil 类。（一般来说，除非绝对必要，否则不要在 static 变量中保留任何资源。）

前面的 DAO 示例遵循了依赖注入模式。它可以很好地融入 Spring IoC 容器，就像使用 Spring 的 HibernateTemplate 编码一样。您也可以在纯 Java 中设置这样的 DAO（例如，在单元测试中）。为此，实例化它并使用所需的 factory 引用调用 setSessionFactory(..)。作为 Spring bean 定义，该 DAO 将类似于以下内容

<beans>

	<bean id="myProductDao" class="product.ProductDaoImpl">
		<property name="sessionFactory" ref="mySessionFactory"/>
	</bean>

</beans>

这种 DAO 风格的主要优点是它仅依赖于 Hibernate API。无需导入任何 Spring 类。从非侵入性的角度来看，这很有吸引力，并且可能让 Hibernate 开发者感觉更自然。

然而，DAO 抛出的是原生的 HibernateException（它是非受控异常，因此不必声明或捕获），这意味着调用者只能将异常视为通常是致命的 — 除非他们想依赖 Hibernate 自己的异常层次结构。如果不将调用者与实现策略绑定，就无法捕获特定的原因（例如乐观锁失败）。对于那些高度依赖 Hibernate、不需要特殊异常处理或两者兼有的应用程序来说，这种权衡可能是可以接受的。

幸运的是，Spring 的 LocalSessionFactoryBean 支持 Hibernate 的 SessionFactory.getCurrentSession() 方法，适用于任何 Spring 事务策略，即使使用 HibernateTransactionManager，也会返回当前由 Spring 管理的事务性 Session。该方法的标准行为仍然是返回与正在进行的 JTA 事务相关联的当前 Session（如果存在）。无论您使用的是 Spring 的 JtaTransactionManager、EJB 容器管理事务（CMTs）还是 JTA，此行为都适用。

总而言之，您可以在基于原生 Hibernate API 实现 DAO 的同时，仍然能够参与 Spring 管理的事务。

声明式事务划分

我们建议您使用 Spring 的声明式事务支持，它允许您用 AOP 事务拦截器替换 Java 代码中的显式事务划分 API 调用。您可以使用 Java 注解或 XML 在 Spring 容器中配置此事务拦截器。这种声明式事务能力让业务服务无需重复的事务划分代码，从而专注于添加业务逻辑，这是您应用程序的真正价值所在。

在继续之前，我们强烈建议您阅读声明式事务管理（如果您尚未阅读）。

您可以使用 @Transactional 注解对服务层进行标注，并指示 Spring 容器查找这些注解并为这些被注解的方法提供事务语义。以下示例展示了如何做到这一点

  • Java

  • Kotlin

public class ProductServiceImpl implements ProductService {

	private ProductDao productDao;

	public void setProductDao(ProductDao productDao) {
		this.productDao = productDao;
	}

	@Transactional
	public void increasePriceOfAllProductsInCategory(final String category) {
		List productsToChange = this.productDao.loadProductsByCategory(category);
		// ...
	}

	@Transactional(readOnly = true)
	public List<Product> findAllProducts() {
		return this.productDao.findAllProducts();
	}
}
class ProductServiceImpl(private val productDao: ProductDao) : ProductService {

	@Transactional
	fun increasePriceOfAllProductsInCategory(category: String) {
		val productsToChange = productDao.loadProductsByCategory(category)
		// ...
	}

	@Transactional(readOnly = true)
	fun findAllProducts() = productDao.findAllProducts()
}

在容器中，您需要设置 PlatformTransactionManager 实现（作为 bean）和一个 <tx:annotation-driven/> 条目，以便在运行时选择处理 @Transactional。以下示例展示了如何做到这一点

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
	xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
	xmlns:aop="http://www.springframework.org/schema/aop"
	xmlns:tx="http://www.springframework.org/schema/tx"
	xsi:schemaLocation="
		http://www.springframework.org/schema/beans
		https://www.springframework.org/schema/beans/spring-beans.xsd
		http://www.springframework.org/schema/tx
		https://www.springframework.org/schema/tx/spring-tx.xsd
		http://www.springframework.org/schema/aop
		https://www.springframework.org/schema/aop/spring-aop.xsd">

	<!-- SessionFactory, DataSource, etc. omitted -->

	<bean id="transactionManager"
			class="org.springframework.orm.hibernate5.HibernateTransactionManager">
		<property name="sessionFactory" ref="sessionFactory"/>
	</bean>

	<tx:annotation-driven/>

	<bean id="myProductService" class="product.SimpleProductService">
		<property name="productDao" ref="myProductDao"/>
	</bean>

</beans>

编程式事务划分

您可以在应用程序的更高层级划分事务，基于跨越任意数量操作的低层数据访问服务。对于周围业务服务的实现也没有限制。它只需要一个 Spring PlatformTransactionManager。同样，后者可以来自任何地方，但最好通过 setTransactionManager(..) 方法以 bean 引用的形式提供。此外，productDAO 应该通过 setProductDao(..) 方法设置。以下两段代码片段展示了 Spring 应用上下文中的事务管理器和业务服务定义，以及业务方法实现的示例

<beans>

	<bean id="myTxManager" class="org.springframework.orm.hibernate5.HibernateTransactionManager">
		<property name="sessionFactory" ref="mySessionFactory"/>
	</bean>

	<bean id="myProductService" class="product.ProductServiceImpl">
		<property name="transactionManager" ref="myTxManager"/>
		<property name="productDao" ref="myProductDao"/>
	</bean>

</beans>

  • Java

  • Kotlin

public class ProductServiceImpl implements ProductService {

	private TransactionTemplate transactionTemplate;
	private ProductDao productDao;

	public void setTransactionManager(PlatformTransactionManager transactionManager) {
		this.transactionTemplate = new TransactionTemplate(transactionManager);
	}

	public void setProductDao(ProductDao productDao) {
		this.productDao = productDao;
	}

	public void increasePriceOfAllProductsInCategory(final String category) {
		this.transactionTemplate.execute(new TransactionCallbackWithoutResult() {
			public void doInTransactionWithoutResult(TransactionStatus status) {
				List productsToChange = this.productDao.loadProductsByCategory(category);
				// do the price increase...
			}
		});
	}
}
class ProductServiceImpl(transactionManager: PlatformTransactionManager,
						private val productDao: ProductDao) : ProductService {

	private val transactionTemplate = TransactionTemplate(transactionManager)

	fun increasePriceOfAllProductsInCategory(category: String) {
		transactionTemplate.execute {
			val productsToChange = productDao.loadProductsByCategory(category)
			// do the price increase...
		}
	}
}

Spring 的 TransactionInterceptor 允许回调代码抛出任何受控应用程序异常，而 TransactionTemplate 仅限于回调中的非受控异常。TransactionTemplate 在发生非受控应用程序异常或事务被应用程序标记为仅回滚时（通过设置 TransactionStatus）触发回滚。默认情况下，TransactionInterceptor 表现相同，但允许根据每个方法配置回滚策略。

事务管理策略

TransactionTemplate 和 TransactionInterceptor 都将实际的事务处理委托给 PlatformTransactionManager 实例（对于单个 Hibernate SessionFactory，可以是使用底层 ThreadLocal Session 的 HibernateTransactionManager），或者对于 Hibernate 应用程序，可以是 JtaTransactionManager（委托给容器的 JTA 子系统）。您甚至可以使用自定义的 PlatformTransactionManager 实现。从原生 Hibernate 事务管理切换到 JTA（例如，当您的应用程序的某些部署面临分布式事务需求时）仅仅是配置问题。您可以将 Hibernate 事务管理器替换为 Spring 的 JTA 事务实现。事务划分和数据访问代码无需更改，因为它们使用通用的事务管理 API。

对于跨多个 Hibernate session factory 的分布式事务，您可以将 JtaTransactionManager 作为事务策略与多个 LocalSessionFactoryBean 定义结合使用。然后，每个 DAO 会将其对应的 bean 属性传递一个特定的 SessionFactory 引用。如果所有底层 JDBC 数据源都是事务性的容器数据源，则业务服务可以在任意数量的 DAO 和任意数量的 session factory 之间划分事务，而无需特别考虑，只要它使用 JtaTransactionManager 作为策略即可。

HibernateTransactionManager 和 JtaTransactionManager 都允许使用 Hibernate 进行适当的 JVM 级别缓存处理，无需特定于容器的事务管理器查找或 JCA 连接器（如果您不使用 EJB 启动事务）。

HibernateTransactionManager 可以将 Hibernate JDBC Connection 导出到用于特定 DataSource 的原生 JDBC 访问代码。这种能力允许在混合使用 Hibernate 和 JDBC 数据访问时进行高级别的事务划分，完全无需 JTA，前提是您只访问一个数据库。如果您已通过 LocalSessionFactoryBean 类的 dataSource 属性使用 DataSource 设置传入的 SessionFactory，HibernateTransactionManager 会自动将 Hibernate 事务作为 JDBC 事务暴露。或者，您可以通过 HibernateTransactionManager 类的 dataSource 属性显式指定应为其暴露事务的 DataSource。

对于 JTA 风格的实际资源连接延迟检索，Spring 为目标连接池提供了一个相应的 DataSource 代理类：参见LazyConnectionDataSourceProxy。这对于 Hibernate 只读事务特别有用，因为它们通常可以从本地缓存处理，而无需访问数据库。

比较容器管理资源和本地定义资源

您可以在容器管理的 JNDI SessionFactory 和本地定义的 SessionFactory 之间切换，而无需更改一行应用程序代码。是将资源定义保存在容器中还是在应用程序内部本地定义，主要取决于您使用的事务策略。与 Spring 定义的本地 SessionFactory 相比，手动注册的 JNDI SessionFactory 不提供任何额外的好处。通过 Hibernate 的 JCA 连接器部署 SessionFactory 提供了参与 Jakarta EE 服务器管理基础设施的附加价值，但除此之外并没有增加实际价值。

Spring 的事务支持不受容器约束。当使用 JTA 以外的任何策略进行配置时，事务支持也可以在独立环境或测试环境中工作。特别是在典型的单数据库事务情况下，Spring 的单资源本地事务支持是 JTA 的轻量且强大的替代方案。当您使用本地 EJB 无状态会话 Bean 来驱动事务时，即使您只访问单个数据库并仅使用无状态会话 Bean 通过容器管理的事务提供声明性事务，您也依赖于 EJB 容器和 JTA。直接通过编程方式使用 JTA 也需要 Jakarta EE 环境。

Spring 驱动的事务可以与本地定义的 Hibernate SessionFactory 一样好地工作，就像它们与本地 JDBC DataSource 一样，前提是它们访问的是单个数据库。因此，只有在您有分布式事务需求时，才需要使用 Spring 的 JTA 事务策略。JCA 连接器需要容器特定的部署步骤，并且首先需要 JCA 支持。与使用本地资源定义和 Spring 驱动事务部署一个简单的 Web 应用程序相比，这种配置需要更多工作。

总而言之，如果您不使用 EJB，请坚持使用本地 SessionFactory 设置和 Spring 的 HibernateTransactionManager 或 JtaTransactionManager。您可以获得所有好处，包括适当的事务性 JVM 级别缓存和分布式事务，而没有容器部署的不便。通过 JCA 连接器注册 Hibernate SessionFactory 仅在与 EJB 结合使用时才增加价值。

使用 Hibernate 时出现的虚假应用服务器警告

在某些具有非常严格的 XADataSource 实现的 JTA 环境中（目前是某些 WebLogic Server 和 WebSphere 版本），如果在配置 Hibernate 时没有考虑该环境的 JTA 事务管理器，应用服务器日志中可能会出现虚假警告或异常。这些警告或异常表示正在访问的连接不再有效，或者 JDBC 访问不再有效，可能是因为事务不再处于活动状态。例如，这是来自 WebLogic 的一个实际异常：

java.sql.SQLException: The transaction is no longer active - status: 'Committed'. No
further JDBC access is allowed within this transaction.

另一个常见问题是 JTA 事务后出现连接泄漏，Hibernate 会话（以及潜在的底层 JDBC 连接）未能正确关闭。

您可以通过使 Hibernate 感知 JTA 事务管理器来解决此类问题，Hibernate 将与 Spring 一起与其同步。您有两种选择：

  • 将您的 Spring JtaTransactionManager bean 传递给您的 Hibernate 设置。最简单的方法是将 bean 引用注入到您的 LocalSessionFactoryBean bean 的 jtaTransactionManager 属性中（请参阅 Hibernate 事务设置）。然后 Spring 会将相应的 JTA 策略提供给 Hibernate。

  • 您也可以在 LocalSessionFactoryBean 的 "hibernateProperties" 中显式配置 Hibernate 的 JTA 相关属性，特别是 "hibernate.transaction.coordinator_class"、"hibernate.connection.handling_mode" 和可能的 "hibernate.transaction.jta.platform"（有关这些属性的详细信息，请参阅 Hibernate 手册）。

本节的其余部分描述了 Hibernate 感知和不感知 JTA PlatformTransactionManager 时发生的事件序列。

当配置 Hibernate 时没有感知 JTA 事务管理器，当 JTA 事务提交时，会发生以下事件：

  • JTA 事务提交。

  • Spring 的 JtaTransactionManager 与 JTA 事务同步，因此 JTA 事务管理器通过 afterCompletion 回调调用它。

  • 在其他活动中，此同步可以触发 Spring 通过 Hibernate 的 afterTransactionCompletion 回调（用于清除 Hibernate 缓存）回调 Hibernate，然后对 Hibernate 会话执行显式的 close() 调用，这会导致 Hibernate 尝试 close() JDBC Connection。

  • 在某些环境中，此 Connection.close() 调用然后触发警告或错误，因为应用服务器不再认为该 Connection 可用，因为事务已提交。

当配置 Hibernate 时感知 JTA 事务管理器，当 JTA 事务提交时，会发生以下事件：

  • JTA 事务准备提交。

  • Spring 的 JtaTransactionManager 与 JTA 事务同步，因此事务管理器通过 beforeCompletion 回调调用事务。

  • Spring 意识到 Hibernate 本身与 JTA 事务同步，并且其行为与前一种情况不同。特别是，它与 Hibernate 的事务性资源管理对齐。

  • JTA 事务提交。

  • Hibernate 与 JTA 事务同步，因此事务管理器通过 afterCompletion 回调调用事务，并且可以正确清除其缓存。