spring事务(3)-----事务传播行为详解

最新推荐文章于 2023-06-13 10:16:59 发布
最新推荐文章于 2023-06-13 10:16:59 发布
阅读量161 收藏
点赞数 1
文章标签： java 数据库

假如你现在还在为自己的技术担忧，假如你现在想提升自己的工资，假如你想在职场上获得更多的话语权，假如你想顺利的度过35岁这个魔咒，假如你想体验BAT的工作环境，那么现在请我们一起开启提升技术之旅吧，详情请点击http://106.12.206.16:8080/qingruihappy/index.html

我们通过一张图引入

这个怎么实现呢？

我们来看这7中传播行为

Propagation（key属性确定代理应该给哪个方法增加事务行为。这样的属性最重要的部份是传播行为。）有以下选项可供使用：

PROPAGATION_REQUIRED--支持当前事务，如果当前没有事务，就新建一个事务。这是最常见的选择。

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

PROPAGATION_MANDATORY--支持当前事务，如果当前没有事务，就抛出异常。 

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

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

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

 

 至于事务的传播入门请看

spring事物(2)-----手写spring注解事务&&事务传播行为

 

下面我们来仔细分析上面的7中行为。

假设有类A的方法methodB(),有类B的方法methodB()。A.methodA()调用B的methodB()方法。这里A.methodA()就是 UserService.add()   B.methodB()就是logService.addLog();

一，传播机制1-----PROPAGATION_REQUIRED  Transactional默认的

A.methodA()调用B的methodB()方法，那么如果A的方法包含事务，则B的方法则不从新开启事务，

 

1、  如果B的methodB()抛出异常，A的methodB()没有捕获，则A和B的事务都会回滚；

 

@Service
public class UserServiceImplc implements UserService {
    @Autowired
    private UserDaoc userDao;
    @Autowired
    private LogService logService;
    
    @Transactional
    public void add() {
        userDao.add("test001", 20);   
        logService.addLog();        
        userDao.add("test002", 21);

    }        
    }
    
public class LogServiceImpl implements LogService {
    @Autowired
    private LogDao logDao;
    public void addLog() {
        logDao.add("addLog" + System.currentTimeMillis());
         int i = 1 / 0;
    }

}

2、如果B的methodB()运行期间异常会导致B的methodB()的回滚，A如果捕获了异常，并正常提交事务，则会发生Transaction rolled back because it has been marked as rollback-only的异常。

@Service
public class UserServiceImplc implements UserService {
    @Autowired
    private UserDaoc userDao;
    @Autowired
    private LogService logService;
    
    @Transactional
    public void add() {
        try{
        userDao.add("test001", 20);   
        logService.addLog();        
        userDao.add("test002", 21);
        }catch{            
        }
    }        
    }
    
public class LogServiceImpl implements LogService {
    @Autowired
    private LogDao logDao;
    public void addLog() {
        logDao.add("addLog" + System.currentTimeMillis());
         int i = 1 / 0;
    }

}

3、如果A的methodA()运行期间异常，则A和B的Method的事务都会被回滚

@Service
public class UserServiceImplc implements UserService {
    @Autowired
    private UserDaoc userDao;
    @Autowired
    private LogService logService;
    
    @Transactional
    public void add() {
        userDao.add("test001", 20);   
        logService.addLog();
        int i = 1 / 0;        
        userDao.add("test002", 21);
    }        
    }
    
public class LogServiceImpl implements LogService {
    @Autowired
    private LogDao logDao;
    public void addLog() {
        logDao.add("addLog" + System.currentTimeMillis());
    }
}

 

二，传播机制2----- PROPAGATION_SUPPORTS


如果B的方法methodB()的事务传播特性是propagation_supports,
A.methodA()调用B的methodB()方法，那么如果A的方法包含事务，则B运行在此事务环境中，如果A的方法不包含事务，则B运行在非事务环境；

1、如果A没有事务，则A和B的运行出现异常都不会回滚。

 

@Service
public class UserServiceImplc implements UserService {
    @Autowired
    private UserDaoc userDao;
    @Autowired
    private LogService logService;
    
    public void add() {
        userDao.add("test001", 20);   
        logService.addLog();
        int i = 1 / 0;        
        userDao.add("test002", 21);
    }        
    }
    @Transactional(propagation = Propagation.PROPAGATION_SUPPORTS)
public class LogServiceImpl implements LogService {
    @Autowired
    private LogDao logDao;
    public void addLog() {
        logDao.add("addLog" + System.currentTimeMillis());
    }
}

 

 

@Service
public class UserServiceImplc implements UserService {
    @Autowired
    private UserDaoc userDao;
    @Autowired
    private LogService logService;
    
    public void add() {
        userDao.add("test001", 20);   
        logService.addLog();            
        userDao.add("test002", 21);
    }        
    }
    
    @Transactional(propagation = Propagation.PROPAGATION_SUPPORTS)
public class LogServiceImpl implements LogService {
    @Autowired
    private LogDao logDao;
    public void addLog() {
        logDao.add("addLog" + System.currentTimeMillis());
        int i = 1 / 0;    
    }
}

 

 

2、如果A有事务，A的method方法执行抛出异常，B.methodB和A.methodA都会回滚。

 

@Service
public class UserServiceImplc implements UserService {
    @Autowired
    private UserDaoc userDao;
    @Autowired
    private LogService logService;
    @Transactional
    public void add() {
        userDao.add("test001", 20);   
        logService.addLog();
        int i = 1 / 0;        
        userDao.add("test002", 21);
    }        
    }
    @Transactional(propagation = Propagation.PROPAGATION_SUPPORTS)
public class LogServiceImpl implements LogService {
    @Autowired
    private LogDao logDao;
    public void addLog() {
        logDao.add("addLog" + System.currentTimeMillis());
    }
}

3、如果A有事务，B.method抛出异常，B.methodB和A.methodA都会回滚，如果A捕获了B.method抛出的异常，则会出现异常Transactionrolled back because it has been marked as rollback-only。

@Service
public class UserServiceImplc implements UserService {
    @Autowired
    private UserDaoc userDao;
    @Autowired
    private LogService logService;
    
    @Transactional
    public void add() {
        userDao.add("test001", 20);   
        logService.addLog();        
        userDao.add("test002", 21);

    }        
    }
    
    @Transactional(propagation = Propagation.PROPAGATION_SUPPORTS)
public class LogServiceImpl implements LogService {
    @Autowired
    private LogDao logDao;
    public void addLog() {
        logDao.add("addLog" + System.currentTimeMillis());
         int i = 1 / 0;
    }

}
@Service
public class UserServiceImplc implements UserService {
    @Autowired
    private UserDaoc userDao;
    @Autowired
    private LogService logService;
    
    @Transactional
    public void add() {
        try{
        userDao.add("test001", 20);   
        logService.addLog();        
        userDao.add("test002", 21);
        }catch{            
        }
    }        
    }
    @Transactional(propagation = Propagation.PROPAGATION_SUPPORTS)
public class LogServiceImpl implements LogService {
    @Autowired
    private LogDao logDao;
    public void addLog() {
        logDao.add("addLog" + System.currentTimeMillis());
         int i = 1 / 0;
    }
}

三，传播机制3----- PROPAGATION_MANDATORY

表示当前方法必须在一个事务中运行，如果没有事务，将抛出异常，如下图调用关系：

B.methodB()事务传播特性定义为:PROPAGATION_MANDATORY

 

1、如果A的methoda()方法没有事务运行环境，则B的methodB()执行的时候会报如下异常：No existingtransaction found for transaction marked with propagation 'mandatory'

 

@Service
public class UserServiceImplc implements UserService {
    @Autowired
    private UserDaoc userDao;
    @Autowired
    private LogService logService;
    

    public void add() {
        userDao.add("test001", 20);   
        logService.addLog();        
        userDao.add("test002", 21);

    }        
    }
    
    @Transactional(propagation = Propagation.PROPAGATION_MANDATORY)
public class LogServiceImpl implements LogService {
    @Autowired
    private LogDao logDao;
    public void addLog() {
        logDao.add("addLog" + System.currentTimeMillis());
         int i = 1 / 0;
    }

}

 

2、如果A的Methoda()方法有事务并且执行过程中抛出异常，则A.methoda（）和B.methodb（）执行的操作被回滚；

 

@Service
public class UserServiceImplc implements UserService {
    @Autowired
    private UserDaoc userDao;
    @Autowired
    private LogService logService;
    
    @Transactional
    public void add() {
        userDao.add("test001", 20);   
        logService.addLog();    
 int i = 1 / 0;        
        userDao.add("test002", 21);

    }        
    }
    
    @Transactional(propagation = Propagation.PROPAGATION_MANDATORY)
public class LogServiceImpl implements LogService {
    @Autowired
    private LogDao logDao;
    public void addLog() {
        logDao.add("addLog" + System.currentTimeMillis());
        
    }

}

3、如果A的methoda()方法有事务，则B.methodB()抛出异常时，A的methoda()和B.methodB()都会被回滚；如果A捕获了B.method抛出的异常，则会出现异常Transaction rolled back because ithas been marked as rollback-only

 

@Service
public class UserServiceImplc implements UserService {
    @Autowired
    private UserDaoc userDao;
    @Autowired
    private LogService logService;
    
 @Transactional
    public void add() {

        userDao.add("test001", 20);   
        logService.addLog();        
        userDao.add("test002", 21);

    }        

    
    @Transactional(propagation = Propagation.PROPAGATION_MANDATORY)
public class LogServiceImpl implements LogService {
    @Autowired
    private LogDao logDao;
    public void addLog() {
        logDao.add("addLog" + System.currentTimeMillis());
         int i = 1 / 0;
    }

}
@Service
public class UserServiceImplc implements UserService {
    @Autowired
    private UserDaoc userDao;
    @Autowired
    private LogService logService;
    
 @Transactional
    public void add() {
        try{
        userDao.add("test001", 20);   
        logService.addLog();        
        userDao.add("test002", 21);
        }catch{
        }
    }        

    
    @Transactional(propagation = Propagation.PROPAGATION_MANDATORY)
public class LogServiceImpl implements LogService {
    @Autowired
    private LogDao logDao;
    public void addLog() {
        logDao.add("addLog" + System.currentTimeMillis());
         int i = 1 / 0;
    }

}

四，传播机制4----- PROPAGATION_NESTED

 

B的methodB()定义的事务为PROPAGATION_NESTED；

 

 

1、如果A的MethodA()不存在事务，则B的methodB()运行在一个新的事务中，B.method()抛出的异常，B.methodB()回滚,但A.methodA()不回滚；如果A.methoda()抛出异常，则A.methodA()和B.methodB()操作不回。

 

@Service
public class UserServiceImplc implements UserService {
    @Autowired
    private UserDaoc userDao;
    @Autowired
    private LogService logService;
    

    public void add() {
        userDao.add("test001", 20);   
        logService.addLog();        
        userDao.add("test002", 21);

    }        
    }
    
    @Transactional(propagation = Propagation.PROPAGATION_NESTED)
public class LogServiceImpl implements LogService {
    @Autowired
    private LogDao logDao;
    public void addLog() {
        logDao.add("addLog" + System.currentTimeMillis());
         int i = 1 / 0;
    }

}
@Service
public class UserServiceImplc implements UserService {
    @Autowired
    private UserDaoc userDao;
    @Autowired
    private LogService logService;
    

    public void add() {
        userDao.add("test001", 20);   
        logService.addLog();
int i = 1 / 0;        
        userDao.add("test002", 21);

    }        
    }
    
    @Transactional(propagation = Propagation.PROPAGATION_NESTED)
public class LogServiceImpl implements LogService {
    @Autowired
    private LogDao logDao;
    public void addLog() {
        logDao.add("addLog" + System.currentTimeMillis());
         
    }

}

2、如果A的methodA()存在事务，则A的methoda()抛出异常，则A的methoda()和B的Methodb()都会被回滚；

 

@Service
public class UserServiceImplc implements UserService {
    @Autowired
    private UserDaoc userDao;
    @Autowired
    private LogService logService;
    
@Transactional
    public void add() {
        userDao.add("test001", 20);   
        logService.addLog();
int i = 1 / 0;        
        userDao.add("test002", 21);

    }        

}
    @Transactional(propagation = Propagation.PROPAGATION_NESTED)
public class LogServiceImpl implements LogService {
    @Autowired
    private LogDao logDao;
    public void addLog() {
        logDao.add("addLog" + System.currentTimeMillis());
         
    }

}

3、如果A的MethodA()存在事务，则B的methodB()抛出异常，B.methodB()回滚，如果A不捕获异常，则A.methodA()和B.methodB()都会回滚，如果A捕获异常，则B.methodB()回滚,A不回滚；

 

@Service
public class UserServiceImplc implements UserService {
    @Autowired
    private UserDaoc userDao;
    @Autowired
    private LogService logService;
    
@Transactional
    public void add() {
        userDao.add("test001", 20);   
        logService.addLog();    
        userDao.add("test002", 21);

    }        

}
    @Transactional(propagation = Propagation.PROPAGATION_NESTED)
public class LogServiceImpl implements LogService {
    @Autowired
    private LogDao logDao;
    public void addLog() {
        logDao.add("addLog" + System.currentTimeMillis());
        int i = 1 / 0;    
         
    }

}
@Service
public class UserServiceImplc implements UserService {
    @Autowired
    private UserDaoc userDao;
    @Autowired
    private LogService logService;
    
@Transactional
    public void add() {
        try{
        userDao.add("test001", 20);   
        logService.addLog();    
        userDao.add("test002", 21);
        }catch{
        }

    }        

}
    @Transactional(propagation = Propagation.PROPAGATION_NESTED)
public class LogServiceImpl implements LogService {
    @Autowired
    private LogDao logDao;
    public void addLog() {
        logDao.add("addLog" + System.currentTimeMillis());
        int i = 1 / 0;    
         
    }

}


五，传播机制5----- PROPAGATION_NEVER

 

 

表示事务传播特性定义为PROPAGATION_NEVER的方法不应该运行在一个事务环境中

 

 

 如果B.methodB()的事务传播特性被定义为PROPAGATION_NEVER，则如果A.methodA()方法存在事务，则会出现异常Existingtransaction found for transaction marked with propagation 'never'。

 

@Service
public class UserServiceImplc implements UserService {
    @Autowired
    private UserDaoc userDao;
    @Autowired
    private LogService logService;
    
@Transactional
    public void add() {
        try{
        userDao.add("test001", 20);   
        logService.addLog();    
        userDao.add("test002", 21);
        }catch{
        }

    }        

}
    @Transactional(propagation = Propagation.PROPAGATION_NEVER)
public class LogServiceImpl implements LogService {
    @Autowired
    private LogDao logDao;
    public void addLog() {
        logDao.add("addLog" + System.currentTimeMillis());
        int i = 1 / 0;    
         
    }

}

六，传播机制6----- PROPAGATION_REQUIRES_NEW

 

 表示事务传播特性定义为PROPAGATION_REQUIRES_NEW的方法需要运行在一个新的事务中。

如有一下调用关系：B.methodB()事务传播特性为PROPAGATION_REQUIRES_NEW.

 

 

1、如果A存在事务，A.methodA()抛出异常，A.methodA()的事务被回滚，但B.methodB()事务不受影响；
如果B.methodB()抛出异常，A不捕获的话，A.methodA()和B.methodB()的事务都会被回滚。
如果A捕获的话，A.methodA()的事务不受影响但B.methodB()的事务回滚。

 

@Service
public class UserServiceImplc implements UserService {
    @Autowired
    private UserDaoc userDao;
    @Autowired
    private LogService logService;
    
@Transactional
    public void add() {
        userDao.add("test001", 20);   
        logService.addLog();    
        int i=1/0;
        userDao.add("test002", 21);
    }        

}
    @Transactional(propagation = Propagation.PROPAGATION_REQUIRES_NEW)
public class LogServiceImpl implements LogService {
    @Autowired
    private LogDao logDao;
    public void addLog() {
        logDao.add("addLog" + System.currentTimeMillis());
         
    }
}

如果B.methodB()抛出异常，A不捕获的话，A.methodA()和B.methodB()的事务都会被回滚。

 

 

@Service
public class UserServiceImplc implements UserService {
    @Autowired
    private UserDaoc userDao;
    @Autowired
    private LogService logService;
    
@Transactional
    public void add() {
        userDao.add("test001", 20);   
        logService.addLog();    
        userDao.add("test002", 21);
    }        

}
    @Transactional(propagation = Propagation.PROPAGATION_REQUIRES_NEW)
public class LogServiceImpl implements LogService {
    @Autowired
    private LogDao logDao;
    public void addLog() {
        logDao.add("addLog" + System.currentTimeMillis());
         int i=1/0;
    }

}

如果A捕获的话，A.methodA()的事务不受影响但B.methodB()的事务回滚。

 

@Service
public class UserServiceImplc implements UserService {
    @Autowired
    private UserDaoc userDao;
    @Autowired
    private LogService logService;
    
@Transactional
    public void add() {
        try{
        userDao.add("test001", 20);   
        logService.addLog();    

        userDao.add("test002", 21);
        }catch{
        }

    }        

}
    @Transactional(propagation = Propagation.PROPAGATION_REQUIRES_NEW)
public class LogServiceImpl implements LogService {
    @Autowired
    private LogDao logDao;
    public void addLog() {
        logDao.add("addLog" + System.currentTimeMillis());
                 int i=1/0;
    }

}

七，传播机制7----- PROPAGATION_NOT_SUPPORTED

 

表示该方法不应该在一个事务中运行。如果有一个事务正在运行，他将在运行期被挂起，直到这个事务提交或者回滚才恢复执行。

如有一下调用关系图：

如果B.methodB()方法传播特性被定义为：PROPAGATION_NOT_SUPPORTED。

 

1、如果A.methodA()存在事务，如果B.methodB()抛出异常，A.methodA()不捕获的话，A.methodA()的事务被回滚，而B.methodB()出现异常前数据库操作不受影响。如果A.methodA()捕获的话，则A.methodA()的事务不受影响，
B.methodB()异常抛出前的数据操作不受影响。

@Service
public class UserServiceImplc implements UserService {
    @Autowired
    private UserDaoc userDao;
    @Autowired
    private LogService logService;
    
@Transactional
    public void add() {
        userDao.add("test001", 20);   
        logService.addLog();    
        userDao.add("test002", 21);
    }        

}
    @Transactional(propagation = Propagation.PROPAGATION_NOT_SUPPORTED)
public class LogServiceImpl implements LogService {
    @Autowired
    private LogDao logDao;
    public void addLog() {
        logDao.add("addLog" + System.currentTimeMillis());
         int i=1/0;
    }

}
@Service
public class UserServiceImplc implements UserService {
    @Autowired
    private UserDaoc userDao;
    @Autowired
    private LogService logService;
    
@Transactional
    public void add() {
    try{
        userDao.add("test001", 20);   
        logService.addLog();    
        userDao.add("test002", 21);}catch{
        }
    }        

}
    @Transactional(propagation = Propagation.PROPAGATION_NOT_SUPPORTED)
public class LogServiceImpl implements LogService {
    @Autowired
    private LogDao logDao;
    public void addLog() {
        logDao.add("addLog" + System.currentTimeMillis());
         int i=1/0;
    }

}

 

八，事务的使用案例 

1、  在一个话费充值业务处理逻辑中，有如下图所示操作:

业务需要扣款操作和创建订单操作同成功或者失败，因此，charger()和order()的事务不能相互独立，需要包含在chargeHandle()的事务中；

通过以上需求，可以给charge()和order()的事务传播行为定义成：PROPAGATION_MANDATORY

只要charge()或者order()抛出异常整个chargeHandle()都一起回滚，即使chargeHandle()捕获异常也没用，不允许提交事务。

2、  如果业务需求没接受到一次请求到要记录日志到数据库，如下图：

 

因为log()的操作不管扣款和创建订单成功与否都要生成日志，并且日志的操作成功与否不影响充值处理，所以log()方法的事务传播行为可以定义为:PROPAGATION_REQUIRES_NEW.

3、  在订单的售后处理中，更新完订单金额后，需要自动统计销售报表，如下图所示：

 

根据业务可知，售后是已经处理完订单的充值请求后的功能，是对订单的后续管理，统计报表report()方法耗时较长，因此，我们需要设置report()的事务传播行为为:PROPAGATION_NEVER,表示不适合在有事务的操作中调用，因为report()太耗时。

4、  在银行新增银行卡业务中，需要执行两个操作，一个是保存银行卡信息，一个是登记新创建的银行卡信息，其中登记银行卡信息成功与否不影响银行卡的创建。

 

 

 

由以上需求，我们可知对于regster()方法的事务传播行为，可以设置为PROPAGATION_NESTED，action()事务的回滚，regster()保存的信息就没意义，也就需要跟着回滚，而regster()的回滚不影响action()事务；insert()的事务传播行为可以设置为PROPAGATION_REQUIRED, PROPAGATION_MANDATORY，即insert()回滚事务，action()的事务必须跟着回滚。

假如你现在还在为自己的技术担忧，假如你现在想提升自己的工资，假如你想在职场上获得更多的话语权，假如你想顺利的度过35岁这个魔咒，假如你想体验BAT的工作环境，那么现在请我们一起开启提升技术之旅吧，详情请点击http://106.12.206.16:8080/qingruihappy/index.html

 

weixin_33727510
关注
Spring事务传播行为详解
刘树之的博客
08-17 624
前言 Spring在TransactionDefinition接口中规定了7种类型的事务传播行为。事务传播行为是Spring框架独有的事务增强(通知)特性，是Spring为我们提供的强大的工具箱，使用事务传播行可以为我们的开发工作提供许多便利。但是人们对他的误解也颇多，你一定也听过“service方法事务最好不要嵌套”的传言。要想正确的使用工具首先需要了解工具。本文对七种事务传播行为做详细介绍，内容主要代码示例的方式呈现。 基础概念 1.什么是事务传播行为？ 事务传播行为用来描述由某一个事务传播行为修饰的方
Spring事务以及事务传播行为详解
java1_boy的博客
03-18 381
目录 Spring事务以及事务传播行为详解 一：事务的概念 二：事务的四大特性 1：原子性（Atomicity） 2：⼀致性（Consistency） 3：隔离性（Isolation） 4：持久性（Durability） 三：事务的隔离级别 1：脏读 2：不可重复读...
理解Spring的事务传播机制
【欢迎关注公众号：冬瓜白】
03-08 539
Spring其中一个强大之处在于，他是支持声明式事务的。而用好声明式事务的前提是，要理解Spring的事务传播机制。 本文详细介绍了Spring事务传播机制。 Spring的事务传播类型 Spring的事务传播机制类型定义在了Propagation枚举类中。主要有以下几种类型。 下面主要对常用的PROPAGATION_REQUIRED、PROPAGATION_REQUIRES_NEW和PROPAGATION_NESTED做详细介绍。 PROPAGATION_REQUIRED PROPAGAT
spring事务传播机制实例讲解
low_coder
12-02 1713
对于SQL事务的概念以及ACID性质，可以参见我的另一篇博文 http://kingj.iteye.com/admin/blogs/1675011spring的管理的事务可以分为如下2类： 逻辑事务   在spring中定义的事务通常指逻辑事务，提供比物理事务更抽象，方便的事务配置管理，但也基于物理事务物理事务  特定于数据库的事务 spring中支持一下2中事务声明方式 编程式事务
【Spring】事务以及传播行为理解
Jorgen_s的博客
06-27 328
我们都知道事务的概念，那么事务的传播特性是什么呢？(此处着重介绍传播特性的概念...）
spring-example-db-tx:数据库事务的Spring示例
04-30
《Spring数据库事务管理详解——基于spring-example-db-tx示例》 在软件开发中，数据库事务是确保数据一致性、完整性和可靠性的关键机制。本文将以"spring-example-db-tx"项目为例，深入探讨如何在Java环境中，特别...
spring-boot-starter-mybatis-spring-boot-1.2.0.tar.gz
最新发布
04-19
- 注意事务管理的问题，如未开启事务、事务传播属性设置不正确等。 通过以上步骤和知识点，你可以在Spring Boot 1.2.0版本中成功集成并使用Mybatis，实现高效的数据访问。理解并掌握这些内容，将有助于你构建出...
spring-mybatis-spring-1.2.2.zip
04-19
通过@Transactional注解，可以在方法级别定义事务的传播行为和隔离级别。 6. **AOP代理**：Spring的AOP（面向切面编程）支持可以用于拦截Mapper接口的方法调用，实现例如日志记录、权限检查等切面逻辑。 7. **性能...
Spring框架(五)--Spring事务管理和Spring事务传播行为
XiaoFanMi的博客
07-10 205
Spring事务管理 事务可以看做是由对数据库若干操作组成的一个单元 作用:保证用户的每一个操作都是可靠地,每一个操作都必须成功,只要发生异常就回退到事务未操作的状态,要么都完成,要么都取消,保证一致性的要求 事物的特性:原子性 隔离性 持久性 一致性 Spring事务管理分两种类型: 1.编程式事务:在代码中需要自己写代码实现事物的提交和回滚 2.声明式事务:只要生命哪个方法需要在事务中执行,Spring就会知道添加事物的提交和回滚操作 Spring事务管理方式: 1.基于xml配置 <1.
Spring 支持的事务传播行为
fwk19840301的博客
06-06 425
只能支付第一本书, 不够支付第二本书：required：两本书都买不成required new：第一本能买成 第二本回滚了
Propagation.NESTED 和Propagation.REQUIRES_NEW的区别
aiyaya_66da的博客
06-29 4172
Propagation.NESTED 和Propagation.REQUIRES_NEW的区别 首先感谢这个微博的博主，解决了我的疑惑。https://www.cnblogs.com/-flq/p/9768576.html 说到spring的事务传播行为，最难理解的不过是Propagation.REQUIRES_NEW和Propagation.NESTED了。上网搜了一下大家的描述，我自己总结...
propagation定义了7个事物传播行为
qq_36074064的博客
08-28 1130
REQUIRED：如果存在一个事物，则支持当前事物。如果没有事物则开启一个新的事物。 SUPPORTS：如果存在一个事物，支持当前事物。如果没有事物，则非事物的执行。但是对于事物同步的事务管理SUPPORTS与不使用事物有少许不同。 REQUIRES_NEW：总是开启一个新的事物。如果一个事物已经存在，则将这个存在的事物挂起。 NOT_SUPPORTED：总是非事物的执行，并挂起任何存在的事
PROPAGATION_REQUIRES_NEW 和 PROPAGATION_NESTED区别
热门推荐
u011285162的专栏
02-15 1万+
最容易弄混淆的其实是 PROPAGATION_REQUIRES_NEW 和 PROPAGATION_NESTED, 那么这两种方式又有何区别呢? 我简单的翻译一下 Juergen Hoeller 的话 :           PROPAGATION_REQUIRES_NEW 启动一个新的, 不依赖于环境的 "内部" 事务. 这个事务将被完全 commited 或 rolled back 而
Spring 事务传播机制源码浅析——PROPAGATION_REQUIRES_NEW
龚小帅的博客
08-24 2585
两个方法都使用 PROPAGATION_REQUIRES_NEW 传播机制进行演示，并分析源码：示例如下： 还是要进入 TransactionInterceptor 类，这各类是入口，这里截取出核心源码如下：进入 createTransactionIfNecessary() 方法，可以分成六个核心步骤，源码如下：源码如下：可以发现第一步骤有两行非常重要的代码，第一行代码主要是从 ThreadLocal 类型的变量中去获取值，源码如下：第一次也就是现在过来的 add() 方法，现在从这个 ThreadLoc
事务的传播行为
qq_36722039的博客
07-18 331
举例： 用户想要买两本书，但是账户的钱只够支付一本书，这时需要先支付一本。 如果事默认的事务传播行为（REQUIRED），则两本书都不能购买成功，这是需要将事务的传播行为设置为REQUIRES_NEW 重点事这两种传播行为： REQUIRED 传播行为： 默认的事务传播行为，当前方法内的所有方法都在一个事务中，要么都成功，要么都不成功。 @Transactional(propaga...
Spring事务传播问题 — PROPAGATION_REQUIRES_NEW
BraveHeart
06-11 1762
原文：https://blog.csdn.net/wangjunjun2008/article/details/53669951 一、描述 Spring遇到嵌套事务时，当被嵌套的事务被定义为“PROPAGATION_REQUIRES_NEW”时， 内层Service的方法被调用时，外层方法的事务被挂起； 内层事务相对于外层事务是完全独立的，有独立的隔离性等等。 二、实验 但实验时却遇到一个奇怪的问...
No existing transaction found for transaction marked with propagation mandatory报错原因
枫叶
06-13 1109
No existing transaction found for transaction marked with propagation 'mandatory报错原因
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值