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

2024-04-27 11:18
文章标签 java 分析 spring 源代码 jdbctemplate orm 能行

本文主要是介绍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 {

  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 {

  3.     //自己实现：
  4.     Object doInPreparedStatement(PreparedStatement ps) throws SQLException, DataAccessException;

  6. }

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

  1. public Object execute(ConnectionCallback action) throws DataAccessException 

对应于：
  1. public interface ConnectionCallback {

  3.     //用户可以自定义connection操作；
  4.     Object doInConnection(Connection con) throws SQLException, DataAccessException;

  6. }
  1. public Object execute(StatementCallback action) throws DataAccessException {
同理对应于：
  1.  public interface StatementCallback {

  3.      //扩展statement操作；
  4.      Object doInStatement(Statement stmt) throws SQLException, DataAccessException;

  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 {

  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 {

  3.     //可以在这里对结果集进行处理，转化成为对象；
  4.     Object extractData(ResultSet rs) throws SQLException, DataAccessException;

  6. }


如下：
  1. public class CoreyExtractor implements ResultSetExtractor {

  3.     public Object extractData(ResultSet rs) throws SQLException,
  4.             DataAccessException {
  5.         List<Person> customers=new ArrayList()<Person>;
  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.     }

  15. }


这样，就能返回对象了；

同样，存在一下方法：
  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 {

  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;

  12. }

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

  6. }


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

  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.     }

  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 {

  3.         private final RowCallbackHandler rch;

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

  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. }



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

  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());


    }

这篇关于Spring源代码分析（12)---JdbcTemplate(ORM我也能行)的文章就介绍到这儿，希望我们推荐的文章对编程师们有所帮助！


http://www.chinasem.cn/article/940357。

相关文章

SpringBoot中四种AOP实战应用场景及代码实现

SpringBoot中四种AOP实战应用场景及代码实现

《SpringBoot中四种AOP实战应用场景及代码实现》面向切面编程(AOP)是Spring框架的核心功能之一,它通过预编译和运行期动态代理实现程序功能的统一维护,在SpringBoot应用中,AO... 目录引言场景一：日志记录与性能监控业务需求实现方案使用示例扩展：MDC实现请求跟踪场景二：权限控制与
阅读更多...
慢sql提前分析预警和动态sql替换-Mybatis-SQL

慢sql提前分析预警和动态sql替换-Mybatis-SQL

《慢sql提前分析预警和动态sql替换-Mybatis-SQL》为防止慢SQL问题而开发的MyBatis组件,该组件能够在开发、测试阶段自动分析SQL语句,并在出现慢SQL问题时通过Ducc配置实现动... 目录背景解决思路开源方案调研设计方案详细设计使用方法1、引入依赖jar包2、配置组件XML3、核心配
阅读更多...
Java NoClassDefFoundError运行时错误分析解决

Java NoClassDefFoundError运行时错误分析解决

《JavaNoClassDefFoundError运行时错误分析解决》在Java开发中,NoClassDefFoundError是一种常见的运行时错误,它通常表明Java虚拟机在尝试加载一个类时未能... 目录前言一、问题分析二、报错原因三、解决思路检查类路径配置检查依赖库检查类文件调试类加载器问题四、常见
阅读更多...
Java注解之超越Javadoc的元数据利器详解

Java注解之超越Javadoc的元数据利器详解

《Java注解之超越Javadoc的元数据利器详解》本文将深入探讨Java注解的定义、类型、内置注解、自定义注解、保留策略、实际应用场景及最佳实践,无论是初学者还是资深开发者,都能通过本文了解如何利用... 目录什么是注解？注解的类型内置注编程解自定义注解注解的保留策略实际用例最佳实践总结在 Java 编程
阅读更多...
Java 实用工具类Spring 的 AnnotationUtils详解

Java 实用工具类Spring 的 AnnotationUtils详解

《Java实用工具类Spring的AnnotationUtils详解》Spring框架提供了一个强大的注解工具类org.springframework.core.annotation.Annot... 目录前言一、AnnotationUtils 的常用方法二、常见应用场景三、与 JDK 原生注解 API 的
阅读更多...
Java controller接口出入参时间序列化转换操作方法(两种)

Java controller接口出入参时间序列化转换操作方法(两种)

《Javacontroller接口出入参时间序列化转换操作方法(两种)》：本文主要介绍Javacontroller接口出入参时间序列化转换操作方法,本文给大家列举两种简单方法,感兴趣的朋友一起看... 目录方式一、使用注解方式二、统一配置场景：在controller编写的接口，在前后端交互过程中一般都会涉及
阅读更多...
Java中的StringBuilder之如何高效构建字符串

Java中的StringBuilder之如何高效构建字符串

《Java中的StringBuilder之如何高效构建字符串》本文将深入浅出地介绍StringBuilder的使用方法、性能优势以及相关字符串处理技术,结合代码示例帮助读者更好地理解和应用,希望对大家... 目录关键点什么是 StringBuilder？为什么需要 StringBuilder？如何使用 St
阅读更多...
使用Java将各种数据写入Excel表格的操作示例

使用Java将各种数据写入Excel表格的操作示例

《使用Java将各种数据写入Excel表格的操作示例》在数据处理与管理领域,Excel凭借其强大的功能和广泛的应用,成为了数据存储与展示的重要工具,在Java开发过程中,常常需要将不同类型的数据,本文... 目录前言安装免费Java库1. 写入文本、或数值到 Excel单元格2. 写入数组到 Excel表格
阅读更多...
Java并发编程之如何优雅关闭钩子Shutdown Hook

Java并发编程之如何优雅关闭钩子Shutdown Hook

《Java并发编程之如何优雅关闭钩子ShutdownHook》这篇文章主要为大家详细介绍了Java如何实现优雅关闭钩子ShutdownHook,文中的示例代码讲解详细,感兴趣的小伙伴可以跟随小编一起... 目录关闭钩子简介关闭钩子应用场景数据库连接实战演示使用关闭钩子的注意事项开源框架中的关闭钩子机制1.
阅读更多...
Maven中引入 springboot 相关依赖的方式(最新推荐)

Maven中引入 springboot 相关依赖的方式(最新推荐)

《Maven中引入springboot相关依赖的方式(最新推荐)》：本文主要介绍Maven中引入springboot相关依赖的方式(最新推荐),本文给大家介绍的非常详细,对大家的学习或工作具有... 目录Maven中引入 springboot 相关依赖的方式1. 不使用版本管理（不推荐）2、使用版本管理（推
阅读更多...

Copyright China编程 23002807@qq.com

沪ICP备2023033072号-2