This is to show how to setup JPA with Spring, using Hibernate and EclipseLink respectively. We are not talking about ORM, which is a separate topic. So I am going to use a simple POJO.
First, let's create a simple class:
package my.test;
public class Book
{
public int bookId;
public String bookName;
public String category;
}
Here I don't have getter/setter, since I will have field access later. But in the real world, you may have to use getter/setter if there is any lazy loading.
Then we create a DAO interface:
package my.test;
public interface BookDao
{
void save(Book book);
Book update(Book book);
void delete(Book book);
Book findById(int bookId);
}
Next, we are going to create a JPA entity-mapping file. Alternatively, we could use annotations in Book class. but I don't like this approach since in my environment, the domain models are relatively very large in size. I don't want "pollution" of any underlying implementations. So here is the entity mapping:
<?xml version="1.0" encoding="UTF-8" ?>
<entity-mappings xmlns="http://java.sun.com/xml/ns/persistence/orm"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xsi:schemaLocation="http://java.sun.com/xml/ns/persistence/orm
http://java.sun.com/xml/ns/persistence/orm_2_0.xsd"
version="2.0">
<entity class="my.test.Book" access="FIELD">
<table name="mytest_book"/>
<attributes>
<id name="bookId"><column name="book_id"/></id>
<basic name="bookName"><column name="book_name"/></basic>
<basic name="category"><column name="category"/></basic>
</attributes>
</entity>
</entity-mappings>
I saved this file as book.jpa.xml under package my.test.dao.jpa. Note in JPA, usually we use an orm.xml for entity mapping under META-INF directory. But spring saves me a headache, I can put them anywhere I want. For more info, check: http://wiki.eclipse.org/EclipseLink/Examples/JPA/EclipseLink-ORM.XML
Now let's create the DAO implementation, using spring.
package my.test.dao.jpa;
import my.test.Book;
import my.test.BookDao;
import javax.persistence.EntityManager;
import javax.persistence.PersistenceContext;
public class BookDaoJpaImpl implements BookDao
{
@PersistenceContext
private EntityManager em;
public void save(Book book)
{
this.em.persist(book);
}
public Book update(Book book)
{
return this.em.merge(book);
}
public void delete(Book book)
{
this.em.remove(book);
}
public Book findById(int bookId)
{
return this.em.find(Book.class, bookId);
}
}
Note that EntityManager is in general not thread safe, but this instance injected by Spring is thread safe since it will create a new transactional entity manager for each thread. Another note is that the annotation usage here is within the DAO implementation, it's not "polluting" my domain model.
Now we need to create the standard persistence.xml.
<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_2_0.xsd"
version="2.0" xmlns="http://java.sun.com/xml/ns/persistence">
<persistence-unit name="myPersistenceUnit" transaction-type="RESOURCE_LOCAL">
<mapping-file>my/test/dao/jpa/book.jpa.xml</mapping-file>
</persistence-unit>
</persistence>
I saved this file in persistence.xml under package my.dao.jpa. In standard JPA, this file has to be under META-INF in classpath. But Spring saves me another headache. I can put it anywhere I want.
Now, we need to create the spring xml to stitch everything together.
<?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"
xmlns:p="http://www.springframework.org/schema/p"
xsi:schemaLocation="http://www.springframework.org/schema/beans
http://www.springframework.org/schema/beans/spring-beans-3.0.xsd
http://www.springframework.org/schema/context
http://www.springframework.org/schema/context/spring-context-3.0.xsd
http://www.springframework.org/schema/tx
http://www.springframework.org/schema/tx/spring-tx-3.0.xsd
http://www.springframework.org/schema/aop
http://www.springframework.org/schema/aop/spring-aop-3.0.xsd">
<bean id="bookDao" class="my.test.dao.jpa.BookDaoJpaImpl"/>
<!-- bean post-processor for JPA annotations -->
<bean class="org.springframework.orm.jpa.support.PersistenceAnnotationBeanPostProcessor"/>
<aop:config>
<aop:pointcut id="bookDaoMethods" expression="execution(* my.test.dao.jpa.BookDaoJpaImpl.*(..))"/>
<aop:advisor advice-ref="bookDaoTxAdvice" pointcut-ref="bookDaoMethods"/>
</aop:config>
<tx:advice id="bookDaoTxAdvice" transaction-manager="myTxManager">
<tx:attributes>
<tx:method name="*" propagation="REQUIRED"/>
</tx:attributes>
</tx:advice>
<bean id="myTxManager" class="org.springframework.orm.jpa.JpaTransactionManager">
<property name="entityManagerFactory" ref="myEmf"/>
</bean>
<bean id="mydataSource" class="org.apache.commons.dbcp.BasicDataSource" destroy-method="close">
<property name="driverClassName" value="${jdbc.driver}"/>
<property name="url" value="${jdbc.url}"/>
<property name="username" value="${jdbc.username}"/>
<property name="password" value="${jdbc.password}"/>
<property name="maxIdle" value="10"/>
<property name="maxActive" value="100"/>
<property name="maxWait" value="10000"/>
<property name="testOnBorrow" value="true"/>
<property name="testWhileIdle" value="true"/>
<property name="timeBetweenEvictionRunsMillis" value="1200000"/>
<property name="minEvictableIdleTimeMillis" value="1800000"/>
<property name="numTestsPerEvictionRun" value="5"/>
<property name="defaultAutoCommit" value="true"/>
</bean>
<context:property-placeholder location="classpath:my/test/dao/jpa/jdbc.properties"/>
</beans>
Here we define the DAO class, the transaction manager, and the datasource. The jdbc.properties is like this:
jdbc.driver=oracle.jdbc.OracleDriver
jdbc.url=jdbc:oracle:thin:@*****
jdbc.username=
jdbc.password=
So far we haven't define the EntityManagerFactory yet, since we still stays in JPA.
If we use Hibernate as the JPA implementation, the EntityManagerFactory is like this:
<bean id="myEmf" class="org.springframework.orm.jpa.LocalContainerEntityManagerFactoryBean">
<property name="persistenceUnitName" value="myPersistenceUnit"/>
<property name="dataSource" ref="mydataSource"/>
<property name="persistenceXmlLocation" value="classpath:my/test/dao/jpa/persistence.xml"/>
<property name="loadTimeWeaver">
<bean class="org.springframework.instrument.classloading.InstrumentationLoadTimeWeaver"/>
</property>
<property name="jpaVendorAdapter">
<bean class="org.springframework.orm.jpa.vendor.HibernateJpaVendorAdapter">
<!-- <property name="showSql" value="true"/> -->
<property name="generateDdl" value="false"/>
<property name="database" value="ORACLE"/>
<property name="databasePlatform" value="org.hibernate.dialect.OracleDialect"/>
</bean>
</property>
</bean>
The only thing specific to Hibernate is the jpaVendorAdapter entry. Also note here we specify the persistence.xml location. For more info on load time weaver, check: http://static.springsource.org/spring/docs/2.5.6/reference/orm.html#orm-jpa-setup-lcemfb and
http://www.eclipse.org/aspectj/doc/released/devguide/ltw.html
If we use EclipseLink, then the above bean becomes:
<bean id="myEmf" class="org.springframework.orm.jpa.LocalContainerEntityManagerFactoryBean">
<property name="persistenceUnitName" value="myPersistenceUnit"/>
<property name="dataSource" ref="mydataSource"/>
<property name="persistenceXmlLocation" value="classpath:my/test/dao/jpa/persistence.xml"/>
<property name="loadTimeWeaver">
<bean class="org.springframework.instrument.classloading.InstrumentationLoadTimeWeaver"/>
</property>
<property name="jpaVendorAdapter">
<bean class="org.springframework.orm.jpa.vendor.EclipseLinkJpaVendorAdapter">
<property name="generateDdl" value="false"/>
<property name="database" value="ORACLE"/>
<property name="databasePlatform" value="org.eclipse.persistence.platform.database.OraclePlatform"/>
</bean>
</property>
</bean>
For spring: we need to following jars: spring jars and commons-logging. We also need aspectjweaver.jar and aopalliance.jar
For hibernate: we need hibernate jar, the jars in the required directory, and the jar in the jpa directory.
For eclipselink: we need eclipselink jar and standard persistence 2.0 jar.
and don't forget jdbc driver jar, I am just using oracle. I am also using commons dbcp and pool jars.
If you are using eclipselink, don't forget to use -javaagent: <spring instrument jar>. Hiberate doesn't need this switch.
And for jdbc/orm, don't forget the nice handy small tool: p6spy. It could print out full SQL statements without ? marks.
Here are some references:
Hibernate: http://www.hibernate.org/
EclipseLink: http://www.eclipse.org/eclipselink/
JPA: http://jcp.org/en/jsr/detail?id=317
P6spy: http://sourceforge.net/projects/p6spy/
SQLProfiler: http://sourceforge.net/projects/sqlprofiler/
分享到:
相关推荐
这是整合SpringMVC+Spring+SpringDataJPA+Hibernate简单的实现登录的功能,用的是mysql数据库,这是一个web Project 如果你用的是JavaEE6那么你要注意bean-validator.jar和weld-osgi-bundle.jar与slf4j的jar包冲突。...
本项目整合spring_jpa_hibernate_shiro,spring_jpa_hibernate_shiro.zip 里有代码,spring_jpa_hibernate常用的小弟就没有单独说明了,在项目配置文件里写得比较清楚,小弟在主要是shiro权限控制做了单独说明,如有...
基础框架,可满足开发需要
Maven整合Spring+SpringMVC+Hibernate+SpringDataJPA
Spring集成Jpa(Hibernate实现)例子,原代码哦~! 包涵所需要的jar包,这些jar包不好找,版本如果不兼容就会出现各种各样的莫名其妙的错误或异常。
JSF+Spring+JPA(Hibernate实现)的环境搭建.doc JSF+Spring+JPA(Hibernate实现)的环境搭建.doc
Struts2+Spring+JPA(Hibernate)项目所需要的jar包
手把手教你从最基本的Java工程搭建SpringMVC+SpringDataJPA+Hibernate。 http://blog.csdn.net/anxpp中有详细搭建教程
Java Web高级编程 涵盖WebSockets、Spring Framework、JPA Hibernate和Spring Security, 有目录,很清晰
NULL 博文链接:https://remotejavasky.iteye.com/blog/1182721
5、spring:3.1.1 hibernate:4.1.6 Hibernate-JPA:2.0 6、若更换数据库后代码有误,无法调通,请先运行com.web.test代码调试数据库配置,运行测试,数据库调通再运行com.web.mvc下的controller。 7、附带的另一...
Spring Data JPA API。 Spring Data JPA 开发文档。 官网 Spring Data JPA API。
库文件 博文链接:https://log-cd.iteye.com/blog/562054
JSF+Spring+JPA_Hibernate实现_的环境搭建.pdf
java框架整合例子(spring、spring mvc、spring data jpa、hibernate)
NULL 博文链接:https://prowl.iteye.com/blog/519618
spring4.2+spring mvc +spring data+jpa+hibernate的程序构架
spring4.0.1 springMVC jpa2.0 hibernate4.3.7 框架整合
SpringMvc+Spring+JPA+Hibernate实现的增删改查 采用idea和eclipse两种方式