@Resource
    private UserMapper userMapper;
    @Resource
    private PlatformTransactionManager transactionManager;
    @GetMapping(value = "/transaction", produces = MediaType.APPLICATION_JSON_VALUE)
    public ResponseEntity<String> transaction() throws InterruptedException {
        TransactionStatus transaction = null;
        try {
            //開(kāi)啟事務(wù)
            transaction = transactionManager.getTransaction(new DefaultTransactionDefinition());
            User user = userMapper.findById(1L);
            System.out.println("更新前：" + user);
            user.setAge(28);
            userMapper.updateById(user);
            //事物未提交前其他線程讀取數(shù)據(jù)
            Thread otherThread = new Thread(() -> {
                User newUser = userMapper.findById(1L);
                System.out.println("新線程獲取更新后的值：" + newUser);
            });
            otherThread.start();
            otherThread.join();
            User newUser = userMapper.findById(1L);
            System.out.println("更新后：" + newUser);
        } finally {
            if (transaction != null) {
                //提交事務(wù)
                transactionManager.commit(transaction);
                //其他線程讀取事務(wù)提交后的值
                Thread otherThread = new Thread(() -> {
                    User user = userMapper.findById(1L);
                    System.out.println("新線程獲取事務(wù)提交后的值：" + user);
                });
                otherThread.start();
                otherThread.join();
            }
        }
        return ResponseEntity.ok("transaction");
    }

    @Resource
    private UserMapper userMapper;
    @Resource
    private PlatformTransactionManager transactionManager;
    @Resource
    private SqlSessionFactory sqlSessionFactory;
    @GetMapping(value = "/transaction2", produces = MediaType.APPLICATION_JSON_VALUE)
    public ResponseEntity<String> transaction2() {
        TransactionStatus transaction = null;
        DefaultSqlSession sqlSession = null;
        try {
            //開(kāi)啟事務(wù)
            transaction = transactionManager.getTransaction(new DefaultTransactionDefinition());
            User user = userMapper.findById(1L);
            System.out.println("更新前：" + user);
            user.setAge(28);
            userMapper.updateById(user);
            //重新開(kāi)啟一個(gè)連接
            Configuration configuration = sqlSessionFactory.getConfiguration();
            sqlSession = new DefaultSqlSession(
                    configuration,
                    configuration.newExecutor(
                            new JdbcTransaction(configuration.getEnvironment().getDataSource().getConnection()),
                            ExecutorType.SIMPLE),
                    true);
            User user2 = sqlSession.getMapper(UserMapper.class).findById(1L);
            System.out.println("新SqlSession獲取更新后的值：" + user2);
            User newUser = userMapper.findById(1L);
            System.out.println("更新后：" + newUser);
        } catch (SQLException e) {
            throw new RuntimeException(e);
        } finally {
            if (transaction != null) {
                //提交事務(wù)
                transactionManager.commit(transaction);
                if (sqlSession != null) {
                    User newUser = sqlSession.getMapper(UserMapper.class).findById(1L);
                    System.out.println("新SqlSession獲取事務(wù)提交后的值：" + newUser);
                    sqlSession.close();
                }
            }
        }
        return ResponseEntity.ok("transaction2");
    }

    @Options(flushCache = Options.FlushCachePolicy.TRUE)
    @Select("select * from user where id = #{id}")
    User findById(Long id);

transaction = transactionManager.getTransaction(new DefaultTransactionDefinition());

public final TransactionStatus getTransaction(@Nullable TransactionDefinition definition)
			throws TransactionException {
		// 省略相關(guān)代碼。。。
		// No existing transaction found -> check propagation behavior to find out how to proceed.
		if (def.getPropagationBehavior() == TransactionDefinition.PROPAGATION_MANDATORY) {
			throw new IllegalTransactionStateException(
					"No existing transaction found for transaction marked with propagation 'mandatory'");
		}
		else if (def.getPropagationBehavior() == TransactionDefinition.PROPAGATION_REQUIRED ||
				def.getPropagationBehavior() == TransactionDefinition.PROPAGATION_REQUIRES_NEW ||
				def.getPropagationBehavior() == TransactionDefinition.PROPAGATION_NESTED) {
			SuspendedResourcesHolder suspendedResources = suspend(null);
			if (debugEnabled) {
				logger.debug("Creating new transaction with name [" + def.getName() + "]: " + def);
			}
			try {
				//開(kāi)啟新的事務(wù)
				return startTransaction(def, transaction, false, debugEnabled, suspendedResources);
			}
			catch (RuntimeException | Error ex) {
				resume(null, suspendedResources);
				throw ex;
			}
		}
		else {
			// Create "empty" transaction: no actual transaction, but potentially synchronization.
			// 省略相關(guān)代碼。。。
		}
	}
	private TransactionStatus startTransaction(TransactionDefinition definition, Object transaction,
			boolean nested, boolean debugEnabled, @Nullable SuspendedResourcesHolder suspendedResources) {
		boolean newSynchronization = (getTransactionSynchronization() != SYNCHRONIZATION_NEVER);
		DefaultTransactionStatus status = newTransactionStatus(
				definition, transaction, true, newSynchronization, nested, debugEnabled, suspendedResources);
		this.transactionExecutionListeners.forEach(listener -> listener.beforeBegin(status));
		try {
			//此處由實(shí)現(xiàn)類實(shí)現(xiàn)
			doBegin(transaction, definition);
		}
		catch (RuntimeException | Error ex) {
			this.transactionExecutionListeners.forEach(listener -> listener.afterBegin(status, ex));
			throw ex;
		}
		prepareSynchronization(status, definition);
		this.transactionExecutionListeners.forEach(listener -> listener.afterBegin(status, null));
		return status;
	}

protected void doBegin(Object transaction, TransactionDefinition definition) {
		DataSourceTransactionObject txObject = (DataSourceTransactionObject) transaction;
		Connection con = null;
		try {
			if (!txObject.hasConnectionHolder() ||
					txObject.getConnectionHolder().isSynchronizedWithTransaction()) {
				//從數(shù)據(jù)源中獲取一個(gè)新的連接
				Connection newCon = obtainDataSource().getConnection();
				if (logger.isDebugEnabled()) {
					logger.debug("Acquired Connection [" + newCon + "] for JDBC transaction");
				}
				if (definition.isReadOnly()) {
					checkDefaultReadOnly(newCon);
				}
				// 把新的數(shù)據(jù)庫(kù)連接綁定到ConnectionHolder中
				txObject.setConnectionHolder(new ConnectionHolder(newCon), true);
			}
			txObject.getConnectionHolder().setSynchronizedWithTransaction(true);
			con = txObject.getConnectionHolder().getConnection();
			// 省略部分代碼。。。
			// Switch to manual commit if necessary. This is very expensive in some JDBC drivers,
			// so we don't want to do it unnecessarily (for example if we've explicitly
			// configured the connection pool to set it already).
			// 正常情況下新獲取的連接都是自動(dòng)提交
			if (con.getAutoCommit()) {
				txObject.setMustRestoreAutoCommit(true);
				if (logger.isDebugEnabled()) {
					logger.debug("Switching JDBC Connection [" + con + "] to manual commit");
				}
				//將數(shù)據(jù)庫(kù)連接改為手動(dòng)提交
				con.setAutoCommit(false);
			}
			// 省略部分代碼。。。
			// Bind the connection holder to the thread.
			if (txObject.isNewConnectionHolder()) {
				//給當(dāng)前線程的數(shù)據(jù)源綁定一個(gè)ConnectionHolder
				TransactionSynchronizationManager.bindResource(obtainDataSource(), txObject.getConnectionHolder());
			}
		}
		catch (Throwable ex) {
			// 省略部分代碼。。。
		}
	}

  public Connection getConnection() throws SQLException {
    if (this.connection == null) {
      openConnection();
    }
    return this.connection;
  }
  private void openConnection() throws SQLException {
    this.connection = DataSourceUtils.getConnection(this.dataSource);
    this.autoCommit = this.connection.getAutoCommit();
    this.isConnectionTransactional = DataSourceUtils.isConnectionTransactional(this.connection, this.dataSource);
    LOGGER.debug(() -> "JDBC Connection [" + this.connection + "] will"
        + (this.isConnectionTransactional ? " " : " not ") + "be managed by Spring");
  }

public static Connection getConnection(DataSource dataSource) throws CannotGetJdbcConnectionException {
		try {
			return doGetConnection(dataSource);
		}
		catch (SQLException ex) {
			throw new CannotGetJdbcConnectionException("Failed to obtain JDBC Connection", ex);
		}
		catch (IllegalStateException ex) {
			throw new CannotGetJdbcConnectionException("Failed to obtain JDBC Connection", ex);
		}
	}
    public static Connection doGetConnection(DataSource dataSource) throws SQLException {
        Assert.notNull(dataSource, "No DataSource specified");
        //這里能看到連接是從事務(wù)同步器中拿的
        ConnectionHolder conHolder = (ConnectionHolder) TransactionSynchronizationManager.getResource(dataSource);
        if (conHolder != null && (conHolder.hasConnection() || conHolder.isSynchronizedWithTransaction())) {
            conHolder.requested();
            if (!conHolder.hasConnection()) {
                logger.debug("Fetching resumed JDBC Connection from DataSource");
                conHolder.setConnection(fetchConnection(dataSource));
            }
            return conHolder.getConnection();
        }
        // Else we either got no holder or an empty thread-bound holder here.
        // 省略相關(guān)代碼。。。
        return con;
    }

	protected void doCommit(DefaultTransactionStatus status) {
		DataSourceTransactionObject txObject = (DataSourceTransactionObject) status.getTransaction();
		// 最開(kāi)始創(chuàng)建一個(gè)新的事務(wù)時(shí)txObject中已經(jīng)綁定了ConnectionHolder
		Connection con = txObject.getConnectionHolder().getConnection();
		if (status.isDebug()) {
			logger.debug("Committing JDBC transaction on Connection [" + con + "]");
		}
		try {
			con.commit();
		}
		catch (SQLException ex) {
			throw translateException("JDBC commit", ex);
		}
	}

protected void doCleanupAfterCompletion(Object transaction) {
		DataSourceTransactionObject txObject = (DataSourceTransactionObject) transaction;
		// Remove the connection holder from the thread, if exposed.
		if (txObject.isNewConnectionHolder()) {
			TransactionSynchronizationManager.unbindResource(obtainDataSource());
		}
		// Reset connection.
		Connection con = txObject.getConnectionHolder().getConnection();
		try {
			if (txObject.isMustRestoreAutoCommit()) {
			  // 恢復(fù)為自動(dòng)提交
				con.setAutoCommit(true);
			}
			DataSourceUtils.resetConnectionAfterTransaction(con,
					txObject.getPreviousIsolationLevel(),
					(txObject.isReadOnly() && !isDefaultReadOnly()));
		}
		catch (Throwable ex) {
			logger.debug("Could not reset JDBC Connection after transaction", ex);
		}
		// 省略部分代碼。。。
	}

  public <E> List<E> query(MappedStatement ms, Object parameter, RowBounds rowBounds, ResultHandler resultHandler,
      CacheKey key, BoundSql boundSql) throws SQLException {
    ErrorContext.instance().resource(ms.getResource()).activity("executing a query").object(ms.getId());
    if (closed) {
      throw new ExecutorException("Executor was closed.");
    }
    // 如果設(shè)置了強(qiáng)制刷新緩存，每次執(zhí)行查詢時(shí)都會(huì)清空一遍緩存
    if (queryStack == 0 && ms.isFlushCacheRequired()) {
      clearLocalCache();
    }
    List<E> list;
    try {
      queryStack++;
      // 如果從緩存中拿到了值就不從數(shù)據(jù)庫(kù)中查詢了
      list = resultHandler == null ? (List<E>) localCache.getObject(key) : null;
      if (list != null) {
        handleLocallyCachedOutputParameters(ms, key, parameter, boundSql);
      } else {
        list = queryFromDatabase(ms, parameter, rowBounds, resultHandler, key, boundSql);
      }
    } finally {
      queryStack--;
    }
    if (queryStack == 0) {
      for (DeferredLoad deferredLoad : deferredLoads) {
        deferredLoad.load();
      }
      // issue #601
      deferredLoads.clear();
      if (configuration.getLocalCacheScope() == LocalCacheScope.STATEMENT) {
        // issue #482
        clearLocalCache();
      }
    }
    return list;
  }