精华内容
下载资源
问答
  • Spring-七种事务传播特性
    2021-04-17 08:53:36

    以下面2个方法为例:

    @Service

    public class DaoService {

    @Transactional

    public void laoda() {

    System.out.println("老大的方法");

    //在老大方法里面调用小弟方法

    xiaodi();

    }

    @Transactional

    public void xiaodi() {

    System.out.println("小弟的方法");

    }

    }

    Spring总共给了7种事务的传播特性:

    就是多个事务方法相互调用时,事务如何在这些方法间传播

    问题:什么叫传播特性, 拿上面两个方法来说,老大方法调用小弟方法,老大方法里面发生异常小弟事务怎么处理?

    分三类:

    1.=死活不要事务===

    1) PROPAGATION_NEVER: 没有就非事务执行,有就抛异常

    eg: 老大调用小弟方法,小弟不允许有事务,当小弟发现老大有事务时,直接抛异常,我不干,没有就正常运行

    2) PROPAGATION_NOT_SUPPORTED: 没有就非事务执行,有就直接挂起,然后非事务执行

    eg: 老大调用小弟方法,小弟不允许有事务,当小弟发现老大有事务时,就将老大的事务挂起,换句话说就是老大的事务管不着小弟,小弟自己非事务运行,不受老大事务约束

    2.=事务可有可无==

    3). PROPAGATION_SUPPORTS: 如果有事务就用,没有就非事务执行

    eg: 老大调用小弟方法,小弟会去看下老大是否有事务,有就用,没有就算了,非事务运行

    3.=必须有事务的==

    4).PROPAGATION_REQUIRED_NEW: 有没有都会新建事务,如果原来有,就将原来的挂起;

    eg: 老大调用小弟方法,小弟方法必须要有事务,它会去看下老大有没有事务,老大有就将老大的挂起,反正不会用老大的事务,自己新建一个新的。小弟由于是一个新的事务,所以不受老大事务影响,但是如果小弟抛异常,小弟回滚,老大就要看下是否处理异常,没有处理也回滚,处理了就不会回滚

    启动一个新的, 不依赖于环境的 “内部” 事务. 这个事务将被完全 commited 或 rolled back 而不依赖于外部事务, 它拥有自己的隔离范围, 自己的锁, 等等. 当内部事务开始执行时, 外部事务将被挂起, 内务事务结束时, 外部事务将继续执行.

    比如我们设计ServiceA.methodA的事务级别为PROPAGATION_REQUIRED,ServiceB.methodB的事务级别为PROPAGATION_REQUIRES_NEW,那么当执行到ServiceB.methodB的时候,ServiceA.methodA所在的事务就会挂起,ServiceB.methodB会起一个新的事务,等待ServiceB.methodB的事务完成以后,他才继续执行。他与PROPAGATION_REQUIRED 的事务区别在于事务的回滚程度了。因为ServiceB.methodB是新起一个事务,那么就是存在两个不同的事务。

    1、如果ServiceB.methodB已经提交,那么ServiceA.methodA失败回滚,ServiceB.methodB是不会回滚的。

    2、如果ServiceB.methodB失败回滚,如果他抛出的异常被ServiceA.methodA的try…catch捕获并处理,ServiceA.methodA事务仍然可能提交;如果他抛出的异常未被ServiceA.methodA捕获处理,ServiceA.methodA事务将回滚。

    5). PROPAGATION_NESTED: 如果没有,就新建一个事务,如果有,就在当前事务中嵌套其他事务;

    eg:老大调用小弟方法,小弟方法必须要有事务,它会去看下老大有没有事务,有就用老大的事务,没有就自己新建一个事务,嵌套其中。当小弟发生异常,会回滚到回滚点 savepoint.,也就是嵌套事务点,外界事务此时不会回滚,除非他对异常没有进行处理,但是如果老大发生异常,由于是嵌套,小弟必然回滚。

    开始一个 “嵌套的” 事务, 它是已经存在事务的一个真正的子事务. 潜套事务开始执行时, 它将取得一个 savepoint. 如果这个嵌套事务失败, 我们将回滚到此 savepoint. 潜套事务是外部事务的一部分, 只有外部事务结束后它才会被提交.

    比如我们设计ServiceA.methodA的事务级别为PROPAGATION_REQUIRED,ServiceB.methodB的事务级别为PROPAGATION_NESTED,那么当执行到ServiceB.methodB的时候,ServiceA.methodA所在的事务就会挂起,ServiceB.methodB会起一个新的子事务并设置savepoint,等待ServiceB.methodB的事务完成以后,他才继续执行。。因为ServiceB.methodB是外部事务的子事务,那么

    1、如果ServiceB.methodB已经提交,那么ServiceA.methodA失败回滚,ServiceB.methodB也将回滚。

    2、如果ServiceB.methodB失败回滚,如果他抛出的异常被ServiceA.methodA的try…catch捕获并处理,ServiceA.methodA事务仍然可能提交;如果他抛出的异常未被ServiceA.methodA捕获处理,ServiceA.methodA事务将回滚。

    理解Nested的关键是savepoint。他与PROPAGATION_REQUIRES_NEW的区别是:

    PROPAGATION_REQUIRES_NEW 完全是一个新的事务,它与外部事务相互独立; 而 PROPAGATION_NESTED 则是外部事务的子事务, 如果外部事务 commit, 嵌套事务也会被 commit, 这个规则同样适用于 roll back.

    在 spring 中使用 PROPAGATION_NESTED的前提:

    我们要设置 transactionManager 的 nestedTransactionAllowed 属性为 true, 注意, 此属性默认为 false!!!

    java.sql.Savepoint 必须存在, 即 jdk 版本要 1.4+

    Connection.getMetaData().supportsSavepoints() 必须为 true, 即 jdbc drive 必须支持 JDBC 3.0

    6) PROPAGATION_REQUIRED: 如果没有,就新建一个事务,如果有,就加入当前事务.

    eg:老大调用小弟方法,小弟方法必须要有事务,它会去看下老大有没有事务,有就用老大的事务,没有就自己新建一个事务。 如果老大有事务,此时小弟使用老大事务,他们是一个整体,要么同时成功,要么同时失败,但是如果老大没有事务,小弟自己新建了一个事务,那么即使小弟事务抛异常也不会影响老大,因为老大没事务.

    7). PROPAGATION_MANDTORY: 如果没有就抛异常,如果有就是使用当前事务

    eg:老大调用小弟方法,小弟方法必须要有事务,它会去看下老大有没有事务,有就用老大的事务,没有就抛异常,反正自己不会去新建事务。

    必须在一个事务中运行。也就是说,他只能被一个父事务调用。否则,他就要抛出异常

    标签:事务,七种,老大,Spring,小弟,PROPAGATION,methodB,ServiceB

    来源: https://blog.csdn.net/Hmj050117/article/details/112690078

    更多相关内容
  • 我们都知道事务的概念,那么事务传播特性什么呢?(此处着重介绍传播特性的概念,关于传播特性的相关配置就不介绍了,可以查看spring的官方文档)在我们用SSH开发项目的时候,我们一般都是将事务设置在Service层 ...

    我们都知道事务的概念,那么事务的传播特性是什么呢?(此处着重介绍传播特性的概念,关于传播特性的相关配置就不介绍了,可以查看spring的官方文档)

    在我们用SSH开发项目的时候,我们一般都是将事务设置在Service层 那么当我们调用Service层的一个方法的时候它能够保证我们的这个方法中执行的所有的对数据库的更新操作保持在一个事务中,在事务层里面调用的这些方 法要么全部成功,要么全部失败。那么事务的传播特性也是从这里说起的。

    如果你在你的Service层的这个方法中,除了调用了Dao层的方法之外,还调用了本类的其他的Service方法,那么在调用其他的 Service方法的时候,这个事务是怎么规定的呢,我必须保证我在我方法里掉用的这个方法与我本身的方法处在同一个事务中,否则如果保证事物的一致性。 事务的传播特性就是解决这个问题的,“事务是会传播的”在Spring中有针对传播特性的多种配置我们大多数情况下只用其中的一 种:PROPGATION_REQUIRED:这个配置项的意思是说当我调用service层的方法的时候开启一个事务(具体调用那一层的方法开始创建事 务,要看你的aop的配置),那么在调用这个service层里面的其他的方法的时候,如果当前方法产生了事务就用当前方法产生的事务,否则就创建一个新 的事务。这个工作使由Spring来帮助我们完成的。

    以前没有Spring帮助我们完成事务的时候我们必须自己手动的控制事务,例如当我们项目中仅仅使用hibernate,而没有集成进 spring的时候,我们在一个service层中调用其他的业务逻辑方法,为了保证事物必须也要把当前的hibernate session传递到下一个方法中,或者采用ThreadLocal的方法,将session传递给下一个方法,其实都是一个目的。现在这个工作由 spring来帮助我们完成,就可以让我们更加的专注于我们的业务逻辑。而不用去关心事务的问题。

    默认情况下当发生RuntimeException的情况下,事务才会回滚,所以要注意一下 如果你在程序发生错误的情况下,有自己的异常处理机制定义自己的Exception,必须从RuntimeException类继承 这样事务才会回滚!

    Spring事务传播特性总结:

    1.只要定义为spring的bean就可以对里面的方法使用@Transactional注解。

    2.Spring的事务传播是Spring特有的。不是对底层jdbc的代理。

    3.使用spring声明式事务,spring使用AOP来支持声明式事务,会根据事务属性,自动在[方法调用之前决定是否开启一个事务],并在[方法执行之后]决定事务提交或回滚事务。

    4.Spring支持的PROPAGATION_NESTED 与PROPAGATION_REQUIRES_NEW的区别:

    PROPAGATION_REQUIRES_NEW:二个事务没有信赖关系,不会存在A事务的成功取决于B事务的情况。有可能存在A提交B失败。A失败(比如执行到doSomeThingB的时候抛出异常)B提交,AB都提交,AB都失败的可能。

    PROPAGATION_NESTED:与PROPAGATION_REQUIRES_NEW不同的是,内嵌事务B会信赖A。即存在A失败B失败。A成功,B失败。A成功,B成功。而不存在A失败,B成功。

    5. 特别注意PROPAGATION_NESTED的使用条件:使用JDBC 3.0驱动时,仅仅支持DataSourceTransactionManager作为事务管理器。需要JDBC 驱动的java.sql.Savepoint类。有一些JTA的事务管理器实现可能也提供了同样的功能。使用PROPAGATION_NESTED,还需 要把PlatformTransactionManager的nestedTransactionAllowed属性设为true;而 nestedTransactionAllowed属性值默认为false;

    6.特别注意PROPAGATION_REQUIRES_NEW的使用条件:JtaTransactionManager作为事务管理器

    的AOP简介与事务传播特性总结2009-10-26 16:56srping用到的另外一项技术就是AOP(Aspect-Oriented Programming, 面向切面编程),它是一种新的方法论, 是对传统 OOP(Object-Oriented Programming, 面向对象编程)的补充。AOP 的主要编程对象是切面(aspect), 而切面模块化横切关注点。在应用 AOP 编程时, 仍然需要在定义公共功能, 但可以明确的定义这个功能在哪里, 以什么方式应用, 并且不必修改受影响的类. 这样一来横切关注点就被模块化到特殊的对象(切面)里。每个事物逻辑位于一个位置, 代码不分散,便于维护和升级,业务模块更简洁, 只包含核心业务代码。

    现实中使用spring最多的就是声明式事务配置功能。下面就来了解其aop在事务上应用。首先要了解的就是AOP中的一些概念:

    Aspect(切面):指横切性关注点的抽象即为切面,它与类相似,只是两者的关注点不一样,类是对物体特征的抽象,而切面是横切性关注点的抽象。

    joinpoint(连接点):所谓连接点是指那些被拦截到的点。在spring中,这些点指的是方法,因为spring只支持方法类型的连接点,实际上joinpoint还可以是field或类构造器)。

    Pointcut(切入点):所谓切入点是指我们要对那些joinpoint进行拦截的定义。

    Advice(通知):所谓通知是指拦截到joinpoint之后所要做的事情就是通知.通知分为前置通知,后置通知,异常通知,最终通知,环绕通知。

    Target(目标对象):代理的目标对象。

    Weave(织入):指将aspects应用到target对象并导致proxy对象创建的过程称为织入。

    Introduction(引入):在不修改类代码的前提下,Introduction可以在运行期为类动态地添加一些方法或Field。

    所谓AOP,我的理解就是应该是这样一个过程,首先需要定义一个切面,这个切面是一个类,里面的方法就是关注点(也是通知),或者说里面的方法就 是用来在执行目标对象方法时需要执行的前置通知,后置通知,异常通知,最终通知,环绕通知等等。有了切面和通知,要应用到目标对象,就需要定义这些通知的 切入点,换句话说就是需要对哪些方法进行拦截,而这些被拦截的方法就是连接点,所谓连接点也就是在动态执行过程,被织入切面的方法(至少在spring中 只能对方法进行拦截)。因此,在动态过程中通知的执行就属于织入过程,而被织入这些通知的对象就是目标对象了。

    通常应用中,被织入的都是事务处理,对事务的织入不是普通简单的织入,它有着事务特有的特性——

    事务的传播特性:

    1. PROPAGATION_REQUIRED: 如果存在一个事务,则支持当前事务。如果没有事务则开启新的事物。

    2. PROPAGATION_SUPPORTS: 如果存在一个事务,支持当前事务。如果没有事务,则非事务的执行。

    3. PROPAGATION_MANDATORY: 如果已经存在一个事务,支持当前事务。如果没有一个活动的事务,则抛出异常。

    4. PROPAGATION_REQUIRES_NEW: 总是开启一个新的事务。如果一个事务已经存在,则将这个存在的事务挂起。

    5. PROPAGATION_NOT_SUPPORTED: 总是非事务地执行,并挂起任何存在的事务。

    6. PROPAGATION_NEVER: 总是非事务地执行,如果存在一个活动事务,则抛出异常

    7.(spring)PROPAGATION_NESTED:如果一个活动的事务存在,则运行在一个嵌套的事务中. 如果没有活动事务, 则按TransactionDefinition.PROPAGATION_REQUIRED 属性执行。

    这些都是事务特有的特性,比如前面分析的,如果两个在代码上不相关的操作,需要放在同一个事务中,这就需要利用到传播特性了,这时后调用的方法的 传播特性的值就应该是PROPAGATION_REQUIRED。在spring中只需要进行这样的配置,就实现了生命式的事物处理。

    最后一点需要提及的就是Spring事务的隔离级别:

    1. ISOLATION_DEFAULT:这是一个PlatfromTransactionManager默认的隔离级别,使用数据库默认的事务隔离级别。

    2. ISOLATION_READ_UNCOMMITTED:这是事务最低的隔离级别,它充许令外一个事务可以看到这个事务未提交的数据。

    3. ISOLATION_READ_COMMITTED:保证一个事务修改的数据提交后才能被另外一个事务读取。另外一个事务不能读取该事务未提交的数据。

    4. ISOLATION_REPEATABLE_READ:这种事务隔离级别可以防止脏读,不可重复读。但是可能出现幻像读。它除了保证一个事务不能读取另一个事务未提交的数据外,还保证了避免下面的情况产生(不可重复读)。

    5. ISOLATION_SERIALIZABLE 这是花费最高代价但是最可靠的事务隔离级别。事务被处理为顺序执行。除了防止脏读,不可重复读外,还避免了幻像读。

    除了第一个是spring特有的,另外四个与JDBC的隔离级别相对应。第二种隔离级别会产生脏读,不可重复读和幻像读,特别是脏读,一般情况下 是不允许的,所以这种隔离级别是很少用到的。大多说数据库的默认格里基本是第三种。它能消除脏读,但是可重复读保证不了。第四种隔离级别也有一些数据库作 为默认的隔离级别,比如MySQL。最后一种用的地方不多,除非是多数据访问的要求特别高,否则轻易不要用它,因为它会严重影响数据库的性能

    展开全文
  • Spring事务传播特性解析

    热门讨论 2013-11-05 01:00:43
    通过代码解析spring传播特性,包括 1、Propagation.REQUIRED 方法被调用时自动开启事务,在事务范围内使用则使用同一个事务,否则开启新事务。 2、Propagation.REQUIRES_NEW 无论何时自身都会开启事务 3、...
  • 主要介绍了浅谈Spring事务传播行为实战,文中通过示例代码介绍的非常详细,对大家的学习或者工作具有一定的参考学习价值,需要的朋友们下面随着小编来一起学习学习吧
  • Spring事务传播特性和隔离级别 事务的几种传播特性详细介绍
  • 什么是ACID特性,数据库如何保证ACID特性的?ACID,是指在数据库管理系统(DBMS)中,事务(transaction)所具有的四个特性:原子性(Atomicity)、一致性(Consistency)、隔离性(Isolation,又称独立性)、持久性...

    什么是ACID特性,数据库如何保证ACID特性的?

    ACID,是指在数据库管理系统(DBMS)中,事务(transaction)所具有的四个特性:原子性(Atomicity)、一致性(Consistency)、隔离性(Isolation,又称独立性)、持久性(Durability)。

    在数据库系统中,一个事务是指:由一系列数据库操作组成的一个完整的逻辑过程。例如银行转帐,从原账户扣除金额,以及向目标账户添加金额,这两个数据库操作的总和,构成一个完整的逻辑过程,不可拆分。这个过程被称为一个事务,具有ACID特性。ACID的概念在ISO/IEC 10026-1:1992文件的第四段內有所說明。

    原子性:一整个交易中的所有操作,要么全部完成,要么全部不完成,不可能停滞在中间某个环节。交易在执行过程中发生错误,会被回復(Rollback)到交易开始前的状态,就像这个交易从来没有执行过一样。

    一致性:在交易开始之前和交易结束以后,数据库的完整性限制没有被破坏。

    隔离性:两个交易的执行是互不干扰的,一个交易不可能看到其他交易运行时,中间某一时刻的数据。

    持久性:在交易完成以后,该交易对数据库所作的更改便持久地保存在数据库之中,并不会被回復。

    Oracle中用锁、并发与多版本(非阻塞读)保持一致性和隔离性,用事务的commit,rollback,savepoint保持原子性,用数据库文件保持持久性,断电后,内存数据丢失,硬盘文件数据不丢失,重启后从文件中加载到内存,保持持久性

    事务的传播特性?

    事务的传播行为

    REQUIRED:

    业务方法需要在一个事务中运行,如果方法运行时,已经存在一个事务中,那么加入到该事务,否则自己创建一个新事务。

    NOT_SUPPORTED:

    声明方法不需要事务,如果方法没有关联到事务,容器不会为它开启事务,如果方法在一个事务中被调用,该事务会被挂起,在方法调用结束后,原先的事务便会恢复执行。

    REQUIRESNEW:

    不管是否存在事务,业务方法总为自己发起一个新事务;如果方法已经运行在一个事务中,则原有事务会被挂起,新的事务会被创建,直到方法调用结束,新事务才结束,原先的事务再恢复执行。

    MANDATORY:

    业务方法只能在一个已经存在的事务中进行,业务方法不能发起自己的事务,如果方法在没有事务的环境中调用,那么容器会抛出例外。

    SUPPORTS:

    如果业务方法在某个事务范围内被调用,则方法成为该事务的一部分,如果业务方法在事务外被调用,则方法在没有事务的环境下执行。

    NEVER:

    业务方法绝对不能再事务范围内执行,如果方法在某个事务中执行,容器会抛出例外,只有业务方法没有关联到任何事务,方法才能够正常执行。

    NESTED:

    如果一个活动的事务存在,则运行在一个嵌套的事务中,如果没有活动事务,则按照REQUIRED属性执行,它使用了一个单独的事务,这个事务有多个可以回滚的保存点,内部事务的回滚不会对外部事务产生影响。它只对DataSourceTransactionManager事务管理器有效。

    事务传播特性了解事务的几种传播特性

    数据库操作1

    数据库操作2

    PROPAGATION_REQUIRED

    Transaction1

    Transaction1

    null

    Transaction2

    PROPAGATION_SUPPORTS

    Transaction1

    Transaction1

    null

    null

    PROPAGATION_MANDATORY

    Transaction1

    Transaction1

    null

    Throws Exception

    PROPAGATION_REQUIRES_NEW

    Transaction1

    Transaction2

    null

    Transaction2

    PROPAGATION_NOT_SUPPORTED

    Transaction1

    null

    null

    null

    PROPAGATION_NEVER

    Transaction1

    Throws Exception

    null

    null

    PROPAGATION_NESTED(Spring)

    Transaction1

    Transaction2

    [Transaction1]

    null

    Transaction2

    1.      PROPAGATION_REQUIRED: 如果存在一个事务,则支持当前事务。如果没有事务则开启

    2.      PROPAGATION_SUPPORTS: 如果存在一个事务,支持当前事务。如果没有事务,则非事务的执行

    3.      PROPAGATION_MANDATORY: 如果已经存在一个事务,支持当前事务。如果没有一个活动的事务,则抛出异常。

    4.      PROPAGATION_REQUIRES_NEW: 总是开启一个新的事务。如果一个事务已经存在,则将这个存在的事务挂起。

    5.      PROPAGATION_NOT_SUPPORTED: 总是非事务地执行,并挂起任何存在的事务。

    6.      PROPAGATION_NEVER: 总是非事务地执行,如果存在一个活动事务,则抛出异常

    7.      PROPAGATION_NESTED:如果一个活动的事务存在,则运行在一个嵌套的事务中. 如果没有活动事务,

    则按TransactionDefinition.PROPAGATION_REQUIRED 属性执行

    ---------------------------------------------------------------------

    事务的隔离级别?

    事务的隔离级别

    注:Spring中事务的隔离级别是由数据库实现的

    ISOLATION_DEFAULT

    这是一个PlatfromTransactionManager默认的隔离级别,使用数据库默认的事务隔离级别.另外四个与JDBC的隔离级别相对应

    ISOLATION_READ_UNCOMMITTED 这是事务最低的隔离级别,它充许别外一个事务可以看到这个事务未提交的数据。这种隔离级别会产生脏读,不可重复读和幻像读

    ISOLATION_READ_COMMITTED

    保证一个事务修改的数据提交后才能被另外一个事务读取。另外一个事务不能读取该事务未提交的数据。这种事务隔离级别可以避免脏读出现,但是可能会出现不可重复读和幻像读。

    ISOLATION_REPEATABLE_READ

    这种事务隔离级别可以防止脏读,不可重复读。但是可能出现幻像读。它除了保证一个事务不能读取另一个事务未提交的数据外,还保证了避免下面的情况产生(不可重复读)。

    ISOLATION_SERIALIZABLE

    这是花费最高代价但是最可靠的事务隔离级别。事务被处理为顺序执行。除了防止脏读,不可重复读外,还避免了幻像读。

    脏读:

    一个事务读取到另一个事务未提交的更新数据。

    不可重复读:

    在同一事务中,多次读取同一数据返回的结果有所不同,即后续读取可以读取到另一事务已提交的更新数据;相反,"可重复读"是指在同一事务中多次读取数据时,能够保证所读取的数据是一样,即后续读取不能读到另一事务已提交的数据。

    幻读:

    一个事务读取到另一事务已提交的insert数据。

    事务隔离级别

    脏读

    不可重复读

    幻象读

    ISOLATION_READ_UNCOMMITTED

    ISOLATION_READ_COMMITTED

    ISOLATION_REPEATABLE_READ

    ISOLATION_SERIALIZABLE

    ISOLATION_DEFAULT

    PlatfromTransactionManager

    默认的隔离级别

    SQLServer :READ_COMMITTED

    MySql:REPEATABLE_READ

    Spring事务的隔离级别

    1.      ISOLATION_DEFAULT: 这是一个PlatfromTransactionManager默认的隔离级别,使用数据库默认的事务隔离级别.

    另外四个与JDBC的隔离级别相对应

    2.      ISOLATION_READ_UNCOMMITTED: 这是事务最低的隔离级别,它充许令外一个事务可以看到这个事务未提交的数据。

    这种隔离级别会产生脏读,不可重复读和幻像读。

    3.      ISOLATION_READ_COMMITTED: 保证一个事务修改的数据提交后才能被另外一个事务读取。另外一个事务不能读取该事务未提交的数据

    4.      ISOLATION_REPEATABLE_READ: 这种事务隔离级别可以防止脏读,不可重复读。但是可能出现幻像读。

    5.      ISOLATION_SERIALIZABLE 这是花费最高代价但是最可靠的事务隔离级别。事务被处理为顺序执行。

    除了防止脏读,不可重复读外,还避免了幻像读。

    脏读就是指当一个事务正在访问数据,并且对数据进行了修改,而这种修改还没有提交到数据库中,这时,另外一个事务也访问这个数据,然后使用了这个数据。

    不可重复读是 指在一个事务内,多次读同一数据。在这个事务还没有结束时,另外一个事务也访问该同一数据。

    那么,在第一个事务中的两次读数据之间,由于第二个事务的修 改,那么第一个事务两次读到的的数据可能是不一样的。

    幻觉读是 指当事务不是独立执行时发生的一种现象,例如第一个事务对一个表中的数据进行了修改,这种修改涉及到表中的全部数据行

    。同时,第二个事务也修改这个表中的 数据,这种修改是向表中插入一行新数据。

    那么,以后就会发生操作第一个事务的用户发现表中还有没有修改的数据行,就好象发生了幻觉一样。

    其他关于事务的url:

    展开全文
  • 什么是事务传播特性

    万次阅读 多人点赞 2018-09-03 17:52:52
    看到一个词“事务传播特性”,在网上查找半天没理解是啥,看了一个网友列举的实例才有点明白,此处用其实例整理下思路: 上图方法1对应的事务事务1,方法2对应的事务事务2;其中事务1调用了事务2; 期望:...

    看到一个词“事务的传播特性”,在网上查找半天没理解是啥,看了一个网友列举的实例才有点明白,此处用其实例整理下思路:

    上图方法1对应的事务叫事务1,方法2对应的事务叫事务2;其中事务1调用了事务2;

    期望:想要让事务2发生异常时回滚,而事务1不回滚(catch后继续循环下一个);

    实际:事务2回滚时事务1也回滚了,不符合期许;

    原因:当调用方法1时会创建事务1,当调用方法2时准备创建事务2了,发现已经有事务1存在了,那就节省资源不创建事务2,直接用事务1了,导致方法1方法2用的同一个事务;

    解决:更改事务2的隔离级别为----PROPAGATION_NESTED;

    详细参考:https://blog.csdn.net/u010634066/article/details/78334259

    ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------

    Spring它对JDBC的隔离级别作出了补充和扩展,其提供了7种事务传播行为。

    1、PROPAGATION_REQUIRED:默认事务类型,如果没有,就新建一个事务;如果有,就加入当前事务。适合绝大多数情况。

    2、PROPAGATION_REQUIRES_NEW:如果没有,就新建一个事务;如果有,就将当前事务挂起。

     3、PROPAGATION_NESTED:如果没有,就新建一个事务;如果有,就在当前事务中嵌套其他事务。

    4、PROPAGATION_SUPPORTS:如果没有,就以非事务方式执行;如果有,就使用当前事务。

    5、PROPAGATION_NOT_SUPPORTED:如果没有,就以非事务方式执行;如果有,就将当前事务挂起。即无论如何不支持事务。

    6、PROPAGATION_NEVER:如果没有,就以非事务方式执行;如果有,就抛出异常。

    7、PROPAGATION_MANDATORY:如果没有,就抛出异常;如果有,就使用当前事务。

    展开全文
  • 说明仅仅是支持事务,没有事务就非事务方式执行。mandatory:强制的。说明一定要有事务,没有事务就抛出异常。required_new:必须新建事物。如果当前存在事物就挂起。not_supported:不支持事物,如果存在事物就挂起。...
  • spring事务传播特性

    2021-02-26 17:54:15
    java事务传播特性共分为7种,默认的是REQUIREDREQUIRED(0),SUPPORTS(1),MANDATORY(2),REQUIRES_NEW(3),NOT_SUPPORTED(4),NEVER(5),NESTED(6);【REQUIRED】service1:事务传播机制:REQUIREDservice2:事务传播机制:...
  • 详解事务传播特性

    2020-08-30 16:19:19
    事务传播特性汇总: required:使用当前的事务,如果当前没有事务,则创建一个事务,子方法是必须运行在一个事务中的,如果当前存在事务,则加入这个事务,成为一个整体。 supports:如果当前有事务,则使用事务,...
  • spring事务传播特性

    2021-06-07 15:24:32
    spring事务传播特性 1.Propagation.REQUIRED(spring中@Transactional默认方式) 如果当前有事务就加入当前事务,如果没有事务就新建一个事务 2.Propagation.SUPPORTS 支持当前事务,如果当前没有事务,就以非事务...
  • 作者 | handaqiang ... 目录 前言 ...1. 什么是事务传播行为? 2. Spring 中七种事务传播行为 代码验证 1.PROPAGATION_REQUIRED 1.1 场景一 1.2 场景二 2.PROPAGATION_REQUIRES_NEW 2.1 ...
  • Spring的事务传播特性

    2020-11-18 19:50:19
    Spring的事务传播特性 1、Spring的事务传播特性 事务属性的种类:传播行为、隔离级别、只读和事务超时。 事务传播行为就是多个事务方法相互调用时,事务如何在这些方法间传播。 2、Spring事务传播行为种类 spring...
  • Spring支持的事务传播特性 什么是事务的传播? 首先我们要明确,事务具有原子性,要么都成功,要么都失败。 假如说,你的service层中,A方法是一个事务操作,B方法是一个事务操作,A方法中调用了 B 方法,这就设计到...
  • 事务传播特性可以通过@Transactional的propagation属性指定 例: @Transactional(propagation=Propagation.REUIRED) REQUIRED:默认的传播特性,业务方法需要在一个事务中运行,如果一个方法处在事务中那么就...
  • 2.隔离级别实现上一节介绍了ANSI定义的3种异象,及根据禁止异象的个数而定义的事务隔离级别。因为不存在严格、严谨的“官方”定义,各主流2.1 Lock-based 隔离级别实现在展示Lock-based隔离级别实现前,先介绍几个与...
  • 事务传播特性

    2020-08-26 22:03:13
    1、什么是事务的传播特性? 事务的传播的特性指的是当一个事务方法被另一个事务方法调用时,这个事务方法应该如何进行; spring的事务传播行为一共有7种; 事务的传播行为 传播 特点 required 如果有事务...
  • 1.什么是事务事务是程序中一系列严密的操作,所有操作执行必须成功完成,否则在每个操作所做的更改将会被撤销,这也是事务的原子性(要么成功,要么失败)。 2.事务特性事务特性分为四个:原子性...
  • 情景一:A方法 未添加 事务注解,B方法事务的propagation=Propagation.NEVER 执行结果:A、B均新增成功,B抛出RuntimeException。 情景二:A方法 添加了 事务注解,B方法事务的propagation=Propagation.NEVER ...
  • 脏读:当一个事务读取另一个事务未提交的内容,之后由于另一个事务出现了异常回滚了事务,结果造成读取的数据不一致不可重复读:指一个事务多次读取同一数据,而另一个事务多次对数据进行了修改的操作,这样就导致了...
  • 事务传播特性了解事务的几种传播特性 总共有七种propagation——required propagation——support propagation——mandatory propagation——not——supported propagation_required_new propagation_never ...
  • spring事务传播特性与内部事务回滚问题 前提:同一个类,内部方法调用不走代理,spring基于注解的事务是基于代理的,不走代理,被调用的方法就不受事务管理代码的控制。 原理: 1、<bean id=...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 38,380
精华内容 15,352
关键字:

什么是事务的传播特性