SPRING IN ACTION 第4版笔记-第十一章Persisting data with object-relational mapping-002设置JPA的EntityManagerFactory(<persistence-unit>、<jee:jndi-lookup>)

一、EntityManagerFactory的种类

1.The JPA specification defines two kinds of entity managers:

 Application-managed—Entity managers are created when an application directly requests one from an entity manager factory. With application-managed entity managers, the application is responsible for opening or closing entity managers
and involving the entity manager in transactions. This type of entity manager is most appropriate for use in standalone applications that don’t run in a Java EE container.
 Container-managed—Entity managers are created and managed by a Java EE container. The application doesn’t interact with the entity manager factory at all. Instead, entity managers are obtained directly through injection or from
JNDI . The container is responsible for configuring the entity manager factories.This type of entity manager is most appropriate for use by a Java EE container that wants to maintain some control over JPA configuration beyond what’s specified in persistence.xml.

2.Each flavor of entity manager factory is produced by a corresponding Spring factory bean:

 LocalEntityManagerFactoryBean produces an application-managed EntityManagerFactory .
 LocalContainerEntityManagerFactoryBean produces a container-managed EntityManagerFactory

二、设置方法

Application-managed entity-manager factories derive most of their configuration information from a configuration file called persistence.xml. This file must appear in the META-INF directory in the classpath.The purpose of the ersistence.xml file is to define one or more persistence units.A persistence unit is a grouping of one or more persistent classes that correspond to a single data source.

1.xml

 <persistence xmlns="http://java.sun.com/xml/ns/persistence" version="1.0">
     <persistence-unit name="spitterPU">
         <class>com.habuma.spittr.domain.Spitter</class>
         <class>com.habuma.spittr.domain.Spittle</class>
         <properties>
             <property name="toplink.jdbc.driver" value="org.hsqldb.jdbcDriver" />
             <property name="toplink.jdbc.url" value="jdbc:hsqldb:hsql://localhost/spitter/spitter" />
             <property name="toplink.jdbc.user" value="sa" />
             <property name="toplink.jdbc.password" value="" />
         </properties>
     </persistence-unit>
 </persistence>

在另一个例子中

 <?xml version="1.0"?>
 <persistence xmlns="http://java.sun.com/xml/ns/persistence"
     xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
     xsi:schemaLocation="http://java.sun.com/xml/ns/persistence
     http://java.sun.com/xml/ns/persistence/persistence_1_0.xsd" version="1.0">
   <persistence-unit name="jun" transaction-type="RESOURCE_LOCAL">
       <provider>org.hibernate.ejb.HibernatePersistence</provider>
     <properties>
          <property name="hibernate.dialect"
              value="org.hibernate.dialect.MySQLDialect"/><!--数据库方言-->
          <property name="hibernate.connection.driver_class"
              value="com.mysql.jdbc.Driver"/><!--数据库驱动类-->
          <property name="hibernate.connection.username" value="root"/><!--数据库用户名-->
          <property name="hibernate.connection.password" value="admin"/>
          <property name="hibernate.connection.url"
              value="jdbc:mysql://localhost:3306/quote;"/><!--数据库连接URL-->
          <property name="hibernate.max_fetch_depth" value="3"/><!--外连接抓取树的最大深度 -->
          <property name="hibernate.hbm2ddl.auto" value="update"/><!-- 自动输出schema创建DDL语句 -->
          <property name="hibernate.jdbc.fetch_size" value="18"/><!-- JDBC的获取量大小 -->
          <property name="hibernate.jdbc.batch_size" value="10"/><!-- 开启Hibernate使用JDBC2的批量更新功能  -->
          <property name="hibernate.show_sql" value="true"/><!-- 在控制台输出SQL语句 -->
       </properties>
   </persistence-unit>
 </persistence>

然后bean.xml如下：

 <?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:context="http://www.springframework.org/schema/context"
        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-2.5.xsd
            http://www.springframework.org/schema/context
            http://www.springframework.org/schema/context/spring-context-2.5.xsd
            http://www.springframework.org/schema/aop http://www.springframework.org/schema/aop/spring-aop-2.5.xsd
            http://www.springframework.org/schema/tx http://www.springframework.org/schema/tx/spring-tx-2.5.xsd">
     <!-- 配置哪些包下的类需要自动扫描 -->
     <context:component-scan base-package="com.sanqing"/>    

     <!-- 这里的jun要与persistence.xml中的 <persistence-unit name="jun" transaction-type="RESOURCE_LOCAL">
     中的name值要一致，这样才能找到相关的数据库连接
      -->
    <bean id="entityManagerFactory" class="org.springframework.orm.jpa.LocalEntityManagerFactoryBean">
          <property name="persistenceUnitName" value="jun"/>
    </bean>
    <!-- 配置事物管理器 -->
    <bean id="transactionManager" class="org.springframework.orm.jpa.JpaTransactionManager">
         <property name="entityManagerFactory" ref="entityManagerFactory"/>
    </bean>
    <!-- 配置使用注解来管理事物 -->
    <tx:annotation-driven transaction-manager="transactionManager"/>

 </beans>

2.java

 @Bean
 public LocalEntityManagerFactoryBean entityManagerFactoryBean() {
     LocalEntityManagerFactoryBean emfb = new LocalEntityManagerFactoryBean();
     emfb.setPersistenceUnitName("spitterPU");
     return emfb;
 }

The reason much of what goes into creating an application-managed EntityManagerFactory is contained in persistence.xml has everything to do with what it means to be application-managed.

3.Container-managed JPA takes a different approach. When running in a container, an EntityManagerFactory can be produced using information provided by the container—Spring, in this case.Instead of configuring data-source details in persistence.xml, you can configure this information in the Spring application context.

 @Bean
 public LocalContainerEntityManagerFactoryBean entityManagerFactory(
     DataSource dataSource, JpaVendorAdapter jpaVendorAdapter) {
     LocalContainerEntityManagerFactoryBean emfb =
         new LocalContainerEntityManagerFactoryBean();
     emfb.setDataSource(dataSource);
     emfb.setJpaVendorAdapter(jpaVendorAdapter);
     return emfb;
 }

 @Bean
 public JpaVendorAdapter jpaVendorAdapter() {
     HibernateJpaVendorAdapter adapter = new HibernateJpaVendorAdapter();
     adapter.setDatabase("HSQL");
     adapter.setShowSql(true);
     adapter.setGenerateDdl(false);
     adapter.setDatabasePlatform("org.hibernate.dialect.HSQLDialect");
     return adapter;
 }

4.The primary purpose of the persistence.xml file is to identify the entity classes in a persistence unit. But as of Spring 3.1, you can do that directly with LocalContainerEntityManagerFactoryBean by setting the packagesToScan property:

 @Bean
 public LocalContainerEntityManagerFactoryBean entityManagerFactory(
     DataSource dataSource, JpaVendorAdapter jpaVendorAdapter) {
     LocalContainerEntityManagerFactoryBean emfb =
         new LocalContainerEntityManagerFactoryBean();
     emfb.setDataSource(dataSource);
     emfb.setJpaVendorAdapter(jpaVendorAdapter);
     emfb.setPackagesToScan("com.habuma.spittr.domain");
     return emfb;
 }

there’s no need to configure details about the database in persistence.xml. Therefore,there’s no need for persistence.xml whatsoever! Delete it, and let LocalContainerEntityManagerFactoryBean handle it for you.

三、从JNDI中获取EntityManagerFactory

1.xml

 <jee:jndi-lookup id="emf" jndi-name="persistence/spitterPU" />

2.java

 @Bean
 public JndiObjectFactoryBean entityManagerFactory() {
     JndiObjectFactoryBean jndiObjectFB = new JndiObjectFactoryBean();
     jndiObjectFB.setJndiName("jdbc/SpittrDS");
     return jndiObjectFB;
 }

Although this method doesn’t return an EntityManagerFactory , it will result in an EntityManagerFactory bean. That’s because it returns JndiObjectFactoryBean ,which is an implementation of the FactoryBean interface that produces an EntityManagerFactory .