Spring中的事务以及事务传播级别

一、Spring中事务的隔离级别

Spring 提供了 5 种不同的事务隔离级别,每种级别都代表了一种不同的隔离程度:

1.Isolation.DEFAULT:默认级别,使用数据库默认的隔离级别。不同的数据库默认隔离级别可能不同。

2.Isolation.READ_UNCOMMITTED:最低的隔离级别,事务可以读取未提交的数据,也就是脏读(Dirty Read)。

3.Isolation.READ_COMMITTED:事务只能读取已经提交的数据,可以避免脏读,但是可能会出现不可重复读(Non-repeatable Read)。

4.**Isolation.REPEATABLE_READ:**事务可以多次读取同一数据,保证了数据一致性,但是可能会出现幻读(Phantom Read)。

5.**Isolation.SERIALIZABLE:**最高的隔离级别,事务串行执行,避免了脏读、不可重复读和幻读,但是性能较差。

不可重复度:针对的是数据的修改,前后两次读到的数据不一样。
幻读:针对数据的添加和删除,前后读到的数据数量的不同。

二、七种传播级别

事务的传播级别(Propagation Level)是指在多个事务方法相互调用时,事务如何传播的规则。Spring 提供了 7 种不同的传播级别,每种级别都代表了一种不同的事务传播行为:

1、Propagation.REQUIRED:默认值。如果当前存在事务,则加入该事务;如果不存在事务,则创建一个新的事务。

2、Propagation.SUPPORTS:如果当前存在事务,则加入该事务;如果不存在事务,则不会创建一个新的事务。
3、Propagation.MANDATORY:如果当前存在事务,则加入该事务;如果不存在事务,则抛出一个异常。
4、Propagation.REQUIRES_NEW:无论当前是否存在事务,都会创建一个新的事务。如果当前存在事务,则挂起当前事务,执行新的事务,新的事务执行完毕后再恢复当前事务。
5、Propagation.NOT_SUPPORTED:如果当前存在事务,则挂起当前事务,以非事务状态执行该方法;执行完毕后再恢复当前事务。
6、Propagation.NEVER:如果当前存在事务,则抛出一个异常;如果不存在事务,则以非事务状态执行该方法。
7、Propagation.NESTED:如果当前存在事务,则在当前事务中嵌套一个新的事务;如果不存在事务,则创建一个新的事务。嵌套的事务可以独立提交或回滚,但是如果外层事务回滚,则内层事务也会回滚。

三、七种传播级别的举例

1、Propagation.REQUIRED:

@Transactional
public void methodA(){
    // do something
    methodB();
    // do something
}

@Transactional
public void methodB(){
    // do something
}

在这个例子中,方法 A 和方法 B 都使用了默认的传播级别 Propagation.REQUIRED,即如果当前存在事务,则加入该事务;如果不存在事务,则创建一个新的事务。当调用 methodB() 时,methodB() 将会加入 methodA() 的事务中,因为 methodA() 已经开启了一个事务。当 methodB() 结束时,methodA() 的事务也将结束。如果 methodB() 抛出了异常,则 methodA() 也将回滚。
2、Propagation.SUPPORTS:

@Transactional
public void methodA(){
    // do something
    methodB();
    // do something
}

@Transactional(propagation = Propagation.SUPPORTS)
public void methodB(){
    // do something
}

在这个例子中,方法 A 使用了默认的传播级别 Propagation.REQUIRED,而方法 B 使用了传播级别 Propagation.SUPPORTS,即如果当前存在事务,则加入该事务;如果不存在事务,则不会创建一个新的事务。当调用 methodB() 时,它将加入 methodA() 的事务中,因为 methodA() 已经开启了一个事务。如果 methodB() 抛出了异常,则 methodA() 也将回滚。

3、Propagation.MANDATORY:

@Transactional
public void methodA(){
    // do something
    methodB();
    // do something
}

@Transactional(propagation = Propagation.MANDATORY)
public void methodB(){
    // do something
}

在这个例子中,方法 A 使用了默认的传播级别 Propagation.REQUIRED,而方法 B 使用了传播级别 Propagation.MANDATORY,即如果当前存在事务,则加入该事务;如果不存在事务,则抛出一个异常。当调用 methodB() 时,它将加入 methodA() 的事务中,因为 methodA() 已经开启了一个事务。如果 methodA() 没有事务,则 methodB() 将抛出一个异常。

4、Propagation.REQUIRES_NEW:

@Transactional

public void methodA(){
    // do something
    methodB();
    // do something
}

@Transactional(propagation = Propagation.REQUIRES_NEW)
public void methodB(){
    // do something
}

在这个例子中,方法 A 使用了默认的传播级别 Propagation.REQUIRED,而方法 B 使用了传播级别 Propagation.REQUIRES_NEW,即无论当前是否存在事务,都会创建一个新的事务。当调用 methodB() 时,它将在一个新的事务中执行,与 methodA() 的事务无关。当 methodB() 结束时,仅仅会提交 methodB() 的事务,而不会影响 methodA() 的事务。

5、Propagation.NOT_SUPPORTED:

@Transactional
public void methodA(){
    // do something
    methodB();
    // do something
}

@Transactional(propagation = Propagation.NOT_SUPPORTED)
public void methodB(){
    // do something
}

在这个例子中,方法 A 使用了默认的传播级别 Propagation.REQUIRED,而方法 B 使用了传播级别 Propagation.NOT_SUPPORTED,即如果当前存在事务,则挂起当前事务,以非事务状态执行该方法;执行完毕后再恢复当前事务。当调用 methodB() 时,它将挂起 methodA() 的事务,以非事务状态执行 methodB(),当 methodB() 结束时,恢复 methodA() 的事务。

6、Propagation.NEVER:

@Transactional
public void methodA(){
    // do something
    methodB();
    // do something
}

@Transactional(propagation = Propagation.NEVER)
public void methodB(){
    // do something
}

在这个例子中,方法 A 使用了默认的传播级别 Propagation.REQUIRED,而方法 B 使用了传播级别 Propagation.NEVER,即如果当前存在事务,则抛出一个异常;如果不存在事务,则以非事务状态执行该方法。当调用 methodB() 时,如果 methodA() 已经开启了一个事务,则 methodB() 将抛出一个异常;如果 methodA() 没有事务,则 methodB() 将在非事务状态下执行。

7、Propagation.NESTED:

@Transactional
public void methodA(){
    // do something
    methodB();
    // do something
}

@Transactional(propagation = Propagation.NESTED)
public void methodB(){
    // do something
}

在这个例子中,方法 A 使用了默认的传播级别 Propagation.REQUIRED,而方法 B 使用了传播级别 Propagation.NESTED,即如果当前存在事务,则在当前事务中嵌套一个新的事务;如果不存在事务,则创建一个新的事务。当调用 methodB() 时,它将在 methodA() 的事务中嵌套一个新的事务,这个新的事务可以独立提交或回滚,但是如果 methodA() 的事务回滚,则 methodB() 的事务也会回滚。

你可能感兴趣的:(spring,数据库,java)