SPRING+JPA+Hibernate配置方法

1.applicationContext.xml

 1 <?xml version="1.0" encoding="UTF-8"?>
 2 <beans xmlns="http://www.springframework.org/schema/beans"
 3     xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
 4     xmlns:context="http://www.springframework.org/schema/context"
 5     xmlns:tx="http://www.springframework.org/schema/tx"
 6     xmlns:p="http://www.springframework.org/schema/p"
 7     xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd
 8         http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context.xsd
 9         http://www.springframework.org/schema/tx http://www.springframework.org/schema/tx/spring-tx-4.1.xsd">
10                         
11 
12 <!-- 扫描目录 -->
13     <context:component-scan base-package="com.genius"></context:component-scan>
14     <bean class="org.springframework.orm.jpa.support.PersistenceAnnotationBeanPostProcessor" />
15     <context:property-placeholder location="classpath:jdbc.properties"  ignore-unresolvable="true"/>
16 
17     <bean id="dataSource" class="com.mchange.v2.c3p0.ComboPooledDataSource"
18         destroy-method="close">
19         <property name="driverClass" value="${jdbc.driver}" />
20         <property name="jdbcUrl" value="${jdbc.url}" />
21         <property name="user" value="${jdbc.username}" />
22         <property name="password" value="${jdbc.password}" />
23         <property name="initialPoolSize" value="${connection_pools.initial_pool_size}" />
24         <property name="minPoolSize" value="${connection_pools.min_pool_size}" />
25         <property name="maxPoolSize" value="${connection_pools.max_pool_size}" />
26         <property name="maxIdleTime" value="${connection_pools.max_idle_time}" />
27         <property name="acquireIncrement" value="${connection_pools.acquire_increment}" />
28         <property name="checkoutTimeout" value="${connection_pools.checkout_timeout}" />
29     </bean>
30 
31     <bean id="entityManagerFactory"
32         class="org.springframework.orm.jpa.LocalContainerEntityManagerFactoryBean">
33         <property name="dataSource" ref="dataSource" />
34         <property name="packagesToScan" value="com.genius.han.entity" />
35         <property name="persistenceProvider">
36             <bean class="org.hibernate.jpa.HibernatePersistenceProvider" />
37         </property>
38         <property name="jpaVendorAdapter">
39             <bean class="org.springframework.orm.jpa.vendor.HibernateJpaVendorAdapter">
40                 <property name="generateDdl" value="false" />
41             </bean>
42         </property>
43         <property name="jpaProperties">
44             <props>
45                 <prop key="hibernate.dialect">${hibernate.dialect}</prop>
46                 <prop key="hibernate.ejb.naming_strategy">org.hibernate.cfg.ImprovedNamingStrategy</prop>
47                 <prop key="hibernate.cache.use_second_level_cache">${hibernate.cache.use_second_level_cache}</prop>
48                 <prop key="hibernate.cache.region.factory_class">${hibernate.cache.region.factory_class}</prop>
49                 <prop key="hibernate.cache.use_query_cache">${hibernate.cache.use_query_cache}</prop>
50                 <prop key="hibernate.jdbc.fetch_size">${hibernate.jdbc.fetch_size}</prop>
51                 <prop key="hibernate.jdbc.batch_size">${hibernate.jdbc.batch_size}</prop>
52                 <prop key="hibernate.hbm2ddl.auto">update</prop>
53                 <prop key="hibernate.show_sql">true</prop>
54                 <prop key="hibernate.format_sql">false</prop>
55                 <prop key="hibernate.use_sql_comments">false</prop>
56                 <prop key="hibernate.connection.isolation">2</prop>
57                 <prop key="javax.persistence.validation.mode">none</prop>
58             </props>
59         </property>
60     </bean>
61 
62    
63     <bean id="transactionManager" class="org.springframework.orm.jpa.JpaTransactionManager">
64         <property name="entityManagerFactory" ref="entityManagerFactory" />
65     </bean>
66    
67   
68   <!-- 配置 Annotation 驱动，定义事务 -->
69     <tx:annotation-driven transaction-manager="transactionManager"
70         proxy-target-class="false" />
71 
72 </beans>

jdbc.properties

 1 jdbc.driver=com.mysql.jdbc.Driver
 2 jdbc.url=jdbc:mysql://localhost:3306/han?useUnicode=true&characterEncoding=UTF-8
 3 jdbc.username=xxxx 4 jdbc.password=xxxx
 5 
 6 
 7 #------------ ConnectionPools ------------
 8 connection_pools.initial_pool_size=5
 9 connection_pools.min_pool_size=5
10 connection_pools.max_pool_size=100
11 connection_pools.max_idle_time=600
12 connection_pools.acquire_increment=5
13 connection_pools.checkout_timeout=60000
14 
15 
16 hibernate.dialect=org.hibernate.dialect.MySQLDialect
17 hibernate.current_session_context_class=thread
18 hibernate.hbm2ddl.auto=update
19 hibernate.show_sql=true
20 hibernate.format_sql=false
21 hibernate.query.substitutions=Y
22 
23 hibernate.cache.use_second_level_cache=false
24 hibernate.cache.region.factory_class=org.hibernate.cache.impl.NoCachingRegionFactory
25 hibernate.cache.use_query_cache=false
26 hibernate.jdbc.fetch_size=50
27 hibernate.jdbc.batch_size=30

2. BaseDao

  1 import java.io.Serializable;
  2 
  3 import javax.persistence.LockModeType;
  4 import javax.persistence.Query;
  5 
  6 public interface BaseDao<T,ID extends Serializable> extends Serializable{
  7     
  8     /**
  9      * 查找实体对象
 10      * 
 11      * @param id
 12      *            ID
 13      * @return 实体对象，若不存在则返回null
 14      */
 15     T find(ID id);
 16     /**
 17      * 查找实体对象
 18      * 
 19      * @param id
 20      *            ID
 21      * @param lockModeType
 22      *            锁定方式
 23      * @return 实体对象，若不存在则返回null
 24      */
 25     T find(ID id, LockModeType lockModeType);
 26 
 27     /**
 28      * 持久化实体对象
 29      * 
 30      * @param entity
 31      *            实体对象
 32      */
 33     void persist(T entity);
 34 
 35     /**
 36      * 合并实体对象
 37      * 
 38      * @param entity
 39      *            实体对象
 40      * @return 实体对象
 41      */
 42     T merge(T entity);
 43 
 44     /**
 45      * 移除实体对象
 46      * 
 47      * @param entity
 48      *            实体对象
 49      */
 50     void remove(T entity);
 51     
 52     
 53     /**
 54      * 执行JPA原生sql查询
 55      * 
 56      * @param sql
 57      * */
 58     public Query createNativeQuery(String sql);
 59     
 60 
 61     /**
 62      * 刷新实体对象
 63      * 
 64      * @param entity
 65      *            实体对象
 66      */
 67     void refresh(T entity);
 68 
 69     /**
 70      * 刷新实体对象
 71      * 
 72      * @param entity
 73      *            实体对象
 74      * @param lockModeType
 75      *            锁定方式
 76      */
 77     void refresh(T entity, LockModeType lockModeType);
 78 
 79     /**
 80      * 获取实体对象ID
 81      * 
 82      * @param entity
 83      *            实体对象
 84      * @return 实体对象ID
 85      */
 86     ID getIdentifier(T entity);
 87 
 88     /**
 89      * 判断是否为托管状态
 90      * 
 91      * @param entity
 92      *            实体对象
 93      * @return 是否为托管状态
 94      */
 95     boolean isManaged(T entity);
 96 
 97     /**
 98      * 设置为游离状态
 99      * 
100      * @param entity
101      *            实体对象
102      */
103     void detach(T entity);
104 
105     /**
106      * 锁定实体对象
107      * 
108      * @param entity
109      *            实体对象
110      * @param lockModeType
111      *            锁定方式
112      */
113     void lock(T entity, LockModeType lockModeType);
114 
115     /**
116      * 清除缓存
117      */
118     void clear();
119 
120     /**
121      * 同步数据
122      */
123     void flush();
124 }

3. BaseDaoImpl

  1 package com.genius.han.dao.impl;
  2 
  3 import java.io.Serializable;
  4 import java.lang.reflect.ParameterizedType;
  5 import java.lang.reflect.Type;
  6 
  7 import javax.persistence.EntityManager;
  8 import javax.persistence.LockModeType;
  9 import javax.persistence.PersistenceContext;
 10 import javax.persistence.Query;
 11 import javax.transaction.Transactional;
 12 
 13 import org.springframework.util.Assert;
 14 import org.springframework.util.StringUtils;
 15 
 16 import com.genius.han.dao.BaseDao;
 17 
 18 @Transactional
 19 public class BaseDaoImpl<T, ID extends Serializable> implements BaseDao<T, ID> {
 20     
 21     private static final long serialVersionUID = 1L;
 22 
 23     
 24     private Class<T> entityClass;
 25 
 26     @PersistenceContext
 27     protected EntityManager entityManager;
 28 
 29 
 30     @SuppressWarnings("unchecked")
 31     public BaseDaoImpl()
 32     {
 33         Type type = getClass().getGenericSuperclass();
 34         Type[] parameterizedType = ((ParameterizedType) type).getActualTypeArguments();
 35         entityClass = (Class<T>) parameterizedType[0];
 36     }
 37 
 38     @Override
 39     public T find(ID id)
 40     {
 41         if (id != null)
 42         {
 43             return entityManager.find(entityClass, id);
 44         }
 45         return null;
 46     }
 47 
 48     @Override
 49     public T find(ID id, LockModeType lockModeType)
 50     {
 51         if (id != null)
 52         {
 53             if (lockModeType != null)
 54             {
 55                 return entityManager.find(entityClass, id, lockModeType);
 56             }
 57             else
 58             {
 59                 return entityManager.find(entityClass, id);
 60             }
 61         }
 62         return null;
 63     }
 64 
 65     @Override
 66     public void persist(T entity)
 67     {
 68         Assert.notNull(entity);
 69         entityManager.persist(entity);
 70 
 71     }
 72 
 73     @Override
 74     public T merge(T entity)
 75     {
 76         Assert.notNull(entity);
 77         return entityManager.merge(entity);
 78     }
 79 
 80     @Override
 81     public void remove(T entity)
 82     {
 83         Assert.notNull(entity);
 84         if (entity != null)
 85         {
 86             entityManager.remove(entity);
 87         }
 88     }
 89 
 90     @Override
 91     public Query createNativeQuery(String sql)
 92     {
 93         if (!StringUtils.isEmpty(sql))
 94         {
 95             return entityManager.createNativeQuery(sql);
 96         }
 97         return null;
 98     }
 99 
100     @Override
101     public void refresh(T entity)
102     {
103         Assert.notNull(entity);
104         if (entity != null)
105         {
106             entityManager.refresh(entity);
107         }
108     }
109 
110     @Override
111     public void refresh(T entity, LockModeType lockModeType)
112     {
113         Assert.notNull(entity);
114         if (entity != null)
115         {
116             if (lockModeType != null)
117             {
118                 entityManager.refresh(entity, lockModeType);
119             }
120             else
121             {
122                 entityManager.refresh(entity);
123             }
124         }
125 
126     }
127 
128     @SuppressWarnings("unchecked")
129     @Override
130     public ID getIdentifier(T entity)
131     {
132         Assert.notNull(entity);
133         if (entity != null)
134         {
135             return (ID) entityManager.getEntityManagerFactory().getPersistenceUnitUtil()
136                     .getIdentifier(entity);
137         }
138         return null;
139     }
140 
141     @Override
142     public boolean isManaged(T entity)
143     {
144         Assert.notNull(entity);
145         if (entity != null)
146         {
147             return entityManager.contains(entity);
148         }
149         return false;
150     }
151 
152     @Override
153     public void detach(T entity)
154     {
155         Assert.notNull(entity);
156         if (entity != null)
157         {
158             entityManager.detach(entity);
159         }
160     }
161 
162     @Override
163     public void lock(T entity, LockModeType lockModeType)
164     {
165         Assert.notNull(entity);
166         Assert.notNull(lockModeType);
167         if (entity != null && lockModeType != null)
168         {
169             entityManager.lock(entity, lockModeType);
170         }
171     }
172 
173     @Override
174     public void clear()
175     {
176         entityManager.clear();
177     }
178 
179     @Override
180     public void flush()
181     {
182         entityManager.flush();
183     }
184 
185     
186 }

4 Common Dao

1 import org.springframework.stereotype.Repository;
2 
3 
4 @Repository
5 public class EmployeeDAO extends BaseDaoImpl<EmployeeEntity, Long>  {
6  public void save(EmployeeEntity entity){
7      persist(entity);
8  }
9 }

5 BaseEntity

  1 package com.genius.han.entity;
  2 
  3 
  4 import java.io.Serializable;
  5 import java.util.Date;
  6 
  7 import javax.persistence.Column;
  8 import javax.persistence.GeneratedValue;
  9 import javax.persistence.GenerationType;
 10 import javax.persistence.Id;
 11 import javax.persistence.MappedSuperclass;
 12 import javax.persistence.Temporal;
 13 import javax.persistence.TemporalType;
 14 
 15 
 16 
 17 
 18 
 19 import org.hibernate.search.annotations.DateBridge;
 20 import org.hibernate.search.annotations.DocumentId;
 21 import org.hibernate.search.annotations.Field;
 22 import org.hibernate.search.annotations.Index;
 23 import org.hibernate.search.annotations.Resolution;
 24 import org.hibernate.search.annotations.Store;
 25 
 26 
 27 
 28 
 29 @MappedSuperclass
 30 public abstract class BaseEntity implements Serializable {
 31 
 32     private static final long serialVersionUID = -67188388306700736L;
 33 
 34     
 35 
 36     /** ID */
 37     private Long id;
 38 
 39     /** 创建日期 */
 40     private Date createDate = new Date();
 41 
 42     /** 修改日期 */
 43     private Date modifyDate = new Date();
 44 
 45     /**
 46      * 获取ID
 47      * 
 48      * @return ID
 49      */
 50     
 51     @DocumentId
 52     @Id
 53     // MySQL/SQLServer: @GeneratedValue(strategy = GenerationType.AUTO)
 54     // Oracle: @GeneratedValue(strategy = GenerationType.AUTO, generator = "sequenceGenerator")
 55     @GeneratedValue(strategy = GenerationType.AUTO)
 56     public Long getId() {
 57         return id;
 58     }
 59 
 60     public void setId(Long id) {
 61         this.id = id;
 62     }
 63 
 64     
 65     
 66     
 67     @Field(store = Store.YES, index = Index.UN_TOKENIZED)
 68     @DateBridge(resolution = Resolution.SECOND)
 69     @Column(name="CREATE_DATE",nullable = false, updatable = false)
 70     @Temporal(TemporalType.TIMESTAMP)
 71     public Date getCreateDate() {
 72         return createDate;
 73     }
 74 
 75     
 76     public void setCreateDate(Date createDate) {
 77         this.createDate = createDate;
 78     }
 79 
 80     
 81     
 82     
 83     
 84     @Field(store = Store.YES, index = Index.UN_TOKENIZED)
 85     @DateBridge(resolution = Resolution.SECOND)
 86     @Column(name="MODIFY_DATE",nullable = false)
 87     @Temporal(TemporalType.TIMESTAMP)
 88     public Date getModifyDate() {
 89         return modifyDate;
 90     }
 91 
 92     public void setModifyDate(Date modifyDate) {
 93         this.modifyDate = modifyDate;
 94     }
 95 
 96     
 97     
 98     /**
 99      * 重写equals方法
100      * 
101      * @param obj
102      *            对象
103      * @return 是否相等
104      */
105     @Override
106     public boolean equals(Object obj) {
107         if (obj == null) {
108             return false;
109         }
110         if (this == obj) {
111             return true;
112         }
113         if (!BaseEntity.class.isAssignableFrom(obj.getClass())) {
114             return false;
115         }
116         BaseEntity other = (BaseEntity) obj;
117         return getId() != null ? getId().equals(other.getId()) : false;
118     }
119 
120     /**
121      * 重写hashCode方法
122      * 
123      * @return hashCode
124      */
125     @Override
126     public int hashCode() {
127         int hashCode = 17;
128         hashCode += null == getId() ? 0 : getId().hashCode() * 31;
129         return hashCode;
130     }
131 
132 }

6.Common Entity

 1 package com.genius.han.entity;
 2 
 3 import javax.persistence.Entity;
 4 import javax.persistence.Table;
 5 
 6 @Entity
 7 @Table(name="customerInfo")
 8 public class CustomerInfoEntity extends BaseEntity{
 9 
10     /**
11      * 
12      */
13     private static final long serialVersionUID = -7920396843754746995L;
14     private String name;
15     private String gender;
16     private String email;
17     private String mobile_num;
18     
19     public CustomerInfoEntity(String name, String gender, String email,
20             String mobile_num) {
21         super();
22         this.name = name;
23         this.gender = gender;
24         this.email = email;
25         this.mobile_num = mobile_num;
26     }
27     
28     public String getName() {
29         return name;
30     }
31     public void setName(String name) {
32         this.name = name;
33     }
34     public String getGender() {
35         return gender;
36     }
37     public void setGender(String gender) {
38         this.gender = gender;
39     }
40     public String getEmail() {
41         return email;
42     }
43     public void setEmail(String email) {
44         this.email = email;
45     }
46     public String getMobile_num() {
47         return mobile_num;
48     }
49     public void setMobile_num(String mobile_num) {
50         this.mobile_num = mobile_num;
51     }
52 }