public <T> T execute(PreparedStatementCreator psc, PreparedStatementCallback<T> action)  
        throws DataAccessException {  
    Assert.notNull(psc, "PreparedStatementCreator must not be null");  
    Assert.notNull(action, "Callback object must not be null");  
    if (logger.isDebugEnabled()) {  
        String sql = getSql(psc);  
        logger.debug("Executing prepared SQL statement" + (sql != null ? " [" + sql + "]" : ""));  
    }  
    //获取数据库连接  
    Connection con = DataSourceUtils.getConnection(getDataSource());  
    PreparedStatement ps = null;  
    try {  
        Connection conToUse = con;  
        if (this.nativeJdbcExtractor != null &&  
                this.nativeJdbcExtractor.isNativeConnectionNecessaryForNativePreparedStatements()) {  
            conToUse = this.nativeJdbcExtractor.getNativeConnection(con);  
        }  
        ps = psc.createPreparedStatement(conToUse);  
        //应用用户设定的输入参数  
        applyStatementSettings(ps);  
        PreparedStatement psToUse = ps;  
        if (this.nativeJdbcExtractor != null) {  
            psToUse = this.nativeJdbcExtractor.getNativePreparedStatement(ps);  
        }  
        //调用回掉函数  
        T result = action.doInPreparedStatement(psToUse);  
        handleWarnings(ps);  
        return result;  
    }  
    catch (SQLException ex) {  //释放数据库连接避免当异常转换器没有被初始化的时候出现潜在的连接池死锁  
        if (psc instanceof ParameterDisposer) {  
            ((ParameterDisposer) psc).cleanupParameters();  
        }  
        String sql = getSql(psc);  
        psc = null;  
        JdbcUtils.closeStatement(ps);  
        ps = null;  
        DataSourceUtils.releaseConnection(con, getDataSource());  
        con = null;  
        throw getExceptionTranslator().translate("PreparedStatementCallback", sql, ex);  
    }  
    finally {  
        if (psc instanceof ParameterDisposer) {  
            ((ParameterDisposer) psc).cleanupParameters();  
        }  
        JdbcUtils.closeStatement(ps);  
        DataSourceUtils.releaseConnection(con, getDataSource());  
    }  
} 

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();  
    }  
    logger.debug("Fetching JDBC Connection from DataSource");  
    Connection con = dataSource.getConnection();  
    //当前线程支持同步  
    if (TransactionSynchronizationManager.isSynchronizationActive()) {  
        logger.debug("Registering transaction synchronization for JDBC Connection");  //在事务中使用同一数据库连接  
        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;  
}  

protected void applyStatementSettings(Statement stmt) throws SQLException {  
    int fetchSize = getFetchSize();  
    if (fetchSize > 0) {  
        stmt.setFetchSize(fetchSize);  
    }  
    int maxRows = getMaxRows();  
    if (maxRows > 0) {  
        stmt.setMaxRows(maxRows);  
    }  
    DataSourceUtils.applyTimeout(stmt, getDataSource(), getQueryTimeout());  
}  

protected void handleWarnings(Statement stmt) throws SQLException {  
    //当设置为忽略警告时只尝试打印日志  
    if (isIgnoreWarnings()) {  
        if (logger.isDebugEnabled()) {  
            //如果日志开启的情况下下打印日志  
            SQLWarning warningToLog = stmt.getWarnings();  
            while (warningToLog != null) {  
                logger.debug("SQLWarning ignored: SQL state ‘" + warningToLog.getSQLState() + "‘, error code ‘" +  
                        warningToLog.getErrorCode() + "‘, message [" + warningToLog.getMessage() + "]");  
                warningToLog = warningToLog.getNextWarning();  
            }  
        }  
    }  
    else {  
        handleWarnings(stmt.getWarnings());  
    }  
}  

这里用到了一个类SQLWarning，SQLWarning提供关于数据库访问警告信息的异常。这些警告直接链接到导致报告警告的方法所在的对象。警告可以从Connection、Statement和ResultSet对象中获得。试图在已经关闭的连接上获取警告将导致抛出异常。类似地，试图在已经关闭的语句上或已经关闭的结果集上获取警告也将导致抛出异常。注意，关闭语句时还会关闭它可能生成的结果集。

最常见的警告DataTruncation：DataTruncation直接继承SQLWarning，由于某种原因意外地截断数据值时会以DataTruncation 警告形式报告异常。对于警告的处理方式并不是直接抛出异常，出现警告很可能会出现数据错误，但是，并不一定会影响程序执行，所以用户可以自己设置处理警告的方式，如默认的是忽略警告，当出现警告时只打印警告日志，而另一种方式只直接抛出异常。

public static void doReleaseConnection(Connection con, DataSource dataSource) throws SQLException {  
    if (con == null) {  
        return;  
    }  
    if (dataSource != null) {  
        //当前线程存在事务的情况下说明存在共用数据库连接  
        //直接使用ConnectionHolder中的released方法进行连接数减一而不是真正的释放链接  
        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);  
}