原文地址：https://my.oschina.net/u/218421/blog/38513
Spring提供了两种使用JDBC API的最佳实践，一种是以JdbcTemplate为核心的基于Template的JDBC的使用方式，另一种则是在JdbcTemplate基础之上的构建的基于操作对象的JDBC的使用方式。
基于Template的JDBC的使用方式
该使用方式的最初设想和原型，需要追溯到Rod Johnson在03年出版的Expert One-on-One J2EE Design and Development,在该书的Practical Data Access(数据访问实践)中，Rod针对JDBC使用中的一些问题提出了一套改进的实践原型，并最终将该原型完善后在Spring框架中发布。
JDBC的尴尬
JDBC作为Java平台的访问关系数据库的标准，其成功是 有目共睹的。几乎所有java平台的数据访问，都直接或者间接的使用了JDBC，它是整个java平台面向关系数据库进行数据访问的基石。
作为一个标准，无疑JDBC是很成功的，但是要说JDBC在使用过程当中多么的受人欢迎，则不尽然了。JDBC主要是面向较为底层的数据库操作，所以在设计的过程当中 ，比较的贴切底层以提供尽可能多的功能特色。从这个角度来说，JDBC API的设计无可厚非。可是，过于贴切底层的API的设计，对于开发人员则未必是一件好事。即使执行一个最简单的查询，开发人员也要按照API的规矩写上一大堆雷同的代码，如果不能合理的封装使用JDBC API，在项目中使用JDBC访问数据所出现的问题估计会使人发疯！
对于通常的项目开发来说，如果层次划分很明确，数据访问逻辑一般应该在DAO层中实现。根据功能模块的划分，可能每个开发人员都会分得或多或少的实现相应的DAO的任务，假设开发人员A在分得了DAO实现任务后进行开发，他或许开发了如下所示的代码：
package com.google.spring.jdbc;
import java.sql.Connection;
import java.sql.SQLException;
import java.sql.Statement;
import javax.sql.DataSource;
import org.apache.commons.logging.Log;
import org.apache.commons.logging.LogFactory;
public class DaoWithA implements IDao
{
private final Log logger = LogFactory.getLog(DaoWithA.class);
private DataSource dataSource = null;
public DataSource getDataSource()
{
return dataSource;
}
public void setDataSource(DataSource dataSource)
{
this.dataSource = dataSource;
}
@Override
public int updateSomething(String sql)
{
int count;
Connection conn = null;
Statement stmt = null;
try
{
conn = getDataSource().getConnection();
stmt = conn.createStatement();
count = stmt.executeUpdate(sql);
stmt.close();
stmt = null;
}
catch (SQLException e)
{
throw new RuntimeException(e);
}
finally
{
if(stmt!=null)
{
try
{
stmt.close();
}
catch (SQLException ex)
{
logger.warn("fail to close statement:"+ex);
}
}
if(conn!=null)
{
try
{
conn.close();
}
catch (Exception ex)
{
logger.warn("failed to close Connection:"+ex);
}
}
}
return count;
}
}
而B所负责的DAO的实现中，可能也有类似的更新的操作。无疑，B也要像A这样，在他的DAO实现类中写一大堆同样的JDBC代码，类似的情况还可能扩展到C、D等开发人员。如果每个开发人员都能严格的按照JDBC的编程规范开发还好，但是事实是，一个团队中的开发人员是有差别的。
这其实只是API的使用过程中的一个插曲，当你看到应用程序中成百的使用JDBC实现类的时候，会发现如下的问题：
1、Statement使用完没有关闭，而是想着让Connection关闭的时候一并关闭，可是并非所有的驱动程序都有这样的行为。
2、创建了多个ResultSet或者Statement，只清理了最外层的，忽视了里层的。
3、忘记关闭Connection。
JDBC规范在指定数据库访问异常的时候也没有能够进行的很彻底：
1、将异常类型定义为SQLException是一个值得商榷的地方。
2、SQLExcpetion没有采用将具体的异常情况子类化，以进一步抽象不同的数据访问的情况，而是采用ErrorCode的方式来区分访问过程中所出现的不同异常情况，其实这也没什么，只要能区分出具体的错误就行，但是JDBC规范却把ErrorCode的规范留给了数据库提供商，这导致了不同的数据库供应商对应了不同的ErrorCode，进而应用程序在捕获到SQLException后，还要看当前用的是什么数据库。
针对以上问题，Spring提供了相应的解决方案帮助我们提高开发效率！
为了解决JDBC API在实际使用中的各种尴尬的局面，spring提出了org.springframework.jdbc.core.JdbcTemplate作为数据访问的Helper类。JdbcTemplate是整个spring数据抽象层提供的所有JDBC API最佳实践的基础，框架内其它更加方便的Helper类以及更高层次的抽象，全部的构建于JdbcTemplate之上。抓住了JdbcTemplate，就抓住了spring框架JDBC API最佳实践的核心。
概括的说，JdbcTemplate主要关注一下两个事情：
1、封装所有的基于JDBC的数据访问的代码，以统一的格式和规范来使用JDBC API。所有的基于JDBC API的数据访问全部通过JdbcTemplate，从而避免了容易出错的数据访问方式。
2、对SQLException所提供的异常信息在框架内进行统一的转译，将基于JDBC的数据访问异常纳入Spring自身的异常层次之中，统一了数据接口的定义，简化了客户端代码对数据访问异常的处理。
Spring主要是通过模板方法对基于JDBC的数据访问代码进行统一的封装，所以我们可先看下模板方法：
模板方法主要是用于对算法的行为或者逻辑进行封装，即如果多个类中存在相似的算法逻辑或者行为逻辑，可以将这些逻辑提取到模板方法中实现，然后让相应的子类根据需要实现某些自定义的逻辑。
举个例子，所有的汽车，不管是宝马还是大众，他们的驾驶流程基本上是固定的。实际上，除了少数的实现细节有所不同之外，大部分的流程是相同的，基本上是如下所示的流程说明：
1、点火启动
2、踩刹车，挂前进的档位（不同的车在这一步会存在差异）
3、放下手动控制器（手刹）
4、踩油门启动车辆运行
此时，我们可以声明一个模板方法类，将确定的行为以模板的形式定义，而将不同的行为留给相应的子类来实现：
package com.google.spring.jdbc;
public abstract class Vehicle
{
public final void drive()
{
startTheEnginee();//启动
putIntoGear(); //前进
looseHandBrake();//放下手刹
stepOnTheGasAndGo();//踩油门前进
}
protected abstract void putIntoGear();
private void startTheEnginee()
{
}
private void looseHandBrake()
{
}
private void stepOnTheGasAndGo()
{
}
}
drive()方法就是我们的模板方法，它被声明为final，表示该类是不能被子类重写的，车辆的自动挡和手动挡是不同的，所以留给了子类去实现：
package com.google.spring.jdbc;
public class VehicleAT extends Vehicle
{
@Override
protected void putIntoGear()
{
//挂前进档位
}
}
package com.google.spring.jdbc;
public class VehicleMT extends Vehicle
{
@Override
protected void putIntoGear()
{
//踩离合器 挂前进档位
}
}
这样，每个子类实现特有的逻辑就可以了。
JdbcTemplate的演化
如果回头看一下最初的使用JDBC API进行数据访问的代码。就会发现，不管这些代码是谁负责的，也不管数据访问的逻辑如何，除了小部分的差异之外，所有的这些代码几乎都是按照同一个流程走下来的，如下：
1、conn=getDataSource().getConnection();
2、stmt=conn.createStatement()或者ps=conn.prepareStatement();
3、stmt.executeUpdate(sql)或者ps.executeUpdate() 或者进行相应的查询。
4、stmt.close() stmt=null
5、catch处理数据库访问异常
6、关闭数据库连接避免连接泄露导致系统崩溃
对于多个DAO中充斥着几乎相同的JDBC API的使用代码，我们也可以采用模板方法，多这些代码进行重构，避免因个人操作不当所出现的种种问题，我们要做的，就是将一些公共的行为提取到模板方法中去，而特有的操作，比如每次执行不同的更新，或者对不同的查询结果进行不同的处理，则放入具体的子类中，这样，我们就有个JdbcTemplate的雏形：
package com.google.spring.jdbc;
import java.sql.Connection;
import java.sql.SQLException;
import java.sql.Statement;
import javax.sql.DataSource;
import org.springframework.dao.DataAccessException;
public abstract class JdbcTemplate
{
private DataSource dataSource;
public DataSource getDataSource()
{
return dataSource;
}
public void setDataSource(DataSource dataSource)
{
this.dataSource = dataSource;
}
public final Object execute(String sql)
{
Connection conn = null;
Statement stmt = null;
try
{
conn = this.getDataSource().getConnection();
stmt = conn.createStatement();
Object retValue = this.executeWithStatement(stmt, sql);
return retValue;
}
catch (SQLException e)
{
throw new RuntimeException(e);
}
finally
{
closeStatement(stmt);
closeConnection(conn);
}
}
protected abstract Object executeWithStatement(Statement stmt,String sql);
private final DataAccessException translateSQLException(SQLException e)
{
DataAccessException dataAccessException = null;
//进行相应的转译
return dataAccessException;
}
private final void closeStatement(Statement stmt)
{
//关闭Statement
}
private final void closeConnection(Connection conn)
{
//关闭Connection
}
}
这样处理之后，JDBC代码的使用有了规范。但是，只使用模板方法还不足以提供方便的Helper类。顶着abstract的帽子，每次使用都要进行相应的子类化，这也太不靠谱了。所以，spring中的JdbcTemplate除了引入了模板方法之外，还引入了相应的Callback，避免了每次都子类化，比如，当引入了StatementCallback接口以后：
package com.google.spring.jdbc;
import java.sql.Statement;
public interface StatementCallback
{
public Object doWithStatement(Statement stmt) throws SQLException;
}
这样这个真正的Helper类就存在了，如下所示：
package com.google.spring.jdbc;
import java.sql.Connection;
import java.sql.SQLException;
import java.sql.Statement;
import javax.sql.DataSource;
import org.springframework.dao.DataAccessException;
public class JdbcTemplate
{
private DataSource dataSource;
public DataSource getDataSource()
{
return dataSource;
}
public void setDataSource(DataSource dataSource)
{
this.dataSource = dataSource;
}
public final Object execute(StatementCallback callback)
{
Connection conn = null;
Statement stmt = null;
try
{
conn = this.getDataSource().getConnection();
stmt = conn.createStatement();
Object retValue = callback.doWithStatement(stmt);
return retValue;
}
catch (SQLException e)
{
throw new RuntimeException(e);
}
finally
{
closeStatement(stmt);
closeConnection(conn);
}
}
private final DataAccessException translateSQLException(SQLException e)
{
DataAccessException dataAccessException = null;
//进行相应的转译
return dataAccessException;
}
private final void closeStatement(Statement stmt)
{
//关闭Statement
}
private final void closeConnection(Connection conn)
{
//关闭Connection
}
}
要在相应的DAO中使用该JdbcTemplate，只需要根据情况提供参数和相应的callback就可以了，如下所示：
final String sql = "update";
JdbcTemplate jdbcTemplate = new JdbcTemplate();
BasicDataSource dataSource = new BasicDataSource();
jdbcTemplate.setDataSource(dataSource);
//对dataSource进行setter操作
StatementCallback callback = new StatementCallback()
{
public Object doWithStatement(Statement stmt) throws SQLException
{
return new Integer(stmt.executeUpdate(sql)) ;
}
};
jdbcTemplate.execute(callback);
这样，开发人员只需要关注与数据访问逻辑相关的东西，JDBC底层的细节不需要再考虑了。
上述是spring中JdbcTemplate的中心思想，实际上，JdbcTemplate在实现上要考虑很多的东西，继承层次如下：
org.springframework.jdbc.core.JdbcOperations接口定义了JdbcTemplate可以使用的JDBC操作集合，该接口提供的操作声明，从查询到更新无所不有。
JdbcTemplate的直接父类是JdbcAccessor，这是一个抽象类，主要为子类提供一些公用的属性：
DataSource：javax.sql.DataSource是JDBC2.0之后引入的接口定义，用来替代java.sql.DriverManager的数据库连接方式，它的角色可以看做是JDBC的连接工厂，所以，基本上现在它应该作为获取数据库资源的统一接口。
SQLExceptionTranslator：JdbcTemplate委托此类进行异常的转译。
JdbcTemplate中的模板方法可分为如下的四组：
面向Connection的模板方法：
通过ConnectionCallback接口所公开的Connection进行数据访问
import java.sql.Connection;
import java.sql.SQLException;
import org.springframework.dao.DataAccessException;
public interface ConnectionCallback
{
Object doInConnection(Connection con) throws SQLException, DataAccessException;
}
public Object execute(ConnectionCallback action) throws DataAccessException {
Assert.notNull(action, "Callback object must not be null");
Connection con = DataSourceUtils.getConnection(getDataSource());
try {
Connection conToUse = con;
if (this.nativeJdbcExtractor != null) {
// Extract native JDBC Connection, castable to OracleConnection or the like.
conToUse = this.nativeJdbcExtractor.getNativeConnection(con);
}
else {
// Create close-suppressing Connection proxy, also preparing returned Statements.
conToUse = createConnectionProxy(con);
}
return action.doInConnection(conToUse); }
catch (SQLException ex) {
// Release Connection early, to avoid potential connection pool deadlock
// in the case when the exception translator hasn't been initialized yet.
DataSourceUtils.releaseConnection(con, getDataSource());
con = null;
throw getExceptionTranslator().translate("ConnectionCallback", getSql(action), ex);
}
finally {
DataSourceUtils.releaseConnection(con, getDataSource());
}
}
可以随意操作Connection。
面向Statement的模板方法：
该模板方法主要处理基于SQL的数据访问请求。该组模板方法通过org.springframework.jdbc.core.StatementCallback回调接口，对外公开java.sql.Statement的操作句柄。该方式缩小了回调接口内的权限范围，但是提高了API使用上的安全性和便捷性。
面向PreparedStatement的模板方法：
对于使用包含查询参数的SQL请求来说，使用PreparedStatement可以让我们免于SQL注入的攻击，而在使用PreparedStatement之前，需要根据传入的包含参数的SQL对其进行创建，所以，面向PreparedStatement的模板方式会通过org.springframework.jdbc.core.PreparedStatementCreator的回调接口公开Connection以允许PreparedStatement的创建。PreparedStatement创建之后，会公开org.springframework.jdbc.core.PreparedStatementCallback回调接口，以支持其使用PreparedStatement进行数据访问。
面向CallableStatement的模板方法：
JDBC支持使用CallableStatement进行数据库存储过程的访问，面向CallableStatement的的模板方法会通过org.springframework.jdbc.core.CallableStatementCreator公开的Connection用于创建调用存储过程的CallableStatement。之后，再通过org.springframework.jdbc.core.CallableStatementCallback公开的CallableStatement的操作句柄，实现基于存储过程的数据访问。
每一组的模板方法都 有一个核心的方法实现，其它的属于同一组的重载的模板方法，会调用这个核心的方法来完成最终的工作。以面向Statement的模板方法为例，使用StatementCallback回调接口作为方法参数的execute方法是这组的核心代码:
public Object execute(StatementCallback action) throws DataAccessException {
Assert.notNull(action, "Callback object must not be null");
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();
applyStatementSettings(stmt);
Statement stmtToUse = stmt;
if (this.nativeJdbcExtractor != null) {
stmtToUse = this.nativeJdbcExtractor.getNativeStatement(stmt);
}
Object result = action.doInStatement(stmtToUse);
handleWarnings(stmt);
return result;
}
catch (SQLException ex) {
// Release Connection early, to avoid potential connection pool deadlock
// in the case when the exception translator hasn't been initialized yet.
JdbcUtils.closeStatement(stmt);
stmt = null;
DataSourceUtils.releaseConnection(con, getDataSource());
con = null;
throw getExceptionTranslator().translate("StatementCallback", getSql(action), ex);
}
finally {
JdbcUtils.closeStatement(stmt);
DataSourceUtils.releaseConnection(con, getDataSource());
}
}
其它模板方法会根据自身的签名，构建相应的StatementCallback实例以调用回调接口中公开的方法，例如：
public void execute(final String sql) throws DataAccessException {
if (logger.isDebugEnabled()) {
logger.debug("Executing SQL statement [" + sql + "]");
}
class ExecuteStatementCallback implements StatementCallback, SqlProvider {
public Object doInStatement(Statement stmt) throws SQLException {
stmt.execute(sql);
return null;
}
public String getSql() {
return sql;
}
}
execute(new ExecuteStatementCallback());
}
同一组内的模板方法，可以根据使用的方便性进行增加，只要在实现的时候，将相应的条件加以对应，改组的回调接口进行封装，最终调用当前组的核心模板方法即可。
下面来逐一看下这些方法：
public void execute(final String sql):
public void execute(final String sql) throws DataAccessException {
if (logger.isDebugEnabled()) {
logger.debug("Executing SQL statement [" + sql + "]");
}
class ExecuteStatementCallback implements StatementCallback, SqlProvider {
public Object doInStatement(Statement stmt) throws SQLException {
stmt.execute(sql);
return null;
}
public String getSql() {
return sql;
}
}
execute(new ExecuteStatementCallback());
}
根据传入的静态SQL语句进行更新，无返回值，使用的是Statement
public Object execute(String callString, CallableStatementCallback action) throws DataAccessException:
public Object execute(String callString, CallableStatementCallback action) throws DataAccessException {
return execute(new SimpleCallableStatementCreator(callString), action);
}
内部调的是
public Object execute(CallableStatementCreator csc, CallableStatementCallback action)
throws DataAccessException {
Assert.notNull(csc, "CallableStatementCreator must not be null");
Assert.notNull(action, "Callback object must not be null");
if (logger.isDebugEnabled()) {
String sql = getSql(csc);
logger.debug("Calling stored procedure" + (sql != null ? " [" + sql + "]" : ""));
}
Connection con = DataSourceUtils.getConnection(getDataSource());
CallableStatement cs = null;
try {
Connection conToUse = con;
if (this.nativeJdbcExtractor != null) {
conToUse = this.nativeJdbcExtractor.getNativeConnection(con);
}
cs = csc.createCallableStatement(conToUse);
applyStatementSettings(cs);
CallableStatement csToUse = cs;
if (this.nativeJdbcExtractor != null) {
csToUse = this.nativeJdbcExtractor.getNativeCallableStatement(cs);
}
Object result = action.doInCallableStatement(csToUse);
handleWarnings(cs);
return result;
}
catch (SQLException ex) {
// Release Connection early, to avoid potential connection pool deadlock
// in the case when the exception translator hasn't been initialized yet.
if (csc instanceof ParameterDisposer) {
((ParameterDisposer) csc).cleanupParameters();
}
String sql = getSql(csc);
csc = null;
JdbcUtils.closeStatement(cs);
cs = null;
DataSourceUtils.releaseConnection(con, getDataSource());
con = null;
throw getExceptionTranslator().translate("CallableStatementCallback", sql, ex);
}
finally {
if (csc instanceof ParameterDisposer) {
((ParameterDisposer) csc).cleanupParameters();
}
JdbcUtils.closeStatement(cs);
DataSourceUtils.releaseConnection(con, getDataSource());
}
}
JdbcTemplate在此提供了一个内部类SimpleCallableStatementCreator：
private static class SimpleCallableStatementCreator implements CallableStatementCreator, SqlProvider {
private final String callString;
public SimpleCallableStatementCreator(String callString) {
Assert.notNull(callString, "Call string must not be null");
this.callString = callString;
}
public CallableStatement createCallableStatement(Connection con) throws SQLException {
return con.prepareCall(this.callString);
}
public String getSql() {
return this.callString;
}
}
根据传入的sql语句创建一CallableStatement
public Object execute(String sql, PreparedStatementCallback action) throws DataAccessException
public Object execute(String sql, PreparedStatementCallback action) throws DataAccessException {
return execute(new SimplePreparedStatementCreator(sql), action);
}
可知其内部调用了
execute(new SimplePreparedStatementCreator(sql), action)方法。
public Object execute(PreparedStatementCreator psc, PreparedStatementCallback 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);
}
Object result = action.doInPreparedStatement(psToUse);
handleWarnings(ps);
return result;
}
catch (SQLException ex) {
// Release Connection early, to avoid potential connection pool deadlock
// in the case when the exception translator hasn't been initialized yet.
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());
}
}
在创建PreparedStatementCreator实现类的时候，JdbcTemplate为其默认提供了一个SimplePreparedStatementCreator内部静态类，可根据传入的SQL语句创建一个PreparedStatement 代码如下：
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;
}
}
其它的模仿方法与此类似，可以触类旁通！