spring事务

springmvc事务的配置方式

springmvc配置事务方式有五种，好多都不怎么常用，说白了就是我也不会，最常用的基于注解的我还是有一些了解。我们来一起学习一下springmvc的事务配置方式。
首先来看声明式事务

  • 1 使用tx标签
<!-- 第一种配置事务的方式 ，tx-->
<tx:advice id="txadvice" transaction-manager="transactionManager">
    <tx:attributes>
        <tx:method name="add*" propagation="REQUIRED" rollback-for="Exception" />
        <tx:method name="modify*" propagation="REQUIRED" rollback-for="Exception" />
        <tx:method name="del*" propagation="REQUIRED" rollback-for="Exception"/>
        <tx:method name="*" propagation="REQUIRED" read-only="true"/>
    </tx:attributes>
</tx:advice>

<aop:config>
    <aop:pointcut id="daoMethod" expression="execution(* com.dao.*.*(..))"/>
    <aop:advisor pointcut-ref="daoMethod" advice-ref="txadvice"/>
</aop:config>

这种主要是要求开发者在方法起名的时候需要保持前缀一直。

  • 2 使用代理的方式
<!-- 第二种配置事务的方式 ，代理-->
<bean id="transactionProxy"
    class="org.springframework.transaction.interceptor.TransactionProxyFactoryBean"    abstract="true">
    <property name="transactionManager" ref="transactionManager"></property>
    <property name="transactionAttributes">
        <props>
            <prop key="add*">PROPAGATION_REQUIRED, -Exception</prop>
            <prop key="modify*">PROPAGATION_REQUIRED, -Exception</prop>
            <prop key="del*">PROPAGATION_REQUIRED, -Exception</prop>
            <prop key="*">PROPAGATION_REQUIRED, readOnly</prop>
        </props>
    </property>
</bean>
<bean id="userDao" parent="transactionProxy">
    <property name="target">
        <!-- 用bean代替ref的方式-->
        <bean class="com.dao.UserDaoImpl">
            <property name="sessionFactory" ref="sessionFactory"></property>
        </bean>
    </property>
</bean>

感觉和第一种很像，只是实现的方式不一样而已

  • 3 使用拦截器
<!-- 第三种配置事务的方式，拦截器 (不常用)-->
<bean id="transactionInterceptor" class="org.springframework.transaction.interceptor.TransactionInterceptor">
    <property name="transactionManager" ref="transactionManager"></property>
    <property name="transactionAttributes">
        <props>
            <prop key="add*">PROPAGATION_REQUIRED, -Exception</prop>
            <prop key="modify*">PROPAGATION_REQUIRED, -Exception</prop>
            <prop key="del*">PROPAGATION_REQUIRED, -Exception</prop>
            <prop key="*">PROPAGATION_REQUIRED, readOnly</prop>
        </props>
    </property>
</bean>
<bean id="proxyFactory" class="org.springframework.aop.framework.autoproxy.BeanNameAutoProxyCreator">
    <property name="interceptorNames">
        <list>
            <value>transactionInterceptor</value>
        </list>
    </property>
    <property name="beanNames">
        <list>
            <value>*Dao</value>
        </list>
    </property>
</bean>

这个就更少用了

  • 4 使用全注解
    这个就使用的很多了，我也就会使用这一种。因为这个使用很简单。直接看配置和代码
 <!--数据库事务注解支持-->
    <bean id="txManager" class="org.springframework.jdbc.datasource.DataSourceTransactionManager">
        <property name="dataSource" ref="dataSource"/>
    </bean>

    <tx:annotation-driven transaction-manager="txManager"/>

再看一下代码：

    //首先设置为requried
    @Transactional(propagation= Propagation.REQUIRED, rollbackFor = Exception.class)
    public void insert() {
        User user = new User();
        user.setName("yuxi");
       int pk =  userDao.insert(user);
        //新增账单
        orderService.insert(pk);
        System.out.println("......");
    }
  • 5 编程式
    意思就是自己在代码里实现事务，这个还是一个比较好的方式，可以精确的控制边界。
    TransactionTemplate tt = new TransactionTemplate(); // 新建一个TransactionTemplate
    Object result = tt.execute(
        new TransactionCallback(){  
            public Object doTransaction(TransactionStatus status){  
                updateOperation();  
                return resultOfUpdateOperation();  
            }  
    }); // 执行execute方法进行事务管理

springmvc事务的传播行为

事务的传播行为有七种，接下来我们就一种一种探讨一下。

    1. propagation_required 默认的
      具体来说就，如果当前没有事务就会新建一个事务，如果有事务就会加入当前事务。
 //首先设置为requried
    @Transactional(propagation= Propagation.REQUIRED, rollbackFor = Exception.class)
    public void insert() {
        User user = new User();
        user.setName("yuxi");
       int pk =  userDao.insert(user);
        //新增账单
       //因为有事务所有，orderService.insert(pk)会加入当前事务
        orderService.insert(pk);
    }

总结起来就是这两个方法要么一起执行，要么一起回滚，不会一个执行成功，另外一个执行回滚。

流程图
  • 2 propagation_requried_new
    具体来说就是，methodA设置为requried,methodB设置为requried_new，当执行methodB的时候，会先挂起methodA,等待methodB执行完了，methodA才继续执行。
    requried和requried_new 区别：
    主要在于回滚程度了，methodB是新启的一个事务。
    如果methodB执行失败，methodB肯定回滚，如果methodA捕获这个异常，methodA可以正常提交，如果methodA没有捕获methodA也回滚。
    如果methodB执行成功，methodA执行失败，那么methodB不会回滚，methodA会执行回滚。
    //首先设置为requried
    @Transactional(propagation= Propagation.REQUIRED, rollbackFor = Exception.class)
    public void insert() {
        User user = new User();
        user.setName("yuxi");
       int pk =  userDao.insert(user);
        //requried_new ,如果执行失败
        try {
            orderService.insert(pk);
        }catch (Exception e){
            //不做处理,让当前事务执行完
        }
        System.out.println("......");
    }

  //requried_new
    @Transactional(rollbackFor = Exception.class,propagation = Propagation.REQUIRES_NEW)
    public  void insert(int userId) {
        Order order = new Order();
        order.setDescs("desc yx");
        order.setOrderId("0101");
        order.setUserId(userId);
        orderDao.insert(order);
        int i = 1/0;
    }

执行结果：
user表有数据，order表没有数据。
我们在换成另外一种情况， orderService.insert(pk);执行成功

 //首先设置为requried
    @Transactional(propagation= Propagation.REQUIRED, rollbackFor = Exception.class)
    public void insert() {
        User user = new User();
        user.setName("yuxi");
       int pk =  userDao.insert(user);
        //requried_new ,如果执行失败
//        try {
            orderService.insert(pk);
//        }catch (Exception e){
//            //不做处理,让当前事务执行完
//        }
        int i = 1/0;
        System.out.println("......");
    }


 //requried_new
    @Transactional(rollbackFor = Exception.class,propagation = Propagation.REQUIRES_NEW)
    public  void insert(int userId) {
        Order order = new Order();
        order.setDescs("desc yx");
        order.setOrderId("0101");
        order.setUserId(userId);
        orderDao.insert(order);
//        int i = 1/0;
    }

执行结果：
order表有数据，user没有数据。

流程图
  • 3 propagation_nested
    具体来说，就是嵌套事务。

第一种情况：
nested事务抛了异常，外部事务捕获了异常。

 //首先设置为requried
    @Transactional(propagation= Propagation.REQUIRED, rollbackFor = Exception.class)
    public void insert() {
        User user = new User();
        user.setName("yuxi");
       int pk =  userDao.insert(user);
        //NESTED ,如果执行失败
        try {
            orderService.insert(pk);
        }catch (Exception e){
            System.out.println("可以继续执行这里面的逻辑.....");
        }
        System.out.println("当前事务继续执行......");
    }
 //NESTED
    @Transactional(rollbackFor = Exception.class,propagation = Propagation.NESTED)
    public  void insert(int userId) {
        Order order = new Order();
        order.setDescs("desc yx");
        order.setOrderId("0101");
        order.setUserId(userId);
        orderDao.insert(order);
        int i = 1/0;
    }

结果是：
外部事务正常执行，嵌套事务回滚。
第二种情况：嵌套事务正常执行完成，外部事务抛了异常。

   //首先设置为requried
    @Transactional(propagation= Propagation.REQUIRED, rollbackFor = Exception.class)
    public void insert() {
        User user = new User();
        user.setName("yuxi");
       int pk =  userDao.insert(user);
        //NESTED ,如果执行失败
        try {
            orderService.insert(pk);
        }catch (Exception e){
            System.out.println("可以继续执行这里面的逻辑.....");
        }
        int i = 1/0;
        System.out.println("当前事务继续执行......");
    }
 //NESTED
    @Transactional(rollbackFor = Exception.class,propagation = Propagation.NESTED)
    public  void insert(int userId) {
        Order order = new Order();
        order.setDescs("desc yx");
        order.setOrderId("0101");
        order.setUserId(userId);
        orderDao.insert(order);
//        int i = 1/0;
    }

结果是：
两个都被回滚了，我理解这个就是嵌套事务和requried_new 的最大区别了。

  • 4 propagation_supported
    具体来说，就是支持当前事务，如果没有就以非事务的方式运行。

  • 5 propagation_not_supported
    具体来说就是不支持以事务的方式运行，如果当前有事物就会挂起。

  • 6 propagation_never
    具体来说，就是不支持事务的方式运行，如果有事务就会抛出异常。

  • 7 propagation_mandatory
    具体来说，就是支持当前事务，如果当前没有事务，就抛出异常。
    后面的基本都不常用。

参考文章：
http://blog.csdn.net/it_wangxiangpan/article/details/24180085
http://blog.csdn.net/paincupid/article/details/48185597

最后编辑于 ：
©著作权归作者所有,转载或内容合作请联系作者
【社区内容提示】社区部分内容疑似由AI辅助生成，浏览时请结合常识与多方信息审慎甄别。
平台声明：文章内容（如有图片或视频亦包括在内）由作者上传并发布，文章内容仅代表作者本人观点，简书系信息发布平台，仅提供信息存储服务。

相关阅读更多精彩内容

  • 由浅入深谈论spring事务
    很多人喜欢这篇文章，特此同步过来 由浅入深谈论spring事务 前言 这篇其实也要归纳到《常识》系列中，但这重点又...
    码农戏码阅读 10,215评论 2赞 59
  • Spring事务管理机制(转载)
    Spring事务机制主要包括声明式事务和编程式事务，此处侧重讲解声明式事务，编程式事务在实际开发中得不到广泛使用，...
    EnigmaXXX阅读 3,856评论 0赞 0
  • Spring 事务 详解
    1. 关于事务 事务控制就是将一系列操作当成一个不可拆分的逻辑单元，保证这些操作要么都成功，要么都失败。在关系数据...
    七弦桐语阅读 7,923评论 0赞 14
  • 深入理解 Spring 事务原理
    深入理解 Spring 事务原理参考：https://mp.weixin.qq.com/s/HHLGfRuD_Yn...
    it_zzy阅读 4,090评论 0赞 8
  • Spring事务处理
    1. 事务基础 1.1 什么是事务 所谓事务就是用户定义的一个数据库操作序列，这些操作要么全做，要么全不做，是一个...
    执笔弄风月阅读 3,511评论 0赞 0

友情链接更多精彩内容