`

关于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制造异常，进行测试事务回滚功能
测试用例1 
	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;
	}

测试结果：是没有回滚，
另外又做其他的测试
测试用例2 
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数据库 有些引擎是不支持事务的
参考：http://www.baike369.com/content/?id=5456
4、查找自己底层dao代码
二、注意openSession（）和getCurrentSession（）的区别

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

您还没有登录,请您登录后再发表评论

相关推荐

    jsp+Spring+hibernate 博客系统

    通过结合JSP的视图呈现、Spring的控制层管理和Hibernate的数据持久化，开发者能够快速、高效地开发出具有复杂业务逻辑的博客平台。如果你希望深入了解这个系统的实现细节，需要深入研究源代码和配置文件，理解它们...

    springmvc+spring+hibernate

    Spring MVC、Spring 和 Hibernate 是Java Web开发中的三大主流框架，它们各司其职，共同构建了一个强大而灵活的后端架构。Spring MVC 负责处理HTTP请求并将其路由到相应的控制器，Spring 提供了依赖注入（DI）和面向...

    spring mvc + spring + hibernate 全注解整合开发视频教程 11

    在本教程中，我们将深入探讨如何使用Spring MVC、Spring和Hibernate三大框架进行全注解的整合开发。这个视频教程系列的第11部分，重点可能是建立在前几部分的基础之上，进一步深化对这三个核心技术的理解和实践。 ...

    gwt+spring+hibernate

    标题 "gwt+spring+hibernate" 涉及的是一个使用Google Web Toolkit (GWT)、Spring框架和Hibernate ORM技术的集成示例。这是一个常见的Web应用开发组合，用于构建高效、可扩展且功能丰富的Java web应用程序。下面将...

    声明式事务控制spring+hibernate集成

    在"声明式事务控制，spring2.5+hibernate3集成源码"中，开发者可以学习如何配置Spring的事务管理器，以及如何在Hibernate的SessionFactory和SessionFactoryBuilder上使用Spring的TransactionProxyFactoryBean来创建...

    图书管理系统spring+struts+hibernate

    在本系统中，Spring作为“胶水”连接各个组件，如控制层的Struts和持久层的Hibernate，使得系统模块化，易于维护和扩展。此外，Spring还提供事务管理，确保数据操作的一致性。 Struts是Java Web应用的一个MVC框架，...

    spring mvc + spring + hibernate 全注解整合开发视频教程 04

    在本视频教程“Spring MVC + Spring + Hibernate 全注解整合开发视频教程 04”中，我们将深入探讨Java企业级开发中的三大核心技术——Spring、Spring MVC和Hibernate的集成与应用，尤其是通过注解实现的简化配置。...

    Struts+Spring+Hibernate开发实例.pdf

    标题和描述中指出的文档《Struts+Spring+Hibernate开发实例.pdf》包含了关于这三个流行的Java开源框架结合使用的示例代码和相关知识点。Struts负责视图与控制器部分，Spring负责业务逻辑层及依赖注入，Hibernate负责...

    struts+spring+hibernate实现图书修改和删除

    此外，Spring还可以与Hibernate集成，实现数据访问层的事务管理。 **Hibernate** Hibernate是一个对象关系映射（ORM）框架，它简化了数据库操作，将Java对象和数据库记录进行映射，使得开发者可以使用面向对象的...

    JSF+Spring+Hibernate小例子

    在这个例子中，Spring主要负责管理JSF和Hibernate之间的协作，提供服务层的实现，如通过@Autowired注解自动注入依赖，以及通过@Transactional管理事务。 **Hibernate** Hibernate是一个强大的对象关系映射（ORM）...

    spring mvc + spring + hibernate 全注解整合开发视频教程 12

    通过@PersistenceContext注解，Spring可以注入EntityManager，@Transactional注解则可以方便地进行事务控制。 本教程将涵盖以下主题： 1. Spring MVC的基本概念和配置，包括DispatcherServlet、HandlerMapping和...

    struts+spring+hibernate三大框架整合

    Struts处理请求转发，Spring管理bean和事务，Hibernate负责数据库交互。通过Spring的IoC和AOP特性，可以有效地降低耦合度，提高代码的可测试性和可扩展性。在实际开发中，应根据项目需求选择合适的整合方式，以实现...

    struts+spring+hibernate(mysql)用户登录及文件上传

    Struts、Spring 和 Hibernate 是Java Web开发中的三大框架，它们结合使用可以构建高效、模块化的应用程序，特别是对于处理用户登录和文件上传等常见功能。在这个项目中，"struts+spring+hibernate(mysql)用户登录及...

    Struts2+Spring+Hibernate+Jsp+Mysql5 项目申报系统.zip

    Struts2+Spring+Hibernate+JSP+MySQL5是一个经典的Java Web开发框架组合，也被称为SSH框架。这个项目申报系统是基于这些技术构建的，它提供了高效、灵活且可扩展的后端架构来处理复杂的业务逻辑和数据管理。以下是...

    Flex+spring+hibernate示例

    在Flex+Spring+Hibernate组合中，Spring主要负责服务层和控制层的实现，为业务逻辑提供容器管理和事务支持。 Hibernate是一个流行的Java ORM（对象关系映射）框架，它简化了数据库操作，允许开发者用Java对象来表示...

    flex+Spring+Hibernate整合配置详解

    Flex+Spring+Hibernate 整合是企业级应用开发中常见的一种技术栈组合，它结合了Flex前端的富互联网应用程序（RIA）开发能力、Spring框架的依赖注入和事务管理功能，以及Hibernate持久化框架的数据库操作便捷性。...

    第二部分spring+hibernate+jta 分布式事务Demo

    在事务管理方面，Spring提供了一种声明式和编程式的事务管理方式，使得开发者能够方便地控制事务的边界。 2. **Hibernate**：这是一个流行的ORM（对象关系映射）框架，用于简化数据库操作。它允许开发者通过Java...

    ssh(struts+spring+hibernate)教务管理信息系统(全部代码) 可以直接运行

    SSH（Struts+Spring+Hibernate）是一个经典的Java Web开发框架，用于构建高效、可扩展的企业级应用程序。这个教务管理信息系统是基于SSH框架实现的，提供了完整的源代码，可以直接运行，便于开发者学习和参考。 **...

    Struts2+Spring+Hibernate和Struts2+Spring+Ibatis

    通过这种方式，开发人员可以利用Struts2的控制层、Spring的服务层管理和依赖注入，以及Hibernate或Ibatis的数据访问能力，构建出高效且可扩展的Web应用。这些整合示例可以帮助初学者快速理解各个组件的交互方式，...

    maven(springmvc+spring+hibernate)

    在SSH整合中，Spring管理Struts和Hibernate，提供了统一的事务管理，使得业务逻辑处理更为一致。同时，Spring还能够与Struts进行深度集成，比如通过Spring的ModelAndView对象替代Struts的ActionForward，使得模型和...

Magicbox
Global site tag (gtag.js) - Google Analytics