spring的JdbcTemplate封装了jdbc的实现，下面通过源代码看一下其实现
1，一个执行Statement回调的接口
public interface StatementCallback 
{
Object doInStatement(Statement stmt) throws SQLException, DataAccessException;
}
public Object execute(StatementCallback action) throws DataAccessException {
//获取线程的同一个连接
Connection con = DataSourceUtils.getConnection(getDataSource());
Statement stmt = null;
try {
Connection conToUse = con;
if (this.nativeJdbcExtractor != null &&
this.nativeJdbcExtractor.
isNativeConnectionNecessaryForNativeStatements()) {
//通过特定厂商的特定方法，获取特定厂商的连接
conToUse = this.nativeJdbcExtractor.getNativeConnection(con);
}
stmt = conToUse.createStatement();
//计算并调用stmt.setQueryTimeout(..)
DataSourceUtils.applyTransactionTimeout(stmt, getDataSource());
Statement stmtToUse = stmt;
if (this.nativeJdbcExtractor != null) {
stmtToUse = this.nativeJdbcExtractor.getNativeStatement(stmt);
}
//执行回调
Object result = action.doInStatement(stmtToUse);
SQLWarning warning = stmt.getWarnings();
throwExceptionOnWarningIfNotIgnoringWarnings(warning);
return result;
} catch (SQLException ex) {
//对异常进行转译，所有抛出异常都继承DataAccessException这个非受控异常
throw getExceptionTranslator().translate(
"executing StatementCallback", getSql(action), ex);
} finally {
JdbcUtils.closeStatement(stmt);
DataSourceUtils.releaseConnection(con, getDataSource());
}
}2，一个StatementCallback预定义实现，提供query接口
public Object query(final String sql, final ResultSetExtractor rse) throws DataAccessException {
if (sql == null) {
throw new InvalidDataAccessApiUsageException("SQL must not be null");
}
if (JdbcUtils.countParameterPlaceholders(sql, '?', "'\"") > 0) {
throw new InvalidDataAccessApiUsageException(
"Cannot execute [" + sql +
"] as a static query: it contains bind variables");
}
if (logger.isDebugEnabled()) {
logger.debug("Executing SQL query [" + sql + "]");
}
//执行回调的内部类
class QueryStatementCallback implements StatementCallback, SqlProvider {
public Object doInStatement(Statement stmt) throws SQLException {
ResultSet rs = null;
try {
if (getFetchSize() > 0) {
stmt.setFetchSize(getFetchSize());
}
if (getMaxRows() > 0) {
stmt.setMaxRows(getMaxRows());
}
rs = stmt.executeQuery(sql);
ResultSet rsToUse = rs;
if (nativeJdbcExtractor != null) {
rsToUse = nativeJdbcExtractor.getNativeResultSet(rs);
}
//又一个回调
return rse.extractData(rsToUse);
} finally {
JdbcUtils.closeResultSet(rs);
}
}
public String getSql() {
return sql;
}
}
return execute(new QueryStatementCallback());
} 3，看一下一个预定义的ResultSetExtractor实现
private static class RowCallbackHandlerResultSetExtractor implements ResultSetExtractor {
private final RowCallbackHandler rch;
public RowCallbackHandlerResultSetExtractor(RowCallbackHandler rch) {
this.rch = rch;
}
public Object extractData(ResultSet rs) throws SQLException {
//利用RowCallbackHandler处理resultset，返回处理结果List
while (rs.next()) {
this.rch.processRow(rs);
}
if (this.rch instanceof ResultReader) {
return ((ResultReader) this.rch).getResults();
}
else {
return null;
}
}
}
public interface ResultReader extends RowCallbackHandler {
/** *//**
* Return all results, disconnected from the JDBC ResultSet.
* Never returns null; returns the empty collection if there
* were no results.
*/
List getResults();
}
public class RowMapperResultReader implements ResultReader {
/** *//** List to save results in */
private final List results;
/** *//** The RowMapper implementation that will be used to map rows */
private final RowMapper rowMapper;
/** *//** The counter used to count rows */
private int rowNum = 0;
/** *//**
* Create a new RowMapperResultReader.
* @param rowMapper the RowMapper which creates an object for each row
*/
public RowMapperResultReader(RowMapper rowMapper) {
this(rowMapper, 0);
}
/** *//**
* Create a new RowMapperResultReader.
* @param rowMapper the RowMapper which creates an object for each row
* @param rowsExpected the number of expected rows
* (just used for optimized collection handling)
*/
public RowMapperResultReader(RowMapper rowMapper, int rowsExpected) {
// Use the more efficient collection if we know how many rows to expect:
// ArrayList in case of a known row count, LinkedList if unknown
this.results = (rowsExpected > 0) ? (List) new ArrayList(rowsExpected) : (List) new LinkedList();
this.rowMapper = rowMapper;
}
public void processRow(ResultSet rs) throws SQLException {
this.results.add(this.rowMapper.mapRow(rs, this.rowNum++));
}
public List getResults() {
return this.results;
}
} 4，连接是如何获取的
public abstract class DataSourceUtils {
//..
public static Connection doGetConnection(DataSource dataSource) throws SQLException {
Assert.notNull(dataSource, "No DataSource specified");
//利用ThreadLocal，获取当前线程对应dataSource的connection封装---ConnectionHolder
ConnectionHolder conHolder = (ConnectionHolder) TransactionSynchronizationManager.getResource(dataSource);
if (conHolder != null) {
conHolder.requested();
return conHolder.getConnection();
}
//如果conHolder为空,为当前线程获取一个新连接，并设置ThreadLocal
logger.debug("Opening JDBC Connection");
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.
conHolder = new ConnectionHolder(con);
conHolder.setSynchronizedWithTransaction(true);
conHolder.requested();
TransactionSynchronizationManager.registerSynchronization(
new ConnectionSynchronization(conHolder, dataSource));
TransactionSynchronizationManager.bindResource(dataSource, conHolder);
}
return con;
}
//注意异常的改变
public static Connection getConnection(DataSource dataSource) throws CannotGetJdbcConnectionException {
try {
return doGetConnection(dataSource);
}
catch (SQLException ex) {
throw new CannotGetJdbcConnectionException("Could not get JDBC Connection", ex);
}
}
} 5，getResource和bindResource实现
public abstract class TransactionSynchronizationManager {
//..
private static final ThreadLocal resources = new ThreadLocal();
private static final ThreadLocal synchronizations = new ThreadLocal();
public static Object getResource(Object key) {
Map map = (Map) resources.get();
if (map == null) {
return null;
}
Object value = map.get(key);
if (value != null && logger.isDebugEnabled()) {
logger.debug("Retrieved value [" + value + "] for key [" + key + "] bound to thread [" +
Thread.currentThread().getName() + "]");
}
return value;
}
public static void bindResource(Object key, Object value) throws IllegalStateException {
Map map = (Map) resources.get();
// set ThreadLocal Map if none found
if (map == null) {
map = new HashMap();
resources.set(map);
}
if (map.containsKey(key)) {
throw new IllegalStateException("Already value [" + map.get(key) + "] for key [" + key +
"] bound to thread [" + Thread.currentThread().getName() + "]");
}
map.put(key, value);
if (logger.isDebugEnabled()) {
logger.debug("Bound value [" + value + "] for key [" + key + "] to thread [" +
Thread.currentThread().getName() + "]");
}
}
} 6，ConnectionHolder 类
public class ConnectionHolder extends ResourceHolderSupport {
private final ConnectionHandle connectionHandle;
private Connection currentConnection;
/** *//**
* Create a new ConnectionHolder for the given ConnectionHandle.
* @param connectionHandle the ConnectionHandle to hold
*/
public ConnectionHolder(ConnectionHandle connectionHandle) {
this.connectionHandle = connectionHandle;
}
/** *//**
* Create a new ConnectionHolder for the given JDBC Connection,
* wrapping it with a SimpleConnectionHandle.
* @param connection the JDBC Connection to hold
* @see SimpleConnectionHandle
*/
public ConnectionHolder(Connection connection) {
this.connectionHandle = new SimpleConnectionHandle(connection);
}
/** *//**
* Return the ConnectionHandle held by this ConnectionHolder.
*/
public ConnectionHandle getConnectionHandle() {
return connectionHandle;
}
/** *//**
* Return the current Connection held by this ConnectionHolder.
* <p>This will be the same Connection until <code>released</code>
* gets called on the ConnectionHolder, which will reset the
* held Connection, fetching a new Connection on demand.
* @see ConnectionHandle#getConnection()
* @see #released()
*/
public Connection getConnection() {
if (this.currentConnection == null) {
this.currentConnection = this.connectionHandle.getConnection();
}
return this.currentConnection;
}
/** *//**
* Releases the current Connection held by this ConnectionHolder.
* <p>This is necessary for ConnectionHandles that expect "Connection borrowing",
* where each returned Connection is only temporarily leased and needs to be
* returned once the data operation is done, to make the Connection available
* for other operations within the same transaction. This is the case with
* JDO 2.0 DataStoreConnections, for example.
* @see org.springframework.orm.jdo.DefaultJdoDialect#getJdbcConnection
*/
public void released() {
super.released();
if (this.currentConnection != null) {
this.connectionHandle.releaseConnection(this.currentConnection);
this.currentConnection = null;
}
}
} public class SimpleConnectionHandle implements ConnectionHandle {
private final Connection connection;
/** *//**
* Create a new SimpleConnectionHandle for the given Connection.
* @param connection the JDBC Connection
*/
public SimpleConnectionHandle(Connection connection) {
this.connection = connection;
}
public Connection getConnection() {
return connection;
}
public void releaseConnection(Connection con) {
}
public String toString() {
return "SimpleConnectionHandle: " + this.connection;
}
}