13.7.JPA
13.7. JPA
位于 org.springframework.orm.jpa
包下的Spring JPA相关类提供了与Hibernate和JDO类似的针对 Java Persistence API 的简单支持。 Spring提供了一些实现类来支持额外的特性。
13.7.1. 在Spring环境中建立JPA
Spring JPA 提供了两种方法创建JPA EntityManagerFactory
:
13.7.1.1. LocalEntityManagerFactoryBean
LocalEntityManagerFactoryBean
负责创建一个适合于当前环境的 EntityManager
来使用JPA进行数据访问。 factory bean将使用JPA PersistenceProvider
类的自动检测机制,而在绝大多数情况下,仅仅需要一个persistence unit名称配置:
<beans> ... <bean id="entityManagerFactory"> <property name="entityManagerName" value="myPersistenceUnit"/> </bean> ... </beans>
切换到一个JNDI的 EntityManagerFactory
(举例来说,在JTA环境中),只需要简单更改XML配置:
<beans> ... <jndi:lookup id="entityManagerFactory" jndi-name="jpa/myPersistenceUnit"/> ... </beans>
13.7.1.2. LocalContainerEntityManagerFactoryBean
LocalContainerEntityManagerFactoryBean
提供了对JPA EntityManagerFactory
的完整控制,并且非常适合那种有简单用户定制需要的环境。 LocalContainerEntityManagerFactoryBean
将基于 'persistence.xml'
文件、提供的 dataSourceLookup
策略和 loadTimeWeaver
创建一个 PersistenceUnitInfo
类。 这就是为何它能够在JNDI之外的用户定义的数据源之上工作,并且能够控制织入流程。
<beans> ... <bean id="entityManagerFactory"> <property name="dataSources"> <map> <entry key="dataSource1" value-ref="someDataSource"/> <entry key="dataSource2" value-ref="anotherDataSource"/> </map> </property> <property name="loadTimeWeaver"> <bean/> </property> </bean> </beans>
LoadTimeWeaver
接口是由Spring提供的允许JPA ClassTransformer
实例能够插入到特定的应用环境中的支持类(web容器/应用服务器)。 通过一个JDK 5.0的 代理 挂钩,在典型情况下不是非常有效率。 代理通常在 整个虚拟机 环境下工作,并且监控 每一个 被加载的类 - 有时这在生产环境下是不提倡的。
Spring提供了许多在不同环境中的 LoadTimeWeaver
实现类,允许 ClassTransformer
实例能够仅仅在 每个classloader 而不是每个虚拟机上被应用。
13.7.1.2.1. 在Tomcat上创建
Jakarta Tomcat 默认的类装载器并不支持类的切换,但是它允许使用用户自定义的类装载器。 Spring提供了 TomcatInstrumentableClassLoader
类(位于 org.springframework.instrument.classloading.tomcat
包中), 这个类继承自Tomcat的类装载器(WebappClassLoader
)并且允许JPA ClassTransformer
的实例来“增强”所有由它加载的类。 简单来说,JPA转化器(JPA transformer)仅仅在特定的web应用中才能被使用。(使用 TomcatInstrumentableClassLoader
的那些应用)。
为了使用用户自定义的类装载器:
将
spring-tomcat-weaver.jar
复制到 $CATALINA_HOME/server/lib 下(其中$CATALINA_HOME 表示Tomcat的安装路径)。通过修改web application context使Tomcat使用用户自定义的类装载器(而不是默认的类装载器):
<Context path="/myWebApp" docBase="/my/webApp/location" ...> <Loader loaderClass="org.springframework.instrument.classloading.tomcat.TomcatInstrumentableClassLoader"/> ... </Context>
Tomcat 5.0.x 和 5.5.x 系列支持多个上下文路径(context locations):全局的上下文路径($CATALINA_HOME/conf/context.xml)会影响所有被部署的web应用、每个单独部署在Server上的web应用的配置 ($CATALINA_HOME/conf/[enginename]/[hostname]/my-webapp-context.xml)或者跟随着web应用的配置(your-webapp.war/META-INF/context.xml)。 从效率的角度说,我们推荐后者的配置方式,因为仅仅使用JPA的应用会使用用户自定义的类装载器。更多具体有关可用的上下文路径的内容请参见Tomcat 5.x的文档。
在Tomcat 4.x中,你可以使用相同的context.xml并将它放到 $CATALINA_HOME/webapps 下,或者修改 $CATALINA_HOME/conf/server.xml 来使用用户自定义的类装载器。 更多信息请参看Tomcat 4.x的文档
在配置
LocalContainerEntityManagerFactoryBean
时,使用合适的LoadTimeWeaver
:<bean id="entityManagerFactory"> ... <property name="loadTimeWeaver"> <bean/> </property> ... </bean>
通过使用这种技术,JPA应用依赖于特定的“仪器”,从而无需任何代理可以在Tomcat中运行。 当主应用程序依赖于不同JPA实现时这点显得尤为重要,因为JPA转换器只在classloader级别运行并各自独立
13.7.2. JpaTemplate
和 JpaDaoSupport
每个基于JPA的DAO将通过IoC接收一个 EntityManagerFactory
实例。 这样的DAO可以通过 EntityManagerFactory
来操作原生JPA的API进行数据访问,也可以直接使用Spring的 JpaTemplate
:
<beans> ... <bean id="myProductDao"> <property name="entityManagerFactory" ref="entityManagerFactory"/> </bean> ... </beans>
public class JpaProductDao implements ProductDao { private EntityManagerFactory entityManagerFactory; public void setEntityManagerFactory(EntityManagerFactory emf) { this.entityManagerFactoryeManagerFactory = emf; } public Collection loadProductsByCategory(final String category) throws DataAccessException { JpaTemplate jpaTemplate = new JpaTemplate(this.entityManagerFactory); return (Collection) jpaTemplate.execute(new JpaCallback() { public Object doInJpa(EntityManager em) throws PersistenceException { Query query = em.createQuery("from Product"); List result = query.execute(category); // do some further stuff with the result list return result; } }); } }
JpaCallback
实现允许所有类型的JPA数据访问。 JpaTemplate
将确保 EntityManager
正确的打开和关闭,并且能够自动地参与到事务中去。 除此之外,JpaTemplate
能够恰当地处理异常,确保资源的及时清理以及必要时的事务回滚。 Template实例不仅是线程安全的,而且它是可重用的,因而它能够作为实例变量被一个类持有。 注意 JpaTemplate
提供了简单的诸如find、load、merge等操作的快捷函数来替代默认的回调实现。
不仅如此,Spring还提供了一个方便的 JpaDaoSupport
基类,提供了 get/setEntityManagerFactory
方法以及 getJpaTemplate()
方法供子类调用:
public class ProductDaoImpl extends JpaDaoSupport implements ProductDao { public Collection loadProductsByCategory(String category) throws DataAccessException { return getJpaTemplate().find("from Product"); } }
除了直接使用Spring的 JpaTemplate
,你也可以使用原生JPA的API来实现基于Spring的DAO,此时你需要自行明确地处理EntityManager。 正如在相应的Hibernate章节描述的一样,这种做法的主要优点在于你的数据访问代码可以在整个过程中抛出checked exceptions。JpaDaoSupport
为这种情况提供了多种函数支持,包括获取和释放一个具备事务管理功能的 EntityManager
和相关的异常转化。
13.7.3. 基于原生的JPA实现DAO
你完全可以使用原生的JPA的API进行编程而无需对Spring产生任何依赖,这可以通过一个被注入的 EntityManagerFactory
或 EntityManager
来完成。 注意Spring能够识别字段或者方法级别的 @PersistenceUnit
和 @PersistenceContext
标注,如果 PersistenceAnnotationBeanPostProcessor
功能被激活的话。 一个相应的DAO实现类看上去就像这样:
public class ProductDaoImpl implements ProductDao { @PersistenceUnit private EntityManagerFactory entityManagerFactory; public Collection loadProductsByCategory(String category) { EntityManager em = this.entityManagerFactory.getEntityManager(); try { Query query = em.createQuery("from Product"); return result = query.execute(category); } finally { if (em != null) { em.close(); } } } }
上述的DAO不对Spring产生任何依赖,而它就如同使用Spring的 JpaTemplate
那样,非常适合在Spring的application context中进行配置。 此外,这样的DAO可以利用标注来要求 EntityManagerFactory
的注入:
<beans> ... <!-- JPA annotations bean post processor --> <bean/> <bean id="myProductDao"/> </beans>
这类DAO的主要问题在于每次总是从工厂中获取一个新的 EntityManager
实例。 这一点可以通过对 EntityManager
而不是factory进行注入来解决:
public class ProductDaoImpl implements ProductDao { private EntityManager em; @PersistenceContext public void setEntityManager(EntityManager em) { this.em = em; } public Collection loadProductsByCategory(String category) { Query query = em.createQuery("from Product"); return result = query.execute(category); } }
被注入的 EntityManager
是受到Spring管理的(能够感知当前的事务)。 非常值得注意的是,即使这种新的实现更倾向于方法级别的注入(使用 EntityManager
而不是 EntityManagerFactory
), 对于注解的使用,application context的XML配置无需任何改变。
这种DAO风格的主要优点在于它仅仅依赖JPA,而无需依赖任何的Spring的类。除此之外,JPA的标注是被识别的,注入能够被Spring容器自动应用。 从无入侵性的角度来说,这一点非常有吸引力,它对于JPA开发者来说也更自然。
13.7.4. 异常转化
DAO不仅会抛出普通的 PersistenceException
异常,(这是一个无需声明和捕获的unchecked exception),还会抛出诸如 IllegalArgumentException
和 IllegalStateException
之类的异常。 这意味着,DAO的调用者只能以普通的错误来处理这些异常,除非完全依赖JPA自身的异常体系。因而,除非你将DAO的调用者绑定到具体的实现策略上去,否则你将无法捕获特定的异常原因(诸如乐观锁异常)。 这种折中平衡或许可以被接受,如果你的应用完全基于JPA或者无需进行特殊的异常处理。不过,Spring提供了一个允许你进行透明的异常转化的解决方案:通过使用 @Repository
注解:
@Repository public class ProductDaoImpl implements ProductDao { ... }
<beans>
...
<!-- Exception
translation bean post processor -->
<bean/>
<bean id="myProductDao"/>
</beans>
后置处理器将自动的寻找所有的异常转化器(PersistenceExceptionTranslator
这个接口的实现类)并通知所有打上 @Repository
注解的bean,从而能够使得被找到的异常转化器能够在抛出异常时做相应的异常转化工作。
总结来说:DAO能够基于普通的Java持久层API和注解来实现,但同样也能享受到由Spring管理事务、IoC和透明的异常转化(转化成为Spring的异常体系)等好处。
13.7.5. 事务管理
将事务管理纳入到Service操作的执行中,你可以使用Spring通用的声明式的事务管理功能,参加下面的例子:
<?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 http://www.springframework.org/schema/beans/spring-beans.xsd http://www.springframework.org/schema/tx http://www.springframework.org/schema/tx/spring-tx.xsd http://www.springframework.org/schema/aop http://www.springframework.org/schema/aop/spring-aop.xsd"> ... <bean id="myTxManager"> <property name="entityManagerFactory" ref="myEmf"/> </bean> <bean id="myProductService"> <property name="productDao" ref="myProductDao"/> </bean> <aop:config> <aop:pointcut id="productServiceMethods" expression="execution(* product.ProductService.*(..))"/> <aop:advisor advice-ref="txAdvice" pointcut-ref="productServiceMethods"/> </aop:config> <tx:advice id="txAdvice" transaction-manager="myTxManager"> <tx:attributes> <tx:method name="increasePrice*" propagation="REQUIRED"/> <tx:method name="someOtherBusinessMethod" propagation="REQUIRES_NEW"/> <tx:method name="*" propagation="SUPPORTS" read-only="true"/> </tx:attributes> </tx:advice> </beans>
Spring JPA允许将一个JPA事务暴露给访问相同的JDBC DataSource
的JDBC访问代码,前提条件是,被注册的 JpaDialect
能够支持获取底层的JDBC Connection
。 Spring提供了针对Toplink和Hibernate的JPA实现的Dialect。具体参见下一节有关 JpaDialect
的机制。
13.7.6. JpaDialect
作为一个高级特性,JpaTemplate
、JpaTransactionManager
和 AbstractEntityManagerFactoryBean
的子类支持用户自定义的 JpaDialect
作为"jpaDialect"的bean属性进行注入。 在这种情况下,DAO将不再接收 EntityManagerFactory
的引用作为参数,而是接收一个完整的 JpaTemplate
(也就是将它注入到 JpaDaoSupport
的"jpaTemplate"属性中去 一个 JpaDialect
实现能够激活一些由Spring支持的高级特性,这通常由特定的实现供应商指定: 一个 JpaDialect
实现能够激活一些由Spring支持的高级特性,这通常由特定的实现供应商指定:
使用特定的事务语义(例如用户自定义的事务隔离级别和事务超时)
获取具备事务功能的Connection对象(暴露给基于JDBC的DAO)
从
PersistenceExceptions
到Spring的DataAccessExceptions
高级转化
这对于特殊的事务语义和异常的高级转化这样的高级特性比较有价值。注意默认的实现(使用DefaultJpaDialect
)并不提供任何特殊的功能。如果你需要上述的特殊功能,你必须指定合适的Dialect。
更多有关它的操作以及它如何在Spring的JPA支持中使用的详细信息请参看 JpaDialect
的Javadoc。