JPA（Java Persistence API）Java持久化API-应用

JPA（Java Persistence API）Java持久化API-应用：
下面的例子是基于Hibernate的EntityManager的JPA来实现的，Hibernate EntityManager底层依赖于Hibernate依赖于Hibernate和Hibernate Annotation。

在开发JPA的过程中，开发者需要在classpath类路径中的/META-INF目录下提供persistence.xml。

下面给出列模板例子：

<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="default" transaction-type="RESOURCE_LOCAL">

</persistence-unit>

</persistence>

为了再Java SE环境中操控JPA实体，开发者需要借助Persistence完成EntityManager工程的创建。之后，使用它创建的EntityManager从而借助JPA实体完成对RDBMS的CRUD操作。

如果开发者需要在JavaEE服务器端采用JPA，则@PersistenceContext、@PersistenceUnit等注解能够减轻JPA开发者的编程负担。因为他们能够自动完成EntityManager和EntityManagerFactory的注入工作。

注意：JpaTemplate JpaDaoSupport已经不建议使用。

@PersistenceContext:会将EntityManager实例注入到EntityManager变量中--非线程安全

@PersistenceUnit:会将EntityManagerFactory实例注入到EntityManagerFactory变量中--线程安全

使用了上面两个注解的DAO类不用集成JpaDaoSupport

如果类中使用到@Repository注解，而且它直接使用EntityManager进行各种CRUD操作。为完成JPA异常到Spring DAO异常体系的转换，必须启用这一对象。

AbstractEntityManagerFactoryBean继承链：

两个类：LocalEntityManagerFactory和LocalContainerEntityManagerFactoryBean

LocalEntityManagerFactory辅助类：

LocalEntityManagerFactory是依据JPA标准单独引导契约而实现的一个辅助类，它能够创建本地EntityManagerFactory实例。于此同时，它只能从classpath路径下得META-INF位置装载persistence.xml文件。

下面给出了配置：

<!-- JPA EntityManagerFactory -->
<bean id="entityManagerFactory" class="org.springframework.orm.jpa.LocalEntityManagerFactoryBean"
p:dataSource-ref="dataSource">
<property name="jpaVendorAdapter">
<bean class="org.springframework.orm.jpa.vendor.HibernateJpaVendorAdapter">

<property name="generateDdl" value="false"/>
<property name="database" value="${jdbc.database}"/>
<property name="showSql" value="${jdbc.showSql}"/>
</bean>
</property>
</bean>

<bean id="jpaProperties" class="org.springframework.beans.factory.config.PropertiesFactoryBean">

<property name="properties">

<props>  <prorp key="hibernate.format_sql">true</prop>

<prop key="hibernate.use_sql_conmments">true</prop>

</props>

</property></bean>

关于LocalEntityManageFactoryBean(LocalContainerEntityManagerFactoryBean)存在以下几个重要的知识点：

1.单META-INF目录中存在多个persistence.xml或同一个persistence.xml中存在多个<persistence-unit/>元素时，开发者需要通过辅助类暴露的persistenceUnitName属性指定一个具体的持久化单元名。

2.由于不同的ORM提供者的配置存在差异，为解决这一差异，JPA集成专门提供了大量的JpaVendorAdapter实现类。

比如：HibernateJpaVendorAdapter、EclipseLinkJpaVendorAdapter、TopLinkJpaVendorAdapter、OpenJpaVendorAdapter等

默认时，JpaVendorAdapter实现类都暴露了generateDdl、showSql、database等属性。如果需要将最近JPA实体对应的SQL DDL语句同步到RDBMS中则可以将generateDdl属性设置为true。database用于指定特定的数据库。

取值范围如下：

DEFAULT DB2 DERBY H2 HSQL INFORMIX MYSQL ORACLE POSTGRESQL SQL_SERVER SYBASE

3.借助jpaProperties（jpaPropertiesMap）属性，开发者能够设置JPA提供者暴露的专有属性，比如hibernate.format_sql。

HibernateJpaVerdorAdapter中设置的属性值会被jpaProperties属性提供的值覆盖掉。persistence.xml也出现时候，同样以jpaProperties的值有准。

LocalContainerEntityManagerFactoryBean辅助类：

与LocalEntityManagerFactoryBean相比LocalContainerEntityManagerFactoryBean更具工业强度。更适应与Spring的应用。

配置实例如下：

<context:property-placeholder location="classpath:jdbc.properties"/>

<!-- Connection Pool -->
<bean id="dataSource" class="com.mchange.v2.c3p0.ComboPooledDataSource" destroy-method="close">
<property name="driverClass" value="${jdbc.driverClass}"/>
<property name="jdbcUrl" value="${jdbc.url}"/>
<property name="user" value="${jdbc.username}"/>
<property name="password" value="${jdbc.password}"/>
</bean>

<!-- JPA EntityManagerFactory -->
<bean id="entityManagerFactory" class="org.springframework.orm.jpa.LocalContainerEntityManagerFactoryBean"
p:dataSource-ref="dataSource">
<property name="jpaVendorAdapter">
<bean class="org.springframework.orm.jpa.vendor.HibernateJpaVendorAdapter">
<property name="database" value="${jdbc.database}"/>
<property name="showSql" value="${jdbc.showSql}"/>
</bean>
</property>
</bean>

<!-- Transaction manager for a single JPA EntityManagerFactory (alternative to JTA) -->
<bean id="transactionManager" class="org.springframework.orm.jpa.JpaTransactionManager"
p:entityManagerFactory-ref="entityManagerFactory"/>

<!-- Activates various annotations to be detected in bean classes for eg @Autowired-->
<context:annotation-config/>

<!-- enable the configuration of transactional behavior based on annotations  -->
<tx:annotation-driven transaction-manager="transactionManager"/>

可以看出：persitence.xml不用再制定数据库的任何信息了，因为DI容器接管了这一工作。

事务管理支持：

针对单个的EntityManagerFactory,JPA提供了相应的JpaTranactionManager事务管理类。它类似于HibernateTransactionManager。实际上JpaTransactionManager也是借助于Connection完成事务管理工作的。

<!-- Transaction manager for a single JPA EntityManagerFactory (alternative to JTA) -->
<bean id="transactionManager" class="org.springframework.orm.jpa.JpaTransactionManager"
p:entityManagerFactory-ref="entityManagerFactory"/>

事务集成中的各种事务策略同样适用于JPA集成，比如：@Transaction <tx:advice/> TransactionProxyFactoryBean等。

+++++++++++++++++++++++++++++++++++++++++++++++++++++++

下面给出示例：



pom.xml：

<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/maven-v4_0_0.xsd"> <modelVersion>4.0.0</modelVersion>
<groupId>com.spring.test</groupId>
<artifactId>spring-20120810</artifactId>
<packaging>war</packaging>
<version>0.0.1-SNAPSHOT</version>
<name>spring-20120810 Maven Webapp</name>
<url>http://maven.apache.org</url>

<properties>
<org.springframework-version>3.1.2.RELEASE</org.springframework-version>
<slf4j-log4j12-version>1.6.6</slf4j-log4j12-version>
</properties>

<dependencies>
<!-- with spring -->
<dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-core</artifactId>
<version>${org.springframework-version}</version>
</dependency>
<dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-web</artifactId>
<version>${org.springframework-version}</version>
</dependency>
<dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-jdbc</artifactId>
<version>${org.springframework-version}</version>
</dependency>
<dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-jms</artifactId>
<version>${org.springframework-version}</version>
</dependency>
<dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-test</artifactId>
<version>${org.springframework-version}</version>
</dependency>
<dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-orm</artifactId>
<version>${org.springframework-version}</version>
</dependency>
<dependency>
<groupId>org.apache.geronimo.specs</groupId>
<artifactId>geronimo-jms_1.1_spec</artifactId>
<version>1.1</version>
</dependency>
<!-- <dependency>
<groupId>activemq-core</groupId>
<artifactId>activemq-core</artifactId>
<version>5.6.0</version>
</dependency>
-->
<dependency>
<groupId>javax.management.j2ee</groupId>
<artifactId>management-api</artifactId>
<version>1.1-rev-1</version>
</dependency>
<dependency>
<groupId>org.slf4j</groupId>
<artifactId>integration</artifactId>
<version>1.6.6</version>
</dependency>

<dependency>
<groupId>commons-dbcp</groupId>
<artifactId>commons-dbcp</artifactId>
<version>1.2.2</version>
</dependency>
<dependency>
<groupId>mysql</groupId>
<artifactId>mysql-connector-java</artifactId>
<version>5.0.5</version>
</dependency>
<dependency>
<groupId>org.aspectj</groupId>
<artifactId>aspectjweaver</artifactId>
<version>1.7.0</version>
</dependency>
<dependency>
<groupId>org.springframework.integration</groupId>
<artifactId>spring-integration-mail</artifactId>
<version>2.1.3.RELEASE</version>
</dependency>
<dependency>
<groupId>javax.mail</groupId>
<artifactId>mail</artifactId>
<version>1.4.5</version>
</dependency>
<dependency>
<groupId>toplink.essentials</groupId>
<artifactId>toplink-essentials</artifactId>
<version>2.1-60f</version>
</dependency>
<!-- jdbc driver -->
<dependency>
<groupId>mysql</groupId>
<artifactId>mysql-connector-java</artifactId>
<version>5.0.5</version>
</dependency>

<!-- connect pool with c3p0 -->
<dependency>
<groupId>c3p0</groupId>
<artifactId>c3p0</artifactId>
<version>0.9.1.2</version>
</dependency>
<dependency>
<groupId>hibernate</groupId>
<artifactId>hibernate-entitymanager</artifactId>
<version>3.4.0.GA</version>
</dependency>
<dependency>
<groupId>cglib</groupId>
<artifactId>cglib-nodep</artifactId>
<version>2.2.2</version>
</dependency>

<dependency>
<groupId>junit</groupId>
<artifactId>junit</artifactId>
<version>4.10</version>
<scope>test</scope>
</dependency>
</dependencies>
<build>
<finalName>spring-20120810</finalName>
</build>
</project>

persistence.xml：

<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="default" transaction-type="RESOURCE_LOCAL">

</persistence-unit>

</persistence>

applicationContext.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:p="http://www.springframework.org/schema/p" xmlns:aop="http://www.springframework.org/schema/aop"
xmlns:context="http://www.springframework.org/schema/context" xmlns:jee="http://www.springframework.org/schema/jee"
xmlns:tx="http://www.springframework.org/schema/tx"
xsi:schemaLocation=" http://www.springframework.org/schema/aop http://www.springframework.org/schema/aop/spring-aop-2.5.xsd 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/jee http://www.springframework.org/schema/jee/spring-jee-2.5.xsd http://www.springframework.org/schema/tx http://www.springframework.org/schema/tx/spring-tx-2.5.xsd">

<context:property-placeholder location="classpath:jdbc.properties"/>

<!-- Connection Pool -->
<bean id="dataSource" class="com.mchange.v2.c3p0.ComboPooledDataSource" destroy-method="close">
<property name="driverClass" value="${jdbc.driverClass}"/>
<property name="jdbcUrl" value="${jdbc.url}"/>
<property name="user" value="${jdbc.username}"/>
<property name="password" value="${jdbc.password}"/>
</bean>

<!-- JPA EntityManagerFactory -->
<bean id="entityManagerFactory" class="org.springframework.orm.jpa.LocalContainerEntityManagerFactoryBean"
p:dataSource-ref="dataSource">
<property name="jpaVendorAdapter">
<bean class="org.springframework.orm.jpa.vendor.HibernateJpaVendorAdapter">
<property name="database" value="${jdbc.database}"/>
<property name="showSql" value="${jdbc.showSql}"/>
</bean>
</property>
</bean>

<!-- Transaction manager for a single JPA EntityManagerFactory (alternative to JTA) -->
<bean id="transactionManager" class="org.springframework.orm.jpa.JpaTransactionManager"
p:entityManagerFactory-ref="entityManagerFactory"/>
<!-- Activates various annotations to be detected in bean classes for eg @Autowired-->
<context:annotation-config/>

<!-- enable the configuration of transactional behavior based on annotations  -->
<tx:annotation-driven transaction-manager="transactionManager"/>

<!-- Property Configurator -->
<bean id="propertyConfigurer" class="org.springframework.beans.factory.config.PropertyPlaceholderConfigurer">
<property name="location" value="jdbc.properties"/>
</bean>

<!-- 因为类中使用到@Repository注解，而且它直接使用EntityManager进行各种CRUD操作。为完成JPA异常到Spring DAO异常体系的转换，必须启用这一对象 -->
<bean class="org.springframework.dao.annotation.PersistenceExceptionTranslationPostProcessor"></bean>

<context:component-scan base-package="com.test.dao"/>

<bean id="contactService" class="com.test.service.ContactServiceImpl"/>

</beans>

jdbc.properties：

jdbc.driverClass=com.mysql.jdbc.Driver
jdbc.url=jdbc:mysql://localhost:3306/bekiz?characterEncoding=utf-8
jdbc.username=root
jdbc.password=root
jdbc.database=MYSQL
jdbc.showSql=true

log4j.properties：

log4j.rootCategory=debug, stdout, logfile

log4j.appender.stdout=org.apache.log4j.ConsoleAppender
log4j.appender.stdout.layout=org.apache.log4j.PatternLayout
log4j.appender.stdout.layout.ConversionPattern=%d %p [%c] - <%m>%n

log4j.appender.logfile=org.apache.log4j.RollingFileAppender
log4j.appender.logfile.File=C://templog/clinicComponet.log
log4j.appender.logfile.MaxFileSize=1MB

# Keep three backup files
log4j.appender.logfile.MaxBackupIndex=3
log4j.appender.logfile.layout=org.apache.log4j.PatternLayout

#Pattern to output : date priority [category] - <message>line_separator
log4j.appender.logfile.layout.ConversionPattern=%d %p [%c] - <%m>%n

ContactDAO.java：

public class ContactDAO {
/**
*@PersistenceContext:会将EntityManager实例注入到EntityManager变量中--非线程安全
*@PersistenceUnit:会将EntityManagerFactory实例注入到EntityManagerFactory变量中--线程安全
*使用了上面两个注解的DAO类不用集成JpaDaoSupport
*/
@PersistenceContext
private EntityManager entityManagerFactory;
//@PersistenceUnit
//private EntityManagerFactory entityManagerFactory;
public void addContact(ContactEO contactEO){
//this.entityManagerFactory.persist(contactEO);
entityManagerFactory.persist(contactEO);
}

}

Contact：

public interface Contact {

public String getFirstName();
public void setFirstName(String firstName);

public String getLastName();
public void setLastName(String lastName);

public String getEmail();
public void setEmail(String email);

public long getId();
public void setId(long id);

}

ContactEO：

public class ContactEO implements Contact{

@Transient
Contact contact;

@Transient
public Contact getContact() {
return contact;
}

public void setContact(Contact contact) {
this.contact = contact;
}

public ContactEO(){
contact = new ContactVO();
}

public ContactEO(Contact contact){
this.contact = contact;
}

@Column(name="FIRSTNAME")
public String getFirstName() {
return contact.getFirstName();
}

public void setFirstName(String firstName) {
contact.setFirstName(firstName);
}

@Column(name="LASTNAME")
public String getLastName() {
return contact.getLastName();
}

public void setLastName(String lastName) {
contact.setLastName(lastName);
}

@Column(name="EMAIL")
public String getEmail() {
return contact.getEmail();
}
public void setEmail(String email) {
contact.setEmail(email);
}

@Id
@GeneratedValue(strategy = GenerationType.IDENTITY)
@Column(name="ID")
public long getId() {
return contact.getId();
}

public void setId(long id) {
contact.setId(id);
}
}

ContactService：

@Component
public interface ContactService {
public void addContactInformation(Contact contact);
}

ContactServiceImpl：

public class ContactServiceImpl implements ContactService{
@Autowired
ContactDAO contactDAO;

private final Log log = LogFactory.getLog(this.getClass());

@Transactional(readOnly = false)
public void addContactInformation(Contact contact){
try {
// construct the Entity bean
ContactEO contactEO = new ContactEO(contact);

// save it
contactDAO.addContact(contactEO);
} catch (Exception e) {
e.printStackTrace();
log.fatal("Problem in prepareDataForUpdate while comparing persistent data with the csv file data", e);
}
}
}

TestContract.java：

public class TestContact {
/** logging variable */
private static final Log log = LogFactory.getLog(TestContact.class);

public static void main(String args[]){

ContactService contactService ;

log.info("Starting the ClinicSubnet Component batch updation process on "+new java.util.Date());

ClassPathXmlApplicationContext appContext = new ClassPathXmlApplicationContext(new String[] {
"applicationContext.xml"
});

contactService = (ContactService) appContext.getBean("contactService");

Contact contact = new ContactVO();
contact.setFirstName("Smitha");
contact.setLastName("Rao");
contact.setEmail("smitha@xxx.com");
contactService.addContactInformation(contact);
}
}