Spring @Transactional 与 JTA @Transactional

骑猪看日落 2024-04-07 15:04 78阅读 0赞

本文主要介绍Spring javax.transaction.Transactional 与 JTA org.springframework.transaction.annotation.Transactional注解的差别。首先先看下各自的源码：

#### 源码 ####

**javax.transaction.Transactional**

@Inherited
    @InterceptorBinding
    @Target({
        ElementType.TYPE, ElementType.METHOD})
    @Retention(value = RetentionPolicy.RUNTIME)
    public @interface Transactional {
        
        
        TxType value() default TxType.REQUIRED;
        
        public enum TxType {
        
    
            REQUIRED,
            
            REQUIRES_NEW,
            
            MANDATORY,
            
            SUPPORTS,
            
            NOT_SUPPORTED,
            
            NEVER
        }
        
        @Nonbinding
        public Class[] rollbackOn() default {
        };
        
        @Nonbinding
        public Class[] dontRollbackOn() default {
        };
    
    }

**org.springframework.transaction.annotation.Transactional**

@Target({
        ElementType.TYPE, ElementType.METHOD})
    @Retention(RetentionPolicy.RUNTIME)
    @Inherited
    @Documented
    public @interface Transactional {
        
        
    	@AliasFor("transactionManager")
    	String value() default "";
    
    	@AliasFor("value")
    	String transactionManager() default "";
        
    	String[] label() default {
        };
        
    	Propagation propagation() default Propagation.REQUIRED;
        
    	Isolation isolation() default Isolation.DEFAULT;
        
    	int timeout() default TransactionDefinition.TIMEOUT_DEFAULT;
        
    	String timeoutString() default "";
        
    	boolean readOnly() default false;
        
    	Class<? extends Throwable>[] rollbackFor() default {
        };
        
    	String[] rollbackForClassName() default {
        };
        
    	Class<? extends Throwable>[] noRollbackFor() default {
        };
        
    	String[] noRollbackForClassName() default {
        };
    
    }
    
    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;
        }
    
    }

#### 配置差异 ####

从源码中可以看到，Spring的Transactional注解比JTA对应项相比多了些额外的属性：

*  **transactionManager**： Spring可以指定transactionManager，JTA不可以。
 *  **Isolation**： Spring通过isolation属性提供了事务级别的隔离性，JTA隔离性只能控制在connection级别。
 *  **Propagation**：两者都支持，Spring通过propagation指定，JTA通过value指定。Spring多了一个Nested传播类型。
 *  **Timeout**：仅Spring支持。
 *  **Rollback**： 都支持。 JTA通过rollbackOn和dontRollbackOn属性，Spring通过rollbackFor和noRollbackFor属性，并额外附加了2个属性rollbackForClassName和noRollbackForClassName。

#### 使用差异 ####

在Spring应用中可以使用JTA事务注解，但是在Spring应用外无法使用Spring事务注解，只能用JTA。

参考文档：https://www.baeldung.com/spring-vs-jta-transactional\#applicability-and-interchangeability