The most common reason for using transactions in an application is to maintain a high degree of data integrity and consistency.

1.事务定义：事务包含哪些属性
2.事务管理器：如何将我们对事务的诉求转化为数据库层面的实现
3.事务切面：Spring底层是如何将业务和事务串起来的

TransactionTemplate template = new TransactionTemplate();
template.setIsolationLevel(org.springframework.transaction.TransactionDefinition.ISOLATION_DEFAULT);
template.setPropagationBehavior(org.springframework.transaction.TransactionDefinition.PROPAGATION_REQUIRED);
template.setTransactionManager(transactionManager);
template.execute(new TransactionCallback<UserAo>() {
    @Override
    public UserAo doInTransaction(TransactionStatus status) {
         //business logic
    }
});

public <T> T execute(TransactionCallback<T> action) throws TransactionException {
    TransactionStatus status = this.transactionManager.getTransaction(this);    //获取并初始化事务，处理比如事务传播形式等
    T result;
    try {
        result = action.doInTransaction(status);    //业务逻辑，包括自定义的回滚
    } catch (RuntimeException ex) {
        // Transactional code threw application exception -> rollback
        rollbackOnException(status, ex);
        throw ex;
    } catch (Error err) {
        // Transactional code threw error -> rollback
        rollbackOnException(status, err);
        throw err;
    } catch (Exception ex) {
        // Transactional code threw unexpected exception -> rollback
        rollbackOnException(status, ex);
        throw new UndeclaredThrowableException(ex, "TransactionCallback threw undeclared checked exception");
    }
    this.transactionManager.commit(status); //事务提交
    return result;
}

<bean id="txManager" class="org.springframework.jdbc.datasource.DataSourceTransactionManager">
    <property name="dataSource" ref="dataSource"/>
</bean>

<tx:annotation-driven transaction-manager="txManager"/>

The Spring team’s recommendation is that you only annotate concrete classes with the @Transactional annotation, as opposed to annotating interfaces. 
You certainly can place the @Transactional annotation on an interface (or an interface method), but this will only work as you would expect it to if you are using interface-based proxies. 
The fact that annotations are not inherited means that if you are using class-based proxies (proxy-target-class=“true“) or the weaving-based aspect (mode=“aspectj“) then the transaction settings will not be recognised by the proxying/weaving infrastructure and the object will not be wrapped in a transactional proxy (which would be decidedly bad). 
So please do take the Spring team’s advice and only annotate concrete classes (and the methods of concrete classes) with the @Transactional annotation.

public @interface Transactional {
    /**
     * 用于配置事务管理器，当系统中存在多个数据源多个事务管理器的时候有用
     * 配置 txManager1 这种 bean name
     */
    String value() default "";

    /**
     * 事务传播级别
     */
    Propagation propagation() default Propagation.REQUIRED;

    /**
     * 事务隔离级别
     */
    Isolation isolation() default Isolation.DEFAULT;

    /**
     * 事务超时时间
     */
    int timeout() default TransactionDefinition.TIMEOUT_DEFAULT;

    /**
     * 事务是否read-only
     * 注意：这个设置对真实的事务执行系统是一个 hint 而不是 强制要求有这个配置的情况下 write 一定导致失败
     */
    boolean readOnly() default false;

    /**
     * 定义0个或多个exception，当事务遇到这些异常的时候，事务会回滚
     */
    Class<? extends Throwable>[] rollbackFor() default {};

    /**
     * 定义0个或多个exception的name，当事务遇到这些异常的时候，事务会回滚
     * 最好定义完整的路径，比如 javax.servlet.ServletException 会代表 ServletException 本身及子类
     */
    String[] rollbackForClassName() default {};

    /**
     * 定义0个或多个exception，当事务遇到这些异常的时候，事务不会回滚
     */
    Class<? extends Throwable>[] noRollbackFor() default {};

    /**
     * 定义0个或多个exception的name，当事务遇到这些异常的时候，事务不会回滚
     */
    String[] noRollbackForClassName() default {};
}

public interface TransactionDefinition {
    /**
     * 事务传播行为,可选项参见 TransactionDefinition 中定义的 PROPAGATION_XXX
     */
    int getPropagationBehavior();

    /**
     * 事务隔离级别,可选项参见 TransactionDefinition 中定义的 ISOLATION_XXX
     * 只在 PROPAGATION_REQUIRED 和 PROPAGATION_REQUIRES_NEW 这两个事务传播行为配置下有效
     */
    int getIsolationLevel();

    /**
     * 事务超时时间,单位秒
     * 默认 TIMEOUT_DEFAULT = -1 表示使用底层实现的超时时间或者没有(不支持事务超时时间)
     * 只在 PROPAGATION_REQUIRED 和 PROPAGATION_REQUIRES_NEW 这两个事务传播行为配置下有效
     * 如果事务管理器不支持设置超时时间，而调用了这个接口会抛出异常
     */
    int getTimeout();

    boolean isReadOnly();

    /**
     * 事务name，允许为null
     * 对于申明式事务，默认的name为：完整的class名称.metho名称
     */
    String getName();
}

private int propagationBehavior = PROPAGATION_REQUIRED;
private int isolationLevel = ISOLATION_DEFAULT;
private int timeout = TIMEOUT_DEFAULT;
private boolean readOnly = false;

/**
 * 如果已经存在事务直接使用，如果不存在则创建一个新事务
 */
int PROPAGATION_REQUIRED = 0;

/**
 * 如果已经存在事务直接使用，如果不存在则不使用事务
 */
int PROPAGATION_SUPPORTS = 1;

/**
 * 如果已经存在事务直接使用，如果不存在则抛出异常
 */
int PROPAGATION_MANDATORY = 2;

/**
 * 创建一个新事务，如果如果已经存在事务则将当前事务挂起
 */
int PROPAGATION_REQUIRES_NEW = 3;

/**
 * 不使用事务，如果当前已经存在事务则将当前事务挂起
 */
int PROPAGATION_NOT_SUPPORTED = 4;

/**
 * 不使用事务，如果当前存在事务则跑出异常
 */
int PROPAGATION_NEVER = 5;

/**
 * 如果已经存在事务直接使用，则执行一个嵌套事务，如果当前没有事务就创建一个新事务
 */
int PROPAGATION_NESTED = 6;

PROPAGATION_NESTED uses a single physical transaction with multiple savepoints that it can roll back to. 
Such partial rollbacks allow an inner transaction scope to trigger a rollback for its scope, with the outer transaction being able to continue the physical transaction despite some operations having been rolled back. 
This setting is typically mapped onto JDBC savepoints, so will only work with JDBC resource transactions. See Spring's DataSourceTransactionManager.

/**
 * 使用底层数据源的隔离级别
 * 参考：java.sql.Connection.getTransactionIsolation()
 */
int ISOLATION_DEFAULT = -1;

/**
 * READ_UNCOMMITTED
 */
int ISOLATION_READ_UNCOMMITTED = Connection.TRANSACTION_READ_UNCOMMITTED;

/**
 * READ_COMMITTED
 */
int ISOLATION_READ_COMMITTED = Connection.TRANSACTION_READ_COMMITTED;

/**
 * REPEATABLE_READ
 */
int ISOLATION_REPEATABLE_READ = Connection.TRANSACTION_REPEATABLE_READ;

/**
 * SERIALIZABLE
 */
int ISOLATION_SERIALIZABLE = Connection.TRANSACTION_SERIALIZABLE;

public interface PlatformTransactionManager {
    /**
     * 根据事务定义(TransactionDefinition),返回当前active事务或者创建一个新的事务
     * 注意：
     * 1.TransactionDefinition 中的隔离级别超时时间等设置只在创建了新事物的时候有效，如果使用当前已存在的事务则无效
     * 2.不是所有的事务管理器都支持 TransactionDefinition 中的所有属性，当事务管理器遇到不支持的属性则抛异常
     * 3.上条规则的例外是 read-only这个属性，如果事务管理器不支持这个属性直接忽略
     */
    TransactionStatus getTransaction(TransactionDefinition definition) throws TransactionException;

    /**
     * 事务提交
     */
    void commit(TransactionStatus status) throws TransactionException;

    /**
     * 回滚事务
     */
    void rollback(TransactionStatus status) throws TransactionException;
}