spring源码分析之spring-jdbc模块详解

0 概述

Spring将替我们完成所有使用JDBC API进行开发的单调乏味的、底层细节处理工作。下表描述了哪些是spring帮助我们做好的，哪些是我们要做的。

1. 异常处理

异常结构如下：

2. config模块

NamespaceHandler接口，DefaultBeanDefinitionDocumentReader使用该接口来处理在spring xml配置文件中自定义的命名空间。

在jdbc模块，我们使用JdbcNamespaceHandler来处理jdbc配置的命名空间，其代码如下：

public class JdbcNamespaceHandler extends NamespaceHandlerSupport {      @Override     public void init() {         registerBeanDefinitionParser("embedded-database", new EmbeddedDatabaseBeanDefinitionParser());         registerBeanDefinitionParser("initialize-database", new InitializeDatabaseBeanDefinitionParser());     } }

其中，

EmbeddedDatabaseBeanDefinitionParser继承了AbstractBeanDefinitionParser，解析<embedded-database>元素，并使用EmbeddedDatabaseFactoryBean创建一个BeanDefinition。顺便介绍一下用到的软件包 org.w3c.dom。

软件包 org.w3c.dom:为文档对象模型 (DOM) 提供接口，该模型是 Java API for XML Processing 的组件 API。该 Document Object Model Level 2 Core API 允许程序动态访问和更新文档的内容和结构。

3. core模块

3.1 NativeJdbcExtractor 从线程池中的封装的对象中提取出本地的jdbc对象，其结构如下：

其实现原理如下(以c3po为例)：

/**  * Retrieve the Connection via C3P0's {@code rawConnectionOperation} API,  * using the {@code getRawConnection} as callback to get access to the  * raw Connection (which is otherwise not directly supported by C3P0).  * @see #getRawConnection  */ @Override protected Connection doGetNativeConnection(Connection con) throws SQLException {  if (con instanceof C3P0ProxyConnection) {   C3P0ProxyConnection cpCon = (C3P0ProxyConnection) con;   try {    return (Connection) cpCon.rawConnectionOperation(      this.getRawConnectionMethod, null, new Object[] {C3P0ProxyConnection.RAW_CONNECTION});   }   catch (SQLException ex) {    throw ex;   }   catch (Exception ex) {    ReflectionUtils.handleReflectionException(ex);   }  }  return con; } 

上述代码通过调用C3P0的rawConnectionOperation api来获取Connection，使用getRawConnection的回调方法来获取原生的Connection(C3P0不直接支持原生的Connection)。

NativeJdbcExtractorAdapter是NativeJdbcExtractor的一个简单实现，它的getNativeConnection()方法检查ConnectionProxy链，并且代理doGetNativeConnection方法。Spring的TransactionAwareDataSourceProxy和LazyConnectionDataSourceProxy使用ConnectionProxy。目标Connection置于本地连接池中，被子类实现的doGetNativeConnection的方法去掉封装获取到原生的Connection。其实现如下：

@Override public Connection getNativeConnection(Connection con) throws SQLException {  if (con == null) {   return null;  }  Connection targetCon = DataSourceUtils.getTargetConnection(con);  Connection nativeCon = doGetNativeConnection(targetCon);  if (nativeCon == targetCon) {   // We haven't received a different Connection, so we'll assume that there's   // some additional proxying going on. Let's check whether we get something   // different back from the DatabaseMetaData.getConnection() call.   DatabaseMetaData metaData = targetCon.getMetaData();   // The following check is only really there for mock Connections   // which might not carry a DatabaseMetaData instance.   if (metaData != null) {    Connection metaCon = metaData.getConnection();    if (metaCon != null && metaCon != targetCon) {     // We've received a different Connection there:     // Let's retry the native extraction process with it.     nativeCon = doGetNativeConnection(metaCon);    }   }  }  return nativeCon; } 

3.2 RowMapper

3.3 元数据metaData模块

本节中spring应用到工厂模式，结合代码可以更具体了解。

CallMetaDataProviderFactory创建CallMetaDataProvider的工厂类，其代码如下：

/** List of supported database products for procedure calls */ public static final List<String> supportedDatabaseProductsForProcedures = Arrays.asList(   "Apache Derby",   "DB2",   "MySQL",   "Microsoft SQL Server",   "Oracle",   "PostgreSQL",   "Sybase"  ); /** List of supported database products for function calls */ public static final List<String> supportedDatabaseProductsForFunctions = Arrays.asList(   "MySQL",   "Microsoft SQL Server",   "Oracle",   "PostgreSQL"  ); /**  * Create a CallMetaDataProvider based on the database metadata  * @param dataSource used to retrieve metadata  * @param context the class that holds configuration and metadata  * @return instance of the CallMetaDataProvider implementation to be used  */ static public CallMetaDataProvider createMetaDataProvider(DataSource dataSource, final CallMetaDataContext context) {  try {   return (CallMetaDataProvider) JdbcUtils.extractDatabaseMetaData(dataSource, new DatabaseMetaDataCallback() {    @Override    public Object processMetaData(DatabaseMetaData databaseMetaData) throws SQLException, MetaDataAccessException {     String databaseProductName = JdbcUtils.commonDatabaseName(databaseMetaData.getDatabaseProductName());     boolean accessProcedureColumnMetaData = context.isAccessCallParameterMetaData();     if (context.isFunction()) {      if (!supportedDatabaseProductsForFunctions.contains(databaseProductName)) {       if (logger.isWarnEnabled()) {        logger.warn(databaseProductName + " is not one of the databases fully supported for function calls " +          "-- supported are: " + supportedDatabaseProductsForFunctions);       }       if (accessProcedureColumnMetaData) {        logger.warn("Metadata processing disabled - you must specify all parameters explicitly");        accessProcedureColumnMetaData = false;       }      }     }     else {      if (!supportedDatabaseProductsForProcedures.contains(databaseProductName)) {       if (logger.isWarnEnabled()) {        logger.warn(databaseProductName + " is not one of the databases fully supported for procedure calls " +          "-- supported are: " + supportedDatabaseProductsForProcedures);       }       if (accessProcedureColumnMetaData) {        logger.warn("Metadata processing disabled - you must specify all parameters explicitly");        accessProcedureColumnMetaData = false;       }      }     }     CallMetaDataProvider provider;     if ("Oracle".equals(databaseProductName)) {      provider = new OracleCallMetaDataProvider(databaseMetaData);     }     else if ("DB2".equals(databaseProductName)) {      provider = new Db2CallMetaDataProvider((databaseMetaData));     }     else if ("Apache Derby".equals(databaseProductName)) {      provider = new DerbyCallMetaDataProvider((databaseMetaData));     }     else if ("PostgreSQL".equals(databaseProductName)) {      provider = new PostgresCallMetaDataProvider((databaseMetaData));     }     else if ("Sybase".equals(databaseProductName)) {      provider = new SybaseCallMetaDataProvider((databaseMetaData));     }     else if ("Microsoft SQL Server".equals(databaseProductName)) {      provider = new SqlServerCallMetaDataProvider((databaseMetaData));     }     else {      provider = new GenericCallMetaDataProvider(databaseMetaData);     }     if (logger.isDebugEnabled()) {      logger.debug("Using " + provider.getClass().getName());     }     provider.initializeWithMetaData(databaseMetaData);     if (accessProcedureColumnMetaData) {      provider.initializeWithProcedureColumnMetaData(        databaseMetaData, context.getCatalogName(), context.getSchemaName(), context.getProcedureName());     }     return provider;    }   });  }  catch (MetaDataAccessException ex) {   throw new DataAccessResourceFailureException("Error retreiving database metadata", ex);  } } 

TableMetaDataProviderFactory创建TableMetaDataProvider工厂类，其创建过程如下：

/**  * Create a TableMetaDataProvider based on the database metedata  * @param dataSource used to retrieve metedata  * @param context the class that holds configuration and metedata  * @param nativeJdbcExtractor the NativeJdbcExtractor to be used  * @return instance of the TableMetaDataProvider implementation to be used  */ public static TableMetaDataProvider createMetaDataProvider(DataSource dataSource,    final TableMetaDataContext context, final NativeJdbcExtractor nativeJdbcExtractor) {  try {   return (TableMetaDataProvider) JdbcUtils.extractDatabaseMetaData(dataSource,     new DatabaseMetaDataCallback() {      @Override      public Object processMetaData(DatabaseMetaData databaseMetaData) throws SQLException {       String databaseProductName =         JdbcUtils.commonDatabaseName(databaseMetaData.getDatabaseProductName());       boolean accessTableColumnMetaData = context.isAccessTableColumnMetaData();       TableMetaDataProvider provider;       if ("Oracle".equals(databaseProductName)) {        provider = new OracleTableMetaDataProvider(databaseMetaData,          context.isOverrideIncludeSynonymsDefault());       }       else if ("HSQL Database Engine".equals(databaseProductName)) {        provider = new HsqlTableMetaDataProvider(databaseMetaData);       }       else if ("PostgreSQL".equals(databaseProductName)) {        provider = new PostgresTableMetaDataProvider(databaseMetaData);       }       else if ("Apache Derby".equals(databaseProductName)) {        provider = new DerbyTableMetaDataProvider(databaseMetaData);       }       else {        provider = new GenericTableMetaDataProvider(databaseMetaData);       }       if (nativeJdbcExtractor != null) {        provider.setNativeJdbcExtractor(nativeJdbcExtractor);       }       if (logger.isDebugEnabled()) {        logger.debug("Using " + provider.getClass().getSimpleName());       }       provider.initializeWithMetaData(databaseMetaData);       if (accessTableColumnMetaData) {        provider.initializeWithTableColumnMetaData(databaseMetaData, context.getCatalogName(),          context.getSchemaName(), context.getTableName());       }       return provider;      }     });  }  catch (MetaDataAccessException ex) {   throw new DataAccessResourceFailureException("Error retrieving database metadata", ex);  } } 

3.4 使用SqlParameterSource提供参数值使用Map来指定参数值有时候工作得非常好，但是这并不是最简单的使用方式。Spring提供了一些其他的SqlParameterSource实现类来指定参数值。 我们首先可以看看BeanPropertySqlParameterSource类，这是一个非常简便的指定参数的实现类，只要你有一个符合JavaBean规范的类就行了。它将使用其中的getter方法来获取参数值。

SqlParameter 封装了定义sql 参数的对象。

CallableStateMentCallback，PrePareStateMentCallback，StateMentCallback，ConnectionCallback回调类分别对应JdbcTemplate中的不同处理方法。

3.5 simple实现

4. DataSource

spring通过DataSource获取数据库的连接。Datasource是jdbc 规范的一部分，它通过ConnectionFactory获取。一个容器和框架可以在应用代码层中隐藏连接池和事务管理。

当使用spring的jdbc层，你可以通过JNDI来获取DataSource，也可以通过你自己配置的第三方连接池实现来获取。流行的第三方实现由apache Jakarta Commons dbcp和c3p0.

注意：DriverManagerDataSource仅限于测试使用，因为它没有提供池的功能，这会导致在多个请求获取连接时性能很差。

5. object模块

6. JdbcTemplate是core包的核心类。

7. NamedParameterJdbcTemplate类为JDBC操作增加了命名参数的特性支持，而不是传统的使用（'?'）作为参数的占位符。NamedParameterJdbcTemplate类对JdbcTemplate类进行了封装， 在底层，JdbcTemplate完成了多数的工作。

小结：

传统的JDBC对数据库的操作，有很多重复的代码，这样给程序员带来了很多额外的工作量，Spring提供了JDBC模板很好的解决了这个问题，由于传统的方法比较简单，在这里不介绍了，直接说模板吧。

使用JDBC模板：

Spring的JDBC框架能够承担资源管理和异常处理的工作。对于JDBC来说，Spring提供了3个模板类

• JdbcTemplate：Spring里最基本的JDBC模板，利用JDBC和简单的索引参数查询提供对数据库的简单访问。
• NamedParameterJdbcTemplate：能够在执行查询时把值绑定到SQL里的命名参数，而不是使用索引参数。
• SimpleJdbcTemplate：利用Java 5 的特性，比如自动装箱、通用（generic）和可变参数类表来简化JDBC模板的使用。

参考文献：

http://www.360doc.com/content/14/0625/22/834950_389749909.shtml

http://www.360doc.com/content/14/0625/23/834950_389759601.shtml