spring3.2+hibernate4 事务管理(支持自定义部分开发和关闭事务)

现在公司在做一个互联网应用的项目，前端是手机APP和PC，后端处理是WEB和WEBSERVICE(spring3.2.0+hibernate4.1.6.FINAL+c3p0 based maven)，由于此项目中牵扯到资金交易，故事务处理必不可少，同时手机APP与Web Service通信，最终和数据库交互，WebService服务器和数据库压力较大，此系统的设计使用Nginx实现WebService的负载均衡，数据库使用MySQL集群，数据库中间件经过甄选使用atlas。

在开发阶段，hibernate通过JDBC连接atlas，但是遇到了以下问题：

连接能成功，也可以进行正常的操作，但是hibernate请求的任何数据交互(即使只有select)，也是带有事务的处理（原因貌似是这么解释的，在service层进行query查询，可能包含多个查询语句，只有同时都查询成功了才是请求成功，否则就是失败）。但事务的处理都会放到atlas的master主机执行，导致matster压力过大，不能有效的实现读写分离。

注：atlas主机读写分离规范： 所有事务处理都在master进行，所有写操作都在master进行，非事务的只读操作才在slave进行读取，即

master	rw
slave1	ro
slave2	ro

rw: read, write

ro: read only

现在要解决的问题是实现读写分离，实现数据库的负载均衡（即在WebService的service层实现事务的开启或关闭），看到这里好多人肯定会回答，这个很简单，只要配置一下spring事务拦截器就可以了。我们也是用这种方法尝试解决问题，但未果，在如下情况下：

	<bean id="BaseDao" class="com.base.BaseDao">
		<property name="sessionFactory" >
			  <ref bean="sessionFactory" />
		</property>
	</bean>

	public Session getSession(){
    	try{
			session=sessionFactory.getCurrentSession();
		}catch (Exception e) {
			e.printStackTrace();
		}
    	
		return session;
	}

hibernate4无论如何都关不掉事务处理，换成hibernate3再试试，要么全都开启事务，要么全都关闭事务，貌似配置的transactionAttributes（<prop key="query*">PROPAGATION_NOT_SUPPORTED,readOnly</prop>）不起作用。你若不信，可以动手试试。

1.  尝试修改atlas源码

   将hibernate操作数据库的hql全部修改成createSQLQuery(sql).addEntiry(TargetClass);   其中需要进行读取的操作sql前加入 /*slave*/ ,如 

/*slave*/select * from userinfo;

 然后修改atlas源码，在rw_split函数中进行拦截和根据获取的token进行读写分发。此方法解决了问题。

2. 编写自己的spring拦截器

   方法1虽然解决了问题，但是没能从更不上解决问题，还需要修改大量的源码，方法2是自己编写事务拦截器，然后实现事务处理操作。

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:tx="http://www.springframework.org/schema/tx"
	xmlns:mvc="http://www.springframework.org/schema/mvc"
	xmlns:aop="http://www.springframework.org/schema/aop"
	xsi:schemaLocation="http://www.springframework.org/schema/beans 
           http://www.springframework.org/schema/beans/spring-beans-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/mvc 
           http://www.springframework.org/schema/mvc/spring-mvc-3.0.xsd 
           http://www.springframework.org/schema/aop 
           http://www.springframework.org/schema/aop/spring-aop-3.0.xsd">

	<bean id="ConfigBean"
		class="org.springframework.beans.factory.config.PropertyPlaceholderConfigurer">
		<property name="locations">
			<list>
				<!-- for development -->
				<value>classpath:jdbc.properties</value>
				<!-- deploy1 <value>file:/data/webconfig/ipark/jdbc.properties </value> -->
				<!-- deploy: file:/data/webconfig/ipark/jdbc.properties -->
				<!-- deploy2 <value>file:${catalina.base}/config/ipark/jdbc.properties</value> -->
			</list>
		</property>
	</bean>
<!--
 	<bean id="dataSourceHibernate"
		class="org.springframework.jdbc.datasource.DriverManagerDataSource">
		<property name="driverClassName" value="${jdbc.driverClassName}"></property>
		<property name="url" value="${jdbc.url}"></property>
		<property name="username" value="${jdbc.username}"></property>
		<property name="password" value="${jdbc.password}"></property>
	</bean>
 -->

	<bean id="dataSourceC3P0" class="com.mchange.v2.c3p0.ComboPooledDataSource"
		destroy-method="close">
		<property name="driverClass" value="${jdbc.driverClassName}" />
		<property name="jdbcUrl" value="${jdbc.url}" />
		<property name="user" value="${jdbc.username}" />
		<property name="password" value="${jdbc.password}" />
		<property name="acquireIncrement" value="1"></property>
		<property name="idleConnectionTestPeriod" value="6000"></property>
		<property name="initialPoolSize" value="10"></property>
		<property name="autoCommitOnClose" value="true"></property>
		<property name="maxIdleTime" value="10" ></property>
		<property name="minPoolSize" value="5" ></property>
		<property name="maxPoolSize" value="30" ></property>
		<property name="maxStatements" value="100" ></property>
	</bean>

	<!-- 数据源切换使用下面的配置  masterDataSource & slaveDataSource 
	<bean id="masterDataSource" parent="dataSourceC3P0">
		<property name="driverClass" value="${jdbc.driverClassName}" />
		<property name="jdbcUrl" value="${jdbc.url}" />
		<property name="user" value="${jdbc.username}" />
		<property name="password" value="${jdbc.password}" />
	</bean>

	<bean id="slaveDataSource" parent="dataSourceC3P0">
		<property name="driverClass" value="${slave.jdbc.driverClassName}" />
		<property name="jdbcUrl" value="${slave.jdbc.url}" />
		<property name="user" value="${slave.jdbc.username}" />
		<property name="password" value="${slave.jdbc.password}" />
	</bean>
  
	<bean id="dataSource" class="com.base.DynamicDataSource">
		<property name="targetDataSources">
			<map key-type="java.lang.String">
				<entry key="slave" value-ref="slaveDataSource" />
			</map>
		</property>
		<property name="defaultTargetDataSource" ref="masterDataSource" />
	</bean>
	-->

 	<bean id="hibermateInterceptor" class="com.base.HibermateInterceptor"/>  
 	
	<bean id="sessionFactory"
		class="org.springframework.orm.hibernate4.LocalSessionFactoryBean">

		<!-- connection -->
		<property name="dataSource">
			<ref local="dataSourceC3P0" />
		</property>
		
		<property name="entityInterceptor" ref="hibermateInterceptor"/>  
		  
		<!-- hibernate自身属性 -->
		<property name="hibernateProperties">
			<props>
				<prop key="hibernate.autoReconnect">false</prop>
				<prop key="hibernate.defaultAutoCommit">true</prop>
				<prop key="hibernate.connection.autocommit">true</prop>  
				<prop key="hibernate.connection.defaultAutoCommit">true</prop>
				<prop key="hibernate.show_sql">false</prop>
				<prop key="hibernate.format_sql">false</prop>
				<prop key="hibernate.dialect">org.hibernate.dialect.MySQL5Dialect</prop>
				<prop key="hibernate.cache.use_second_level_cache">false</prop>
				<!-- Disable the second-level cache -->
				<prop key="hibernate.cache.provider_class">org.hibernate.cache.internal.NoCacheProvider</prop>

				<!-- 
				<prop key="hibernate.current_session_context_class">org.springframework.orm.hibernate4.SpringSessionContext</prop> 
				<prop key="hibernate.current_session_context_class">thread</prop> 
				-->
				<!-- c3p0 -->
				<!-- 连接池hibernate配置 <prop key="hibernate.connection.provider_class">org.hibernate.connection.ProxoolConnectionProvider</prop> -->

				<!-- 需要再次配置数据源,c3p0才起作用 -->
				<prop key="hibernate.connection.provider_class">org.hibernate.service.jdbc.connections.internal.C3P0ConnectionProvider </prop> 
				<prop key="hibernate.connection.driver_class">${jdbc.driverClassName}</prop> 
				<prop key="hibernate.connection.url">${jdbc.url}</prop> 
				<prop key="hibernate.connection.username">${jdbc.username}</prop> 
				<prop key="hibernate.connection.password">${jdbc.password}</prop> <!-- -->

				<!-- <prop key="hibernate.connection.autoCommit">false</prop> <prop key="hibernate.connection.defaultAutoCommit">true</prop> -->
				<prop key="hibernate.transaction.auto_close_session">true</prop>

				<!-- 连接池中JDBC连接的最小数量。Hibernate默认为1 -->
				<prop key="hibernate.c3p0.min_size">3</prop>
				<!-- 连接池中JDBC连接的最大数量。Hibernate默认为100 -->
				<prop key="hibernate.c3p0.max_size">56</prop>
				<!-- 何时从连接池中移除一个空闲的连接（以秒为单位）时。Hibernate默认为0，永不过期 -->
				<prop key="hibernate.c3p0.timeout">600</prop>
				<!-- 被缓存的预编译语句数量。用来提高性能。Hibernate默认为0，缓存不可用 -->
				<prop key="c3p0.max_statements">255</prop>
				<!-- 一个连接被自动验证前的闲置时间（以秒为单位）。Hibernate默认为0 -->
				<prop key="hibernate.c3p0.idle_test_period">600</prop>
				<!-- 当连接池里面的连接用完的时候，C3P0一下获取的新的连接数 -->
				<prop key="hibernate.c3p0.acquire_increment">2</prop>
				<!-- 每次都验证连接是否可用 -->
				<prop key="hibernate.c3p0.validate">true</prop>

				<!--因性能消耗大请只在需要的时候使用它。如果设为true那么在每个connection提交的 时候都将校验其有效性。 建议使用idleConnectionTestPeriod或automaticTestTable 
					等方法来提升连接测试的性能。Default: false -->
				<prop key="idleConnectionTestPeriod">6000</prop>
				<prop key="automaticTestTable">c3p0Test</prop>
				<prop key="preferredTestQuery">select * from c3p0Test</prop>

			</props>
		</property>

		<!-- 映射文件 -->
		<property name="mappingDirectoryLocations">
			<list>
				<value>classpath:/com/hbm</value>
			</list>
		</property>
	</bean>
	
	<!-- 自动切换主从， 一定要配置在事务AOP之上 -->
	<!-- 
	<bean id="dataSourceAdvice" class="com.base.DataSourceAdvice" />
	<aop:config>
		<aop:advisor pointcut="execution(* com.dao..*.*(..))" advice-ref="dataSourceAdvice" />
	</aop:config> 
	-->
	
	<!-- 自定义事务拦截器 -->
	<bean id="transactionInterceptor" class="com.base.TransactionInterceptor">
		<property name="transactionManager" ref="transactionManager"></property>
		<property name="transactionAttributes">
			<props>
				<prop key="delete*">PROPAGATION_REQUIRED,-Exception</prop>
				<prop key="update*">PROPAGATION_REQUIRED,-Exception</prop>
				<prop key="add*">PROPAGATION_REQUIRED,-Exception</prop>
				<prop key="save*">PROPAGATION_REQUIRED,-Exception</prop>
				<prop key="create*">PROPAGATION_REQUIRED,-Exception</prop>
				<prop key="log*">PROPAGATION_REQUIRED,-Exception</prop>
				<prop key="login*">PROPAGATION_REQUIRED,-Exception</prop>
				<prop key="query*">PROPAGATION_NOT_SUPPORTED,readOnly</prop>
				<prop key="get*">PROPAGATION_NOT_SUPPORTED,readOnly</prop>
			</props>
		</property>
	</bean>
	<!-- 注册事务拦截器 -->
	<bean id="autoproxy"
		class="org.springframework.aop.framework.autoproxy.BeanNameAutoProxyCreator">
		<property name="beanNames">
			<list>
				<value>*Dao</value>
			</list>
		</property>
		<property name="interceptorNames">
			<list>
				<value>transactionInterceptor</value>
			</list>
		</property>
	</bean> 
		
	<!-- 事务管理配置  -->
	<bean id="transactionManager"	class="org.springframework.orm.hibernate4.HibernateTransactionManager">
		<property name="sessionFactory" ref="sessionFactory"></property>
		<property name="transactionSynchronization" value="1"></property>
	</bean>
	
	<!-- 配置事务传播特性 -->
	<!-- Spring中Propagation类的事务属性详解： PROPAGATION_REQUIRED：支持当前事务，如果当前没有事务，就新建一个事务。这是最常见的选择。 
		PROPAGATION_SUPPORTS：支持当前事务，如果当前没有事务，就以非事务方式执行。 PROPAGATION_MANDATORY：支持当前事务，如果当前没有事务，就抛出异常。 
		PROPAGATION_REQUIRES_NEW：新建事务，如果当前存在事务，把当前事务挂起。 PROPAGATION_NOT_SUPPORTED：以非事务方式执行操作，如果当前存在事务，就把当前事务挂起。 
		PROPAGATION_NEVER：以非事务方式执行，如果当前存在事务，则抛出异常。 PROPAGATION_NESTED：支持当前事务，如果当前事务存在，则执行一个嵌套事务，如果当前没有事务，就新建一个事务。 -->
	<!-- 
	<tx:advice id="TransAdvice" transaction-manager="transactionManager">
		<tx:attributes>
			<tx:method name="save*" propagation="REQUIRED" />
			<tx:method name="add*" propagation="REQUIRED" />
			<tx:method name="create*" propagation="REQUIRED" />
			<tx:method name="insert*" propagation="REQUIRED" />
			<tx:method name="update*" propagation="REQUIRED" />
			<tx:method name="merge*" propagation="REQUIRED" />
			<tx:method name="del*" propagation="REQUIRED" />
			<tx:method name="remove*" propagation="REQUIRED" />
			<tx:method name="put*" propagation="REQUIRED" />
			<tx:method name="get*" propagation="NOT_SUPPORTED" read-only="true" />
			<tx:method name="query*" propagation="NOT_SUPPORTED"  read-only="true" />
			<tx:method name="login*" propagation="NOT_SUPPORTED"  read-only="true" />
			<tx:method name="*" read-only="true" />
			<tx:method name="*" timeout="30" />
		</tx:attributes>
	</tx:advice>
	 -->
	 
	 
	<!-- 配置参与事务的类 
	<aop:config>
		<aop:pointcut id="allTransServiceMethod" expression="execution(* com.dao..*.*(..))" />
		<aop:advisor pointcut-ref="allTransServiceMethod" advice-ref="TransAdvice" />
	</aop:config>
	-->
	
	<!--=============================导入DAO bean配置文件==================================== -->
	<import resource="classpath:spring/*-spring.xml" />


</beans>

com.base.TransactionInterceptor

package com.base;

import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;

import javax.transaction.TransactionManager;

import org.aopalliance.intercept.MethodInterceptor;
import org.aopalliance.intercept.MethodInvocation;
import org.apache.log4j.Logger;
import org.springframework.transaction.PlatformTransactionManager;
import org.springframework.transaction.TransactionDefinition;
import org.springframework.transaction.TransactionStatus;
import org.springframework.transaction.interceptor.MethodMapTransactionAttributeSource;
import org.springframework.transaction.interceptor.TransactionAspectSupport;
import org.springframework.transaction.interceptor.TransactionAttribute;
import org.springframework.transaction.interceptor.TransactionAttributeSource;
import org.springframework.transaction.support.DefaultTransactionDefinition;

public class TransactionInterceptor  extends TransactionAspectSupport implements MethodInterceptor {  

	private Logger log = Logger.getLogger(HibermateInterceptor.class);

	private PlatformTransactionManager transactionManager;

	private ThreadLocal<Integer> lockDeep = new ThreadLocal<Integer>();  

	private List<String> methodsList = new ArrayList<String>();//开始事务 
	private TransactionAttributeSource transactionAttributeSource=null;
	//   private Map<String, String> transactionAttributes = new HashMap<String, String>();

	public TransactionInterceptor(){
		methodsList.add("add");
		methodsList.add("save");
		methodsList.add("update");
		methodsList.add("delete");
		methodsList.add("log");

		//  	log.info("事务 拦截器");
	}
	public boolean ChekcMethods(String methodName){
		for(String str:methodsList){
			if(methodName.startsWith(str))
				return true;
		}
		return false;
	}

	public Object invoke(MethodInvocation invocation) throws Throwable {  
		Object result = null;  
		String methodName = invocation.getMethod().getName();  

		transactionAttributeSource = this.getTransactionAttributeSource();
		TransactionAttribute ta = transactionAttributeSource.getTransactionAttribute(invocation.getMethod(), invocation.getMethod().getClass());

		log.info("事务 拦截器");
		boolean isBeginTransaction = false;//是否需要开事务  
		log.info("TransactionInterceptor invoke()");
		try {  
			log.info(TransactionInterceptor.class + " methodName="+methodName );
			TransactionStatus status = null;
			DefaultTransactionDefinition definition  =  new DefaultTransactionDefinition();
			//判断是否需要事务  
			if ( ta!=null && 
					( ta.getPropagationBehavior()==DefaultTransactionDefinition.PROPAGATION_REQUIRED ||
					ta.getPropagationBehavior()==DefaultTransactionDefinition.PROPAGATION_NESTED || 
					ta.getPropagationBehavior()==DefaultTransactionDefinition.PROPAGATION_REQUIRES_NEW
							) ) {  
				//线程变量中事务数加1  
				Integer deep = lockDeep.get();  
				if (deep == null || deep.intValue() == 0) {  
					deep = new Integer(1);  
				} else {  
					deep = new Integer(deep.intValue() + 1);  
				}  
				lockDeep.set(deep);  
				definition.setPropagationBehavior( ta.getPropagationBehavior() );
				status =  transactionManager.getTransaction(definition);
				//    HibernateUtil.beginTransaction();//开始事务  
				isBeginTransaction = true;//标志事务已打开  
				log.info("开启事务 @ methodName="+methodName);
			} 

			//执行业务逻辑方法  
			result = invocation.proceed();  

			if (isBeginTransaction && status!=null) {  

				//线程变量  
				int deep = lockDeep.get().intValue();  
				deep = deep - 1;  
				if (deep == 0) {
					transactionManager.commit(status);
					//         HibernateUtil.commitTransaction();//提交事务  
				}  
				//若正常提交事务，线程变量中事务数减1  
				lockDeep.set(new Integer(deep));  

			}  
		} catch(Exception e) {  
			if (isBeginTransaction) {  

				//线程变量  
				int deep = lockDeep.get().intValue();  
				deep = deep - 1;  
				//线程变量中事务数减1  
				lockDeep.set(new Integer(deep));  

				HibernateUtil.rollbackTransaction();//异常则回滚DB事务  

			}  

			throw e;  

		} finally {  
			Integer deep = lockDeep.get();  
			if (deep == null || deep.intValue() == 0) {  
				HibernateUtil.closeSession();//如果上下文有开启的session，关闭session  
			}  
		}  

		return result;  
	}


	public void setTransactionManager(PlatformTransactionManager transactionManager) {
		this.transactionManager = transactionManager;
		log.info("setTransactionManager with "+transactionManager);
	}

	public PlatformTransactionManager getTransactionManager() {
		return transactionManager;
	}  
}  

方3：修改session的获取

applicationConetext.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:tx="http://www.springframework.org/schema/tx"
	xmlns:mvc="http://www.springframework.org/schema/mvc"
	xmlns:aop="http://www.springframework.org/schema/aop"
	xsi:schemaLocation="http://www.springframework.org/schema/beans 
           http://www.springframework.org/schema/beans/spring-beans-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/mvc 
           http://www.springframework.org/schema/mvc/spring-mvc-3.0.xsd 
           http://www.springframework.org/schema/aop 
           http://www.springframework.org/schema/aop/spring-aop-3.0.xsd">

	<bean id="ConfigBean"
		class="org.springframework.beans.factory.config.PropertyPlaceholderConfigurer">
		<property name="locations">
			<list>
				<!-- for development -->
				<value>classpath:jdbc.properties</value>
				<!-- deploy1 <value>file:/data/webconfig/ipark/jdbc.properties </value> -->
				<!-- deploy: file:/data/webconfig/ipark/jdbc.properties -->
				<!-- deploy2 <value>file:${catalina.base}/config/ipark/jdbc.properties</value> -->
			</list>
		</property>
	</bean>
<!--
 	<bean id="dataSourceHibernate"
		class="org.springframework.jdbc.datasource.DriverManagerDataSource">
		<property name="driverClassName" value="${jdbc.driverClassName}"></property>
		<property name="url" value="${jdbc.url}"></property>
		<property name="username" value="${jdbc.username}"></property>
		<property name="password" value="${jdbc.password}"></property>
	</bean>
 -->

	<bean id="dataSourceC3P0" class="com.mchange.v2.c3p0.ComboPooledDataSource"
		destroy-method="close">
		<property name="driverClass" value="${jdbc.driverClassName}" />
		<property name="jdbcUrl" value="${jdbc.url}" />
		<property name="user" value="${jdbc.username}" />
		<property name="password" value="${jdbc.password}" />
		<property name="acquireIncrement" value="1"></property>
		<property name="idleConnectionTestPeriod" value="6000"></property>
		<property name="initialPoolSize" value="10"></property>
		<property name="autoCommitOnClose" value="true"></property>
		<property name="maxIdleTime" value="10" ></property>
		<property name="minPoolSize" value="5" ></property>
		<property name="maxPoolSize" value="30" ></property>
		<property name="maxStatements" value="100" ></property>
	</bean>

	<!-- 数据源切换使用下面的配置  masterDataSource & slaveDataSource 
	<bean id="masterDataSource" parent="dataSourceC3P0">
		<property name="driverClass" value="${jdbc.driverClassName}" />
		<property name="jdbcUrl" value="${jdbc.url}" />
		<property name="user" value="${jdbc.username}" />
		<property name="password" value="${jdbc.password}" />
	</bean>

	<bean id="slaveDataSource" parent="dataSourceC3P0">
		<property name="driverClass" value="${slave.jdbc.driverClassName}" />
		<property name="jdbcUrl" value="${slave.jdbc.url}" />
		<property name="user" value="${slave.jdbc.username}" />
		<property name="password" value="${slave.jdbc.password}" />
	</bean>
  
	<bean id="dataSource" class="com.base.DynamicDataSource">
		<property name="targetDataSources">
			<map key-type="java.lang.String">
				<entry key="slave" value-ref="slaveDataSource" />
			</map>
		</property>
		<property name="defaultTargetDataSource" ref="masterDataSource" />
	</bean>
	-->

 	<bean id="hibermateInterceptor" class="com.base.HibermateInterceptor"/>  
 	
	<bean id="sessionFactory"
		class="org.springframework.orm.hibernate4.LocalSessionFactoryBean">

		<!-- connection -->
		<property name="dataSource">
			<ref local="dataSourceC3P0" />
		</property>
		
		<property name="entityInterceptor" ref="hibermateInterceptor"/>  
		  
		<!-- hibernate自身属性 -->
		<property name="hibernateProperties">
			<props>
				<prop key="hibernate.autoReconnect">false</prop>
				<prop key="hibernate.defaultAutoCommit">true</prop>
				<prop key="hibernate.connection.autocommit">true</prop>  
				<prop key="hibernate.connection.defaultAutoCommit">true</prop>
				<prop key="hibernate.show_sql">false</prop>
				<prop key="hibernate.format_sql">false</prop>
				<prop key="hibernate.dialect">org.hibernate.dialect.MySQL5Dialect</prop>
				<prop key="hibernate.cache.use_second_level_cache">false</prop>
				<!-- Disable the second-level cache -->
				<prop key="hibernate.cache.provider_class">org.hibernate.cache.internal.NoCacheProvider</prop>

				<!-- 
				<prop key="hibernate.current_session_context_class">org.springframework.orm.hibernate4.SpringSessionContext</prop> 
				-->
				<prop key="hibernate.current_session_context_class">thread</prop> 

				<!-- c3p0 -->
				<!-- 连接池hibernate配置 <prop key="hibernate.connection.provider_class">org.hibernate.connection.ProxoolConnectionProvider</prop> -->

				<!-- 需要再次配置数据源,c3p0才起作用 -->
				<prop key="hibernate.connection.provider_class">org.hibernate.service.jdbc.connections.internal.C3P0ConnectionProvider </prop> 
				<prop key="hibernate.connection.driver_class">${jdbc.driverClassName}</prop> 
				<prop key="hibernate.connection.url">${jdbc.url}</prop> 
				<prop key="hibernate.connection.username">${jdbc.username}</prop> 
				<prop key="hibernate.connection.password">${jdbc.password}</prop> <!-- -->

				<!-- 连接池中JDBC连接的最小数量。Hibernate默认为1 -->
				<prop key="hibernate.c3p0.min_size">3</prop>
				<!-- 连接池中JDBC连接的最大数量。Hibernate默认为100 -->
				<prop key="hibernate.c3p0.max_size">56</prop>
				<!-- 何时从连接池中移除一个空闲的连接（以秒为单位）时。Hibernate默认为0，永不过期 -->
				<prop key="hibernate.c3p0.timeout">600</prop>
				<!-- 被缓存的预编译语句数量。用来提高性能。Hibernate默认为0，缓存不可用 -->
				<prop key="c3p0.max_statements">255</prop>
				<!-- 一个连接被自动验证前的闲置时间（以秒为单位）。Hibernate默认为0 -->
				<prop key="hibernate.c3p0.idle_test_period">600</prop>
				<!-- 当连接池里面的连接用完的时候，C3P0一下获取的新的连接数 -->
				<prop key="hibernate.c3p0.acquire_increment">2</prop>
				<!-- 每次都验证连接是否可用 -->
				<prop key="hibernate.c3p0.validate">true</prop>

				<!--因性能消耗大请只在需要的时候使用它。如果设为true那么在每个connection提交的 时候都将校验其有效性。 建议使用idleConnectionTestPeriod或automaticTestTable 
					等方法来提升连接测试的性能。Default: false -->
				<prop key="idleConnectionTestPeriod">6000</prop>
				<prop key="automaticTestTable">c3p0Test</prop>
				<prop key="preferredTestQuery">select * from c3p0Test</prop>

			</props>
		</property>

		<!-- 映射文件 -->
		<property name="mappingDirectoryLocations">
			<list>
				<value>classpath:/com/hbm</value>
			</list>
		</property>
	</bean>
	
	<!-- 自动切换主从， 一定要配置在事务AOP之上 -->
	<!-- 
	<bean id="dataSourceAdvice" class="com.base.DataSourceAdvice" />
	<aop:config>
		<aop:advisor pointcut="execution(* com.dao..*.*(..))" advice-ref="dataSourceAdvice" />
	</aop:config> 
	-->
	
	<!-- 自定义事务拦截器
	<bean id="transactionInterceptor" class="com.base.TransactionInterceptor">
		<property name="transactionManager" ref="transactionManager"></property>
		<property name="transactionAttributes">
			<props>
				<prop key="delete*">PROPAGATION_REQUIRED,-Exception</prop>
				<prop key="update*">PROPAGATION_REQUIRED,-Exception</prop>
				<prop key="add*">PROPAGATION_REQUIRED,-Exception</prop>
				<prop key="save*">PROPAGATION_REQUIRED,-Exception</prop>
				<prop key="create*">PROPAGATION_REQUIRED,-Exception</prop>
				<prop key="log*">PROPAGATION_REQUIRED,-Exception</prop>
				<prop key="login*">PROPAGATION_REQUIRED,-Exception</prop>
				<prop key="query*">PROPAGATION_NOT_SUPPORTED,readOnly</prop>
				<prop key="get*">PROPAGATION_NOT_SUPPORTED,readOnly</prop>
			</props>
		</property>
	</bean>
	 -->
	 
	<!-- 注册事务拦截器
	<bean id="autoproxy"
		class="org.springframework.aop.framework.autoproxy.BeanNameAutoProxyCreator">
		<property name="beanNames">
			<list>
				<value>*Dao</value>
			</list>
		</property>
		<property name="interceptorNames">
			<list>
				<value>transactionInterceptor</value>
			</list>
		</property>
	</bean> 
	-->
		 
		 
	<!-- 事务管理配置  -->
	<bean id="transactionManager"	class="org.springframework.orm.hibernate4.HibernateTransactionManager">
		<property name="sessionFactory" ref="sessionFactory"></property>
	</bean>
	
	<!-- 配置事务传播特性 -->
	<!-- Spring中Propagation类的事务属性详解： PROPAGATION_REQUIRED：支持当前事务，如果当前没有事务，就新建一个事务。这是最常见的选择。 
		PROPAGATION_SUPPORTS：支持当前事务，如果当前没有事务，就以非事务方式执行。 PROPAGATION_MANDATORY：支持当前事务，如果当前没有事务，就抛出异常。 
		PROPAGATION_REQUIRES_NEW：新建事务，如果当前存在事务，把当前事务挂起。 PROPAGATION_NOT_SUPPORTED：以非事务方式执行操作，如果当前存在事务，就把当前事务挂起。 
		PROPAGATION_NEVER：以非事务方式执行，如果当前存在事务，则抛出异常。 PROPAGATION_NESTED：支持当前事务，如果当前事务存在，则执行一个嵌套事务，如果当前没有事务，就新建一个事务。 -->
	<!-- -->
	<tx:advice id="TransAdvice" transaction-manager="transactionManager">
		<tx:attributes>
			<tx:method name="save*" propagation="REQUIRED" />
			<tx:method name="add*" propagation="REQUIRED" />
			<tx:method name="create*" propagation="REQUIRED" />
			<tx:method name="insert*" propagation="REQUIRED" />
			<tx:method name="update*" propagation="REQUIRED" />
			<tx:method name="merge*" propagation="REQUIRED" />
			<tx:method name="del*" propagation="REQUIRED" />
			<tx:method name="remove*" propagation="REQUIRED" />
			<tx:method name="put*" propagation="REQUIRED" />
			<tx:method name="get*" propagation="NOT_SUPPORTED" read-only="true" />
			<tx:method name="query*" propagation="NOT_SUPPORTED"  read-only="true" />
			<tx:method name="login*" propagation="REQUIRED"   />
			<tx:method name="*"  propagation="NOT_SUPPORTED"  read-only="true" />
			<tx:method name="*" timeout="30" />
		</tx:attributes>
	</tx:advice>
	 
	<!-- 配置参与事务的类 -->
	<aop:config>
		<aop:pointcut id="allTransServiceMethod" expression="execution(* com.dao..*.*(..))" />
		<aop:advisor pointcut-ref="allTransServiceMethod" advice-ref="TransAdvice" />
	</aop:config>
	
	
	<!--=============================导入DAO bean配置文件==================================== -->
	<import resource="classpath:spring/*-spring.xml" />


</beans>

HibernateUtil.java

/*
 * @author : TF-BJ-C064
 * @creation : 2014-7-23 下午3:57:39
 * @description : 
 *
 */

package com.base;

import org.hibernate.HibernateException;
import org.hibernate.Session;
import org.hibernate.SessionFactory;
import org.hibernate.Transaction;
import org.hibernate.cfg.Configuration;
import org.springframework.context.support.ClassPathXmlApplicationContext;

public class HibernateUtil {
	private static String CONFIG_FILE_LOCATION = "/hibernate.cfg.xml";  
	private static final ThreadLocal localSession = new ThreadLocal();  
	private static final ThreadLocal localTransaction = new ThreadLocal();  
	private  static Configuration configuration = new Configuration();  
	private static SessionFactory sessionFactory;  
	private static String configFile = CONFIG_FILE_LOCATION;  

	static {  
		try {  
			//方式一
//			configuration.configure(configFile);
//			sessionFactory = configuration.buildSessionFactory();  

			//方式二
			String[] configLocations = new String[] {"classpath:applicationContext.xml"}; 
			ClassPathXmlApplicationContext ctx = new ClassPathXmlApplicationContext(configLocations); 
			sessionFactory =  ctx.getBean("sessionFactory", SessionFactory.class);

		} catch (Exception e) {  
			System.err.println("%%%% Error Creating SessionFactory %%%%");  
			e.printStackTrace();  
		}  
	}  
	private HibernateUtil() {  
	}  

	/** 
	 * Returns the ThreadLocal Session instance.  Lazy initialize 
	 * the <code>SessionFactory</code> if needed. 
	 * 
	 *  @return Session 
	 *  @throws HibernateException 
	 */  
	public static Session getSession() throws HibernateException {  
		Session session = (Session) localSession.get();  

		if (session == null || !session.isOpen()) {  
			if (sessionFactory == null) {  
				rebuildSessionFactory();  
			}  
			session = (sessionFactory != null) ? sessionFactory.openSession()  
					: null;  
			localSession.set(session);  
		}  

		return session;  
	}  

	/** 
	 *  Rebuild hibernate session factory 
	 * 
	 */  
	public static void rebuildSessionFactory() {  
		try {  
			//方式一
//			configuration.configure(configFile);  
//			sessionFactory = configuration.buildSessionFactory();  

			//方式二
			String[] configLocations = new String[] {"classpath:applicationContext.xml"}; 
			ClassPathXmlApplicationContext ctx = new ClassPathXmlApplicationContext(configLocations); 
			sessionFactory =  ctx.getBean("sessionFactory", SessionFactory.class);

		} catch (Exception e) {  
			System.err.println("%%%% Error Creating SessionFactory %%%%");  
			e.printStackTrace();  
		}  
	}  

	/** 
	 *  Close the single hibernate session instance. 
	 * 
	 *  @throws HibernateException 
	 */  
	public static void closeSession() throws HibernateException {  
		Session session = (Session) localSession.get();  
		localSession.set(null);  

		if (session != null && session.isOpen()) {  
			session.close();  
		}  
	}  

	/** 
	 *  return session factory 
	 * 
	 */  
	public static SessionFactory getSessionFactory() {  
		return sessionFactory;  
	}  

	/** 
	 *  return session factory 
	 * 
	 *  session factory will be rebuilded in the next call 
	 */  
	public static void setConfigFile(String configFile) {  
		HibernateUtil.configFile = configFile;  
		sessionFactory = null;  
	}  

	/** 
	 *  return hibernate configuration 
	 * 
	 */  
	public static Configuration getConfiguration() {  
		return configuration;  
	}  

	/** 
	 * 开始当前线程中Hibernate Session的事务 
	 * @return Transaction 
	 * @throws HibernateException 
	 */  
	public static Transaction beginTransaction() throws HibernateException {  
		Transaction tx = (Transaction)localTransaction.get();  
		if(tx == null || tx.wasCommitted() || tx.wasRolledBack()){  
			Session session = getSession();   
			tx = (session != null) ? session.beginTransaction() : null;  
			localTransaction.set(tx);  
		}  

		return tx;  
	}  

	/** 
	 * 提交当前线程中Hibernate Session的事务 
	 * @throws HibernateException 
	 */  
	public static void commitTransaction() throws HibernateException {  
		Transaction tx = (Transaction)localTransaction.get();  
		localTransaction.set(null);  
		if(tx != null || (!tx.wasCommitted() && !tx.wasRolledBack())){  
			tx.commit();  
		}  
	}  
	/** 
	 * 回滚当前线程中Hibernate Session的事务 
	 * @throws HibernateException 
	 */  
	public static void rollbackTransaction() throws HibernateException {  
		Transaction tx = (Transaction)localTransaction.get();  
		localTransaction.set(null);  
		if(tx != null || (!tx.wasCommitted() && !tx.wasRolledBack())){  
			tx.rollback();  

		}  
	}  

	/** 
	 * 当前Hibernate Session是否打开 
	 * @return 
	 */  
	public static boolean isOpenSession() {  
		Session session = (Session) localSession.get();  
		if (session != null && session.isOpen()) {  
			return true;  
		}  
		return false;  
	}  
}

*Dao.query()

session = HibernateUtil.getSession();
//todo sth...
HibernateUtil.closeSession();

经过测试登录LoginDao.login()函数，login函数中包含query 和 update 结果：

参考：http://blog.csdn.net/bluishglc/article/details/7774131