io.seata.tm.api.transaction

枚举 Propagation

java.lang.Object

java.lang.Enum<Propagation>

io.seata.tm.api.transaction.Propagation

所有已实现的接口:

Serializable, Comparable<Propagation>

public enum Propagation
extends Enum<Propagation>

Propagation level of global transactions.

另请参阅:

// TM annotation, // the interceptor of TM, // the transaction template of TM

枚举常量概要

枚举常量

枚举常量和说明
MANDATORY The MANDATORY.
NEVER The NEVER.
NOT_SUPPORTED The NOT_SUPPORTED.
REQUIRED The REQUIRED.
REQUIRES_NEW The REQUIRES_NEW.
SUPPORTS The SUPPORTS.

方法概要

限定符和类型	方法和说明
static Propagation	valueOf(String name) 返回带有指定名称的该类型的枚举常量。
static Propagation[]	values() 按照声明该枚举类型的常量的顺序, 返回 包含这些常量的数组。

从类继承的方法 java.lang.Enum

clone, compareTo, equals, finalize, getDeclaringClass, hashCode, name, ordinal, toString, valueOf

从类继承的方法 java.lang.Object

getClass, notify, notifyAll, wait, wait, wait

枚举常量详细资料

REQUIRED

public static final Propagation REQUIRED

The REQUIRED. The default propagation.

If transaction is existing, execute with current transaction, else execute with new transaction.

The logic is similar to the following code:

     if (tx == null) {
         try {
             tx = beginNewTransaction(); // begin new transaction, is not existing
             Object rs = business.execute(); // execute with new transaction
             commitTransaction(tx);
             return rs;
         } catch (Exception ex) {
             rollbackTransaction(tx);
             throw ex;
         }
     } else {
         return business.execute(); // execute with current transaction
     }
 

REQUIRES_NEW

public static final Propagation REQUIRES_NEW

The REQUIRES_NEW.

If transaction is existing, suspend it, and then execute business with new transaction.

The logic is similar to the following code:

     try {
         if (tx != null) {
             suspendedResource = suspendTransaction(tx); // suspend current transaction
         }
         try {
             tx = beginNewTransaction(); // begin new transaction
             Object rs = business.execute(); // execute with new transaction
             commitTransaction(tx);
             return rs;
         } catch (Exception ex) {
             rollbackTransaction(tx);
             throw ex;
         }
     } finally {
         if (suspendedResource != null) {
             resumeTransaction(suspendedResource); // resume transaction
         }
     }
 

NOT_SUPPORTED

public static final Propagation NOT_SUPPORTED

The NOT_SUPPORTED.

If transaction is existing, suspend it, and then execute business without transaction.

The logic is similar to the following code:

     try {
         if (tx != null) {
             suspendedResource = suspendTransaction(tx); // suspend current transaction
         }
         return business.execute(); // execute without transaction
     } finally {
         if (suspendedResource != null) {
             resumeTransaction(suspendedResource); // resume transaction
         }
     }
 

SUPPORTS

public static final Propagation SUPPORTS

The SUPPORTS.

If transaction is not existing, execute without global transaction, else execute business with current transaction.

The logic is similar to the following code:

     if (tx != null) {
         return business.execute(); // execute with current transaction
     } else {
         return business.execute(); // execute without transaction
     }
 

NEVER

public static final Propagation NEVER

The NEVER.

If transaction is existing, throw exception, else execute business without transaction.

The logic is similar to the following code:

     if (tx != null) {
         throw new TransactionException("existing transaction");
     }
     return business.execute(); // execute without transaction
 

MANDATORY

public static final Propagation MANDATORY

The MANDATORY.

If transaction is not existing, throw exception, else execute business with current transaction.

The logic is similar to the following code:

     if (tx == null) {
         throw new TransactionException("not existing transaction");
     }
     return business.execute(); // execute with current transaction
 

方法详细资料

values

public static Propagation[] values()

按照声明该枚举类型的常量的顺序, 返回 包含这些常量的数组。该方法可用于迭代 常量, 如下所示:

for (Propagation c : Propagation.values())
    System.out.println(c);

返回:

按照声明该枚举类型的常量的顺序返回的包含这些常量的数组

valueOf

public static Propagation valueOf(String name)

返回带有指定名称的该类型的枚举常量。 字符串必须与用于声明该类型的枚举常量的 标识符完全匹配。(不允许有多余 的空格字符。)

参数:

name - 要返回的枚举常量的名称。

返回:

返回带有指定名称的枚举常量

抛出:

IllegalArgumentException - 如果该枚举类型没有带有指定名称的常量

NullPointerException - 如果参数为空值