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;

     }

 }

巴特西

SPRING+JPA+Hibernate配置方法

最新文章

热门文章