关于spring+hibernate 事务控制的问题

最近项目自己搭建了springMVC+spring+hibernate 的框架，事务使用了spring的注解@Transactional
spring与hibernate的配置文件

<?xml version="1.0" encoding="UTF-8"?>
<!--
	  - Middle tier application context definition for the image database.
	  -->
<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"
	xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-2.5.xsd
	http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context-2.5.xsd
	http://www.springframework.org/schema/tx http://www.springframework.org/schema/tx/spring-tx-2.5.xsd"
	default-autowire="byName" default-lazy-init="false">
	<!-- 不加default-autowire="byName" 会得不到hibernateTemplate -->
	<!-- 配置spring扫描注解的范围 -->
	<context:component-scan base-package="com.holpe.dao.*"  />

	<!-- 定义占位符所在的文件 -->
	<context:property-placeholder location="classpath:jdbc.properties"/>

	<!-- 配置数据源，使用了占位符 -->
	<bean id="dataSource" class="com.mchange.v2.c3p0.ComboPooledDataSource" destroy-method="close">
		<property name="driverClass" value="${driverClassName}"/>
		<property name="jdbcUrl" value="${jdbc_url}"/>
		<property name="user" value="${jdbc_username}"/>
		<property name="password" value="${jdbc_password}"/>
	</bean>


	<!-- 配置sessionFactory，使用了占位符 -->
	<bean id="sessionFactory"
		class="org.springframework.orm.hibernate3.annotation.AnnotationSessionFactoryBean">
		<property name="dataSource">
			<ref bean="dataSource" />			
		</property>
		<!-- 加载hibernate的jpa注解形式的实体类 -->
		<!-- <property name="packagesToScan" value="com.holpe.entity*" /> -->

	   <!-- 自动扫描hbm方式配置的hibernate文件和.hbm文件 -->
		<property name="mappingLocations">
			<list><value>classpath*:hibernate/*.hbm.xml</value></list>
		</property>
		<property name="hibernateProperties">
			<props>
				<prop key="hibernate.hbm2ddl.auto">${hibernate.hbm2ddl}</prop>
				<prop key="hibernate.show_sql">${hibernate.show_sql}</prop>
				<prop key="hibernate.dialect">${hibernate.dialect}</prop>
				<prop key="hibernate.query.factory_class">org.hibernate.hql.ast.ASTQueryTranslatorFactory</prop>
				<prop key="connection.useUnicode">true</prop>
				<prop key="connection.characterEncoding">UTF-8</prop>
				<!-- <prop key="hibernate.current_session_context_class">org.springframework.orm.hibernate3.SpringSessionContext</prop> -->
			</props>
		</property>
	</bean>



</beans>

然后进行测试 在service制造异常，进行测试事务回滚功能
[b]测试用例1[/b]

	public void delRole(String roleIds) {
		String roleSql="DELETE r from t_role r where r.role_id in("+roleIds+")";
		String roleRelationSql="DELETE r from t_role_menu_relation r where r.role_id  in("+roleIds+")";
		String userRelationSql="DELETE r from t_user_role_relation r where r.role_id  in("+roleIds+")";
		dao.execSql(roleSql);
		dao.execSql(roleRelationSql);
		dao.execSql(userRelationSql);
		int a=10;
	}

测试结果：是没有回滚，
另外又做其他的测试
[b]测试用例2[/b]

public void saveRole(TRole role) {
		dao.saveOrUpdate(role);
		int a=10;
	}

测试结果：是回滚的
结合上面两个测试用例，可以知道事务配置是起作用的，问题出现在哪里呢？然后我进入到dao层进行逐步排查发现
execSql

public boolean execSql(String sql) {
		String strsql = sql;
		SessionFactory sf = null;
		Session session = null;
		Transaction tx = null;
		try {
			sf = getHibernateTemplate().getSessionFactory();
			session = sf.openSession();
			tx = session.beginTransaction();
			Query query = session.createSQLQuery(strsql);
			query.executeUpdate();
			tx.commit();
		} catch (Exception e) {
			tx.rollback();
			e.printStackTrace();
			return false;
		} finally {
			if (session != null && session.isOpen()) {
				session.close();
			}
		}
		return true;
	}

saveOrUpdate

	/**
	 * 保存实体 包括添加和修改
	 * 
	 * @param t
	 *            实体对象
	 */
	@Override
	public <T> void saveOrUpdate(T t) {
		getHibernateTemplate().saveOrUpdate(t);

	}

进过比较发现，使用getHibernateTemplate()提供的方法是可以事务回滚的，而session.createSQLQuery 使用原生sql或者Hql的事务不回滚，知道这原因，然后百度去找答案，得到的答案是：openSession()、getCurrentSession()的区别
1、getCurrentSession()与openSession()的区别？
在 SessionFactory 启动的时候， Hibernate 会根据配置创建相应的 CurrentSessionContext ，在 getCurrentSession() 被调用的时候，实际被执行的方法是CurrentSessionContext.currentSession() 。在 currentSession() 执行时，如果当前 Session 为空，currentSession 会调用SessionFactory的openSession 。所以getCurrentSession() 对于 Java EE 来说是更好的获取 Session 的方法。
* 采用getCurrentSession()创建的session会绑定到当前线程中，而采用openSession()创建的session则不会
* 采用getCurrentSession()创建的session在commit或rollback时会自动关闭，而采用openSession()创建的session必须手动关闭
2、使用getCurrentSession()需要在hibernate.cfg.xml文件中加入如下配置：
* 如果使用的是本地事务（jdbc事务）
<property name="hibernate.current_session_context_class">thread</property>
* 如果使用的是全局事务（jta事务）
<property name="hibernate.current_session_context_class">jta</property>
* 如果使用的是session的管理机制（不太常用）
<property name="hibernate.current_session_context_class">managed</property>


1 getCurrentSession创建的session会和绑定到当前线程,而openSession不会。

2 getCurrentSession创建的线程会在事务回滚或事物提交后自动关闭,而openSession必须手动关闭





这里getCurrentSession本地事务(本地事务:jdbc)时 要在配置文件里进行如下设置

* 如果使用的是本地事务（jdbc事务）
<property name="hibernate.current_session_context_class">thread</property>
* 如果使用的是全局事务（jta事务）
<property name="hibernate.current_session_context_class">jta</property>



getCurrentSession () 使用当前的session
openSession() 重新建立一个新的session

在一个应用程序中，如果DAO 层使用spring 的hibernate 模板，通过Spring 来控制session 的生命周期，则首选getCurrentSession ()。

结合本项目，我是用spring进行事务控制的，必须选择getCurrentSession ()
修改后 execSql

public boolean execSql(String sql, Object... params) {
		String strsql = sql;// "delete from TPrintPaper where id = ?";
		SessionFactory sf = null;
		Session session = null;
		Transaction tx = null;
		try {
			sf = getHibernateTemplate().getSessionFactory();
			session=sf.getCurrentSession();
//			session = sf.openSession();
//			tx = session.beginTransaction();
			Query query = session.createSQLQuery(strsql);
			for (int position = 0; position < params.length; position++) {
				query.setParameter(position, params[position]);
			}
			query.executeUpdate();
//			tx.commit();
		} catch (Exception e) {

//			tx.rollback();
			e.printStackTrace();
			return false;
		} finally {
			if (session != null && session.isOpen()) {
				session.close();
			}
		}
		return true;
	}

网上资料说，使用getCurrentSession()需要在hibernate.cfg.xml文件中加入如下配置：
* 如果使用的是本地事务（jdbc事务）

<property name="hibernate.current_session_context_class">thread</property>

* 如果使用的是全局事务（jta事务）

<property name="hibernate.current_session_context_class">jta</property>

* 如果使用的是session的管理机制（不太常用）

<property name="hibernate.current_session_context_class">managed</property>

修改spring与hibernate的配置文件
<!-- 配置sessionFactory，使用了占位符 -->

	<bean id="sessionFactory"
		class="org.springframework.orm.hibernate3.annotation.AnnotationSessionFactoryBean">
		<property name="dataSource">
			<ref bean="dataSource" />			
		</property>
		<!-- 加载hibernate的jpa注解形式的实体类 -->
		<!-- <property name="packagesToScan" value="com.holpe.entity*" /> -->

	   <!-- 自动扫描hbm方式配置的hibernate文件和.hbm文件 -->
		<property name="mappingLocations">
			<list><value>classpath*:hibernate/*.hbm.xml</value></list>
		</property>
		<property name="hibernateProperties">
			<props>
				<prop key="hibernate.hbm2ddl.auto">${hibernate.hbm2ddl}</prop>
				<prop key="hibernate.show_sql">${hibernate.show_sql}</prop>
				<prop key="hibernate.dialect">${hibernate.dialect}</prop>
				<prop key="hibernate.query.factory_class">org.hibernate.hql.ast.ASTQueryTranslatorFactory</prop>
				<prop key="connection.useUnicode">true</prop>
				<prop key="connection.characterEncoding">UTF-8</prop>
				 <prop key="hibernate.current_session_context_class">jta</prop> 
			</props>
		</property>
	</bean>

再用以上的测试用例进行测试，结果是报

	org.hibernate.HibernateException: No TransactionManagerLookup specified
	at org.hibernate.context.JTASessionContext.currentSession(JTASessionContext.java:54)
	at org.hibernate.impl.SessionFactoryImpl.getCurrentSession(SessionFactoryImpl.java:544)
	at com.holpe.dao.impl.BaseDaoImpl.execSql(BaseDaoImpl.java:683)
	at com.holpe.service.impl.UserServiceImpl.updatePwd(UserServiceImpl.java:123)
	at com.holpe.service.impl.UserServiceImpl$$FastClassByCGLIB$$a90d3b56.invoke(<generated>)
	at org.springframework.cglib.proxy.MethodProxy.invoke(MethodProxy.java:204)
	at org.springframework.aop.framework.CglibAopProxy$CglibMethodInvocation.invokeJoinpoint(CglibAopProxy.java:698)
	at org.springframework.aop.framework.ReflectiveMethodInvocation.proceed(ReflectiveMethodInvocation.java:150)
	at org.springframework.transaction.interceptor.TransactionInterceptor$1.proceedWithInvocation(TransactionInterceptor.java:96)
	at org.springframework.transaction.interceptor.TransactionAspectSupport.invokeWithinTransaction(TransactionAspectSupport.java:260)
	at org.springframework.transaction.interceptor.TransactionInterceptor.invoke(TransactionInterceptor.java:94)
	at org.springframework.aop.framework.ReflectiveMethodInvocation.proceed(ReflectiveMethodInvocation.java:172)
	at org.springframework.aop.framework.CglibAopProxy$DynamicAdvisedInterceptor.intercept(CglibAopProxy.java:631)
	at com.holpe.service.impl.UserServiceImpl$$EnhancerByCGLIB$$31e15f26.updatePwd(<generated>)
	at com.holpe.action.UserAction.updatePwd(UserAction.java:117)
	at sun.reflect.NativeMethodAccessorImpl.invoke0(Native Method)
	at sun.reflect.NativeMethodAccessorImpl.invoke(NativeMethodAccessorImpl.java:57)
	at sun.reflect.DelegatingMethodAccessorImpl.invoke(DelegatingMethodAccessorImpl.java:43)
	at java.lang.reflect.Method.invoke(Method.java:606)
	at org.springframework.web.method.support.InvocableHandlerMethod.invoke(InvocableHandlerMethod.java:219)
	at org.springframework.web.method.support.InvocableHandlerMethod.invokeForRequest(InvocableHandlerMethod.java:132)
	at org.springframework.web.servlet.mvc.method.annotation.ServletInvocableHandlerMethod.invokeAndHandle(ServletInvocableHandlerMethod.java:104)
	at org.springframework.web.servlet.mvc.method.annotation.RequestMappingHandlerAdapter.invokeHandleMethod(RequestMappingHandlerAdapter.java:745)
	at org.springframework.web.servlet.mvc.method.annotation.RequestMappingHandlerAdapter.handleInternal(RequestMappingHandlerAdapter.java:686)
	at org.springframework.web.servlet.mvc.method.AbstractHandlerMethodAdapter.handle(AbstractHandlerMethodAdapter.java:80)
	at org.springframework.web.servlet.DispatcherServlet.doDispatch(DispatcherServlet.java:925)
	at org.springframework.web.servlet.DispatcherServlet.doService(DispatcherServlet.java:856)
	at org.springframework.web.servlet.FrameworkServlet.processRequest(FrameworkServlet.java:936)
	at org.springframework.web.servlet.FrameworkServlet.doPost(FrameworkServlet.java:838)
	at javax.servlet.http.HttpServlet.service(HttpServlet.java:646)
	at org.springframework.web.servlet.FrameworkServlet.service(FrameworkServlet.java:812)
	at javax.servlet.http.HttpServlet.service(HttpServlet.java:727)
	at org.apache.catalina.core.ApplicationFilterChain.internalDoFilter(ApplicationFilterChain.java:303)
	at org.apache.catalina.core.ApplicationFilterChain.doFilter(ApplicationFilterChain.java:208)
	at org.apache.tomcat.websocket.server.WsFilter.doFilter(WsFilter.java:52)
	at org.apache.catalina.core.ApplicationFilterChain.internalDoFilter(ApplicationFilterChain.java:241)
	at org.apache.catalina.core.ApplicationFilterChain.doFilter(ApplicationFilterChain.java:208)
	at org.springframework.web.filter.CharacterEncodingFilter.doFilterInternal(CharacterEncodingFilter.java:88)
	at org.springframework.web.filter.OncePerRequestFilter.doFilter(OncePerRequestFilter.java:107)
	at org.apache.catalina.core.ApplicationFilterChain.internalDoFilter(ApplicationFilterChain.java:241)
	at org.apache.catalina.core.ApplicationFilterChain.doFilter(ApplicationFilterChain.java:208)
	at com.holpe.comom.SessionListenerFilter.doFilter(SessionListenerFilter.java:119)
	at org.apache.catalina.core.ApplicationFilterChain.internalDoFilter(ApplicationFilterChain.java:241)
	at org.apache.catalina.core.ApplicationFilterChain.doFilter(ApplicationFilterChain.java:208)
	at org.apache.catalina.core.StandardWrapperValve.invoke(StandardWrapperValve.java:220)
	at org.apache.catalina.core.StandardContextValve.invoke(StandardContextValve.java:122)
	at org.apache.catalina.authenticator.AuthenticatorBase.invoke(AuthenticatorBase.java:501)
	at org.apache.catalina.core.StandardHostValve.invoke(StandardHostValve.java:171)
	at org.apache.catalina.valves.ErrorReportValve.invoke(ErrorReportValve.java:103)
	at org.apache.catalina.valves.AccessLogValve.invoke(AccessLogValve.java:950)
	at org.apache.catalina.core.StandardEngineValve.invoke(StandardEngineValve.java:116)
	at org.apache.catalina.connector.CoyoteAdapter.service(CoyoteAdapter.java:408)
	at org.apache.coyote.http11.AbstractHttp11Processor.process(AbstractHttp11Processor.java:1070)
	at org.apache.coyote.AbstractProtocol$AbstractConnectionHandler.process(AbstractProtocol.java:611)
	at org.apache.tomcat.util.net.JIoEndpoint$SocketProcessor.run(JIoEndpoint.java:316)
	at java.util.concurrent.ThreadPoolExecutor.runWorker(ThreadPoolExecutor.java:1145)
	at java.util.concurrent.ThreadPoolExecutor$Worker.run(ThreadPoolExecutor.java:615)
	at org.apache.tomcat.util.threads.TaskThread$WrappingRunnable.run(TaskThread.java:61)
	at java.lang.Thread.run(Thread.java:745)

网上查询资料

发现在spring与hibernate的配置中配置了

<prop key="hibernate.current_session_context_class">jta</prop>

而用spring管理事务，会默认设置hibernate.current_session_context_class 为org.springframework.orm.hibernate3.SpringSessionContext
于是我把这一行给注释掉，然后不报着错误了，报另外一个错误
session is closed

检查了自己写的dao层代码发现

	public boolean execSql(String sql) {
		String strsql = sql;// "delete from TPrintPaper where id = ?";
		SessionFactory sf = null;
		Session session = null;
//		Transaction tx = null;
		try {
			sf = getHibernateTemplate().getSessionFactory();
			session=sf.getCurrentSession();
//			session = sf.openSession();
//			tx = session.beginTransaction();
			Query query = session.createSQLQuery(strsql);
			query.executeUpdate();
//			tx.commit();
		} catch (Exception e) {
//			tx.rollback();
			e.printStackTrace();
			return false;
		} finally {
			[color=red]if (session != null && session.isOpen()) {
				session.close();
			}[/color]
		}
		return true;
	}

标红的地方出现问题了，使用getCurrentSession（），会自己关闭session ，不需要手动关闭session的，把这删除，一切正常了。
总结：
一、事务不起作用，怎么去排查
1、查看配置文件是否正确
2、代码中是否添加try catch 捕获异常，没有抛出来
3、是否是使用mysql数据库，因为mysql数据库 有些引擎是不支持事务的
参考：[url]http://www.baike369.com/content/?id=5456[/url]
4、查找自己底层dao代码
二、注意openSession（）和getCurrentSession（）的区别

（1）openSession每次打开都是新的Session，所以多次获取的Session实例是不同的，并且需要人为的调用close方法进行Session关闭。
（2）getCurrentSession是从当前上下文中获取Session并且会绑定到当前线程，第一次调用时会创建一个Session实例，如果该Session未关闭，后续多次获取的是同一个Session实例；事务提交或者回滚时会自动关闭Sesison，无需人工关闭。