实践hibernate加spring的整合

     写此文的目的：以后在hibernate和spring 整合的时候就不用再走弯路了；

    

     我这里没用到Struts所以spring的加载就由TOMCAT来完成；

   

      web.xml配置如下：

1. <listener> 
2.     <listener-class> 
3.        org.springframework.web.context.ContextLoaderListener 
4.     </listener-class> 
5.          </listener> 
6. <context-param> 
7.     <param-name>contextConfigLocation</param-name> 
8.  <!-- 多个配置文件用逗号隔开 -->
9.     <param-value>/WEB-INF/springDB.xml,/WEB-INF/FacadeContext.xml</param-value> 
10.     </context-param>    

       在程序中获取该spring容器的方式：

         

2.  //获取ServletContext 对象引用，这里的this对象是一个servlet实例。
3.  ServletContext sc = this.getServletContext();
4.  ac = WebApplicationContextUtils.getRequiredWebApplicationContext(sc);

      springDB.xml配置文件文件，难点在于事务代理机制的理解，如文件中配置的beanNames属性为 *Dao，意思是在所有以Dao结尾的bean中的find*,delete*,。。。。自动进行代理，对事物进行管理，当你从容器中将该bean取出来时，要用该Dao实现的接口来进行类型转换(jdk动态代理的理解),

 

1. <?xml version="1.0" encoding="UTF-8"?>
2. <!DOCTYPE beans PUBLIC "-//SPRING//DTD BEAN//EN" "http://www.springframework.org/dtd/spring-beans.dtd">
3. <beans default-autowire="no" default-dependency-check="none" default-lazy-init="false">
5.     <!-- ========================= Start of PERSISTENCE DEFINITIONS ========================= -->
7.     <!-- Hibernate SessionFactory Definition-->
8.    <bean id="placeholderConfig" class="org.springframework.beans.factory.config.PropertyPlaceholderConfigurer">
9.         <!-- localhost 默认的配置-->
10.             <property name="location">
11.             <value>/hibernates.properties</value>
12.         </property>
13.     </bean>
14. <!-- 需要引入proxool-0.9.0RC3.jar  ehcache-1.2.jar(与二级缓存相关)-->
15.    <bean id="dataSource" class="org.logicalcobwebs.proxool.ProxoolDataSource">   
16.             <property name="driver">
17.                 <value>${jdbc.driver}</value>
18.             </property>
19.             <property name="driverUrl">
20.                <value>${jdbc.url}</value>
21.             </property>
22.           
23.             <property name="user">
24.                <value>${jdbc.username}</value>
25.             </property>
26.         
27.             <property name="password">
28.                <value>${jdbc.password}</value>
29.             </property> 
30.             <property name="alias">
31.                <value>${jdbc.alias}</value>
32.               </property>   
33.             <property name="houseKeepingSleepTime">
34.                <value>${jdbc.houseKeepingSleepTime}</value>
35.             </property>
36.             <property name="prototypeCount">
37.                <value>${jdbc.prototypeCount}</value>
38.             </property>
39.             <property name="maximumConnectionCount">
40.                <value>${jdbc.maximumConnectionCount}</value>
41.             </property>
42.             <property name="minimumConnectionCount">
43.                <value>${jdbc.minimumConnectionCount}</value>
44.             </property>
45.             <property name="maximumConnectionLifetime">
46.                <value>${proxool.maximumConnectionLifetime}</value>
47.             </property>
48.             <property name="maximumActiveTime">
49.                <value>${proxool.maximumActiveTime}</value>
50.             </property>
51.         
52.             <property name="trace">
53.                <value>${jdbc.trace}</value>
54.             </property>
55.             <property name="verbose">
56.                <value>${jdbc.verbose}</value>
57.             </property>  
58.             <property name="houseKeepingTestSql">
59.                  <value>${proxool.houseKeepingTestSql}</value> 
60.              </property>
61.              <property name="statistics">
62.                  <value>${proxool.statistics}</value> 
63.              </property>
64.              <property name="statisticsLogLevel">
65.                  <value>${proxool.statisticsLogLevel}</value> 
66.              </property>
67.        
68.             </bean>    
69.             
70.      <!-- 第二中配置方式，单独的类似dbcp的使用 ，配置结束-->   
72.     <!-- Hibernate SessionFactory Definition：定义Hibernate的SessionFactory -->
73.     <!-- use spring sessionFactory of configurtion -->
74.     <!-- 定义了Hibernate的会话工厂，会话工厂类用Spring提供的LocalSessionFactoryBean维护，它注入了数据源dataSource和资源映射文件com/cfc/bo，此外还通过一些键值对设置了Hibernate所需的属性 -->
75.     <bean id="sessionFactory"
76.         class="org.springframework.orm.hibernate3.LocalSessionFactoryBean">
77.         
78.         <property name="dataSource">
79.             <ref local="dataSource" />
80.         </property>
81.         <property name="mappingDirectoryLocations">
82.             <!-- 在此可以匹配*.hbm.xml映射文件 -->
83.             <list>
84.                 <value>classpath:/com/cfc/web/pojo</value>
85.             </list>
86.         </property>
87.          <!-- 定义Hibernate的SessionFactory属性 -->
88.         <property name="hibernateProperties">
89.             <props>
90.                 <prop key="hibernate.dialect">
91.                     ${hibernate.dialect}
92.                 </prop>
93.                 <prop key="hibernate.show_sql">
94.                     ${hibernate.show_sql}
95.                 </prop>
96.                 <prop key="hibernate.format_sql">
97.                     ${hibernate.format_sql}
98.                 </prop>
99.                 <prop key="hibernate.jdbc.fetch_size">
100.                     ${hibernate.jdbc.fetch_size}
101.                 </prop>
102.                 <prop key="hibernate.jdbc.batch_size">  
103.                     ${hibernate.jdbc.batch_size}
104.                 </prop>
105.             
106.                 <!-- second cache -->
107.                 <!--  使用ehcache，适合项目用 
108.                 <prop key="hibernate.cache.use_query_cache">
109.                     ${hibernate.cache.use_query_cache}
110.                 </prop>
111.                 <prop key="hibernate.cache.use_second_level_cache">
112.                     ${hibernate.cache.use_second_level_cache}
113.                 </prop>
114.                 <prop key="hibernate.cache.provider_class">
115.                     ${hibernate.cache.provider_class}
116.                 </prop> 
117.                 -->
118.                 <!--   
119. 此处要注意因为proxool自己释放数据库连接比慢,所以要在此给出释放连接的模式,具体几种模式对应的意思,可以Google一下hibernate.connection.release_mode,有很多说明,在此不多说  
120.                --> 
121.                
122.                 <prop key="hibernate.connectionReleaseMode">  
123.                     ${hibernate.connectionReleaseMode}   
124.                 </prop>  
125.                 <prop key="simultaneous-build-throttle">
126.                    ${simultaneous-build-throttle}
127.                  </prop>
128.                  <prop key="jdbc.maximumnewConnections">
129.                     ${jdbc.maximumnewConnections}
130.                  </prop>
131.                  <prop key="hibernate.connection.provider_class">org.hibernate.connection.ProxoolConnectionProvider</prop>
132.                  <prop key="hibernate.proxool.existing_pool">false</prop>
133.                  <prop key="hibernate.cglib.use_reflection_optimizer">true</prop>
134.                  
135.                  
136.             </props>
137.         </property>
138.     </bean>
140.     
141.     <!-- Hibernate Transaction Manager Definition :配置Hibernate的事务管理器-->     
142.     <bean id="transactionManager"
143.         class="org.springframework.orm.hibernate3.HibernateTransactionManager">
144.         <!-- HibernateTransactionManager Bean，它需要依赖注入一个SessionFactory
145.         Bean的引用 -->
146.         <property name="sessionFactory">
147.             <ref bean="sessionFactory" />
148.         </property>
149.     </bean>
152.     <!-- jdbcTemplate  -->
153.     <!-- 这个基础类来实战连接Mysql数据库.JdbcTemplate的使用需要有一个DataSource的支持,所以在配置文件中,
154.          我们首先要配置一个Spring的DriverManagerDataSource,然后将这个DataSource配置到JdbcTemplate里.
155.          接着将JdbcTemplate配置到DAO层.最后将DAO配置到Model层 -->
156.     <bean id="jdbcTemplate" class="org.springframework.jdbc.core.JdbcTemplate">   
157.         <property name="dataSource">
158.         <ref bean="dataSource" />
159.         </property> 
160.         </bean>   
162.     <!-- Hibernate Template Defintion -->
163.     <bean id="hibernateTemplate"
164.         class="org.springframework.orm.hibernate3.HibernateTemplate">
165.         <property name="sessionFactory">
166.             <ref bean="sessionFactory" />
167.         </property>
168.         <property name="jdbcExceptionTranslator">
169.             <ref bean="jdbcExceptionTranslator" />
170.         </property>
171.     </bean>
173.     <!-- Spring Data Access Exception Translator Defintion -->
175.     <bean id="jdbcExceptionTranslator"
176.         class="org.springframework.jdbc.support.SQLErrorCodeSQLExceptionTranslator">
177.         <property name="dataSource">
178.             <ref bean="dataSource" />
179.         </property>
180.     </bean>
182.     <!-- define transaction interceptor -->
184.     <bean id="txInterceptor"
185.         class="org.springframework.transaction.interceptor.TransactionInterceptor">
186.         <property name="transactionManager">
187.             <ref bean="transactionManager" />
188.         </property>
189.         <property name="transactionAttributeSource">
190.             <ref bean="txAttributes" />
191.         </property>
192.     </bean>
195.     <bean id="autoProxyCreator"
196.         class="org.springframework.aop.framework.autoproxy.BeanNameAutoProxyCreator">
197.         <property name="interceptorNames">
198.             <value>txInterceptor</value>
199.         </property>
200.         <!--这里通过配置文件，引用bean有数据库的操作。也可以直接在这个文件中配置。本项目中是分开配置，即FacadeContext.xml文件 -->
201.         <property name="beanNames">
202.             <value>*Dao,*Service</value>
203.         </property>
204.     </bean>
206.     <bean id="txAttributes"
207.         class="org.springframework.transaction.interceptor.NameMatchTransactionAttributeSource">
208.         <property name="properties">
209.             <value>
210.                 find*=PROPAGATION_REQUIRED,readOnly
211.                 get*=PROPAGATION_REQUIRED,readOnly
212.                 save*=PROPAGATION_REQUIRED
213.                 add*=PROPAGATION_REQUIRED
214.                 insert*=PROPAGATION_REQUIRED
215.                 update*=PROPAGATION_REQUIRED
216.                 delete*=PROPAGATION_REQUIRED 
217.                 create*=PROPAGATION_REQUIRED
218.                 batch*=PROPAGATION_REQUIRED
219.                 generate*=PROPAGATION_REQUIRED
220.             </value>
221.         </property>
222.     </bean>
224. </beans>

hibernate.proterty文件代码

1. #database driver
2. jdbc.driver=com.mysql.jdbc.Driver
3. #url:这里一定要这样写，否则报错：Access denied for user 'root'@'localhost' (using password: NO)
4. #jdbcjdbc.url=jdbc:mysql://192.168.1.54:3306/tdscdmanew?useUnicode=truecharacterEncoding=UTF-8user=rootpassword=root
5. jdbcjdbc.url=jdbc:mysql://192.168.1.252:3306/tscdmaweb?useUnicode=truecharacterEncoding=UTF-8user=rootpassword=root
6. #jdbcjdbc.url=jdbc:mysql://192.168.1.252:3306/tdscdmanew?useUnicode=truecharacterEncoding=UTF-8user=rootpassword=root
7. #login database info
8. #如果用proxool配置，这两个属性不用，但是必须这样写，这是个BUG
9. jdbc.username=root  
10. jdbc.password=root
12. #hibernate properties
13. hibernate.dialect=org.hibernate.dialect.MySQLDialect
14. #Batch Size is set to the database to delete bulk, bulk and bulk insert update when the batch size
15. hibernate.jdbc.batch_size=25
16. #Fetch Size is set to read Statement of JDBC data from the database each time out of the number of records
17. hibernate.jdbc.fetch_size=50
18. hibernate.show_sql=true
19. hibernate.format_sql=true
21. #second level cache open configuration
22. #hibernate.cache.use_query_cache=true
23. #hibernate.cache.use_second_level_cache=true
24. #hibernate.cache.provider_class=org.hibernate.cache.EhCacheProvider
26. #pool configuration
27. #pool alias
28. jdbc.alias=dbcptmclnew
29. #proxool自动侦察各个连接状态的时间间隔(毫秒),侦察到空闲的连接就马上回收,超时的销毁
30. jdbc.houseKeepingSleepTime=90000
31. # 指因未有空闲连接可以分配而在队列中等候的最大请求数,超过这个请求数的用户连接就不会被接受 proxool.maximumnewconnections=20
32. jdbc.maximumnewConnections=5
33. #最少保持的空闲连接数（默认2个）.一次产生连接的数量。 但不能超过最大连接数
34. jdbc.prototypeCount=3
35. #允许最大连接数,超过了这个连接，再有请求时，就排在队列中等候，最大的等待请求数由maximum-new-connections决定 （默认5个）
36. #如果超过最大连接数量则会抛出异常。连接数设置过多，服务器CPU和内存性能消耗很大。
38. jdbc.maximumConnectionCount=100
39. #最小连接数 （默认2个）.建议设置0以上，保证第一次连接时间
40. jdbc.minimumConnectionCount=5
41. #最大活动时间(超过此时间线程将被kill,默认为5分钟,10)
42. proxool.maximumActiveTime = 60000000
43. #连接最长时间(默认为8小时:28000s),一个线程的最大寿命
44. proxool.maximumConnectionLifetime=18000000
45. #
46. #hibernate.bytecode.use_reflection_optimizer=true
47. #允许被缓存的JDBC连接开启
48. #因为proxool自己释放数据库连接比慢,所以要在此给出释放连接的模式.AFTER_STATEMENT (也被称做积极释放) - 在每一条语句被执行后就释放连接。但假若语句留下了与session相关的资源，那就不会被释放
49. #hibernate.connectionReleaseMode=after_statement
50. hibernate.connectionReleaseMode=auto
51. #
52. simultaneous-build-throttle=10
53. #trace为true，记录数据库每一步操作
54. jdbc.trace=true
55. #verbose:If this is true then we start logging a lot of stuff everytime we serve a connection and everytime the house keeper and prototyper run. Be prepared for a lot of debug!  
56. #记录执行的详细信息
57. jdbc.verbose=true
58. #
59. proxool.houseKeepingTestSql=select CURRENT_DATE
60. #统计的时隔可以分为s(econds),、m(inutes)、h(ours)与d(ays)，就下面的设定来说，就是15秒、10分钟、1天分别作统计
61. proxool.statistics=15s,10m,1d
62. #INFO,ERROR
63. proxool.statisticsLogLevel=INFO