Detailed explanation of Springboot transaction management

In der Spring Boot Transaktionsverwaltung wird die Schnittstelle PlatformTransactionManager implementiert.

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;
}

Wenn wir spring verwenden-Boot-Starter-Bei Abhängigkeit von jdbc wird der Framework automatisch DataSourceTransactionManager injizieren. Daher benötigen wir keine zusätzliche Konfiguration, um die Verwendung von @Transactional zur Transaktionsverwaltung zu ermöglichen.

jdbc-Transaktionsmanager

In Service, Methoden, die mit @Transactional annotiert sind, unterstützen Transaktionen. Wenn die Annotierung auf der Klasse liegt, unterstützen alle Methoden der Klasse standardmäßig Transaktionen.

Fälle mehrerer Transaktionsmanager

Eins: Sie können das Interface TransactionManagementConfigurer implementieren, das den Standard-Transaktionsmanager zurückgibt.

Zwei: Sie können den Wert auf dem spezifischen Ausführungsmodus einstellen

Wenn im Spring-Container mehrere Instanzen von PlatformTransactionManager existieren und keine Implementierung des Interfaces TransactionManagementConfigurer eine Standardwerte zurückgibt, müssen wir, wenn wir den Annotierung @Transactional in der Methode verwenden, value angeben. Wenn nicht angegeben, wird eine Ausnahme ausgelöst.

//@EnableTransactionManagement // Aktivierung der Annotierungs-Transaktionsverwaltung, entspricht der xml-Konfigurationsdatei <tx:annotation-getrieben />
@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; }
}

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

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

@Transactional(isolation = Isolation.DEFAULT)

传播行为

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

Wir können sehen, dass die Enumerationklasse org.springframework.transaction.annotation.Propagation definiert ist,}6eine Wertrepräsentation für传播行为的枚举werte：

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 : Wenn eine Transaktion vorhanden ist, wird diese Transaktion beigetreten; wenn keine Transaktion vorhanden ist, wird eine neue Transaktion erstellt. Standardwert.

SUPPORTS : Wenn eine Transaktion vorhanden ist, wird diese Transaktion beigetreten; wenn keine Transaktion vorhanden ist, wird fortgegangen, ohne transaktionsbasiert zu sein.

MANDATORY : Wenn eine Transaktion vorhanden ist, wird diese Transaktion beigetreten; wenn keine Transaktion vorhanden ist, wird eine Ausnahme ausgelöst. (Wird in Transaktionen erzwungen.)

REQUIRES_NEW : Eine neue Transaktion wird erstellt, und falls eine Transaktion vorhanden ist, wird diese Transaktion gehängt. (Oft für das Protokollieren von Logs verwendet, auch wenn das Protokoll vor dem R rolling zurückgerufen wird, wird diese Transaktion ausgeführt und Fehlerinformationen werden protokolliert.)

NOT_SUPPORTED : Aus nicht transaktionsbasierter Weise ausgeführt, wird die aktuelle Transaktion, falls vorhanden, gehängt.

NEVER : Aus nicht transaktionsbasierter Weise ausgeführt, wird eine Ausnahme ausgelöst, wenn eine Transaktion vorhanden ist.

NESTED : Wenn eine Transaktion vorhanden ist, wird eine Transaktion als eingebettete Transaktion der aktuellen Transaktion ausgeführt; wenn keine Transaktion vorhanden ist, ist dieser Wert äquivalent zu REQUIRED .

Bezeichnende Methode: Durch die Verwendung der propagation-Eigenschaft zu konfigurieren, z.B.:

@Transactional(propagation = Propagation.REQUIRED)

Fälle, in denen keine Transaktion zurückgerollt wird

Nur bei unbehandelten RuntimeException wird zurückgerollt

Fangen Sie die von catch ausgelöste Ausnahme ab, und beide Einführungen werden erfolgreich sein

@Override
  @Transactional
  public void insertandinsert(Staff staff) {
    staffDao.insert(staff);
    try {
      int i = 1 / 0;
    }
      e.printStackTrace();
    }
    staffDao.insert(staff);
  }

Fügen Sie im catch-Statement der Methode im Service-Layer die Anweisung TransactionAspectSupport.currentTransactionStatus().setRollbackOnly(); hinzu, um manuell das Einfügen von Daten abzubrechen.

@Override
  @Transactional
  public void insertandinsert(Staff staff) throws Exception {
    try {
      staffDao.insert(staff);
      int i =1/0;
      staffDao.insert(staff);
    }
      TransactionAspectSupport.currentTransactionStatus().setRollbackOnly();
    }
  }

Das ist der gesamte Inhalt dieses Artikels. Wir hoffen, dass er Ihnen bei Ihrem Lernen hilft und dass Sie die呐喊教程 unterstützen.

Erklärung: Der Inhalt dieses Artikels wurde aus dem Internet entnommen und gehört dem jeweiligen Urheber. Der Inhalt wurde von Internetbenutzern freiwillig beigesteuert und hochgeladen. Diese Website besitzt keine Eigentumsrechte und hat den Inhalt nicht von Hand bearbeitet. Falls Sie urheberrechtlich beanstandete Inhalte finden, freuen wir uns über eine E-Mail an: notice#oldtoolbag.com (Bitte ersetzen Sie # durch @, wenn Sie eine Beschwerde einreichen, und fügen Sie relevante Beweise bei. Bei nachgewiesener Urheberrechtsverletzung wird diese Website die beanstandeten Inhalte sofort löschen.)

Basic Tutorial