详解Springboot事务管理

在spring boot事务管理中，实现自接口platformtransactionmanager。

public interface platformtransactionmanager {
  org.springframework.transaction.transactionstatus gettransaction(org.springframework.transaction.transactiondefinition transactiondefinition) throws org.springframework.transaction.transactionexception;

  void commit(org.springframework.transaction.transactionstatus transactionstatus) throws org.springframework.transaction.transactionexception;

  void rollback(org.springframework.transaction.transactionstatus transactionstatus) throws org.springframework.transaction.transactionexception;
}

当我们使用了spring-boot-starter-jdbc依赖的时候，框 架会自动默认注入datasourcetransactionmanager。所以我们不需要任何额外 配置就可以用@transactional注解进行事务的使用。

jdbc事务管理器

在service中，被 @transactional 注解的方法，将支持事务。如果注解在类上，则整个类的所有方法都默认支持事务。

多事务管理器情况

一：可以通过实现transactionmanagementconfigurer接口，里面方法返回值是默认的事务管理器。

二：可以在具体执行方法上设置value

如果spring容器中存在多个 platformtransactionmanager 实例，并且没有实现接口transactionmanagementconfigurer 指定默认值，在我们在方法上使用注解 @transactional 的时候，就必须要用value指定，如果不指定，则会抛出异常。

//@enabletransactionmanagement // 开启注解事务管理，等同于xml配置文件中的 <tx:annotation-driven />
@springbootapplication
public class profiledemoapplication implements transactionmanagementconfigurer {
  @resource(name="txmanager2")
  private platformtransactionmanager txmanager2;
  // 手动创建事务管理器1 datasource框架会自动注入
  //在spring容器中，我们手工注解@bean 将被优先加载，框架不会重新实例化其他的 platformtransactionmanager 实现类。
  @bean(name = "txmanager1")
  public platformtransactionmanager txmanager(datasource datasource) {
    return new datasourcetransactionmanager(datasource);
  }

  // 创建事务管理器2
  @bean(name = "txmanager2")
  public platformtransactionmanager txmanager2(entitymanagerfactory factory) {
    return new jpatransactionmanager(factory);
  }

  // 实现接口 transactionmanagementconfigurer 方法，其返回值代表在拥有多个事务管理器的情况下默认使用的事务管理器
  @override
  public platformtransactionmanager annotationdriventransactionmanager() {
    return txmanager2;
  }

  public static void main(string[] args) {
    springapplication.run(profiledemoapplication.class, args);
  }

}

具体实现

@component
public class devsendmessage implements sendmessage {
  // 使用value具体指定使用哪个事务管理器
  @transactional(value="txmanager1")
  @override
  public void send() {
    system.out.println(">>>>>>>>dev send()<<<<<<<<");
    send2();
  }

  @transactional
  public void send2() {
    system.out.println(">>>>>>>>dev send2()<<<<<<<<");
  }
}

隔离级别

public enum isolation {
  default(transactiondefinition.isolation_default),
  read_uncommitted(transactiondefinition.isolation_read_uncommitted),
  read_committed(transactiondefinition.isolation_read_committed),
  repeatable_read(transactiondefinition.isolation_repeatable_read),
  serializable(transactiondefinition.isolation_serializable);
  private final int value;
  isolation(int value) { this.value = value; }
  public int value() { return this.value; }

}

1. default ：这是默认值，表示使用底层数据库的默认隔离级别。对大部分数据库而言，通常这值就是： read_committed 。
2. read_uncommitted ：该隔离级别表示一个事务可以读取另一个事务修改但还没有提交的数据。该级别不能防止脏读和不可重复读，因此很少使用该隔离级别。
3. read_committed ：该隔离级别表示一个事务只能读取另一个事务已经提交的数据。该级别可以防止脏读，这也是大多数情况下的推荐值。
4. repeatable_read ：该隔离级别表示一个事务在整个过程中可以多次重复执行某个查询，并且每次返回的记录都相同。即使在多次查询之间有新增的数据满足该查询，这些新增的记录也会被忽略。该级别可以防止脏读和不可重复读。
5. serializable ：所有的事务依次逐个执行，这样事务之间就完全不可能产生干扰，也就是说，该级别可以防止脏读、不可重复读以及幻读。但是这将严重影响程序的性能。通常情况下也不会用到该级别。

指定方法：通过使用 isolation 属性设置，例如：

@transactional(isolation = isolation.default)

传播行为

所谓事务的传播行为是指，如果在开始当前事务之前，一个事务上下文已经存在，此时有若干选项可以指定一个事务性方法的执行行为。

我们可以看 org.springframework.transaction.annotation.propagation 枚举类中定义了6个表示传播行为的枚举值：

public enum propagation {
  required(transactiondefinition.propagation_required),
  supports(transactiondefinition.propagation_supports),
  mandatory(transactiondefinition.propagation_mandatory),
  requires_new(transactiondefinition.propagation_requires_new),
  not_supported(transactiondefinition.propagation_not_supported),
  never(transactiondefinition.propagation_never),
  nested(transactiondefinition.propagation_nested);
  private final int value;
  propagation(int value) { this.value = value; }
  public int value() { return this.value; }
}

required ：如果当前存在事务，则加入该事务；如果当前没有事务，则创建一个新的事务。默认值。

supports ：如果当前存在事务，则加入该事务；如果当前没有事务，则以非事务的方式继续运行。

mandatory ：如果当前存在事务，则加入该事务；如果当前没有事务，则抛出异常。（强制放入事务中）

requires_new ：创建一个新的事务，如果当前存在事务，则把当前事务挂起。（打印日志常用，即使前面回滚，该事务也会执行，记录报错信息）

not_supported ：以非事务方式运行，如果当前存在事务，则把当前事务挂起。

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

nested ：如果当前存在事务，则创建一个事务作为当前事务的嵌套事务来运行；如果当前没有事务，则该取值等价于 required 。

指定方法：通过使用 propagation 属性设置，例如：

@transactional(propagation = propagation.required)

事务不回滚情况

只在发生未被捕获的 runtimeexception 时才回滚

catch抛出的异常，两次插入都会成功

@override
  @transactional
  public void insertandinsert(staff staff) {
    staffdao.insert(staff);
    try {
      int i = 1 / 0;
    }catch (exception e){
      e.printstacktrace();
    }
    staffdao.insert(staff);
  }

在service层方法的catch语句中增加：transactionaspectsupport.currenttransactionstatus().setrollbackonly();语句，手动回滚不会插入数据

@override
  @transactional
  public void insertandinsert(staff staff) throws exception {
    try {
      staffdao.insert(staff);
      int i=1/0;
      staffdao.insert(staff);
    }catch (exception e){
      transactionaspectsupport.currenttransactionstatus().setrollbackonly();
    }
  }

以上就是本文的全部内容，希望对大家的学习有所帮助，也希望大家多多支持服务器之家。

原文链接：http://www.jianshu.com/p/1ff821a0f070