Spring事务管理

Transactional注解属性

public @interface Transactional {
    String value() default "";

    // 该属性用于设置事务的传播行为
    Propagation propagation() default Propagation.REQUIRED;

    // 该属性用于设置底层数据库的事务隔离级别，事务隔离级别用于处理多事务并发的情况，通常使用数据库的默认隔离级别即可。
    Isolation isolation() default Isolation.DEFAULT;

    // 该属性用于设置事务的超时秒数，默认值为-1表示永不超时。
    int timeout() default TransactionDefinition.TIMEOUT_DEFAULT;

    // 该属性用于设置当前事务是否为只读事务，设置为true表示只读，false则表示可读写，默认值为false。
    boolean readOnly() default false;

    // 该属性用于设置需要进行回滚的异常类数组，当方法中抛出指定异常数组中的异常时，则进行事务回滚。
    // 例如: 指定单一异常类使用@Transactional(rollbackFor=RuntimeException.class)
    // 例如: 指定多个异常类使用@Transactional(rollbackFor={RuntimeException.class, Exception.class})
    Class<? extends Throwable>[] rollbackFor() default {};

    // 该属性用于设置需要进行回滚的异常类名称数组，当方法中抛出指定异常名称数组中的异常时，则进行事务回滚。
    // 例如: 指定单一异常类名称使用@Transactional(rollbackForClassName="RuntimeException")
    // 例如: 指定多个异常类名称使用@Transactional(rollbackForClassName={"RuntimeException","Exception"})
    String[] rollbackForClassName() default {};

    // 该属性用于设置不需要进行回滚的异常类数组，当方法中抛出指定异常数组中的异常时，不进行事务回滚。
    // 例如: 指定单一异常类使用@Transactional(noRollbackFor=RuntimeException.class)
    // 例如: 指定多个异常类使用@Transactional(noRollbackFor={RuntimeException.class, Exception.class})
    Class<? extends Throwable>[] noRollbackFor() default {};

    // 该属性用于设置不需要进行回滚的异常类名称数组，当方法中抛出指定异常名称数组中的异常时，不进行事务回滚。
    // 例如: 指定单一异常类名称使用@Transactional(noRollbackForClassName="RuntimeException")
    // 例如: 指定多个异常类名称使用@Transactional(noRollbackForClassName={"RuntimeException","Exception"})
    String[] noRollbackForClassName() default {};
}

注意点:
1 @Transactional只能被应用到public方法上。对于其它非public的方法，如果标记了@Transactional也不会报错，但方法没有事务功能。
2 用Spring事务管理器是由Spring来负责数据库的打开、提交和回滚。默认遇到运行期例外、即遇到不受检查（unchecked）的例外时回滚；而遇到需要捕获的例外、即遇到受检查的例外时，需要我们指定需要回滚的异常。
3 Spring团队的建议是你在具体的类（或类的方法）上使用 @Transactional 注解，而不要使用在类所要实现的任何接口上。

事务传播行为

PROPAGATION_NEVER 必须在一个没有的事务中执行,否则抛出异常(与Propagation.MANDATORY相反)。

if (definition.getPropagationBehavior() == TransactionDefinition.PROPAGATION_NEVER) {
    throw new IllegalTransactionStateException(
            "Existing transaction found for transaction marked with propagation 'never'");
}

PROPAGATION_NOT_SUPPORTED 以非事务方式执行操作，如果当前存在事务，就把当前事务挂起。

if (definition.getPropagationBehavior() == TransactionDefinition.PROPAGATION_NOT_SUPPORTED) {
    if (debugEnabled) {
        logger.debug("Suspending current transaction");
    }
    Object suspendedResources = suspend(transaction);
    boolean newSynchronization = (getTransactionSynchronization() == SYNCHRONIZATION_ALWAYS);
    return prepareTransactionStatus(
            definition, null, false, newSynchronization, debugEnabled, suspendedResources);
}

PROPAGATION_REQUIRES_NEW 不管是否存在事务都创建一个新的事务，原来的挂起，新的执行完毕，继续执行老的事务。

if (definition.getPropagationBehavior() == TransactionDefinition.PROPAGATION_REQUIRES_NEW) {
    if (debugEnabled) {
        logger.debug("Suspending current transaction, creating new transaction with name [" +
                definition.getName() + "]");
    }
    SuspendedResourcesHolder suspendedResources = suspend(transaction);
    try {
        boolean newSynchronization = (getTransactionSynchronization() != SYNCHRONIZATION_NEVER);
        DefaultTransactionStatus status = newTransactionStatus(
                definition, transaction, true, newSynchronization, debugEnabled, suspendedResources);
        doBegin(transaction, definition);
        prepareSynchronization(status, definition);
        return status;
    }
    catch (RuntimeException beginEx) {
        resumeAfterBeginException(transaction, suspendedResources, beginEx);
        throw beginEx;
    }
    catch (Error beginErr) {
        resumeAfterBeginException(transaction, suspendedResources, beginErr);
        throw beginErr;
    }
}

PROPAGATION_NESTED 如果当前存在事务，则在嵌套事务内执行。如果当前没有事务，则执行与PROPAGATION_REQUIRED类似的操作。

if (definition.getPropagationBehavior() == TransactionDefinition.PROPAGATION_NESTED) {
    if (!isNestedTransactionAllowed()) {
        throw new NestedTransactionNotSupportedException(
                "Transaction manager does not allow nested transactions by default - " +
                "specify 'nestedTransactionAllowed' property with value 'true'");
    }
    if (debugEnabled) {
        logger.debug("Creating nested transaction with name [" + definition.getName() + "]");
    }
    if (useSavepointForNestedTransaction()) {
        // Create savepoint within existing Spring-managed transaction,
        // through the SavepointManager API implemented by TransactionStatus.
        // Usually uses JDBC 3.0 savepoints. Never activates Spring synchronization.
        DefaultTransactionStatus status =
                prepareTransactionStatus(definition, transaction, false, false, debugEnabled, null);
        status.createAndHoldSavepoint();
        return status;
    }
    else {
        // Nested transaction through nested begin and commit/rollback calls.
        // Usually only for JTA: Spring synchronization might get activated here
        // in case of a pre-existing JTA transaction.
        boolean newSynchronization = (getTransactionSynchronization() != SYNCHRONIZATION_NEVER);
        DefaultTransactionStatus status = newTransactionStatus(
                definition, transaction, true, newSynchronization, debugEnabled, null);
        doBegin(transaction, definition);
        prepareSynchronization(status, definition);
        return status;
    }
}

PROPAGATION_MANDATORY 必须在一个已有的事务中执行，否则抛出异常。

if (definition.getPropagationBehavior() == TransactionDefinition.PROPAGATION_MANDATORY) {
    throw new IllegalTransactionStateException(
            "No existing transaction found for transaction marked with propagation 'mandatory'");
}

PROPAGATION_REQUIRED 如果当前没有事务，就新建一个事务，如果已经存在一个事务中，加入到这个事务中。

PROPAGATION_SUPPORTS 同当前事务，如果当前没有事务，就以非事务方式执行；如果当前有事务，就以事务方式执行。

事务隔离级别

public enum Isolation {

    DEFAULT(TransactionDefinition.ISOLATION_DEFAULT),

    // 允许另外一个事务看到当前事务未提交的数据(会产生脏读，不可重复读和幻像读)
    READ_UNCOMMITTED(TransactionDefinition.ISOLATION_READ_UNCOMMITTED),
    // 另外一个事务不能读取当前事务未提交的数据(会出现不可重复读和幻读，Oracle的默认隔离级别)
    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; }
}

注：
脏读 : 一个事务读取到另一事务未提交的更新数据。

不可重复读 : 指在一个事务内多次读同一数据。在这个事务还没有结束时，另外一个事务也访问该同一数据。那么，在第一个事务中的两次读数据之间，由于第二个事务的修改，那么第一个事务两次读到的数据可能是不一样的。这样就发生了在一个事务内两次读到的数据是不一样的，因此称为是不可重复读。
例如，一个编辑人员两次读取同一文档，但在两次读取之间，作者重写了该文档。当编辑人员第二次读取文档时，文档已更改。原始读取不可重复。如果只有在作者全部完成编写后编辑人员才可以读取文档，则可以避免该问题。

幻读 : 指当事务不是独立执行时发生的一种现象，例如第一个事务对一个表中的数据进行了修改，这种修改涉及到表中的全部数据行。同时，第二个事务也修改这个表中的数据，这种修改是向表中插入一行新数据。那么，以后就会发生操作第一个事务的用户发现表中还有没有修改的数据行，就好象发生了幻觉一样。
例如，一个编辑人员更改作者提交的文档，但当生产部门将其更改内容合并到该文档的主复本时，发现作者已将未编辑的新材料添加到该文档中。如果在编辑人员和生产部门完成对原始文档的处理之前，任何人都不能将新材料添加到文档中，则可以避免该问题。