对spring JdbcTemplate 代码的一些理解

Spring将数据访问过程中固定和可变的部分明确的划分为两个不同的类：模板（template）和回调（callback）。模板管理过程中固定的部分，而回调处理自定义的数据访问代码。

Spring的JDBC框架承担了资源管理和异常处理的工作，从而简化了JDBC代码，让我们只需编写从数据库读写数据的必须代码。

对于JdbcTemplate类就从query相关的函数开始看吧。

对于query函数按参数大致可以分为三类：callback参数分别为 ResultSetExtractor<T>、RowCallbackHandler、RowMapper<T>

如：

public <T> T query(
PreparedStatementCreator psc, final PreparedStatementSetter pss, final ResultSetExtractor<T> rse)
throws DataAccessException
public void query(PreparedStatementCreator psc, RowCallbackHandler rch) throws DataAccessException
public <T> List<T> query(PreparedStatementCreator psc, RowMapper<T> rowMapper)

public <T> T query(String sql, Object[] args, int[] argTypes, ResultSetExtractor<T> rse) throws DataAccessException
public void query(String sql, Object[] args, int[] argTypes, RowCallbackHandler rch) throws DataAccessException
public <T> List<T> query(String sql, Object[] args, int[] argTypes, RowMapper<T> rowMapper) throws DataAccessException

等

对于ResultSetExtractor<T>类型的参数，不需要再进行封装，在将前两个参数封装成PreparedStatementCreator和PreparedStatementSetter后，就会调用excute函数进行执行。

public <T> T query(
PreparedStatementCreator psc, final PreparedStatementSetter pss, final ResultSetExtractor<T> rse)
throws DataAccessException {

Assert.notNull(rse, "ResultSetExtractor must not be null");
logger.debug("Executing prepared SQL query");

return execute(psc, new PreparedStatementCallback<T>() {
public T doInPreparedStatement(PreparedStatement ps) throws SQLException {
ResultSet rs = null;
try {
if (pss != null) {
pss.setValues(ps);
}
rs = ps.executeQuery();
ResultSet rsToUse = rs;
if (nativeJdbcExtractor != null) {
rsToUse = nativeJdbcExtractor.getNativeResultSet(rs);
}
//结果查询出来后，这里直接调用ResultSetExtractor接口的extractData对Resultset进行转换
return rse.extractData(rsToUse);
}
finally {
JdbcUtils.closeResultSet(rs);
if (pss instanceof ParameterDisposer) {
((ParameterDisposer) pss).cleanupParameters();
}
}
}
});
}

从代码中可以看到，在excute函数的第二个参数中直接创建了PreparedStatementCallback的回调实例，里面首先进行结果查询，得到resultset结果集。然后调用传进来的ResultSetExtractor对结果集进行转换。

如果query的回调参数是RowCallbackHandler类型。如：

public void query(String sql, PreparedStatementSetter pss, RowCallbackHandler rch) throws DataAccessException {
//使用ResultSetExtractor接口的实现类RowCallbackHandlerResultSetExtractor将RowCallbackHandler进行封装
query(sql, pss, new RowCallbackHandlerResultSetExtractor(rch));
}

可以看到对于RowCallbackHandler使用了ResultSetExtractor接口的实现类RowCallbackHandlerResultSetExtractor将RowCallbackHandler进行封装。其中RowCallbackHandlerResultSetExtractor的具体实现如下：

private static class RowCallbackHandlerResultSetExtractor implements ResultSetExtractor<Object> {

private final RowCallbackHandler rch;

public RowCallbackHandlerResultSetExtractor(RowCallbackHandler rch) {
this.rch = rch;
}

public Object extractData(ResultSet rs) throws SQLException {
while (rs.next()) {
this.rch.processRow(rs);
}
return null;
}
}

可以看到在实现的extractData函数中对resultset结果集进行逐行便利，调用RowCallbackHandler的processRow函数进行逐行处理结果。

所以RowCallbackHandler的作用是对结果集中的一行数据进行处理。每一次调用只处理一行数据。最终的结果RowCallbackHandlerResultSetExtractor不负责保存和返回，而是由RowCallbackHandler的实现类自己负责保存。因此query函数返回值为void。

第三种RowMapper<T>回调参数类型，如：

public <T> List<T> query(String sql, Object[] args, RowMapper<T> rowMapper) throws DataAccessException {
//使用ResultSetExtractor接口的实现类RowMapperResultSetExtractor将RowMapper<T>进行封装
return query(sql, args, new RowMapperResultSetExtractor<T>(rowMapper));
}

同样是使用了ResultSetExtractor接口的实现类RowMapperResultSetExtractor对RowMapper<T>进行了封装。RowMapperResultSetExtractor的实现如下：

public class RowMapperResultSetExtractor<T> implements ResultSetExtractor<List<T>> {

private final RowMapper<T> rowMapper;

private final int rowsExpected;

/**
* Create a new RowMapperResultSetExtractor.
* @param rowMapper the RowMapper which creates an object for each row
*/
public RowMapperResultSetExtractor(RowMapper<T> rowMapper) {
this(rowMapper, 0);
}

/**
* Create a new RowMapperResultSetExtractor.
* @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 RowMapperResultSetExtractor(RowMapper<T> rowMapper, int rowsExpected) {
Assert.notNull(rowMapper, "RowMapper is required");
this.rowMapper = rowMapper;
this.rowsExpected = rowsExpected;
}

public List<T> extractData(ResultSet rs) throws SQLException {
List<T> results = (this.rowsExpected > 0 ? new ArrayList<T>(this.rowsExpected) : new ArrayList<T>());
int rowNum = 0;
while (rs.next()) {
//对结果集调用RowMapper<T>的mapRow函数进行逐行处理，extractData负责对所有行的处理结果进行保存。
//RowMapper<T>的mapRow函数将返回每一行的数据处理为T类型的对象实例后返回
results.add(this.rowMapper.mapRow(rs, rowNum++));
}
return results;
}

}

从代码中可以看到extractData函数调用RowMapper<T>的mapRow函数对结果集进行逐行处理，extractData负责对所有行的处理结果进行保存。RowMapper<T>的mapRow函数将返回每一行的数据处理为T类型的对象实例后返回。

这就是在使用RowMapper<T>和RowCallbackHandler上的区别。

下面再看下query函数的第一个参数，第一个参数基本上是两种类型，一个是String，一个是PreparedStatementCreator类型，都是用来表示对sql语句的封装。String类型的表示传进来的sql语句，大多数最终都会封装成PreparedStatementCreator接口类型，除了public <T> List<T> query(String sql, RowMapper<T> rowMapper)
public void query(String sql, RowCallbackHandler rch) throws DataAccessException
public <T> T query(final String sql, final ResultSetExtractor<T> rse) throws DataAccessException
在JdbcTemplate中定义了一个SimplePreparedStatementCreator内部类来实现PreparedStatementCreator接口。

/**
* Simple adapter for PreparedStatementCreator, allowing to use a plain SQL statement.
*/
private static class SimplePreparedStatementCreator implements PreparedStatementCreator, SqlProvider {

private final String sql;

public SimplePreparedStatementCreator(String sql) {
Assert.notNull(sql, "SQL must not be null");
this.sql = sql;
}

public PreparedStatement createPreparedStatement(Connection con) throws SQLException {
return con.prepareStatement(this.sql);
}

public String getSql() {
return this.sql;
}
}

这个类很简单，基本上是将要调用的sql与PreparedStatement进行了封装。
对于query函数的另一个参数，可以看作是sql语句的赋值参数。这个参数有两种类型，一个是Object[]，另一个是PreparedStatementSetter接口类型的参数。Object[]数组类型的参数会封装成ArgumentPreparedStatementSetter类。从这个接口和的名字也可以看出该类的作用。就是用来设置PreparedStatement的，用来对PreparedStatement进行赋值操作的。

**
* Simple adapter for {@link PreparedStatementSetter} that applies a given array of arguments.
*
* @author Juergen Hoeller
* @since 3.2.3
*/
public class ArgumentPreparedStatementSetter implements PreparedStatementSetter, ParameterDisposer {

private final Object[] args;

/**
* Create a new ArgPreparedStatementSetter for the given arguments.
* @param args the arguments to set
*/
public ArgumentPreparedStatementSetter(Object[] args) {
this.args = args;
}

public void setValues(PreparedStatement ps) throws SQLException {
if (this.args != null) {
for (int i = 0; i < this.args.length; i++) {
Object arg = this.args[i];
doSetValue(ps, i + 1, arg);
}
}
}

/**
* Set the value for prepared statements specified parameter index using the passed in value.
* This method can be overridden by sub-classes if needed.
* @param ps the PreparedStatement
* @param parameterPosition index of the parameter position
* @param argValue the value to set
* @throws SQLException
*/
protected void doSetValue(PreparedStatement ps, int parameterPosition, Object argValue) throws SQLException {
if (argValue instanceof SqlParameterValue) {
SqlParameterValue paramValue = (SqlParameterValue) argValue;
StatementCreatorUtils.setParameterValue(ps, parameterPosition, paramValue, paramValue.getValue());
}
else {
StatementCreatorUtils.setParameterValue(ps, parameterPosition, SqlTypeValue.TYPE_UNKNOWN, argValue);
}
}

public void cleanupParameters() {
StatementCreatorUtils.cleanupParameters(this.args);
}

}


现在理解了这几种基本的调用后，对于JdbcTemplate中实现的queryForList、queryForMap、queryForObject等函数就好理解了。基本上就是上面三种基本形式的再封装以及相关接口的实例化实现。