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

最新推荐文章于 2021-02-24 07:27:32 发布

努力突破

最新推荐文章于 2021-02-24 07:27:32 发布

阅读量1.8k

点赞数

CC 4.0 BY-SA版权

文章标签： java jpa api

本文链接：https://blog.youkuaiyun.com/ilovejava_2010/article/details/7900356

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);
	}
}