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。

相关文章

JVM 的类初始化机制

JVM 的类初始化机制

前言 当你在 Java 程序中new对象时，有没有考虑过 JVM 是如何把静态的字节码（byte code）转化为运行时对象的呢，这个问题看似简单，但清楚的同学相信也不会太多，这篇文章首先介绍 JVM 类初始化的机制，然后给出几个易出错的实例来分析，帮助大家更好理解这个知识点。 JVM 将字节码转化为运行时对象分为三个阶段，分别是：loading 、Linking、initialization
阅读更多...
Spring Security 基于表达式的权限控制

Spring Security 基于表达式的权限控制

前言 spring security 3.0已经可以使用spring el表达式来控制授权，允许在表达式中使用复杂的布尔逻辑来控制访问的权限。 常见的表达式 Spring Security可用表达式对象的基类是SecurityExpressionRoot。 表达式描述hasRole([role])用户拥有制定的角色时返回true （Spring security默认会带有ROLE_前缀）,去
阅读更多...
浅析Spring Security认证过程

浅析Spring Security认证过程

类图 为了方便理解Spring Security认证流程，特意画了如下的类图，包含相关的核心认证类 概述 核心验证器 AuthenticationManager 该对象提供了认证方法的入口，接收一个Authentiaton对象作为参数; public interface AuthenticationManager {Authentication authenticate(Authenti
阅读更多...
Spring Security--Architecture Overview

Spring Security--Architecture Overview

1 核心组件 这一节主要介绍一些在Spring Security中常见且核心的Java类，它们之间的依赖，构建起了整个框架。想要理解整个架构，最起码得对这些类眼熟。 1.1 SecurityContextHolder SecurityContextHolder用于存储安全上下文（security context）的信息。当前操作的用户是谁，该用户是否已经被认证，他拥有哪些角色权限…这些都被保
阅读更多...
Spring Security基于数据库验证流程详解

Spring Security基于数据库验证流程详解

Spring Security 校验流程图 相关解释说明（认真看哦） AbstractAuthenticationProcessingFilter 抽象类 /*** 调用 #requiresAuthentication(HttpServletRequest, HttpServletResponse) 决定是否需要进行验证操作。* 如果需要验证，则会调用 #attemptAuthentica
阅读更多...
Spring Security 从入门到进阶系列教程

Spring Security 从入门到进阶系列教程

Spring Security 入门系列 《保护 Web 应用的安全》 《Spring-Security-入门（一）：登录与退出》 《Spring-Security-入门（二）：基于数据库验证》 《Spring-Security-入门（三）：密码加密》 《Spring-Security-入门（四）：自定义-Filter》 《Spring-Security-入门（五）：在 Sprin
阅读更多...
Java架构师知识体认识

Java架构师知识体认识

源码分析 常用设计模式 Proxy代理模式Factory工厂模式Singleton单例模式Delegate委派模式Strategy策略模式Prototype原型模式Template模板模式 Spring5 beans 接口实例化代理Bean操作 Context Ioc容器设计原理及高级特性Aop设计原理Factorybean与Beanfactory Transaction 声明式事物
阅读更多...
Java进阶13讲__第12讲_1/2

Java进阶13讲__第12讲_1/2

多线程、线程池 1.  线程概念 1.1  什么是线程 1.2  线程的好处 2.   创建线程的三种方式 注意事项 2.1  继承Thread类 2.1.1 认识  2.1.2  编码实现  package cn.hdc.oop10.Thread;import org.slf4j.Logger;import org.slf4j.LoggerFactory
阅读更多...
性能分析之MySQL索引实战案例

性能分析之MySQL索引实战案例

文章目录 一、前言二、准备三、MySQL索引优化四、MySQL 索引知识回顾五、总结 一、前言 在上一讲性能工具之 JProfiler 简单登录案例分析实战中已经发现SQL没有建立索引问题，本文将一起从代码层去分析为什么没有建立索引？ 开源ERP项目地址：https://gitee.com/jishenghua/JSH_ERP 二、准备 打开IDEA找到登录请求资源路径位置
阅读更多...
JAVA智听未来一站式有声阅读平台听书系统小程序源码

JAVA智听未来一站式有声阅读平台听书系统小程序源码

智听未来，一站式有声阅读平台听书系统 🌟&nbsp;开篇：遇见未来，从“智听”开始 在这个快节奏的时代，你是否渴望在忙碌的间隙，找到一片属于自己的宁静角落？是否梦想着能随时随地，沉浸在知识的海洋，或是故事的奇幻世界里？今天，就让我带你一起探索“智听未来”——这一站式有声阅读平台听书系统，它正悄悄改变着我们的阅读方式，让未来触手可及！ 📚&nbsp;第一站：海量资源，应有尽有 走进“智听
阅读更多...

Copyright China编程 23002807@qq.com

沪ICP备2023033072号-2