# Spring事务管理

    //Spring源码中事务传播属性的枚举类定义
	public enum Propagation {
    //Spring事务的默认传播属性。
    //支持当前事务，如果当前有事务，那么加入事务，如果当前没有事务则新建一个。
    //默认值： 0。    
    REQUIRED(TransactionDefinition.PROPAGATION_REQUIRED),    
    //如果当前有事务则加入，如果没有则不用事务。
    //默认值： 1。    
    SUPPORTS(TransactionDefinition.PROPAGATION_SUPPORTS)
    //强制的，支持当前事务，如果当前没有事务，则抛出异常。（当前必须有事务）。
    //默认值： 2。    
    MANDATORY(TransactionDefinition.PROPAGATION_MANDATORY),
    //支持当前事务，如果当前有事务，则挂起当前事务，然后新创建一个事务，
    //如果当前没有事务，则自己创建一个事务。
    //默认值： 3。
    REQUIRES_NEW(TransactionDefinition.PROPAGATION_REQUIRES_NEW),
    //以非事务方式执行操作，如果当前存在事务就把当前事务挂起，
    //执行完后恢复事务（忽略当前事务）。
    //默认值： 4。    
    NOT_SUPPORTED(TransactionDefinition.PROPAGATION_NOT_SUPPORTED),
    //以非事务方式执行，如果当前存在事务，则抛出异常。（当前必须不能有事务）。
    //默认值： 5。       
    NEVER(TransactionDefinition.PROPAGATION_NEVER),
    //如果当前存在事务，则嵌套在当前事务中。
    //如果当前没有事务，则新建一个事务自己执行（和required一样）。
    //嵌套的事务使用保存点作为回滚点，当内部事务回滚时不会影响外部事物的提交。
    //但是外部回滚会把内部事务一起回滚回去。（这个和新建一个事务的区别）。
    //默认值： 6。           
    NESTED(TransactionDefinition.PROPAGATION_NESTED);

    private final int value;

    private Propagation(int value) {
        this.value = value;
    }

    public int value() {
        return this.value;
    }
}

//Spring事务的隔离级别源码类
public enum Isolation {
   //默认事务隔离级别：-1
   DEFAULT(TransactionDefinition.ISOLATION_DEFAULT),
   //读未提交： 1
   READ_UNCOMMITTED(TransactionDefinition.ISOLATION_READ_UNCOMMITTED),
   //读提交： 2
   READ_COMMITTED(TransactionDefinition.ISOLATION_READ_COMMITTED),
   //可重复读：4 
   REPEATABLE_READ(TransactionDefinition.ISOLATION_REPEATABLE_READ),
   //串行化：8
   SERIALIZABLE(TransactionDefinition.ISOLATION_SERIALIZABLE);

    private final int value;

    private Isolation(int value) {
        this.value = value;
    }

    public int value() {
        return this.value;
    }
}

    // 编程式事务
    public class SimpleService implements Service {
    // 所有方法共享一个TransactionTemplate实例
    private final TransactionTemplate transactionTemplate;
    // 使用构造函数注入来提供PlatformTransactionManager
    public SimpleService(PlatformTransactionManager transactionManager) {
        this.transactionTemplate = new TransactionTemplate(transactionManager);
    }
    // 此方法可以不用添加@Transactional注解
    public Object someServiceMethod() {
        return transactionTemplate.execute(new TransactionCallback() {
            // 此方法中的代码在事务上下文中执行
            public Object doInTransaction(TransactionStatus status) {
                updateOperation1();
                return resultOfUpdateOperation2();
            }
        });
      }
   }

public abstract class TransactionSynchronizationManager {

	private static final Log logger = LogFactory.getLog(TransactionSynchronizationManager.class);

	private static final ThreadLocal<Map<Object, Object>> resources =
			new NamedThreadLocal<>("Transactional resources");

	private static final ThreadLocal<Set<TransactionSynchronization>> synchronizations =
			new NamedThreadLocal<>("Transaction synchronizations");

	private static final ThreadLocal<String> currentTransactionName =
			new NamedThreadLocal<>("Current transaction name");

	private static final ThreadLocal<Boolean> currentTransactionReadOnly =
			new NamedThreadLocal<>("Current transaction read-only status");

	private static final ThreadLocal<Integer> currentTransactionIsolationLevel =
			new NamedThreadLocal<>("Current transaction isolation level");

	private static final ThreadLocal<Boolean> actualTransactionActive =
			new NamedThreadLocal<>("Actual transaction active");

   /**
   *  TODO : 事务资源绑定
   *   建立当前线程和Map的关系
   *   Map保存的key是数据源，value是数据库连接
   */
   public static void bindResource(Object key, Object value) throws IllegalStateException {
		Object actualKey = TransactionSynchronizationUtils.unwrapResourceIfNecessary(key);
		Assert.notNull(value, "Value must not be null");
		Map<Object, Object> map = resources.get();
		// set ThreadLocal Map if none found
		if (map == null) {
			map = new HashMap<>();
			resources.set(map);
		}
		//DataSource生成的actualKey为key值
		//ConnectionHolder作为value值
		//为了标识连接从哪个数据源来
		Object oldValue = map.put(actualKey, value);
		// Transparently suppress a ResourceHolder that was marked as void...
		if (oldValue instanceof ResourceHolder && ((ResourceHolder) oldValue).isVoid()) {
			oldValue = null;
		}
		if (oldValue != null) {
			throw new IllegalStateException("Already value [" + oldValue + "] for key [" +
					actualKey + "] bound to thread [" + Thread.currentThread().getName() + "]");
		}
		if (logger.isTraceEnabled()) {
			logger.trace("Bound value [" + value + "] for key [" + actualKey + "] to thread [" +
					Thread.currentThread().getName() + "]");
		}
	}

}