Spring @Transactional 与 JTA @Transactional

本文主要介绍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 {};

}

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
30
31

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

}

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
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64

配置差异

从源码中可以看到，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