Spring 事务

Spring 事务

• 依赖

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29

<dependency>
    <groupId>org.springframework</groupId>
    <artifactId>spring-tx</artifactId>
    <version>4.3.2.RELEASE</version>
</dependency>
 ``` 

 * 七个事务传播属性
1.  @Transactional(propagation = Propagation.REQUIRED)//支持当前事务，如果当前没有事务，新建一个事务；
① 如果外部方法没有开启事务的话，Propagation.REQUIRED修饰的内部方法会新开启自己的事务，且开启的事务相互独立，互不干扰。
②如果外部方法开启事务并且被Propagation.REQUIRED的话，所有Propagation.REQUIRED修饰的内部方法和外部方法均属于同一事务 ，只要一个方法回滚，整个事务均回滚。
③ 如果我们上面的aMethod()和bMethod()使用的都是PROPAGATION_REQUIRED传播行为的话，两者使用的就是***同一个事务***，只要其中一个方法回滚，整个事务均回滚。

```java
Class A {
        @Transactional(propagation=propagation.PROPAGATION_REQUIRED)
        public void aMethod {
            //do something
            B b = new B();
            b.bMethod();
        }
    }

    Class B {
        @Transactional(propagation=propagation.PROPAGATION_REQUIRED)
        public void bMethod {
        //do something
        }
    }

2. @Transactional(propagation = Propagation.SUPPORTS)//有事务则支持，没有则非事务运行；

3. @Transactional(propagation = Propagation.MANDATORY)// 如果当前存在事务，则加入该事务；如果当前没有事务，则抛出异常。（mandatory：强制性）

4. @Transactional(propagation = Propagation.NEVER)// 以非事务方式运行操作，如果当前存在事务，则抛出异常；

5. @Transactional(propagation = Propagation.NESTED)// 如果当前存在事务，则创建一个事务作为当前事务的嵌套事务来运行；如果当前没有事务，则该取值等价于TransactionDefinition.PROPAGATION_REQUIRED；
   ① 在外部方法未开启事务的情况下Propagation.NESTED和Propagation.REQUIRED作用相同，修饰的内部方法都会新开启自己的事务，且开启的事务相互独立，互不干扰。
   ② 如果外部方法开启事务的话，Propagation.NESTED修饰的内部方法属于外部事务的子事务，外部主事务回滚的话，子事务也会回滚，而内部子事务可以单独回滚而不影响外部主事务和其他子事务。
   ③ 如果 aMethod() 回滚的话，bMethod()和bMethod2()都要回滚，而bMethod()回滚的话，并不会造成 aMethod() 和bMethod()回滚。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20

Class A {
        @Transactional(propagation=propagation.PROPAGATION_REQUIRED)
        public void aMethod {
            //do something
            B b = new B();
            b.bMethod();
            b.bMethod2();
        }
    }

    Class B {
        @Transactional(propagation=propagation.PROPAGATION_NESTED)
        public void bMethod {
        //do something
        }
        @Transactional(propagation=propagation.PROPAGATION_NESTED)
        public void bMethod2 {
        //do something
        }
    }

6. @Transactional(propagation = Propagation.REQUIRES_NEW)//新建事务，如果当前存在事务，就把事务挂起；执行当前新建事务完成以后，上下文事务恢复再执行，且开启的事务相互独立，互不干扰。
   ① 如果我们上面的bMethod()使用 PROPAGATION_REQUIRES_NEW 事务传播行为修饰，aMethod还是用 PROPAGATION_REQUIRED 修饰的话。如果aMethod()发生异常回滚，bMethod()不会跟着回滚，因为 bMethod()开启了独立的事务。
   ② 如果 bMethod()抛出了未被捕获的异常并且这个异常满足B事务回滚规则的话,aMethod()同样也会回滚，因为这个异常被 aMethod()的事务管理机制检测到了。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

Class A {
        @Transactional(propagation=propagation.PROPAGATION_REQUIRED)
        public void aMethod {
            //do something
            B b = new B();
            b.bMethod();
        }
    }

Class B {
        @Transactional(propagation=propagation.REQUIRES_NEW)
        public void bMethod {
        //do something
        }
    }

7. @Transactional(propagation = Propagation.NOT_SUPPORTED)//以非事务方式运行操作，如果当前存在事务，就把当前事务挂起；执行当前新建事务完成以后，上下文事务恢复再执行。

• 五种隔离级别

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

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

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

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

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

• 查看Mysql数据库默认事务级别

1

SELECT @@tx_isolation;

@Transactional 应用规则

• @Transactional 只能用在public业务方法上，用在private或者protected修饰的方法后。事务会失效；不会回滚；
• 如果这个注解使用在类上的话，表明该注解对该类中所有的 public 方法都生效。
• 本地方法this调用，事务依然不会生效；不会回滚；

事务控制语法

1. BEGIN 或 START TRANSACTION 显式地开启一个事务；
2. COMMIT / COMMIT WORK二者是等价的。提交事务，并使已对数据库进行的所有修改成为永久性的；
3. ROLLBACK / ROLLBACK WORK。回滚会结束用户的事务，并撤销正在进行的所有未提交的修改；
4. SAVEPOINT identifier 在事务中创建一个保存点，一个事务中可以有多个 SAVEPOINT；
5. RELEASE SAVEPOINT identifier 删除一个事务的保存点；
6. ROLLBACK TO identifier 把事务回滚到标记点；
7. SET TRANSACTION 用来设置事务的隔离级别。InnoDB 存储引擎提供事务的隔离级别有READ UNCOMMITTED、READ COMMITTED、REPEATABLE READ 和 SERIALIZABLE

@Transactional 运行机制

如果一个类或者一个类中的 public 方法上被标注@Transactional 注解的话，Spring 容器就会在启动的时候为其创建一个代理类，在调用被@Transactional 注解的 public 方法的时候，实际调用的是，TransactionInterceptor 类中的 invoke()方法。这个方法的作用就是在目标方法之前开启事务，方法执行过程中如果遇到异常的时候回滚事务，方法调用完成之后提交事务。

失效问题

若同一类中的其他没有 @Transactional 注解的方法内部 调用有 @Transactional 注解的方法，有@Transactional 注解的方法的事务会失效。
这是由于Spring AOP代理的原因造成的，因为只有当 @Transactional 注解的方法在类以外被调用的时候，Spring 事务管理才生效。

• MyService 类中的method1()调用method2()就会导致method2()的事务失效。
• 解决办法就是避免同一类中自调用或者使用 AspectJ 取代 Spring AOP 代理。

1
2
3
4
5
6
7
8
9
10
11
12

@Service
public class MyService {

private void method1() {
    method2();
    //......
}
@Transactional
public void method2() {
    //......
}
}

• ← Previous Post
• Next Post →