Spring源代码分析（12)---JdbcTemplate(ORM我也能行)

ai 上一节中，我们已经对JdbcDaoSupport和JdbcTemplate有了一定的了解。但是，我们只是初步的了解了JdbcTemplate,至此Spring也只是让我们更方便的获取连接。其实Spring提供了很多强大的功能，使得JdbcTemplate访问数据库，下面，让我们从来看看：

JdbcTemplate:

1.   public Object execute(String sql, PreparedStatementCallback action) throws DataAccessException {
2.          return execute(new SimplePreparedStatementCreator(sql), action);
3.      }

而在JdbcTemplate中有内部类如下：

1.     private static class SimplePreparedStatementCreator implements PreparedStatementCreator, SqlProvider {
3.         private final String sql;
5.         public SimplePreparedStatementCreator(String sql) {
6.             Assert.notNull(sql, "SQL must not be null");
7.             this.sql = sql;
8.         }
10.         public PreparedStatement createPreparedStatement(Connection con) throws SQLException {
11.             return con.prepareStatement(this.sql);
12.         }
14.         public String getSql() {
15.             return sql;
16.         }
17.     }

SimplePreparedStatementCreator负责从sql String生成查询语句PreparedStatement对象；

1.     public Object execute(PreparedStatementCreator psc, PreparedStatementCallback action)
2.             throws DataAccessException {
3. 
   
4.         Assert.notNull(psc, "PreparedStatementCreator must not be null");
5.         Assert.notNull(action, "Callback object must not be null");
6.         //从数据源获取连接
7.         Connection con = DataSourceUtils.getConnection(getDataSource());
8.         PreparedStatement ps = null;
9.         try {
10.             Connection conToUse = con;
11.             //利用JdbcTemplate的nativeJdbcExtractor的属性，将这个从数据源得到的数据库连接
12.             //（有可能是代理类，而不是原生态的数据库连接）中抽取出原生的数据库连接对象
13.             if (this.nativeJdbcExtractor != null &&
14.                     this.nativeJdbcExtractor.isNativeConnectionNecessaryForNativePreparedStatements()) {
15.                 conToUse = this.nativeJdbcExtractor.getNativeConnection(con);
16.             }
17.             //从这个数据库连接获取查询语句
18.             ps = psc.createPreparedStatement(conToUse);
19.             //将具体的查询语句的属性，比如查询行数等等配置给该查询语句；
20.             applyStatementSettings(ps);
21.             PreparedStatement psToUse = ps;
22.             if (this.nativeJdbcExtractor != null) {
23.                 //同样，用本地JDBC抽取出原生的查询语句；
24.                 psToUse = this.nativeJdbcExtractor.getNativePreparedStatement(ps);
25.             }
26.             //执行该查询语句，并且进行处理；
27.             Object result = action.doInPreparedStatement(psToUse);
28.             handleWarnings(ps.getWarnings());
29.             return result;
30.         }
31.         catch (SQLException ex) {
32.             // Release Connection early, to avoid potential connection pool deadlock
33.             // in the case when the exception translator hasn't been initialized yet.
34.             if (psc instanceof ParameterDisposer) {
35.                 ((ParameterDisposer) psc).cleanupParameters();
36.             }
37.             String sql = getSql(psc);
38.             psc = null;
39.             JdbcUtils.closeStatement(ps);
40.             ps = null;
41.             DataSourceUtils.releaseConnection(con, getDataSource());
42.             con = null;
43.             throw getExceptionTranslator().translate("PreparedStatementCallback", sql, ex);
44.         }
45.         finally {
46.             if (psc instanceof ParameterDisposer) {
47.                 ((ParameterDisposer) psc).cleanupParameters();
48.             }
49.             //这里将查询语句关闭抽出一个独立的方法；避免异常处理的重复和嵌套；
50.             JdbcUtils.closeStatement(ps);
51.             DataSourceUtils.releaseConnection(con, getDataSource());
52.         }
53.     }

查询关闭语句：

1.     public static void closeStatement(Statement stmt) {
2.         if (stmt != null) {
3.             try {
4.                 stmt.close();
5.             }
6.             catch (SQLException ex) {
7.                 logger.debug("Could not close JDBC Statement", ex);
8.             }
9.             catch (Throwable ex) {
10.                 // We don't trust the JDBC driver: It might throw RuntimeException or Error.
11.                 logger.debug("Unexpected exception on closing JDBC Statement", ex);
12.             }
13.         }
14.     }

执行查询回调方法，给开发者留下了扩展的接口，典型的模板方式的应用：

1. public interface PreparedStatementCallback {
2. 
   
3.     //自己实现：
4.     Object doInPreparedStatement(PreparedStatement ps) throws SQLException, DataAccessException;
5. 
   
6. }
7. 
   

接下来，我们可以见到具体的应用；

1. public Object execute(ConnectionCallback action) throws DataAccessException 

对应于：

1. public interface ConnectionCallback {
2. 
   
3.     //用户可以自定义connection操作；
4.     Object doInConnection(Connection con) throws SQLException, DataAccessException;
5. 
   
6. }

1. public Object execute(StatementCallback action) throws DataAccessException {

同理对应于：

1.  public interface StatementCallback {
2. 
   
3.      //扩展statement操作；
4.      Object doInStatement(Statement stmt) throws SQLException, DataAccessException;
5. 
   
6.  }

以上，我们可以看见Spring位我们准备了三中对象层次的扩展点；

其实，我们利用Spring给我们提供的功能，Jdbc一样也能实现一些程度上的ORM，虽然，有限，但是却能让我们在保证数据库连接效率的同时，也能享受到oo的数据库访问机制；

1.     public Object query(PreparedStatementCreator psc, ResultSetExtractor rse) throws DataAccessException {
2.         return query(psc, null, rse);
3.     }

1. public Object query(
2.             PreparedStatementCreator psc, final PreparedStatementSetter pss, final ResultSetExtractor rse)
3.             throws DataAccessException {
4. 
   
5.         Assert.notNull(rse, "ResultSetExtractor must not be null");
6.         if (logger.isDebugEnabled()) {
7.             String sql = getSql(psc);
8.             logger.debug("Executing SQL query" + (sql != null ? " [" + sql  + "]" : ""));
9.         }
10.         //利用了上面介绍的扩展点之一，查询到了结果集合，并且用ResultSetExtractor对结果的集合进行了处理；
11.         return execute(psc, new PreparedStatementCallback() {
12.             public Object doInPreparedStatement(PreparedStatement ps) throws SQLException {
13.                 ResultSet rs = null;
14.                 try {
15.                     if (pss != null) {
16.                         pss.setValues(ps);
17.                     }
18.                     rs = ps.executeQuery();
19.                     ResultSet rsToUse = rs;
20.                     if (nativeJdbcExtractor != null) {
21.                         rsToUse = nativeJdbcExtractor.getNativeResultSet(rs);
22.                     }
23.                     return rse.extractData(rsToUse);
24.                 }
25.                 finally {
26.                     JdbcUtils.closeResultSet(rs);
27.                     if (pss instanceof ParameterDisposer) {
28.                         ((ParameterDisposer) pss).cleanupParameters();
29.                     }
30.                 }
31.             }
32.         });
33.     }

结果集的解压器接口如下：

1. public interface ResultSetExtractor {
2. 
   
3.     //可以在这里对结果集进行处理，转化成为对象；
4.     Object extractData(ResultSet rs) throws SQLException, DataAccessException;
5. 
   
6. }
7. 
   

如下：

1. public class CoreyExtractor implements ResultSetExtractor {
2. 
   
3.     public Object extractData(ResultSet rs) throws SQLException,
4.             DataAccessException {
5.         List customers=new ArrayList();
6.          while(rs.next()){
7.              Person customer=new Person();
8.              customer.setName(rs.getString(1));
9.              customer.setAge(rs.getInt(2));
10.              customers.add(customer);
11.          }
12.          return customers;
13.     }
14. 
    
15. }
16. 
    

这样，就能返回对象了；

同样，存在一下方法：

1.     public List query(String sql, Object[] args, RowMapper rowMapper)
2.             throws DataAccessException {
3.         return query(sql, args, new RowMapperResultReader(rowMapper));
4.     }

1. public interface RowCallbackHandler {
2. 
   
3.       
4.         /*
5.         处理单行。
6.         person.setName(rs.getString(1));
7.         person.setAge(rs.getInt(2));
8.         return person;
9.         */   
10.     void processRow(ResultSet rs) throws SQLException;
11. 
    
12. }
13. 
    

1. public interface ResultReader extends RowCallbackHandler {
2.      
3.     //再此基础上可以实现处理多行；
4.     List getResults();
5. 
   
6. }
7. 
   

1. public interface RowMapper {
2.         
3.         //实现行对应；并且行与行之间可以进行判断；
4.         //这也是他比单纯的RowCallBackHandler好的地方；
5.     Object mapRow(ResultSet rs, int rowNum) throws SQLException; 
6. 
   
7. }

1. public List query(String sql, Object[] args, int[] argTypes, RowMapper rowMapper)
2.             throws DataAccessException {
3.         return query(sql, args, argTypes, new RowMapperResultReader(rowMapper));
4.     }

1.     public List query(String sql, Object[] args, RowCallbackHandler rch)
2.             throws DataAccessException {
3.         return query(sql, new ArgPreparedStatementSetter(args), rch);
4.     }
5. 
   

1.     public List query(String sql, PreparedStatementSetter pss, final RowCallbackHandler rch)
2.             throws DataAccessException {
3.         return (List) query(sql, pss, new RowCallbackHandlerResultSetExtractor(rch));
4.     }

从对单行的处理，一直委托到给结果集解压器处理；而这个具体的解压器如下：

1.     private static class RowCallbackHandlerResultSetExtractor implements ResultSetExtractor {
2. 
   
3.         private final RowCallbackHandler rch;
4. 
   
5.         public RowCallbackHandlerResultSetExtractor(RowCallbackHandler rch) {
6.             this.rch = rch;
7.         }
8. 
   
9.         public Object extractData(ResultSet rs) throws SQLException {
10.             //一行行的处理；实现了RowCallBackHandler
11.            while (rs.next()) {
12.                 this.rch.processRow(rs);
13.             }
14.             //实现整个结果集的处理，实现了RowCallBackHandler的子接口ResultReader;
    
15.             if (this.rch instanceof ResultReader) {
16.                 return ((ResultReader) this.rch).getResults();
17.             }
18.             else {
19.                 return null;
20.             }
21.         }
22.     }

通过这样的一种机制，我们可以直接把结果集合转化成为对象数组；让我们可以像Hibernate一样，直接从数据库里面拿到对象；
从下面的类图结构，可以清晰的看见适配器模式的影子；



我们能够用jdbc从数据库里面直接查询对象，那么有人不禁想问，我们能不能想Hibernate一样，把对象直接更新到数据库里面去呢，答案是肯定的，下面，就像我们来看一下：
我们就要用到SqlUpdate:






经典的运用了模板模式；如下实现；

1. public class CoreySqlUpdate extends SqlUpdate {
2.   
3.     public CoreySqlUpdate(DataSource ds){
4.         super(ds,"insert into Persons(id,name,age) values(?,?,?)");
5.         declareParameter(new SqlParameter(Types.INTEGER));
6.         declareParameter(new SqlParameter(Types.VARCHAR));
7.         declareParameter(new SqlParameter(Types.INTEGER));
8.         compile();
9.     }
10.     
11.     public int insertPerson(Person person){
12.         super.update(person.getId(),person.getName(),person.getAge());
13.     }
14. }
15. 
    

我们再来看一下实现代码：

1.     public SqlUpdate(DataSource ds, String sql) {
2.         setDataSource(ds);
3.         setSql(sql);
4.     }

设置了数据源和执行sql代码；

1.     public void declareParameter(SqlParameter param) throws InvalidDataAccessApiUsageException {
2.         if (isCompiled()) {
3.             throw new InvalidDataAccessApiUsageException("Cannot add parameters once the query is compiled");
4.         }
5.         this.declaredParameters.add(param);
6.     }

将参数类型注册到declaredParameters；

1. public final void compile() throws InvalidDataAccessApiUsageException {
2.         if (!isCompiled()) {
3.             if (getSql() == null) {
4.                 throw new InvalidDataAccessApiUsageException("Property 'sql' is required");
5.             }
7.             try {
8.                 this.jdbcTemplate.afterPropertiesSet();
9.             }
10.             catch (IllegalArgumentException ex) {
11.                 throw new InvalidDataAccessApiUsageException(ex.getMessage());
12.             }   
13.         
14.             compileInternal();
15.             this.compiled = true;
17.             if (logger.isDebugEnabled()) {
18.                 logger.debug("RdbmsOperation with SQL [" + getSql() + "] compiled");
19.             }
20.         }
21.     }

编译sql语句；

1.     protected final void compileInternal() {
2.   //生成查询语句工厂；
3.         this.preparedStatementFactory = new PreparedStatementCreatorFactory(getSql(), getDeclaredParameters());
4.         this.preparedStatementFactory.setResultSetType(getResultSetType());
5.         this.preparedStatementFactory.setUpdatableResults(isUpdatableResults());
6.         this.preparedStatementFactory.setReturnGeneratedKeys(isReturnGeneratedKeys());
7.         if (getGeneratedKeysColumnNames() != null) {
8.             this.preparedStatementFactory.setGeneratedKeysColumnNames(getGeneratedKeysColumnNames());
9.         }
10.         this.preparedStatementFactory.setNativeJdbcExtractor(getJdbcTemplate().getNativeJdbcExtractor());
11.                //钩子方法，可以进行扩展；
12.         onCompileInternal();
13.     }
15.     /**
16.      * Hook method that subclasses may override to post-process compilation.
17.      * This implementation does nothing.
18.      * @see #compileInternal
19.      */
20.     protected void onCompileInternal() {
21.     }

在执行更新的时候，首先进行数据验证:

1. protected void validateParameters(Object[] parameters) throws InvalidDataAccessApiUsageException {
2.         checkCompiled();
4.         int declaredInParameters = 0;
5.         Iterator it = this.declaredParameters.iterator();
6.         while (it.hasNext()) {
7.             SqlParameter param = (SqlParameter) it.next();
8.             if (param.isInputValueProvided()) {
9.                 if (!supportsLobParameters() &&
10.                         (param.getSqlType() == Types.BLOB || param.getSqlType() == Types.CLOB)) {
11.                     throw new InvalidDataAccessApiUsageException(
12.                             "BLOB or CLOB parameters are not allowed for this kind of operation");
13.                 }
14.                 declaredInParameters++;
15.             }
16.         }
18.         validateParameterCount((parameters != null ? parameters.length : 0), declaredInParameters);
19.     }

在执行查询语句：

1. int rowsAffected = getJdbcTemplate().update(newPreparedStatementCreator(params));

1. protected final PreparedStatementCreator newPreparedStatementCreator(Object[] params) {
2.         return this.preparedStatementFactory.newPreparedStatementCreator(params);
3.     }

执行的查询语句是工厂生成的；
如此一来，我们就能够往数据库中直接插入对象，不过再次之前的对象与数据库之间的映射规则我们必须制定，就好比Hibernate的hbm.xml文件一样；

在这一小节中，体现了回调的实现是采用外部类的模板模式，面向接口编程，而我们可以提供具体的回调接口，比如缺省适配器等等，将扩展的点进一步专业细化，比如由PreparedStatementCallBack回调接口的接口方法中实现中，再次采用模板模式模式，我们可以实现ResultSet与对象的映射；

public Object query(final String sql, final ResultSetExtractor rse) throws DataAccessException {
        Assert.notNull(sql, "SQL must not be null");
        Assert.notNull(rse, "ResultSetExtractor must not be null");
        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 {
                    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());


    }