org.springframework.jdbc.datasource.DataSourceUtils

 

/**     * Actually obtain a JDBC Connection from the given DataSource.     * Same as {
    @link #getConnection}, but throwing the original SQLException.     * 
Is aware of a corresponding Connection bound to the current thread, for example     * when using {
    @link DataSourceTransactionManager}. Will bind a Connection to the thread     * if transaction synchronization is active (e.g. if in a JTA transaction).     * 
Directly accessed by {
    @link TransactionAwareDataSourceProxy}.     * @param dataSource the DataSource to obtain Connections from     * @return a JDBC Connection from the given DataSource     * @throws SQLException if thrown by JDBC methods     * @see #doReleaseConnection     */    public static Connection doGetConnection(DataSource dataSource) throws SQLException {        Assert.notNull(dataSource, "No DataSource specified");        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(dataSource.getConnection());            }            return conHolder.getConnection();        }        // Else we either got no holder or an empty thread-bound holder here.        logger.debug("Fetching JDBC Connection from DataSource");        Connection con = dataSource.getConnection();        if (TransactionSynchronizationManager.isSynchronizationActive()) {            logger.debug("Registering transaction synchronization for JDBC Connection");            // Use same Connection for further JDBC actions within the transaction.            // Thread-bound object will get removed by synchronization at transaction completion.            ConnectionHolder holderToUse = conHolder;            if (holderToUse == null) {                holderToUse = new ConnectionHolder(con);            }            else {                holderToUse.setConnection(con);            }            holderToUse.requested();            TransactionSynchronizationManager.registerSynchronization(                    new ConnectionSynchronization(holderToUse, dataSource));            holderToUse.setSynchronizedWithTransaction(true);            if (holderToUse != conHolder) {                TransactionSynchronizationManager.bindResource(dataSource, holderToUse);            }        }        return con;    }

org.mybatis.spring.transaction.SpringManagedTransaction

/**   * Gets a connection from Spring transaction manager and discovers if this   * {
    @code Transaction} should manage connection or let it to Spring.   * 
   * It also reads autocommit setting because when using Spring Transaction MyBatis   * thinks that autocommit is always false and will always call commit/rollback   * so we need to no-op that calls.   */  private void openConnection() throws SQLException {    this.connection = DataSourceUtils.getConnection(this.dataSource);    this.autoCommit = this.connection.getAutoCommit();    this.isConnectionTransactional = DataSourceUtils.isConnectionTransactional(this.connection, this.dataSource);    if (LOGGER.isDebugEnabled()) {      LOGGER.debug(          "JDBC Connection ["              + this.connection              + "] will"              + (this.isConnectionTransactional ? " " : " not ")              + "be managed by Spring");    }  }

 

 

 

 

org.mybatis.spring.SqlSessionUtils

public void beforeCompletion() {            if(!this.holder.isOpen()) {                if(SqlSessionUtils.LOGGER.isDebugEnabled()) {                    SqlSessionUtils.LOGGER.debug("Transaction synchronization deregistering SqlSession [" + this.holder.getSqlSession() + "]");                }                TransactionSynchronizationManager.unbindResource(this.sessionFactory);                this.holderActive = false;                if(SqlSessionUtils.LOGGER.isDebugEnabled()) {                    SqlSessionUtils.LOGGER.debug("Transaction synchronization closing SqlSession [" + this.holder.getSqlSession() + "]");                }                this.holder.getSqlSession().close();            }        }

 

 

 

/**     * Actually close the given Connection, obtained from the given DataSource.     * Same as {
    @link #releaseConnection}, but throwing the original SQLException.     * 
Directly accessed by {
    @link TransactionAwareDataSourceProxy}.     * @param con the Connection to close if necessary     * (if this is {
    @code null}, the call will be ignored)     * @param dataSource the DataSource that the Connection was obtained from     * (may be {
    @code null})     * @throws SQLException if thrown by JDBC methods     * @see #doGetConnection     */    public static void doReleaseConnection(Connection con, DataSource dataSource) throws SQLException {        if (con == null) {            return;        }        if (dataSource != null) {            ConnectionHolder conHolder = (ConnectionHolder) TransactionSynchronizationManager.getResource(dataSource);            if (conHolder != null && connectionEquals(conHolder, con)) {                // It's the transactional Connection: Don't close it.                conHolder.released();                return;            }        }        logger.debug("Returning JDBC Connection to DataSource");        doCloseConnection(con, dataSource);    }