SPRING+JPA+Hibernate配置方法

1.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:context="http://www.springframework.org/schema/context"
     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.xsd
         http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context.xsd
         http://www.springframework.org/schema/tx http://www.springframework.org/schema/tx/spring-tx-4.1.xsd">

 <!-- 扫描目录 -->
     <context:component-scan base-package="com.genius"></context:component-scan>
     <bean class="org.springframework.orm.jpa.support.PersistenceAnnotationBeanPostProcessor" />
     <context:property-placeholder location="classpath:jdbc.properties"  ignore-unresolvable="true"/>

     <bean id="dataSource" class="com.mchange.v2.c3p0.ComboPooledDataSource"
         destroy-method="close">
         <property name="driverClass" value="${jdbc.driver}" />
         <property name="jdbcUrl" value="${jdbc.url}" />
         <property name="user" value="${jdbc.username}" />
         <property name="password" value="${jdbc.password}" />
         <property name="initialPoolSize" value="${connection_pools.initial_pool_size}" />
         <property name="minPoolSize" value="${connection_pools.min_pool_size}" />
         <property name="maxPoolSize" value="${connection_pools.max_pool_size}" />
         <property name="maxIdleTime" value="${connection_pools.max_idle_time}" />
         <property name="acquireIncrement" value="${connection_pools.acquire_increment}" />
         <property name="checkoutTimeout" value="${connection_pools.checkout_timeout}" />
     </bean>

     <bean id="entityManagerFactory"
         class="org.springframework.orm.jpa.LocalContainerEntityManagerFactoryBean">
         <property name="dataSource" ref="dataSource" />
         <property name="packagesToScan" value="com.genius.han.entity" />
         <property name="persistenceProvider">
             <bean class="org.hibernate.jpa.HibernatePersistenceProvider" />
         </property>
         <property name="jpaVendorAdapter">
             <bean class="org.springframework.orm.jpa.vendor.HibernateJpaVendorAdapter">
                 <property name="generateDdl" value="false" />
             </bean>
         </property>
         <property name="jpaProperties">
             <props>
                 <prop key="hibernate.dialect">${hibernate.dialect}</prop>
                 <prop key="hibernate.ejb.naming_strategy">org.hibernate.cfg.ImprovedNamingStrategy</prop>
                 <prop key="hibernate.cache.use_second_level_cache">${hibernate.cache.use_second_level_cache}</prop>
                 <prop key="hibernate.cache.region.factory_class">${hibernate.cache.region.factory_class}</prop>
                 <prop key="hibernate.cache.use_query_cache">${hibernate.cache.use_query_cache}</prop>
                 <prop key="hibernate.jdbc.fetch_size">${hibernate.jdbc.fetch_size}</prop>
                 <prop key="hibernate.jdbc.batch_size">${hibernate.jdbc.batch_size}</prop>
                 <prop key="hibernate.hbm2ddl.auto">update</prop>
                 <prop key="hibernate.show_sql">true</prop>
                 <prop key="hibernate.format_sql">false</prop>
                 <prop key="hibernate.use_sql_comments">false</prop>
                 <prop key="hibernate.connection.isolation">2</prop>
                 <prop key="javax.persistence.validation.mode">none</prop>
             </props>
         </property>
     </bean>

     <bean id="transactionManager" class="org.springframework.orm.jpa.JpaTransactionManager">
         <property name="entityManagerFactory" ref="entityManagerFactory" />
     </bean>

   <!-- 配置 Annotation 驱动，定义事务 -->
     <tx:annotation-driven transaction-manager="transactionManager"
         proxy-target-class="false" />

 </beans>

jdbc.properties

 jdbc.driver=com.mysql.jdbc.Driver
 jdbc.url=jdbc:mysql://localhost:3306/han?useUnicode=true&characterEncoding=UTF-8
 jdbc.username=xxxx jdbc.password=xxxx

 #------------ ConnectionPools ------------
 connection_pools.initial_pool_size=5
 connection_pools.min_pool_size=5
 connection_pools.max_pool_size=100
 connection_pools.max_idle_time=600
 connection_pools.acquire_increment=5
 connection_pools.checkout_timeout=60000

 hibernate.dialect=org.hibernate.dialect.MySQLDialect
 hibernate.current_session_context_class=thread
 hibernate.hbm2ddl.auto=update
 hibernate.show_sql=true
 hibernate.format_sql=false
 hibernate.query.substitutions=Y

 hibernate.cache.use_second_level_cache=false
 hibernate.cache.region.factory_class=org.hibernate.cache.impl.NoCachingRegionFactory
 hibernate.cache.use_query_cache=false
 hibernate.jdbc.fetch_size=50
 hibernate.jdbc.batch_size=30

2. BaseDao

 import java.io.Serializable;

 import javax.persistence.LockModeType;
 import javax.persistence.Query;

 public interface BaseDao<T,ID extends Serializable> extends Serializable{

     /**
      * 查找实体对象
      *
      * @param id
      *            ID
      * @return 实体对象，若不存在则返回null
      */
     T find(ID id);
     /**
      * 查找实体对象
      *
      * @param id
      *            ID
      * @param lockModeType
      *            锁定方式
      * @return 实体对象，若不存在则返回null
      */
     T find(ID id, LockModeType lockModeType);

     /**
      * 持久化实体对象
      *
      * @param entity
      *            实体对象
      */
     void persist(T entity);

     /**
      * 合并实体对象
      *
      * @param entity
      *            实体对象
      * @return 实体对象
      */
     T merge(T entity);

     /**
      * 移除实体对象
      *
      * @param entity
      *            实体对象
      */
     void remove(T entity);

     /**
      * 执行JPA原生sql查询
      *
      * @param sql
      * */
     public Query createNativeQuery(String sql);

     /**
      * 刷新实体对象
      *
      * @param entity
      *            实体对象
      */
     void refresh(T entity);

     /**
      * 刷新实体对象
      *
      * @param entity
      *            实体对象
      * @param lockModeType
      *            锁定方式
      */
     void refresh(T entity, LockModeType lockModeType);

     /**
      * 获取实体对象ID
      *
      * @param entity
      *            实体对象
      * @return 实体对象ID
      */
     ID getIdentifier(T entity);

     /**
      * 判断是否为托管状态
      *
      * @param entity
      *            实体对象
      * @return 是否为托管状态
      */
     boolean isManaged(T entity);

     /**
      * 设置为游离状态
      *
      * @param entity
      *            实体对象
      */
     void detach(T entity);

     /**
      * 锁定实体对象
      *
      * @param entity
      *            实体对象
      * @param lockModeType
      *            锁定方式
      */
     void lock(T entity, LockModeType lockModeType);

     /**
      * 清除缓存
      */
     void clear();

     /**
      * 同步数据
      */
     void flush();
 }

3. BaseDaoImpl

 package com.genius.han.dao.impl;

 import java.io.Serializable;
 import java.lang.reflect.ParameterizedType;
 import java.lang.reflect.Type;

 import javax.persistence.EntityManager;
 import javax.persistence.LockModeType;
 import javax.persistence.PersistenceContext;
 import javax.persistence.Query;
 import javax.transaction.Transactional;

 import org.springframework.util.Assert;
 import org.springframework.util.StringUtils;

 import com.genius.han.dao.BaseDao;

 @Transactional
 public class BaseDaoImpl<T, ID extends Serializable> implements BaseDao<T, ID> {

     private static final long serialVersionUID = 1L;

     private Class<T> entityClass;

     @PersistenceContext
     protected EntityManager entityManager;

     @SuppressWarnings("unchecked")
     public BaseDaoImpl()
     {
         Type type = getClass().getGenericSuperclass();
         Type[] parameterizedType = ((ParameterizedType) type).getActualTypeArguments();
         entityClass = (Class<T>) parameterizedType[0];
     }

     @Override
     public T find(ID id)
     {
         if (id != null)
         {
             return entityManager.find(entityClass, id);
         }
         return null;
     }

     @Override
     public T find(ID id, LockModeType lockModeType)
     {
         if (id != null)
         {
             if (lockModeType != null)
             {
                 return entityManager.find(entityClass, id, lockModeType);
             }
             else
             {
                 return entityManager.find(entityClass, id);
             }
         }
         return null;
     }

     @Override
     public void persist(T entity)
     {
         Assert.notNull(entity);
         entityManager.persist(entity);

     }

     @Override
     public T merge(T entity)
     {
         Assert.notNull(entity);
         return entityManager.merge(entity);
     }

     @Override
     public void remove(T entity)
     {
         Assert.notNull(entity);
         if (entity != null)
         {
             entityManager.remove(entity);
         }
     }

     @Override
     public Query createNativeQuery(String sql)
     {
         if (!StringUtils.isEmpty(sql))
         {
             return entityManager.createNativeQuery(sql);
         }
         return null;
     }

     @Override
     public void refresh(T entity)
     {
         Assert.notNull(entity);
         if (entity != null)
         {
             entityManager.refresh(entity);
         }
     }

     @Override
     public void refresh(T entity, LockModeType lockModeType)
     {
         Assert.notNull(entity);
         if (entity != null)
         {
             if (lockModeType != null)
             {
                 entityManager.refresh(entity, lockModeType);
             }
             else
             {
                 entityManager.refresh(entity);
             }
         }

     }

     @SuppressWarnings("unchecked")
     @Override
     public ID getIdentifier(T entity)
     {
         Assert.notNull(entity);
         if (entity != null)
         {
             return (ID) entityManager.getEntityManagerFactory().getPersistenceUnitUtil()
                     .getIdentifier(entity);
         }
         return null;
     }

     @Override
     public boolean isManaged(T entity)
     {
         Assert.notNull(entity);
         if (entity != null)
         {
             return entityManager.contains(entity);
         }
         return false;
     }

     @Override
     public void detach(T entity)
     {
         Assert.notNull(entity);
         if (entity != null)
         {
             entityManager.detach(entity);
         }
     }

     @Override
     public void lock(T entity, LockModeType lockModeType)
     {
         Assert.notNull(entity);
         Assert.notNull(lockModeType);
         if (entity != null && lockModeType != null)
         {
             entityManager.lock(entity, lockModeType);
         }
     }

     @Override
     public void clear()
     {
         entityManager.clear();
     }

     @Override
     public void flush()
     {
         entityManager.flush();
     }

 }

4 Common Dao

 import org.springframework.stereotype.Repository;

 @Repository
 public class EmployeeDAO extends BaseDaoImpl<EmployeeEntity, Long>  {
  public void save(EmployeeEntity entity){
      persist(entity);
  }
 }

5 BaseEntity

 package com.genius.han.entity;

 import java.io.Serializable;
 import java.util.Date;

 import javax.persistence.Column;
 import javax.persistence.GeneratedValue;
 import javax.persistence.GenerationType;
 import javax.persistence.Id;
 import javax.persistence.MappedSuperclass;
 import javax.persistence.Temporal;
 import javax.persistence.TemporalType;

 import org.hibernate.search.annotations.DateBridge;
 import org.hibernate.search.annotations.DocumentId;
 import org.hibernate.search.annotations.Field;
 import org.hibernate.search.annotations.Index;
 import org.hibernate.search.annotations.Resolution;
 import org.hibernate.search.annotations.Store;

 @MappedSuperclass
 public abstract class BaseEntity implements Serializable {

     private static final long serialVersionUID = -67188388306700736L;

     /** ID */
     private Long id;

     /** 创建日期 */
     private Date createDate = new Date();

     /** 修改日期 */
     private Date modifyDate = new Date();

     /**
      * 获取ID
      *
      * @return ID
      */

     @DocumentId
     @Id
     // MySQL/SQLServer: @GeneratedValue(strategy = GenerationType.AUTO)
     // Oracle: @GeneratedValue(strategy = GenerationType.AUTO, generator = "sequenceGenerator")
     @GeneratedValue(strategy = GenerationType.AUTO)
     public Long getId() {
         return id;
     }

     public void setId(Long id) {
         this.id = id;
     }

     @Field(store = Store.YES, index = Index.UN_TOKENIZED)
     @DateBridge(resolution = Resolution.SECOND)
     @Column(name="CREATE_DATE",nullable = false, updatable = false)
     @Temporal(TemporalType.TIMESTAMP)
     public Date getCreateDate() {
         return createDate;
     }

     public void setCreateDate(Date createDate) {
         this.createDate = createDate;
     }

     @Field(store = Store.YES, index = Index.UN_TOKENIZED)
     @DateBridge(resolution = Resolution.SECOND)
     @Column(name="MODIFY_DATE",nullable = false)
     @Temporal(TemporalType.TIMESTAMP)
     public Date getModifyDate() {
         return modifyDate;
     }

     public void setModifyDate(Date modifyDate) {
         this.modifyDate = modifyDate;
     }

     /**
      * 重写equals方法
      *
      * @param obj
      *            对象
      * @return 是否相等
      */
     @Override
     public boolean equals(Object obj) {
         if (obj == null) {
             return false;
         }
         if (this == obj) {
             return true;
         }
         if (!BaseEntity.class.isAssignableFrom(obj.getClass())) {
             return false;
         }
         BaseEntity other = (BaseEntity) obj;
         return getId() != null ? getId().equals(other.getId()) : false;
     }

     /**
      * 重写hashCode方法
      *
      * @return hashCode
      */
     @Override
     public int hashCode() {
         int hashCode = 17;
         hashCode += null == getId() ? 0 : getId().hashCode() * 31;
         return hashCode;
     }

 }

6.Common Entity

 package com.genius.han.entity;

 import javax.persistence.Entity;
 import javax.persistence.Table;

 @Entity
 @Table(name="customerInfo")
 public class CustomerInfoEntity extends BaseEntity{

     /**
      *
      */
     private static final long serialVersionUID = -7920396843754746995L;
     private String name;
     private String gender;
     private String email;
     private String mobile_num;

     public CustomerInfoEntity(String name, String gender, String email,
             String mobile_num) {
         super();
         this.name = name;
         this.gender = gender;
         this.email = email;
         this.mobile_num = mobile_num;
     }

     public String getName() {
         return name;
     }
     public void setName(String name) {
         this.name = name;
     }
     public String getGender() {
         return gender;
     }
     public void setGender(String gender) {
         this.gender = gender;
     }
     public String getEmail() {
         return email;
     }
     public void setEmail(String email) {
         this.email = email;
     }
     public String getMobile_num() {
         return mobile_num;
     }
     public void setMobile_num(String mobile_num) {
         this.mobile_num = mobile_num;
     }
 }