spring jdbc 之一

使用过jdbc的我们都知道spring jdbc ,首先我们看下JdbcTemplate 中的execute
在exceute的实现中看到了数据库进行操作的基本过程，比如需要获得数据库Connection，根据应用对数据库操作需要创建数据库的statement，对数据库操作进行回调，处理数据库异常
最后把数据库的连接关闭，等等，这里展示了使用JDBC完成数据库操作的完整过程，只是在spring中，对这些较为普通的JDBC使用，JdbcTemplate进行了一个封装而已。
public void execute(final String sql)
throws DataAccessException
{

class _cls1ExecuteStatementCallback
implements StatementCallback, SqlProvider
{

public Object doInStatement(Statement stmt)
throws SQLException
{
stmt.execute(sql);
return null;
}

public String getSql()
{
return sql;
}

final JdbcTemplate this$0;
private final String val$sql;

_cls1ExecuteStatementCallback()
{
this$0 = JdbcTemplate.this;
sql = s;
super();
}
}

execute(((StatementCallback) (new _cls1ExecuteStatementCallback())));
}


public Object execute(StatementCallback action)
throws DataAccessException
{
Connection con;
Statement stmt;
Assert.notNull(action, "Callback object must not be null");
con = DataSourceUtils.getConnection(getDataSource());
stmt = null;
Object obj;
try
{
Connection conToUse = con;
if(nativeJdbcExtractor != null && nativeJdbcExtractor.isNativeConnectionNecessaryForNativeStatements())
conToUse = nativeJdbcExtractor.getNativeConnection(con);
stmt = conToUse.createStatement();
applyStatementSettings(stmt);
Statement stmtToUse = stmt;
if(nativeJdbcExtractor != null)
stmtToUse = nativeJdbcExtractor.getNativeStatement(stmt);
//通过回调函数等到结果
Object result = action.doInStatement(stmtToUse);
handleWarnings(stmt);
obj = result;
}
catch(SQLException ex)
{
JdbcUtils.closeStatement(stmt);
stmt = null;
DataSourceUtils.releaseConnection(con, getDataSource());
con = null;
throw getExceptionTranslator().translate("StatementCallback", getSql(action), ex);
}
JdbcUtils.closeStatement(stmt);
DataSourceUtils.releaseConnection(con, getDataSource());
return obj;
Exception exception;
exception;
JdbcUtils.closeStatement(stmt);
DataSourceUtils.releaseConnection(con, getDataSource());
throw exception;
}

jdbc的基本原理其中的execute方法,我们在看下jdbcTemplate中的query方法
public Object query(PreparedStatementCreator psc, final PreparedStatementSetter pss, final ResultSetExtractor rse)
throws DataAccessException
{
return execute(psc, new PreparedStatementCallback() {
public Object doInPreparedStatement(PreparedStatement ps)
throws SQLException
{
ResultSet rs = null;
Object obj;
if(pss != null)
pss.setValues(ps);
rs = ps.executeQuery();
ResultSet rsToUse = rs;
if(nativeJdbcExtractor != null)
rsToUse = nativeJdbcExtractor.getNativeResultSet(rs);
//采用了接口，进行回调
obj = rse.extractData(rsToUse);
JdbcUtils.closeResultSet(rs);
if(pss instanceof ParameterDisposer)
((ParameterDisposer)pss).cleanupParameters();
return obj;
Exception exception;
exception;
JdbcUtils.closeResultSet(rs);
if(pss instanceof ParameterDisposer)
((ParameterDisposer)pss).cleanupParameters();
throw exception;
}

final JdbcTemplate this$0;
private final PreparedStatementSetter val$pss;
private final ResultSetExtractor val$rse;


{
this$0 = JdbcTemplate.this;
pss = preparedstatementsetter;
rse = resultsetextractor;
super();
}
}
);
}

在对ResultSet进行回调处理的接口有三个，分别为RowMapper,ResultSetExtrator,RowHandlerCallBack接口
RowMapper接口中包含了一个mapRow方法，需要自己实现同通过转换从而得到自己想要的结果。
// 对resultset中封装一个接口为rowMapping
List<VersionInfo> list = jdbcTemplate.query(sql, new
RowMapper<VersionInfo>()
{
@Override
public VersionInfo mapRow(ResultSet rs, int i) throws SQLException
{
VersionInfo versionInfo = new VersionInfo();
versionInfo.setId(rs.getInt("id"));
versionInfo.setVersionName(rs.getString("version_name"));
versionInfo.setUploadTime(rs.getLong("upload_time"));
versionInfo.setActiveState(rs.getString("active_state"));
versionInfo.setVersionType(rs.getString("version_type"));
versionInfo.setFilePath(rs.getString("file_path"));
versionInfo.setReMark(rs.getString("remark"));
versionInfo.setVersionNumber(rs.getString("version_number"));
return versionInfo;
}
});


ResultSetExtrator接口中包含了extractData方法，该方法需要自己遍历Resultset才能得到想要的结果
List<VersionInfo> list = (List<VersionInfo>) jdbcTemplate.query(sql,
new ResultSetExtractor<List<VersionInfo>>()
{
@Override
public List<VersionInfo> extractData(ResultSet rs) throws
SQLException, DataAccessException
{
VersionInfo versionInfo = null;
List<VersionInfo> list = new ArrayList<VersionInfo>();
while (rs.next())
{
versionInfo = new VersionInfo();
versionInfo.setId(rs.getInt("id"));
versionInfo.setVersion_name(rs.getString("version_name"));
versionInfo.setUpload_time(rs.getLong("upload_time"));
versionInfo.setActive_state(rs.getString("active_state"));
versionInfo.setVersion_type(rs.getString("version_type"));
versionInfo.setFile_path(rs.getString("file_path"));
versionInfo.setRemark(rs.getString("remark"));
versionInfo.setVersion_number(rs.getString("version_number"));
list.add(versionInfo);
}
return list;
}
});

RowCallbackHandler接口中包含了processRow方法，该方法中没有返回值，但是会自动的循环ResultSet结果集
final List<VersionInfo> list = new ArrayList<VersionInfo>();
jdbcTemplate.query(sql, new RowCallbackHandler()
{
// 会自动循环ResultSet
@Override
public void processRow(ResultSet rs) throws SQLException
{
VersionInfo versionInfo = new VersionInfo();
versionInfo.setId(rs.getInt("id"));
versionInfo.setVersion_name(rs.getString("version_name"));
versionInfo.setUpload_time(rs.getLong("upload_time"));
versionInfo.setActive_state(rs.getString("active_state"));
versionInfo.setVersion_type(rs.getString("version_type"));
versionInfo.setFile_path(rs.getString("file_path"));
versionInfo.setRemark(rs.getString("remark"));
versionInfo.setVersion_number(rs.getString("version_number"));
list.add(versionInfo);
}
});


可能大家会觉得奇怪，在查询方法中只传入的是ResultSetExtractor接口，而RowMapper和RowCallbackHandler接口与ResultSetExtractor没有相互的集成关系,那么jdbcTemlate是怎样做转换的
首先看下RowCallbackHandler接口

public void query(String sql, PreparedStatementSetter pss, RowCallbackHandler rch)
throws DataAccessException
{
query(sql, pss, ((ResultSetExtractor) (new RowCallbackHandlerResultSetExtractor(rch))));
}


//传入的是RowCallbackHandler接口有一个RowCallbackHandlerResultSetExtractor类进行了转换该类实现了ResultSetExtractor接口

private static class RowCallbackHandlerResultSetExtractor
implements ResultSetExtractor
{

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

private final RowCallbackHandler rch;

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

同理RowMapper

public class RowMapperResultSetExtractor
implements ResultSetExtractor
{

public RowMapperResultSetExtractor(RowMapper rowMapper)
{
this(rowMapper, 0);
}

public RowMapperResultSetExtractor(RowMapper rowMapper, int rowsExpected)
{
Assert.notNull(rowMapper, "RowMapper is required");
this.rowMapper = rowMapper;
this.rowsExpected = rowsExpected;
}

public List extractData(ResultSet rs)
throws SQLException
{
List results = rowsExpected <= 0 ? ((List) (new ArrayList())) : ((List) (new ArrayList(rowsExpected)));
int rowNum = 0;
for(; rs.next(); results.add(rowMapper.mapRow(rs, rowNum++)));
return results;
}

public volatile Object extractData(ResultSet resultset)
throws SQLException, DataAccessException
{
return extractData(resultset);
}

private final RowMapper rowMapper;
private final int rowsExpected;
}