1. Toy模板网首页
  2. > Toy博客

Spring事务切面_传播属性（8）

9月前 作者：chen_yao_kerr 分类：Toy博客 阅读(40) 违法举报

这篇具有很好参考价值的文章主要介绍了Spring事务切面_传播属性（8）。希望对大家有所帮助。如果存在错误或未考虑完全的地方，请大家不吝赐教，您也可以点击"举报违法"按钮提交疑问。

目录

1. 传播属性

2. 案例分享

2.1 测试说明

2.2  Propagation.REQUIRED 演示

案例1：

案例2：

案例3：

案例4：

总结1：

案例5：

案例6： 特殊的传播属性 NESTED 错误使用

案例6的解决方案：

3. 带着问题看源码

3.1 类分析：

3.2 源码分析

3.2.1 事务创建

 3.2.2 事务的链式调用

源码case：

3.2.3 事务的回滚。

总结2：

3.2.4. 伪代码分析：

1. 传播属性

Spring特有一套处理事务处理的逻辑，而今天要讲的传播属性就是Spring独有的。下面对传播属性进行介绍：

PROPAGATION_REQUIRED 如果当前没有事务，就新建一个事务，如果已经存在一个事务中，加入到这个事务中。这是最常见的选择。

PROPAGATION_SUPPORTS 支持当前事务，如果当前没有事务，就以非事务方式执行。

PROPAGATION_MANDATORY 使用当前的事务，如果当前没有事务，就抛出异常。

PROPAGATION_REQUIRES_NEW 新建事务，如果当前存在事务，把当前事务挂起。

PROPAGATION_NOT_SUPPORTED 以非事务方式执行操作，如果当前存在事务，就把当前事务挂起。

PROPAGATION_NEVER 以非事务方式执行，如果当前存在事务，则抛出异常。

PROPAGATION_NESTED 如果当前存在事务，则在嵌套事务内执行。如果当前没有事务，则执行与PROPAGATION_REQUIRED类似的操作。

以上传播属性，使用最高频的是： PROPAGATION_REQUIRED、PROPAGATION_REQUIRES_NEW 和 PROPAGATION_NESTED。其实，所谓的传播属性，就是控制Connection对数据库进行操作的。传统的JDBC连接数据库如下：

 Connection connection = null;
        try {
            connection = ConnectionUtil.getConnection();
            //开启事务
            /*
            *
            * */
            connection.setAutoCommit(false);
            insertTest(connection);
            insertTest1(connection);


            connection.commit();
        } catch (ClassNotFoundException e) {
            e.printStackTrace();
        } catch (SQLException e) {
            e.printStackTrace();
            try {
                connection.rollback();
                System.out.println("JDBC Transaction rolled back successfully");
            } catch (SQLException e1) {
                System.out.println("JDBC Transaction rolled back fail" + e1.getMessage());
            }
        } finally {
            if (connection != null) {
                try {
                    selectAll(connection);
                    connection.close();
                } catch (SQLException e) {
                    e.printStackTrace();
                }
            }
        }

也就是说，每一次连接数据库进行操作，我们底层都需要生成Connection对象，通过Connection对象实际上进行数据库的连接操作。而在我们Spring的事务中，就是按照Spring的逻辑对Connection进行不同的封装调用而已。具体点说就是按照你在业务代码中配置的事务传播属性，进行不同逻辑的Connection生成和封装对象，然后进行数据库的连接。

2. 案例分享

2.1 测试说明

        首先，我们需要一个测试类和一个假设的业务类，但是这个业务类调用的是其他业务类的方法，他们都带有事务。

        测试类：我们会执行propagationTest方法：

package com.xuexi.jack.test;

import com.xuexi.jack.bean.ComponentScanBean;
import com.xuexi.jack.pojo.ConsultConfigArea;
import com.xuexi.jack.pojo.ZgGoods;
import com.xuexi.jack.service.AccountService;
import com.xuexi.jack.service.area.AreaService;
import com.xuexi.jack.service.transaction.TransationService;
import org.junit.Before;
import org.junit.Test;
import org.springframework.context.ApplicationContext;
import org.springframework.context.annotation.AnnotationConfigApplicationContext;

import java.util.HashMap;
import java.util.Map;

public class TransactionTest {

    private ApplicationContext applicationContext;

    @Before
    public void before() {
        applicationContext = new AnnotationConfigApplicationContext(ComponentScanBean.class);
    }

    @Test
    public void test1() {
        AreaService bean = applicationContext.getBean(AreaService.class);
        Map param = new HashMap();
        param.put("areaCode","1001");
        bean.queryAreaFromDB(param);
    }

    @Test
    public void addAreaTest() {
        AreaService bean = applicationContext.getBean(AreaService.class);
        ConsultConfigArea area = new ConsultConfigArea();
        area.setAreaCode("VV1");
        area.setAreaName("VV1");
        area.setState("1");
        bean.addArea(area);
    }

    @Test
    public void propagationTest() {
        String areaStr = "HN1";
        String goodsStr = "iphone 2";
        TransationService transationService = applicationContext.getBean(TransationService.class);
        ConsultConfigArea area = new ConsultConfigArea();
        area.setAreaCode(areaStr);
        area.setAreaName(areaStr);
        area.setState("1");

        ZgGoods zgGoods = new ZgGoods();
        zgGoods.setGoodCode(goodsStr);
        zgGoods.setGoodName(goodsStr);
        zgGoods.setCount(100);
        transationService.transation(area,zgGoods);
    }

    @Test
    public void accountServiceTest() {
        AccountService bean = applicationContext.getBean(AccountService.class);
        bean.queryAccount("d");
    }

}

中转业务类，关注 transation 方法：

package com.xuexi.jack.service.transaction;

import com.xuexi.jack.dao.CommonMapper;
import com.xuexi.jack.pojo.ConsultConfigArea;
import com.xuexi.jack.pojo.ZgGoods;
import com.xuexi.jack.pojo.ZgTicket;
import com.xuexi.jack.service.area.AreaService;
import com.xuexi.jack.service.goods.GoodsService;
import org.springframework.aop.framework.AopContext;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Propagation;
import org.springframework.transaction.annotation.Transactional;
import org.springframework.transaction.support.TransactionTemplate;

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

@Service("transationServiceImpl")
public class TransationServiceImpl implements TransationService {

    @Autowired
    AreaService areaService;

    @Autowired
    GoodsService goodsService;

    @Autowired
    CommonMapper commonMapper;

    //开启了事务
    @Transactional(propagation = Propagation.REQUIRED)
    @Override
    public void transation(ConsultConfigArea area, ZgGoods zgGoods) {
        //try {
            areaService.addArea( area);
            goodsService.addGoods(zgGoods);
       /* }catch (Exception e) {

        }*/
    }
    //提交事务


    @Transactional
    @Override
    public int getTicket() {

        //1、获取锁
        List<ZgTicket> zgTickets = commonMapper.queryTicketById("12306");
        Map lockmap = new HashMap();
        lockmap.put("ticketId", "12306");
        lockmap.put("version", zgTickets.get(0).getVersion());
        int i = commonMapper.updateLock(lockmap);

        if (i > 0) {
            //抢票
            ZgTicket zgTicket = zgTickets.get(0);
            zgTicket.setTicketCount(2);
            int i1 = commonMapper.updateTicket(zgTicket);
        } else {
            //继续抢
            ((TransationService) AopContext.currentProxy()).getTicket();
        }

        return 0;
    }

    @Autowired
    private TransactionTemplate transactionTemplate;

    @Override
    public int getTicketModeOne() {

        Integer execute = transactionTemplate.execute(status -> {
            //1、获取锁
            List<ZgTicket> zgTickets = commonMapper.queryTicketById("12306");
            Map lockmap = new HashMap();
            lockmap.put("ticketId", "12306");
            lockmap.put("version", zgTickets.get(0).getVersion());
            int i = commonMapper.updateLock(lockmap);

            if (i > 0) {
                //抢票
                ZgTicket zgTicket = zgTickets.get(0);
                zgTicket.setTicketCount(2);
                int i1 = commonMapper.updateTicket(zgTicket);
            }
            return i;
        });

        if (execute == 0) {
            //继续抢
            getTicketModeOne();
        }
        return 0;
    }
}

 在上方的业务中转类中，我们设置了事务隔离属性为 propagation = Propagation.REQUIRED，并且它还按顺序，调用了另外2个类。下面是各种case分享：

2.2  Propagation.REQUIRED 演示

案例1：

 areaService.addArea( area) 和 goodsService.addGoods(zgGoods)方法的事务传播属性都是 REQUIRED，但是在addArea方法中抛异常。此时，2张表都无法插入数据。因为他们使用的是同一个Connection对象连接的数据库，而addArea方法抛异常，导致后面的方法无法被执行到。同时，因为主方法 transation 也有事务，因此他会返回到主方法处进行回滚。所以2张表都没有数据。

AreaServiceImpl：
package com.xuexi.jack.service.area;

import com.xuexi.jack.dao.CommonMapper;
import com.xuexi.jack.pojo.ConsultConfigArea;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Propagation;
import org.springframework.transaction.annotation.Transactional;

//@PropertySource("classpath:config/core/core.properties")
@Service
public class AreaServiceImpl implements AreaService {

    private Logger logger = LoggerFactory.getLogger(getClass());

    @Autowired
    private CommonMapper commonMapper;

    @Autowired
    AreaService areaService;

    @Transactional(propagation = Propagation.REQUIRED)
    @Override
    public int addArea(ConsultConfigArea area) {
        int i = commonMapper.addArea(area);
        if(true) throw new RuntimeException("yic");
     /*   try {
            if (true) {throw new RuntimeException("111");}
        }
        catch (Exception e){}*/

        return 1;
    }
}

GoodsServiceImpl：
    package com.xuexi.jack.service.goods;
    
    import com.xuexi.jack.dao.CommonMapper;
    import com.xuexi.jack.pojo.ZgGoods;
    import org.springframework.beans.factory.annotation.Autowired;
    import org.springframework.stereotype.Service;
    import org.springframework.transaction.annotation.Propagation;
    import org.springframework.transaction.annotation.Transactional;
    
    import java.util.List;
    
    @Service
    public class GoodsServiceImpl implements GoodsService {
    
        @Autowired
        CommonMapper commonMapper;
    
        @Transactional(propagation = Propagation.REQUIRED)
        @Override
        public void addGoods(ZgGoods zgGoods) {
            int i = commonMapper.addGood(zgGoods);
            //if(true) throw new RuntimeException("yic");
           /* try {
                if(true) throw new RuntimeException("yic");
            }catch (Exception e) { }*/
    
        }
    
        @Transactional(readOnly = true)
        @Override
        public List<ZgGoods> queryAll() {
            return commonMapper.queryAll();
        }
    }

案例2：

 areaService.addArea( area) 和 goodsService.addGoods(zgGoods)方法的事务传播属性都是 REQUIRED，但是在addArea方法中有异常并且自己捕获到了异常，不再往上抛异常。goodsService.addGoods(zgGoods)方法保持不变，此时执行测试方法，我们会发现，2张表都有数据。原因是异常被我们自己写的 try...catch 捕获并吞掉, spring并没有获取到异常信息。因此2张表会正常的插入数据

AreaServiceImpl：
package com.xuexi.jack.service.area;

import com.xuexi.jack.dao.CommonMapper;
import com.xuexi.jack.pojo.ConsultConfigArea;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Propagation;
import org.springframework.transaction.annotation.Transactional;

//@PropertySource("classpath:config/core/core.properties")
@Service
public class AreaServiceImpl implements AreaService {

    private Logger logger = LoggerFactory.getLogger(getClass());

    @Autowired
    private CommonMapper commonMapper;

    @Autowired
    AreaService areaService;

    @Transactional(propagation = Propagation.REQUIRED)
    @Override
    public int addArea(ConsultConfigArea area) {
        int i = commonMapper.addArea(area);
        //if(true) throw new RuntimeException("yic");
        try {
            if (true) {throw new RuntimeException("111");}
        }
        catch (Exception e){}

        return 1;
    }
}

GoodsServiceImpl：
    package com.xuexi.jack.service.goods;

    import com.xuexi.jack.dao.CommonMapper;
    import com.xuexi.jack.pojo.ZgGoods;
    import org.springframework.beans.factory.annotation.Autowired;
    import org.springframework.stereotype.Service;
    import org.springframework.transaction.annotation.Propagation;
    import org.springframework.transaction.annotation.Transactional;

    import java.util.List;

    @Service
    public class GoodsServiceImpl implements GoodsService {

        @Autowired
        CommonMapper commonMapper;

        @Transactional(propagation = Propagation.REQUIRED)
        @Override
        public void addGoods(ZgGoods zgGoods) {
            int i = commonMapper.addGood(zgGoods);
            //if(true) throw new RuntimeException("yic");
           /* try {
                if(true) throw new RuntimeException("yic");
            }catch (Exception e) { }*/

        }

        @Transactional(readOnly = true)
        @Override
        public List<ZgGoods> queryAll() {
            return commonMapper.queryAll();
        }
    }

案例3：

 areaService.addArea( area) 和 goodsService.addGoods(zgGoods)方法的事务传播属性都是 REQUIRED，但是在addGoods方法中抛异常。此时，2张表都无法插入数据。因为他们使用的是同一个Connection对象连接的数据库，而addGoods方法抛异常会被主方法 transation 捕获到，因此他会返回到主方法处进行回滚。所以2张表都没有数据。

 AreaServiceImpl

package com.xuexi.jack.service.area;

import com.xuexi.jack.dao.CommonMapper;
import com.xuexi.jack.pojo.ConsultConfigArea;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Propagation;
import org.springframework.transaction.annotation.Transactional;

//@PropertySource("classpath:config/core/core.properties")
@Service
public class AreaServiceImpl implements AreaService {

    private Logger logger = LoggerFactory.getLogger(getClass());

    @Autowired
    private CommonMapper commonMapper;

    @Autowired
    AreaService areaService;

    @Transactional(propagation = Propagation.REQUIRED)
    @Override
    public int addArea(ConsultConfigArea area) {
        int i = commonMapper.addArea(area);
        //if(true) throw new RuntimeException("yic");
      /*  try {
            if (true) {throw new RuntimeException("111");}
        }
        catch (Exception e){}*/

        return 1;
    }
}

GoodsServiceImpl

    package com.xuexi.jack.service.goods;

    import com.xuexi.jack.dao.CommonMapper;
    import com.xuexi.jack.pojo.ZgGoods;
    import org.springframework.beans.factory.annotation.Autowired;
    import org.springframework.stereotype.Service;
    import org.springframework.transaction.annotation.Propagation;
    import org.springframework.transaction.annotation.Transactional;

    import java.util.List;

    @Service
    public class GoodsServiceImpl implements GoodsService {

        @Autowired
        CommonMapper commonMapper;

        @Transactional(propagation = Propagation.REQUIRED)
        @Override
        public void addGoods(ZgGoods zgGoods) {
            int i = commonMapper.addGood(zgGoods);
            if(true) throw new RuntimeException("yic");
           /* try {
                if(true) throw new RuntimeException("yic");
            }catch (Exception e) { }*/

        }

        @Transactional(readOnly = true)
        @Override
        public List<ZgGoods> queryAll() {
            return commonMapper.queryAll();
        }
    }

案例4：

 areaService.addArea( area) 和 goodsService.addGoods(zgGoods)方法的事务传播属性都是 REQUIRED，但是在addGoods方法中有异常并且自己捕获到了异常，不再往上抛异常。执行测试用来，我们会发现，2张表都有数据。原因是异常被我们自己写的 try...catch 捕获并吞掉, spring并没有获取到异常信息。因此2张表会正常的插入数据

AreaServiceImpl：

package com.xuexi.jack.service.area;

import com.xuexi.jack.dao.CommonMapper;
import com.xuexi.jack.pojo.ConsultConfigArea;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Propagation;
import org.springframework.transaction.annotation.Transactional;

//@PropertySource("classpath:config/core/core.properties")
@Service
public class AreaServiceImpl implements AreaService {

    private Logger logger = LoggerFactory.getLogger(getClass());

    @Autowired
    private CommonMapper commonMapper;

    @Autowired
    AreaService areaService;

    @Transactional(propagation = Propagation.REQUIRED)
    @Override
    public int addArea(ConsultConfigArea area) {
        int i = commonMapper.addArea(area);
        //if(true) throw new RuntimeException("yic");
      /*  try {
            if (true) {throw new RuntimeException("111");}
        }
        catch (Exception e){}*/

        return 1;
    }
}

 GoodsServiceImpl ：

    package com.xuexi.jack.service.goods;

    import com.xuexi.jack.dao.CommonMapper;
    import com.xuexi.jack.pojo.ZgGoods;
    import org.springframework.beans.factory.annotation.Autowired;
    import org.springframework.stereotype.Service;
    import org.springframework.transaction.annotation.Propagation;
    import org.springframework.transaction.annotation.Transactional;

    import java.util.List;

    @Service
    public class GoodsServiceImpl implements GoodsService {

        @Autowired
        CommonMapper commonMapper;

        @Transactional(propagation = Propagation.REQUIRED)
        @Override
        public void addGoods(ZgGoods zgGoods) {
            int i = commonMapper.addGood(zgGoods);
            //if(true) throw new RuntimeException("yic");
           try {
                if(true) throw new RuntimeException("yic");
            }catch (Exception e) { }

        }

        @Transactional(readOnly = true)
        @Override
        public List<ZgGoods> queryAll() {
            return commonMapper.queryAll();
        }
    }

总结1：

1. 凡是异常被吞掉的，都不会执行回滚，数据会正常插入。 以后的案例中将不会再提到异常被自己捕获，但是不往上抛的情况，基本都是一样的逻辑、

2. 使用同一个Connection对象提交的数据，只要任何一处抛出异常 （一直往上抛，没有自己吞掉），那么会回滚这一次提交的所有数据。即使是不在同一张表，也会被回滚掉。 

3. 使用同一个Connection对象提交的数据，如果前面的方法抛出异常（一直往上抛，没有自己吞掉），那么后面的方法不会被执行。 以后的案例中将不会再提到此种情况，逻辑基本都是一样的。

案例5：

 areaService.addArea( area) 和 goodsService.addGoods(zgGoods)方法的事务传播属性都是 REQUIRED_NEW，但是在addGoods方法中抛异常。此时 areaService.addArea( area)正常插入数据。因为他们每次都新生成一个事务对象，并且持有新的Connection对象。回滚只是针对同一个Connection提交的SQL而言。因此，addArea正常插入数据。

AreaServiceImpl ：

package com.xuexi.jack.service.area;

import com.xuexi.jack.dao.CommonMapper;
import com.xuexi.jack.pojo.ConsultConfigArea;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Propagation;
import org.springframework.transaction.annotation.Transactional;

//@PropertySource("classpath:config/core/core.properties")
@Service
public class AreaServiceImpl implements AreaService {

    private Logger logger = LoggerFactory.getLogger(getClass());

    @Autowired
    private CommonMapper commonMapper;

    @Autowired
    AreaService areaService;

    @Transactional(propagation = Propagation.REQUIRES_NEW)
    @Override
    public int addArea(ConsultConfigArea area) {
        int i = commonMapper.addArea(area);
        //if(true) throw new RuntimeException("yic");
      /*  try {
            if (true) {throw new RuntimeException("111");}
        }
        catch (Exception e){}*/

        return 1;
    }
}

 GoodsServiceImpl ：
    package com.xuexi.jack.service.goods;

    import com.xuexi.jack.dao.CommonMapper;
    import com.xuexi.jack.pojo.ZgGoods;
    import org.springframework.beans.factory.annotation.Autowired;
    import org.springframework.stereotype.Service;
    import org.springframework.transaction.annotation.Propagation;
    import org.springframework.transaction.annotation.Transactional;

    import java.util.List;

    @Service
    public class GoodsServiceImpl implements GoodsService {

        @Autowired
        CommonMapper commonMapper;

        @Transactional(propagation = Propagation.REQUIRES_NEW)
        @Override
        public void addGoods(ZgGoods zgGoods) {
            int i = commonMapper.addGood(zgGoods);
            if(true) throw new RuntimeException("yic");
          /* try {
                if(true) throw new RuntimeException("yic");
            }catch (Exception e) { }
*/
        }

        @Transactional(readOnly = true)
        @Override
        public List<ZgGoods> queryAll() {
            return commonMapper.queryAll();
        }
    }

案例6： 特殊的传播属性 NESTED 错误使用

 areaService.addArea( area) 和 goodsService.addGoods(zgGoods)方法的事务传播属性都是 NESTED，但是在addGoods方法中抛异常。此时 areaService.addArea( area)也无法插入数据。NESTED是设置回滚点进行回滚的，如果我们抛异常，addGoods方法插入的数据就会被回滚掉。

但是，为什么前面的addArea插入的数据也会被回滚掉呢？因为addGoods 是被另一个事务方法 transation调用的，如果我们不处理异常，那么异常就会一直往上抛。因为NESTED 不会创建新的Connection对象，也就是说它和transation方法使用同一个Connection对象，异常一直往上抛，会被 transation 方法给捕获到并且给回滚掉。而 transation方法中也调用了addArea 方法，所以会被整体回滚掉，2张表都没有数据。

TransationServiceImpl ：

package com.xuexi.jack.service.transaction;

import com.xuexi.jack.dao.CommonMapper;
import com.xuexi.jack.pojo.ConsultConfigArea;
import com.xuexi.jack.pojo.ZgGoods;
import com.xuexi.jack.pojo.ZgTicket;
import com.xuexi.jack.service.area.AreaService;
import com.xuexi.jack.service.goods.GoodsService;
import org.springframework.aop.framework.AopContext;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Propagation;
import org.springframework.transaction.annotation.Transactional;
import org.springframework.transaction.support.TransactionTemplate;

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

@Service("transationServiceImpl")
public class TransationServiceImpl implements TransationService {

    @Autowired
    AreaService areaService;

    @Autowired
    GoodsService goodsService;

    @Autowired
    CommonMapper commonMapper;

    //开启了事务
    @Transactional(propagation = Propagation.REQUIRED)
    @Override
    public void transation(ConsultConfigArea area, ZgGoods zgGoods) {
        //try {
            areaService.addArea( area);
            goodsService.addGoods(zgGoods);
       /* }catch (Exception e) {

        }*/
    }
    //提交事务


    @Transactional
    @Override
    public int getTicket() {

        //1、获取锁
        List<ZgTicket> zgTickets = commonMapper.queryTicketById("12306");
        Map lockmap = new HashMap();
        lockmap.put("ticketId", "12306");
        lockmap.put("version", zgTickets.get(0).getVersion());
        int i = commonMapper.updateLock(lockmap);

        if (i > 0) {
            //抢票
            ZgTicket zgTicket = zgTickets.get(0);
            zgTicket.setTicketCount(2);
            int i1 = commonMapper.updateTicket(zgTicket);
        } else {
            //继续抢
            ((TransationService) AopContext.currentProxy()).getTicket();
        }

        return 0;
    }

    @Autowired
    private TransactionTemplate transactionTemplate;

    @Override
    public int getTicketModeOne() {

        Integer execute = transactionTemplate.execute(status -> {
            //1、获取锁
            List<ZgTicket> zgTickets = commonMapper.queryTicketById("12306");
            Map lockmap = new HashMap();
            lockmap.put("ticketId", "12306");
            lockmap.put("version", zgTickets.get(0).getVersion());
            int i = commonMapper.updateLock(lockmap);

            if (i > 0) {
                //抢票
                ZgTicket zgTicket = zgTickets.get(0);
                zgTicket.setTicketCount(2);
                int i1 = commonMapper.updateTicket(zgTicket);
            }
            return i;
        });

        if (execute == 0) {
            //继续抢
            getTicketModeOne();
        }
        return 0;
    }
}

AreaServiceImpl ：

package com.xuexi.jack.service.area;

import com.xuexi.jack.dao.CommonMapper;
import com.xuexi.jack.pojo.ConsultConfigArea;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Propagation;
import org.springframework.transaction.annotation.Transactional;

//@PropertySource("classpath:config/core/core.properties")
@Service
public class AreaServiceImpl implements AreaService {

    private Logger logger = LoggerFactory.getLogger(getClass());

    @Autowired
    private CommonMapper commonMapper;

    @Autowired
    AreaService areaService;

    @Transactional(propagation = Propagation.NESTED)
    @Override
    public int addArea(ConsultConfigArea area) {
        int i = commonMapper.addArea(area);
        return 1;
    }
}

GoodsServiceImpl ：

    package com.xuexi.jack.service.goods;

    import com.xuexi.jack.dao.CommonMapper;
    import com.xuexi.jack.pojo.ZgGoods;
    import org.springframework.beans.factory.annotation.Autowired;
    import org.springframework.stereotype.Service;
    import org.springframework.transaction.annotation.Propagation;
    import org.springframework.transaction.annotation.Transactional;

    import java.util.List;

    @Service
    public class GoodsServiceImpl implements GoodsService {

        @Autowired
        CommonMapper commonMapper;

        @Transactional(propagation = Propagation.NESTED)
        @Override
        public void addGoods(ZgGoods zgGoods) {
            int i = commonMapper.addGood(zgGoods);
            throw new RuntimeException("异常");
        }

        @Transactional(readOnly = true)
        @Override
        public List<ZgGoods> queryAll() {
            return commonMapper.queryAll();
        }
    }

案例6的解决方案：

想要按照回滚点进行回滚，那么异常是必须要抛出的，但是不能一直往上抛，否则会被整体回滚掉。因此，我们可以在addGoods方法中正常抛异常，想别的办法去依旧保留下之前addArea 方法插入的数据。

方法1：前面说过，回滚、提交都是针对同一个Connection对象的。那么，给addArea方法使用 REQUIRES_NEW 传播属性，这样他们2个就会使用不同的Connection对象了。

package com.xuexi.jack.service.area;

import com.xuexi.jack.dao.CommonMapper;
import com.xuexi.jack.pojo.ConsultConfigArea;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Propagation;
import org.springframework.transaction.annotation.Transactional;

//@PropertySource("classpath:config/core/core.properties")
@Service
public class AreaServiceImpl implements AreaService {

    private Logger logger = LoggerFactory.getLogger(getClass());

    @Autowired
    private CommonMapper commonMapper;

    @Autowired
    AreaService areaService;

    @Transactional(propagation = Propagation.REQUIRES_NEW)
    @Override
    public int addArea(ConsultConfigArea area) {
        int i = commonMapper.addArea(area);
        return 1;
    }
}

方法2： 上一个解决方法并不好，因为如果有很多个方法，难到每一次出问题就要去修改传播属性值吗。其实，在addGoods方法中抛异常，但是在上一层方法 transation 中去捕获异常并吞掉异常，一样可以解决这个问题：

TransationServiceImpl：
package com.xuexi.jack.service.transaction;

import com.xuexi.jack.dao.CommonMapper;
import com.xuexi.jack.pojo.ConsultConfigArea;
import com.xuexi.jack.pojo.ZgGoods;
import com.xuexi.jack.pojo.ZgTicket;
import com.xuexi.jack.service.area.AreaService;
import com.xuexi.jack.service.goods.GoodsService;
import org.springframework.aop.framework.AopContext;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Propagation;
import org.springframework.transaction.annotation.Transactional;
import org.springframework.transaction.support.TransactionTemplate;

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

@Service("transationServiceImpl")
public class TransationServiceImpl implements TransationService {

    @Autowired
    AreaService areaService;

    @Autowired
    GoodsService goodsService;

    @Autowired
    CommonMapper commonMapper;

    //开启了事务
    @Transactional(propagation = Propagation.REQUIRED)
    @Override
    public void transation(ConsultConfigArea area, ZgGoods zgGoods) {
        try {
            areaService.addArea( area);
            goodsService.addGoods(zgGoods);
        }catch (Exception e) {}
    }
    //提交事务


    @Transactional
    @Override
    public int getTicket() {

        //1、获取锁
        List<ZgTicket> zgTickets = commonMapper.queryTicketById("12306");
        Map lockmap = new HashMap();
        lockmap.put("ticketId", "12306");
        lockmap.put("version", zgTickets.get(0).getVersion());
        int i = commonMapper.updateLock(lockmap);

        if (i > 0) {
            //抢票
            ZgTicket zgTicket = zgTickets.get(0);
            zgTicket.setTicketCount(2);
            int i1 = commonMapper.updateTicket(zgTicket);
        } else {
            //继续抢
            ((TransationService) AopContext.currentProxy()).getTicket();
        }

        return 0;
    }

    @Autowired
    private TransactionTemplate transactionTemplate;

    @Override
    public int getTicketModeOne() {

        Integer execute = transactionTemplate.execute(status -> {
            //1、获取锁
            List<ZgTicket> zgTickets = commonMapper.queryTicketById("12306");
            Map lockmap = new HashMap();
            lockmap.put("ticketId", "12306");
            lockmap.put("version", zgTickets.get(0).getVersion());
            int i = commonMapper.updateLock(lockmap);

            if (i > 0) {
                //抢票
                ZgTicket zgTicket = zgTickets.get(0);
                zgTicket.setTicketCount(2);
                int i1 = commonMapper.updateTicket(zgTicket);
            }
            return i;
        });

        if (execute == 0) {
            //继续抢
            getTicketModeOne();
        }
        return 0;
    }
}

AreaServiceImpl
package com.xuexi.jack.service.area;

import com.xuexi.jack.dao.CommonMapper;
import com.xuexi.jack.pojo.ConsultConfigArea;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Propagation;
import org.springframework.transaction.annotation.Transactional;

//@PropertySource("classpath:config/core/core.properties")
@Service
public class AreaServiceImpl implements AreaService {

    private Logger logger = LoggerFactory.getLogger(getClass());

    @Autowired
    private CommonMapper commonMapper;

    @Autowired
    AreaService areaService;

    @Transactional(propagation = Propagation.NESTED)
    @Override
    public int addArea(ConsultConfigArea area) {
        int i = commonMapper.addArea(area);
        return 1;
    }
}

GoodsServiceImpl：
    package com.xuexi.jack.service.goods;

    import com.xuexi.jack.dao.CommonMapper;
    import com.xuexi.jack.pojo.ZgGoods;
    import org.springframework.beans.factory.annotation.Autowired;
    import org.springframework.stereotype.Service;
    import org.springframework.transaction.annotation.Propagation;
    import org.springframework.transaction.annotation.Transactional;

    import java.util.List;

    @Service
    public class GoodsServiceImpl implements GoodsService {

        @Autowired
        CommonMapper commonMapper;

        @Transactional(propagation = Propagation.NESTED)
        @Override
        public void addGoods(ZgGoods zgGoods) {
            int i = commonMapper.addGood(zgGoods);
            throw new RuntimeException("异常");
        }

        @Transactional(readOnly = true)
        @Override
        public List<ZgGoods> queryAll() {
            return commonMapper.queryAll();
        }
    }

3. 带着问题看源码

3.1 类分析：

上一篇介绍了@Bean方法的实例化，接下来我们看一下事务支持类ProxyTransactionManagementConfiguration都干了什么事情，

/*
 * Copyright 2002-2017 the original author or authors.
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *      http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */

package org.springframework.transaction.annotation;

import org.springframework.beans.factory.config.BeanDefinition;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.context.annotation.Role;
import org.springframework.transaction.config.TransactionManagementConfigUtils;
import org.springframework.transaction.interceptor.BeanFactoryTransactionAttributeSourceAdvisor;
import org.springframework.transaction.interceptor.TransactionAttributeSource;
import org.springframework.transaction.interceptor.TransactionInterceptor;

/**
 * {@code @Configuration} class that registers the Spring infrastructure beans
 * necessary to enable proxy-based annotation-driven transaction management.
 *
 * @author Chris Beams
 * @since 3.1
 * @see EnableTransactionManagement
 * @see TransactionManagementConfigurationSelector
 */
@Configuration
public class ProxyTransactionManagementConfiguration extends AbstractTransactionManagementConfiguration {

	/*
	* 明显是创建事务切面实例
	* BeanFactoryTransactionAttributeSourceAdvisor
	*
	* */
	@Bean(name = TransactionManagementConfigUtils.TRANSACTION_ADVISOR_BEAN_NAME)
	@Role(BeanDefinition.ROLE_INFRASTRUCTURE)
	public BeanFactoryTransactionAttributeSourceAdvisor transactionAdvisor() {
		BeanFactoryTransactionAttributeSourceAdvisor advisor = new BeanFactoryTransactionAttributeSourceAdvisor();
		advisor.setTransactionAttributeSource(transactionAttributeSource());
		//设置通知类
		advisor.setAdvice(transactionInterceptor());
		if (this.enableTx != null) {
			advisor.setOrder(this.enableTx.<Integer>getNumber("order"));
		}
		return advisor;
	}

	@Bean
	@Role(BeanDefinition.ROLE_INFRASTRUCTURE)
	public TransactionAttributeSource transactionAttributeSource() {
		return new AnnotationTransactionAttributeSource();
	}

	/*
	* 创建事务advice
	* TransactionInterceptor
	* */
	@Bean
	@Role(BeanDefinition.ROLE_INFRASTRUCTURE)
	public TransactionInterceptor transactionInterceptor() {
		TransactionInterceptor interceptor = new TransactionInterceptor();
		interceptor.setTransactionAttributeSource(transactionAttributeSource());
		//事务管理器要跟数据源挂钩，所以需要自己定义
		if (this.txManager != null) {
			interceptor.setTransactionManager(this.txManager);
		}
		return interceptor;
	}

}

1. 在我们调用 transactionAdvisor方法的时候，我们生成了advisor对象

2. 在advisor对象中，我们通过advisor.setTransactionAttributeSource(transactionAttributeSource()) 的调用，生成了事务注解属性类，负责生成包装事务属性的包装类并进行注入

3. 在advisor对象中，我们通过advisor.setAdvice(transactionInterceptor())， 还生成了advice类，也就是最小单元的advisor, 负责具体的拦截、增强的类

4. 最后给advisor设置优先级，确保优先执行

3.2 源码分析

Spring的事务是AOP技术实现的，因此也会走AOP的那一套流程进行调用，最终调用到了事务切面。

Spring事务切面_传播属性（8）

 Spring事务切面_传播属性（8）

贴出这个方法的全部源码，对字方法进行逐步分析：

@Nullable
	protected Object invokeWithinTransaction(Method method, @Nullable Class<?> targetClass,
			final InvocationCallback invocation) throws Throwable {

		// If the transaction attribute is null, the method is non-transactional.
		//获取事务属性类 AnnotationTransactionAttributeSource
		TransactionAttributeSource tas = getTransactionAttributeSource();

		//获取方法上面有@Transactional注解的属性
		final TransactionAttribute txAttr = (tas != null ? tas.getTransactionAttribute(method, targetClass) : null);

		//获取事务管理器
		final PlatformTransactionManager tm = determineTransactionManager(txAttr);
		final String joinpointIdentification = methodIdentification(method, targetClass, txAttr);

		if (txAttr == null || !(tm instanceof CallbackPreferringPlatformTransactionManager)) {
			// Standard transaction demarcation with getTransaction and commit/rollback calls.
			TransactionInfo txInfo = createTransactionIfNecessary(tm, txAttr, joinpointIdentification);
			Object retVal = null;
			try {
				// This is an around advice: Invoke the next interceptor in the chain.
				// This will normally result in a target object being invoked.
				//火炬传递
				retVal = invocation.proceedWithInvocation();
			}
			catch (Throwable ex) {
				// target invocation exception
				//事务回滚
				completeTransactionAfterThrowing(txInfo, ex);
				throw ex;
			}
			finally {
				cleanupTransactionInfo(txInfo);
			}
			//事务提交
			commitTransactionAfterReturning(txInfo);
			return retVal;
		}

		else {
			final ThrowableHolder throwableHolder = new ThrowableHolder();

			// It's a CallbackPreferringPlatformTransactionManager: pass a TransactionCallback in.
			try {
				Object result = ((CallbackPreferringPlatformTransactionManager) tm).execute(txAttr, status -> {
					TransactionInfo txInfo = prepareTransactionInfo(tm, txAttr, joinpointIdentification, status);
					try {
						return invocation.proceedWithInvocation();
					}
					catch (Throwable ex) {
						if (txAttr.rollbackOn(ex)) {
							// A RuntimeException: will lead to a rollback.
							if (ex instanceof RuntimeException) {
								throw (RuntimeException) ex;
							}
							else {
								throw new ThrowableHolderException(ex);
							}
						}
						else {
							// A normal return value: will lead to a commit.
							throwableHolder.throwable = ex;
							return null;
						}
					}
					finally {
						cleanupTransactionInfo(txInfo);
					}
				});

				// Check result state: It might indicate a Throwable to rethrow.
				if (throwableHolder.throwable != null) {
					throw throwableHolder.throwable;
				}
				return result;
			}
			catch (ThrowableHolderException ex) {
				throw ex.getCause();
			}
			catch (TransactionSystemException ex2) {
				if (throwableHolder.throwable != null) {
					logger.error("Application exception overridden by commit exception", throwableHolder.throwable);
					ex2.initApplicationException(throwableHolder.throwable);
				}
				throw ex2;
			}
			catch (Throwable ex2) {
				if (throwableHolder.throwable != null) {
					logger.error("Application exception overridden by commit exception", throwableHolder.throwable);
				}
				throw ex2;
			}
		}
	}

 这里面的方法都很重要，比如 TransactionAttributeSource实例的获取，PlatformTransactionManager的获取都值得着重去了解，但是今天的核心是事务传播属性的使用与底层分析。因此，事务的创建、拦截、回滚是本文的核心。

3.2.1 事务创建

Spring事务切面_传播属性（8）

 进入这个方法Spring事务切面_传播属性（8）

来到核心方法处：

Spring事务切面_传播属性（8）

下面针对这个方法，逐步进行代码分析：

1.  Object transaction = doGetTransaction() 获取数据源对象。其实，每次进来都是 new了一个包装数据源的对象。第一次进来，是没有DataSource数据源对象的，因此， ConnectionHolder为null, 我们拿不到连接数据库的信息。

	@Override
	protected Object doGetTransaction() {
		//管理connection对象，创建回滚点，按照回滚点回滚，释放回滚点
		DataSourceTransactionObject txObject = new DataSourceTransactionObject();

		//DataSourceTransactionManager默认是允许嵌套事务的
		txObject.setSavepointAllowed(isNestedTransactionAllowed());

		//obtainDataSource() 获取数据源对象，其实就是数据库连接块对象
		ConnectionHolder conHolder =
				(ConnectionHolder) TransactionSynchronizationManager.getResource(obtainDataSource());
		txObject.setConnectionHolder(conHolder, false);
		return txObject;
	}

2、 第一次进入，其实核心就是设置连接数据库的信息 

Spring事务切面_传播属性（8）

看看具体设置了写什么东西：注意一下 newTransaction这个参数，这是数据回滚的依据，这里默认是true

Spring事务切面_传播属性（8）

 概括起来就是，本文一开头常用的3个传播属性，第一次进入的时候都会执行相同的操作：

a. 挂起之前的事务，核心就是将之前存储的Connection对象设置为空，并进行数据库还原操作，具体看        SuspendedResourcesHolder suspendedResources = suspend(null) 代码：

b. doBegin(transaction, definition) 开启事务。其实就是获取数据库连接信息，就是我们配置的信息

Spring事务切面_传播属性（8）

 Spring事务切面_传播属性（8）

c. 关闭数据库的自动提交功能,

Spring事务切面_传播属性（8）

d. 搜集DataSource 和 Connection的映射放入map中。

Spring事务切面_传播属性（8）

2.  返回到 createTransactionIfNecessary 方法中继续往下走, 此时我们我们依旧获取到了连接数据库的信息，当前事务的状态（是不是新事务）等信息。

Spring事务切面_传播属性（8）

3. 最后，就是线程绑定，放入到ThreadLocal中：

Spring事务切面_传播属性（8）

 Spring事务切面_传播属性（8）

Spring事务切面_传播属性（8）

 3.2.2 事务的链式调用

Spring事务切面_传播属性（8）

 到这一步，就是事务的链式调用了。

源码case：

 @Transactional(propagation = Propagation.REQUIRED)
    @Override
    public void transation(ConsultConfigArea area, ZgGoods zgGoods) {
     
            areaService.addArea( area);
            goodsService.addGoods(zgGoods);
       
    }
    @Transactional(propagation = Propagation.REQUIRES_NEW)
    @Override
    public int addArea(ConsultConfigArea area) {
        int i = commonMapper.addArea(area);
        return 1;
    }
   @Transactional(propagation = Propagation.NESTED)
        @Override
        public void addGoods(ZgGoods zgGoods) {
            int i = commonMapper.addGood(zgGoods);
            throw new RuntimeException("异常");
        }

1、 我们在调用 transation 方法的时候， 由于它使用了 @Transactional(propagation = Propagation.REQUIRED)注解并且它是第一次调用，我们会在调用实际的transation方法之前先进入代理类，进行事务相关处理。 由于是第一次次进入，我们会生成一个事务，并且事务的 newTransation为true。

2. 调用 retVal = invocation.proceedWithInvocation() 进行火炬传递，也就是链式调用。

3. 我们会进入AreaServiceImpl的代理类，也就是再次把事务的相关流程再走一遍。由于在addArea方法的时候，我们使用了注解 @Transactional(propagation = Propagation.REQUIRES_NEW)。也就是说，挂起之前的事务并生成一个全新的事务，newTransation为true。

4. 调用 retVal = invocation.proceedWithInvocation() 进行火炬传递，继续链式调用。

5. 我们会进入GoodsServiceImpl 的代理类，也就是再次把事务的相关流程再走一遍。由于在addGoods方法的时候，我们使用了注解 @Transactional(propagation = Propagation.NESTED)。他会生成一个回滚点。针对 NESTED 这种传播属性传播属性并且是同一个线程再次创建事务对象，我们会把 newTransation设置为FALSE。

6. 最后按顺序依次调用 

TransationServiceImpl.transation() --> areaService.addArea( area) --> goodsService.addGoods(zgGoods);

针对同一个线程，反复通过链式调用创建事务的过程。刚刚说了第一次创建事务，newTransation为true。 针对第2 、3、4...... 次的创建事务。我们会执行执行以下流程：

Spring事务切面_传播属性（8）

我们会根据不同的传播属性，执行不同的业务逻辑。核心就是处理连接数据库的connection对象实例。

如果是 传播属性是 PROPAGATION_REQUIRES_NEW，我们会完全在创建一个新的、独立的事务。newTransation为true

Spring事务切面_传播属性（8）

如果是 PROPAGATION_NESTED，我们继续使用之前的事务，也就是在调用transation 方法的时候创建的事务。newTransation为 false

Spring事务切面_传播属性（8）

3.2.3 事务的回滚。

由于我们执行最后一个方法的时候抛了异常信息：

 @Transactional(propagation = Propagation.NESTED)
        @Override
        public void addGoods(ZgGoods zgGoods) {
            int i = commonMapper.addGood(zgGoods);
            throw new RuntimeException("异常");
        }

我们会进行异常的处理逻辑，处理完以后接着往上抛异常。

Spring事务切面_传播属性（8）

如何处理回滚的呢？Spring事务切面_传播属性（8）

 Spring事务切面_传播属性（8）

 最终的回滚方法如下：

private void processRollback(DefaultTransactionStatus status, boolean unexpected) {
		try {
			boolean unexpectedRollback = unexpected;

			try {
				triggerBeforeCompletion(status);

				//按照嵌套事务按照回滚点回滚
				if (status.hasSavepoint()) {
					if (status.isDebug()) {
						logger.debug("Rolling back transaction to savepoint");
					}
					status.rollbackToHeldSavepoint();
				}
				//都为PROPAGATION_REQUIRED最外层事务统一回滚
				else if (status.isNewTransaction()) {
					if (status.isDebug()) {
						logger.debug("Initiating transaction rollback");
					}
					doRollback(status);
				}
				else {
					// Participating in larger transaction
					if (status.hasTransaction()) {
						if (status.isLocalRollbackOnly() || isGlobalRollbackOnParticipationFailure()) {
							if (status.isDebug()) {
								logger.debug("Participating transaction failed - marking existing transaction as rollback-only");
							}
							doSetRollbackOnly(status);
						}
						else {
							if (status.isDebug()) {
								logger.debug("Participating transaction failed - letting transaction originator decide on rollback");
							}
						}
					}
					else {
						logger.debug("Should roll back transaction but cannot - no transaction available");
					}
					// Unexpected rollback only matters here if we're asked to fail early
					if (!isFailEarlyOnGlobalRollbackOnly()) {
						unexpectedRollback = false;
					}
				}
			}
			catch (RuntimeException | Error ex) {
				triggerAfterCompletion(status, TransactionSynchronization.STATUS_UNKNOWN);
				throw ex;
			}

			triggerAfterCompletion(status, TransactionSynchronization.STATUS_ROLLED_BACK);

			// Raise UnexpectedRollbackException if we had a global rollback-only marker
			if (unexpectedRollback) {
				throw new UnexpectedRollbackException(
						"Transaction rolled back because it has been marked as rollback-only");
			}
		}
		finally {
			cleanupAfterCompletion(status);
		}
	}

1、首先就是判断右没有回滚点，如果有回滚点就按照回滚点进行回滚；

2.  如果没有回滚点，判断newTransation 是否为true，为true则直接回滚。

3.  既没有回滚点，newTransation 也为FALSE，走默认逻辑，最后接着往上抛异常；找到上一层调用方法，继续仅需1、2步逻辑判断，直到回滚为止。

4. 因为回滚是基于Connection进行的，如果部分子方法已经插入数据，并且传播属性为PROPAGATION_NEW, 那么这个子方法插入的数据不会回滚。

Spring事务切面_传播属性（8）

总结2：

  @Transactional(propagation = Propagation.REQUIRED)
    @Override
    public void transation(ConsultConfigArea area, ZgGoods zgGoods) {

            areaService.addArea( area);
            goodsService.addGoods(zgGoods);

    }

本文的测试case中， transation方法使用的是REQUIRED,  addArea方法使用的是REQUIRED_NEW,  addGoods方法使用的是NESTED。 

addGoods抛异常，代码会按照回滚点进行回滚，然后接着往上抛异常；transation方法捕获到异常并且newTransation 为true，所以会直接回滚所有使用相同Connection对象进行数据库操作的子方法，即全员回滚。

但是，addArea方法的传播属性为REQUIRED_NEW， 它用于独立的Connection对象，与transation方法中持有Connection对象不是同一个，因此在transation捕获到异常并且调用它的connection进行回滚的时候，addArea方法插入的数据不会被回滚掉。

 

3.2.4. 伪代码分析：
 

try {
				// This is an around advice: Invoke the next interceptor in the chain.
				// This will normally result in a target object being invoked.
				//火炬传递
				retVal = invocation.proceedWithInvocation();
			}
			catch (Throwable ex) {
				// target invocation exception
				//事务回滚
				completeTransactionAfterThrowing(txInfo, ex);
				throw ex;
			}
 

其实核心伪代码就是以上这些。
 

假设 存在3个处理异常的一个类，并且这个类具有3个不同的实例a 、 b、 c, 那么久可以改写成这样：
 

        try {
		        a.transation()
			}
			catch (Throwable ex) {
				completeTransactionAfterThrowing(txInfo, ex);
				throw ex;
			}
 

        try {
		        b.addArea();
			}
			catch (Throwable ex) {
				completeTransactionAfterThrowing(txInfo, ex);
				throw ex;
			}
 

        try {
		        c.addGoods();
			}
			catch (Throwable ex) {
				completeTransactionAfterThrowing(txInfo, ex);
				throw ex;
			}
 

a.transation()内部调用了b.addArea()  和 c.addGoods()； 
 

c.addGoods() 内部抛异常进行回滚，继续往上抛异常；
 

a.transation()捕获到异常，也进行回滚，此时回滚掉所有字方法更新的数据，接着往上抛异常；
 

由于回滚用到的是相同的connection对象，b.addArea（）生成的事务中的connection不同于a.transation()生成的connection，因此b.addArea（）更新的数据不会被回滚。
 
 

伪代码的方式进行分析，是非常款速、简洁的，可以重点使用；文章来源地址https://www.toymoban.com/news/detail-409800.html
 
                    
到了这里，关于Spring事务切面_传播属性（8）的文章就介绍完了。如果您还想了解更多内容，请在右上角搜索TOY模板网以前的文章或继续浏览下面的相关文章，希望大家以后多多支持TOY模板网！

                

                

                                                

                   

                       
                            
                            
                            
                            
                    
本文来自互联网用户投稿，该文观点仅代表作者本人，不代表本站立场。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如若转载，请注明出处： 如若内容造成侵权/违法违规/事实不符，请点击违法举报进行投诉反馈，一经查实，立即删除！

                

                                

                    
分享到：

                    领支付宝红包
                    赞助服务器费用
                

                            

            

		        
相关文章

			    
    
			        			        
  • 
			                                    
    
                            
                                Spring Boot 事务和事务传播机制
                            
                        
    
                                                
    
                            
    
                                Spring Boot 事务和事务传播机制
                            
    
                            
    
                                
    事务定义 将一组操作封装成一个执行单元 (封装到一起)，这一组的执行具备原子性, 那么就要么全部成功，要么全部失败. 为什么要用事务? 比如转账分为两个操作: 第一步操作:A 账户-100 元。 第二步操作:B账户 +100 元。 如果没有事务，第一步执行成功了，第二步执行失败了，
    
                            
    
                            
    
                                2024年02月11日
                                
    
                                    浏览(38)
                                 
    
                            
    
                        
    
                    
    • 			        
  • 
			                                    
    
                            
                                【JavaEE进阶】Spring事务和事务传播机制
                            
                        
    
                                                
    
                            
    
                                【JavaEE进阶】Spring事务和事务传播机制
                            
    
                            
    
                                
    Spring 事务是 Spring 框架提供的一种机制，用于 管理数据库操作或其他资源的一组相关操作 ，以确保它们在一个原子、一致、可靠和隔离的执行单元内进行。事务用于维护数据的完整性并支持并发访问数据库时的数据一致性。 Spring 事务的主要特点包括： 原子性（Atomicity）：
    
                            
    
                            
    
                                2024年02月09日
                                
    
                                    浏览(61)
                                 
    
                            
    
                        
    
                    
    • 			        
  • 
			                                    
    
                            
                                Spring事务传播机制
                            
                        
    
                                                
    
                            
    
                                Spring事务传播机制
                            
    
                            
    
                                
    编程式事务管理：通过  TransactionTemplate 或者 TransactionManager 手动管理事务，实际应用中很少使用，这不是本文的重点，就不在这里赘述。 声明式事务管理：使用场景最多，也是最推荐使用的方式，直接加上@Transactional注解即可。 @Transactional 注解是用于声明事务性方法的注解
    
                            
    
                            
    
                                2024年01月16日
                                
    
                                    浏览(37)
                                 
    
                            
    
                        
    
                    
    • 			        
  • 
			                                    
    
                            
    
                                Spring事务传播机制解析
                            
    
                            
    
                                
    在Java的Spring框架中，事务管理是保证应用数据一致性和可靠性的关键。Spring提供了灵活的事务传播机制，它定义了事务边界，以及在嵌套方法调用时如何处理事务。本文旨在深入探讨Spring的事务传播行为，帮助开发者更好地理解和运用这一重要特性。 事务传播机制指的是在
    
                            
    
                            
    
                                2024年01月16日
                                
    
                                    浏览(38)
                                 
    
                            
    
                        
    
                    
    • 			        
  • 
			                                    
    
                            
                                spring的事务传播机制
                            
                        
    
                                                
    
                            
    
                                spring的事务传播机制
                            
    
                            
    
                                
    嫌弃内容代码复杂的可直接看思维导图大纲即可 指的就是当一个事务方法被另一个事务方法调用时，这个事务方法应该如何进行 默认，当前存在事务，则加入该事务；不存在事务，创建新事务。 始终以新的事务运行，当前存在事务，则挂起原事务；不存在事务，创建新事务
    
                            
    
                            
    
                                2023年04月23日
                                
    
                                    浏览(50)
                                 
    
                            
    
                        
    
                    
    • 			        
  • 
			                                    
    
                            
                                一文详解Spring事务传播机制
                            
                        
    
                                                
    
                            
    
                                一文详解Spring事务传播机制
                            
    
                            
    
                                
    目录 背景 Spring事务 @Transactional注解 使用场景 失效场景 原理 常用参数 注意 事务传播机制 处理嵌套事务流程 主事务为REQUIRED子事务为REQUIRED 主事务为REQUIRED子事务为REQUIRES_NEW 主事务为REQUIRED子事务为NESTED 实现方式 源码解析 我们在使用Spring管理数据库事务的时候很方便，只
    
                            
    
                            
    
                                2023年04月26日
                                
    
                                    浏览(46)
                                 
    
                            
    
                        
    
                    
    • 			        
  • 
			                                    
    
                            
                                【Spring】深入理解 Spring 事务及其传播机制
                            
                        
    
                                                
    
                            
    
                                【Spring】深入理解 Spring 事务及其传播机制
                            
    
                            
    
                                
    在 Spring 框架中，事务（Transaction）是一种用于管理数据库操作的机制，旨在 确保数据的 一致性、可靠性和完整性 。事务可以将一组数据库操作（如插入、更新、删除等）视为一个单独的执行单元，要么 全部成功地执行，要么全部回滚 。这样可以确保数据库在任何时候都保
    
                            
    
                            
    
                                2024年02月12日
                                
    
                                    浏览(59)
                                 
    
                            
    
                        
    
                    
    • 			        
  • 
			                                    
    
                            
                                spring事务管理详解和实例（事务传播机制、事务隔离级别）
                            
                        
    
                                                
    
                            
    
                                spring事务管理详解和实例（事务传播机制、事务隔离级别）
                            
    
                            
    
                                
    目录 1 理解spring事务 2 核心接口 2.1 事务管理器 2.1.1 JDBC事务 2.1.2 Hibernate事务 2.1.3 Java持久化API事务（JPA） 2.2 基本事务属性的定义 2.2.1 传播行为 2.2.2 隔离级别 2.2.3 只读 2.2.4 事务超时 2.2.5 回滚规则 2.3 事务状态 3 编程式事务 3.1 编程式和声明式事务的区别 3.2 如何实现编程式
    
                            
    
                            
    
                                2024年02月06日
                                
    
                                    浏览(42)
                                 
    
                            
    
                        
    
                    
    • 			        
  • 
			                                    
    
                            
                                Spring事务的四大特性+事务的传播机制+隔离机制
                            
                        
    
                                                
    
                            
    
                                Spring事务的四大特性+事务的传播机制+隔离机制
                            
    
                            
    
                                
    原子性是指事务是一个不可分割的工作单位，事务中的操作要么都发生，要么都不发生。 事务是一个原子操作, 由一系列动作组成。 组成一个事务的多个数据库操作是一个不可分割的原子单元 ，只有所有的操作执行成功，整个事务才提交。 事务中的任何一个数据库操作失败
    
                            
    
                            
    
                                2024年01月20日
                                
    
                                    浏览(38)
                                 
    
                            
    
                        
    
                    
    • 			        
  • 
			                                    
    
                            
                                Spring事务传播的7种机制
                            
                        
    
                                                
    
                            
    
                                Spring事务传播的7种机制
                            
    
                            
    
                                
    1. Propagation.REQUIRED：默认的事务传播级别，它表示如果当前存在事务，则加入该事务；如果 当前没有事务，则创建一个新的事务。 2. Propagation.SUPPORTS：如果当前存在事务，则加入该事务；如果当前没有事务，则以非事务的 方式继续运行。 3. Propagation.MANDATORY：（mandatory：强制
    
                            
    
                            
    
                                2024年02月09日
                                
    
                                    浏览(45)
                                 
    
                            
    
                        
    
                    
    • 			    

			

        

                
    

    



    
觉得文章有用就打赏一下文章作者



    
支付宝扫一扫打赏

    
博客赞助





    
微信扫一扫打赏

    
请作者喝杯咖啡吧~博客赞助











    
支付宝扫一扫领取红包，优惠每天领

	

	    
二维码1

	    
领取红包

	

	

	    
二维码2

	    
领红包