spring两种事物处理机制,一是声明式事物,二是编程式事物

声明式事物

1)Spring的声明式事务管理在底层是建立在AOP的基础之上的。其本质是对方法前后进行拦截,然后在目标方法开始之前创建或者加入一个事务,在执行完目标方法之后根据执行情况提交或者回滚事务。声明式事务最大的优点就是不需要通过编程的方式管理事务,这样就不需要在业务逻辑代码中掺杂事务管理的代码,只需在配置文件中做相关的事务规则声明(或通过等价的基于标注的方式),便可以将事务规则应用到业务逻辑中。因为事务管理本身就是一个典型的横切逻辑,正是AOP的用武之地。Spring开发团队也意识到了这一点,为声明式事务提供了简单而强大的支持。Spring强大的声明式事务管理功能,这主要得益于Spring依赖注入容器和Spring AOP的支持。依赖注入容器为声明式事务管理提供了基础设施,使得Bean对于Spring框架而言是可管理的;而Spring AOP则是声明式事务管理的直接实现者。和编程式事务相比,声明式事务唯一不足地方是,后者的最细粒度只能作用到方法级别,无法做到像编程式事务那样可以作用到代码块级别。但是即便有这样的需求,也存在很多变通的方法,比如,可以将需要进行事务管理的代码块独立为方法等等。

2)5种配置方式
Spring配置文件中关于事务配置总是由三个组成部分,分别是DataSource、TransactionManager和代理机制这三部分,无论哪种配置方式,一般变化的只是代理机制这部分。
DataSource、TransactionManager这两部分只是会根据数据访问方式有所变化,比如使用hibernate进行数据访问时,DataSource实际为SessionFactory,TransactionManager的实现为HibernateTransactionManager。
关系图如下:

<bean id="sessionFactory"

class="org.springframework.orm.hibernate3.LocalSessionFactoryBean">

<property name="configLocation" value="classpath:hibernate.cfg.xml" />

<property name="configurationClass" value="org.hibernate.cfg.AnnotationConfiguration" />

</bean>

<!-- 定义事务管理器(声明式的事务) -->

<bean id="transactionManager" class="org.springframework.orm.hibernate3.HibernateTransactionManager">

<property name="sessionFactory" ref="sessionFactory" />

</bean>

注意:sessionFactorty和transactionManager是下面5中配置方式的基本配置,

第一种方式:每个Bean都有一个代理

<!-- 配置DAO -->

<bean id="userDaoTarget" class="com.test.spring.dao.UserDaoImpl">

<property name="sessionFactory" ref="sessionFactory" />

</bean>

<bean id="userDao" class="org.springframework.transaction.interceptor.TransactionProxyFactoryBean">

<!-- 配置事务管理器 -->

<property name="transactionManager" ref="transactionManager" />

<property name="target" ref="userDaoTarget" />

<property name="proxyInterfaces" value="com.test.spring.dao.GeneratorDao" />

<!-- 配置事务属性 -->

<property name="transactionAttributes">

<props>

<prop key="*">PROPAGATION_REQUIRED</prop>

</props>

</property>

</bean>

第二种方式:所有Bean共享一个代理基类

<bean id="transactionBase" class="org.springframework.transaction.interceptor.TransactionProxyFactoryBean" lazy-init="true" abstract="true">

<!-- 配置事务管理器 -->

<property name="transactionManager" ref="transactionManager" />

<!-- 配置事务属性 -->

<property name="transactionAttributes">

<props>

<prop key="*">PROPAGATION_REQUIRED</prop>

</props>

</property>

</bean>

<!-- 配置DAO -->

<bean id="userDaoTarget" class="com.test.spring.dao.UserDaoImpl">

<property name="sessionFactory" ref="sessionFactory" />

</bean>

<bean id="userDao" parent="transactionBase">

<property name="target" ref="userDaoTarget" />

</bean>

第三种方式:使用拦截器

<bean id="transactionInterceptor" class="org.springframework.transaction.interceptor.TransactionInterceptor">

<property name="transactionManager" ref="transactionManager" />

<!-- 配置事务属性 -->

<property name="transactionAttributes">

<props>

<prop key="*">PROPAGATION_REQUIRED</prop>

</props>

</property>

</bean>

<bean 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>

<!-- 配置DAO -->

<bean id="userDao" class="com.test.spring.dao.UserDaoImpl">

<property name="sessionFactory" ref="sessionFactory" />

</bean>

第四种方式:使用tx标签配置的拦截器

<tx:advice id="txAdvice" transaction-manager="transactionManager">

<tx:attributes>

<tx:method name="*" propagation="REQUIRED" />

</tx:attributes>

</tx:advice>

<aop:config>

<aop:pointcut id="interceptorPointCuts"

expression="execution(* com.test.spring.dao.*.*(..))" />

<aop:advisor advice-ref="txAdvice" pointcut-ref="interceptorPointCuts" />

</aop:config>

第五种方式:全注解

public class test {

@Transactional

public class UserDaoImpl extends HibernateDaoSupport implements UserDao {

public List<User> listUsers() {

return null

}

}

}

编程式事务

Spring的编程式事务即在代码中使用编程的方式进行事务处理,可以做到比声明式事务更细粒度。有两种方式一是使用TransactionManager,另外就是TransactionTemplate。

1)TransactionManager使用方式

public class UserDaoImpl extends HibernateDaoSupport implements UserDao {

private HibernateTransactionManager transactionManager;

private DefaultTransactionDefinition def;

public HibernateTransactionManager getTransactionManager() {

return transactionManager;

}

public void setTransactionManager(HibernateTransactionManager transactionManager) {

this.transactionManager = transactionManager;

}

public void createTransactionDefinition() {

def = new DefaultTransactionDefinition();

def.setPropagationBehavior(TransactionDefinition.PROPAGATION_REQUIRED);

def.setIsolationLevel(TransactionDefinition.ISOLATION_READ_COMMITTED);

}

public void saveOrUpdate(User user) {

TransactionStatus status = transactionManager.getTransaction(def);

try {

this.getHibernateTemplate().saveOrUpdate(user);

} catch (DataAccessException ex) {

transactionManager.rollback(status);

throw ex;

}

transactionManager.commit(status);

}

}

2)TransactionTemplate方式

ResultDto ret = null;

ret = (ResultDto) this.transactionTemplate.execute(new TransactionCallback() {

@Override

public Object doInTransaction(TransactionStatus status) {

ResultDto ret = null;

try {

drillTaskDao.deleteByKey(taskid);

} catch (Exception e) {

logger.error("delDrillTask:" + e.getMessage(), e);

ret = ResultBuilder.buildResult(ResultBuilder.FAIL_CODE, null, ErrorCode.COM_DBDELETEERROR);

return ret;

}

finally {

status.setRollbackOnly();

}

ret = cleartaskrelativedata(taskid, appid, true);

return ret;

}

});

return ret;

spring两种事物处理机制,一是声明式事物,二是编程式事物

声明式事物

1)Spring的声明式事务管理在底层是建立在AOP的基础之上的。其本质是对方法前后进行拦截,然后在目标方法开始之前创建或者加入一个事务,在执行完目标方法之后根据执行情况提交或者回滚事务。声明式事务最大的优点就是不需要通过编程的方式管理事务,这样就不需要在业务逻辑代码中掺杂事务管理的代码,只需在配置文件中做相关的事务规则声明(或通过等价的基于标注的方式),便可以将事务规则应用到业务逻辑中。因为事务管理本身就是一个典型的横切逻辑,正是AOP的用武之地。Spring开发团队也意识到了这一点,为声明式事务提供了简单而强大的支持。Spring强大的声明式事务管理功能,这主要得益于Spring依赖注入容器和Spring AOP的支持。依赖注入容器为声明式事务管理提供了基础设施,使得Bean对于Spring框架而言是可管理的;而Spring AOP则是声明式事务管理的直接实现者。和编程式事务相比,声明式事务唯一不足地方是,后者的最细粒度只能作用到方法级别,无法做到像编程式事务那样可以作用到代码块级别。但是即便有这样的需求,也存在很多变通的方法,比如,可以将需要进行事务管理的代码块独立为方法等等。

2)5种配置方式
Spring配置文件中关于事务配置总是由三个组成部分,分别是DataSource、TransactionManager和代理机制这三部分,无论哪种配置方式,一般变化的只是代理机制这部分。
DataSource、TransactionManager这两部分只是会根据数据访问方式有所变化,比如使用hibernate进行数据访问时,DataSource实际为SessionFactory,TransactionManager的实现为HibernateTransactionManager。
关系图如下:

<bean id="sessionFactory"

class="org.springframework.orm.hibernate3.LocalSessionFactoryBean">

<property name="configLocation" value="classpath:hibernate.cfg.xml" />

<property name="configurationClass" value="org.hibernate.cfg.AnnotationConfiguration" />

</bean>

<!-- 定义事务管理器(声明式的事务) -->

<bean id="transactionManager" class="org.springframework.orm.hibernate3.HibernateTransactionManager">

<property name="sessionFactory" ref="sessionFactory" />

</bean>

注意:sessionFactorty和transactionManager是下面5中配置方式的基本配置,

第一种方式:每个Bean都有一个代理

<!-- 配置DAO -->

<bean id="userDaoTarget" class="com.test.spring.dao.UserDaoImpl">

<property name="sessionFactory" ref="sessionFactory" />

</bean>

<bean id="userDao" class="org.springframework.transaction.interceptor.TransactionProxyFactoryBean">

<!-- 配置事务管理器 -->

<property name="transactionManager" ref="transactionManager" />

<property name="target" ref="userDaoTarget" />

<property name="proxyInterfaces" value="com.test.spring.dao.GeneratorDao" />

<!-- 配置事务属性 -->

<property name="transactionAttributes">

<props>

<prop key="*">PROPAGATION_REQUIRED</prop>

</props>

</property>

</bean>

第二种方式:所有Bean共享一个代理基类

<bean id="transactionBase" class="org.springframework.transaction.interceptor.TransactionProxyFactoryBean" lazy-init="true" abstract="true">

<!-- 配置事务管理器 -->

<property name="transactionManager" ref="transactionManager" />

<!-- 配置事务属性 -->

<property name="transactionAttributes">

<props>

<prop key="*">PROPAGATION_REQUIRED</prop>

</props>

</property>

</bean>

<!-- 配置DAO -->

<bean id="userDaoTarget" class="com.test.spring.dao.UserDaoImpl">

<property name="sessionFactory" ref="sessionFactory" />

</bean>

<bean id="userDao" parent="transactionBase">

<property name="target" ref="userDaoTarget" />

</bean>

第三种方式:使用拦截器

<bean id="transactionInterceptor" class="org.springframework.transaction.interceptor.TransactionInterceptor">

<property name="transactionManager" ref="transactionManager" />

<!-- 配置事务属性 -->

<property name="transactionAttributes">

<props>

<prop key="*">PROPAGATION_REQUIRED</prop>

</props>

</property>

</bean>

<bean 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>

<!-- 配置DAO -->

<bean id="userDao" class="com.test.spring.dao.UserDaoImpl">

<property name="sessionFactory" ref="sessionFactory" />

</bean>

第四种方式:使用tx标签配置的拦截器

<tx:advice id="txAdvice" transaction-manager="transactionManager">

<tx:attributes>

<tx:method name="*" propagation="REQUIRED" />

</tx:attributes>

</tx:advice>

<aop:config>

<aop:pointcut id="interceptorPointCuts"

expression="execution(* com.test.spring.dao.*.*(..))" />

<aop:advisor advice-ref="txAdvice" pointcut-ref="interceptorPointCuts" />

</aop:config>

第五种方式:全注解

public class test {

@Transactional

public class UserDaoImpl extends HibernateDaoSupport implements UserDao {

public List<User> listUsers() {

return null

}

}

}

编程式事务

Spring的编程式事务即在代码中使用编程的方式进行事务处理,可以做到比声明式事务更细粒度。有两种方式一是使用TransactionManager,另外就是TransactionTemplate。

1)TransactionManager使用方式

public class UserDaoImpl extends HibernateDaoSupport implements UserDao {

private HibernateTransactionManager transactionManager;

private DefaultTransactionDefinition def;

public HibernateTransactionManager getTransactionManager() {

return transactionManager;

}

public void setTransactionManager(HibernateTransactionManager transactionManager) {

this.transactionManager = transactionManager;

}

public void createTransactionDefinition() {

def = new DefaultTransactionDefinition();

def.setPropagationBehavior(TransactionDefinition.PROPAGATION_REQUIRED);

def.setIsolationLevel(TransactionDefinition.ISOLATION_READ_COMMITTED);

}

public void saveOrUpdate(User user) {

TransactionStatus status = transactionManager.getTransaction(def);

try {

this.getHibernateTemplate().saveOrUpdate(user);

} catch (DataAccessException ex) {

transactionManager.rollback(status);

throw ex;

}

transactionManager.commit(status);

}

}

2)TransactionTemplate方式

ResultDto ret = null;

ret = (ResultDto) this.transactionTemplate.execute(new TransactionCallback() {

@Override

public Object doInTransaction(TransactionStatus status) {

ResultDto ret = null;

try {

drillTaskDao.deleteByKey(taskid);

} catch (Exception e) {

logger.error("delDrillTask:" + e.getMessage(), e);

ret = ResultBuilder.buildResult(ResultBuilder.FAIL_CODE, null, ErrorCode.COM_DBDELETEERROR);

return ret;

}

finally {

status.setRollbackOnly();

}

ret = cleartaskrelativedata(taskid, appid, true);

return ret;

}

});

return ret;

170110、Spring 事物机制总结的更多相关文章

  1. Spring 事物机制

    Spring两种事物处理机制,一是声明式事物,二是编程式事物  声明式事物 1)Spring的声明式事务管理在底层是建立在AOP的基础之上的. 其本质是对方法前后进行拦截,然后在目标方法开始之前创建或 ...

  2. Spring 事物机制总结

    Spring两种事物处理机制,一是声明式事务,二是编程式事务 声明式事物 1)Spring的声明式事务管理在底层是建立在AOP的基础之上的.其本质是对方法前后进行拦截,然后在目标方法开始之前创建或者加 ...

  3. 170608、Spring 事物机制总结

    spring两种事物处理机制,一是声明式事物,二是编程式事物 声明式事物 1)Spring的声明式事务管理在底层是建立在AOP的基础之上的.其本质是对方法前后进行拦截,然后在目标方法开始之前创建或者加 ...

  4. 170323、Spring 事物机制总结

    spring两种事物处理机制,一是声明式事物,二是编程式事物 声明式事物 1)Spring的声明式事务管理在底层是建立在AOP的基础之上的.其本质是对方法前后进行拦截,然后在目标方法开始之前创建或者加 ...

  5. Spring 事物机制(总结)

    Spring两种事物处理机制,一是声明式事物,二是编程式事物 声明式事物 1)Spring的声明式事务管理在底层是建立在AOP的基础之上的.其本质是对方法前后进行拦截,然后在目标方法开始之前创建或者加 ...

  6. spring事物的传播行为

    1.spring事物的传播行为,主要是用来解决业务层拥有事物的方法,相互调用的问题. 2.声明事物, 在代码执行前,开启事务.代码执行完,提交事务 3.spring并没有提供事务具体的处理,而只是调用 ...

  7. Spring 事物Transaction

    日常开发中Spring 为我们提供了两种事物的定义方式 XML 配置 方式 :这种方式配置起来比较麻烦,但后期比较好进行维护 注解方式:配置起来比较方便,也是日常开发常用的: 我们这里进行第二种注解的 ...

  8. spring 事物的一些理解

    推荐一个我认为Spring事物写得很好的文章. 文章链接:http://www.codeceo.com/article/spring-transactions.html  文章作者:码农网 – 吴极心 ...

  9. Hibernate工作原理及为什么要用?. Struts工作机制?为什么要使用Struts? spring工作机制及为什么要用?

    三大框架是用来开发web应用程序中使用的.Struts:基于MVC的充当了其中的试图层和控制器Hibernate:做持久化的,对JDBC轻量级的封装,使得我们能过面向对象的操作数据库Spring: 采 ...

随机推荐

  1. 数据结构(逻辑结构,物理结构,特点) C#多线程编程的同步也线程安全 C#多线程编程笔记 String 与 StringBuilder (StringBuffer) 数据结构与算法-初体验(极客专栏)

    数据结构(逻辑结构,物理结构,特点) 一.数据的逻辑结构:指反映数据元素之间的逻辑关系的数据结构,其中的逻辑关系是指数据元素之间的前后件关系,而与他们在计算机中的存储位置无关.逻辑结构包括: 集合 数 ...

  2. 修改System.Web.Mvc.WebViewPage创建自己的pageBase

    <system.web.webPages.razor> <host factoryType="System.Web.Mvc.MvcWebRazorHostFactory, ...

  3. 实战Nginx负载均衡高冗余高可用WEB架构

       最近公司主力网站之一改版完成终于上线了,牵扯了我大半年的时间,现在终于有时间坐下来写点东西,总结沉淀一下自己的技术心得.此次,根据服务器的数量和质量,我采用负载均衡高冗余的架构,考虑单点故障,W ...

  4. 在CentOS7系统上执行Scala脚本

    在类Unix系统上,可以在scala文件中开头第一行指定脚本的解释程序.如下例: Script.scala #!/usr/bin/env scala println("Hello" ...

  5. 深入Activity

    此刻,你应该静下心来,在阅读中思考.在思考中进步,读完本篇文章的你一定会有不一样的收获,请让我们共同进步! 核心内容 1.Activity数据交换 2.Activity中的任务栈 3.Activity ...

  6. Sublime Text的列模式

    Sublime Text的列模式如何操作? 听语音 | 浏览:6551 | 更新:2014-12-09 13:27 | 标签:软件 Sublime Text的列模式如何操作?各个系统不一样,请跟进系统 ...

  7. JQ集合

    获取所有id以a开头的div$("div[id^='a']") $('div').last() $('#item1') <div id='select'>点击这里< ...

  8. myeclipse修改jsp文件的名称之后,再也打不开的解决方案

    方案一.重启myEclipse 方案二. 删除对应workspace目录下 “.metadata\.plugins\org.eclipse.jst.jsp.core\jspsearch” 里的 *.i ...

  9. 日期在苹果手机上显示NaN的处理方法

    注意两点即可: 1.苹果只认识 yyyy/mmmm/dddd/  这类格式的日期 2.如果输出后还要进行处理日期对比,苹果默认会带中文字,如:年月日,需要转成上面1当中的日期格式在转时间戳进行比较 G ...

  10. mysql之内存表

    一.引言 昨天下午老大让我查资料看一下mysql的内存表在主从备份中是否能被复制,我还没听说过内存表呢,于是上网查资料,记录一下,以便查阅.学习 二.进展 参考: http://www.cnblogs ...