Spring源代码分析之Spring JDBC

àì夳堔傛蜴生んèń 2022-09-20 15:14 133阅读 0赞

1 JdbcOperations接口提供了对数据库的基本操作

public interface JdbcOperations {
 <T> T execute(ConnectionCallback<T> action) throws DataAccessException;
 .......
 }

2 JdbcAccessor 定义一些普通属性例如 DataSource 和 exception translator

/*
 * Copyright 2002-2012 the original author or authors.
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 * http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */
 
 package org.springframework.jdbc.support;
 
 import javax.sql.DataSource;
 
 import org.apache.commons.logging.Log;
 import org.apache.commons.logging.LogFactory;
 
 import org.springframework.beans.factory.InitializingBean;
 
 /**
 * Base class for {@link org.springframework.jdbc.core.JdbcTemplate} and
 * other JDBC-accessing DAO helpers, defining common properties such as
 * DataSource and exception translator.
 *
 * Not intended to be used directly.
 * See {@link org.springframework.jdbc.core.JdbcTemplate}.
 *
 * @author Juergen Hoeller
 * @since 28.11.2003
 * @see org.springframework.jdbc.core.JdbcTemplate
 */
 public abstract class JdbcAccessor implements InitializingBean {
 
 	/** Logger available to subclasses */
 	protected final Log logger = LogFactory.getLog(getClass());
 
 	private DataSource dataSource;
 
 	private SQLExceptionTranslator exceptionTranslator;
 
 	private boolean lazyInit = true;
 
 
 	/**
 	 * Set the JDBC DataSource to obtain connections from.
 	 */
 	public void setDataSource(DataSource dataSource) {
 		this.dataSource = dataSource;
 	}
 
 	/**
 	 * Return the DataSource used by this template.
 	 */
 	public DataSource getDataSource() {
 		return this.dataSource;
 	}
 
 	/**
 	 * Specify the database product name for the DataSource that this accessor uses.
 	 * This allows to initialize a SQLErrorCodeSQLExceptionTranslator without
 	 * obtaining a Connection from the DataSource to get the metadata.
 	 * @param dbName the database product name that identifies the error codes entry
 	 * @see SQLErrorCodeSQLExceptionTranslator#setDatabaseProductName
 	 * @see java.sql.DatabaseMetaData#getDatabaseProductName()
 	 */
 	public void setDatabaseProductName(String dbName) {
 		this.exceptionTranslator = new SQLErrorCodeSQLExceptionTranslator(dbName);
 	}
 
 	/**
 	 * Set the exception translator for this instance.
 	 * If no custom translator is provided, a default
 	 * {@link SQLErrorCodeSQLExceptionTranslator} is used
 	 * which examines the SQLException's vendor-specific error code.
 	 * @see org.springframework.jdbc.support.SQLErrorCodeSQLExceptionTranslator
 	 * @see org.springframework.jdbc.support.SQLStateSQLExceptionTranslator
 	 */
 	public void setExceptionTranslator(SQLExceptionTranslator exceptionTranslator) {
 		this.exceptionTranslator = exceptionTranslator;
 	}
 
 	/**
 	 * Return the exception translator for this instance.
 	 * Creates a default {@link SQLErrorCodeSQLExceptionTranslator}
 	 * for the specified DataSource if none set, or a
 	 * {@link SQLStateSQLExceptionTranslator} in case of no DataSource.
 	 * @see #getDataSource()
 	 */
 	public synchronized SQLExceptionTranslator getExceptionTranslator() {
 		if (this.exceptionTranslator == null) {
 			DataSource dataSource = getDataSource();
 			if (dataSource != null) {
 				this.exceptionTranslator = new SQLErrorCodeSQLExceptionTranslator(dataSource);
 			}
 			else {
 				this.exceptionTranslator = new SQLStateSQLExceptionTranslator();
 			}
 		}
 		return this.exceptionTranslator;
 	}
 
 	/**
 	 * Set whether to lazily initialize the SQLExceptionTranslator for this accessor,
 	 * on first encounter of a SQLException. Default is "true"; can be switched to
 	 * "false" for initialization on startup.
 	 * Early initialization just applies if {@code afterPropertiesSet()} is called.
 	 * @see #getExceptionTranslator()
 	 * @see #afterPropertiesSet()
 	 */
 	public void setLazyInit(boolean lazyInit) {
 		this.lazyInit = lazyInit;
 	}
 
 	/**
 	 * Return whether to lazily initialize the SQLExceptionTranslator for this accessor.
 	 * @see #getExceptionTranslator()
 	 */
 	public boolean isLazyInit() {
 		return this.lazyInit;
 	}
 
 	/**
 	 * Eagerly initialize the exception translator, if demanded,
 	 * creating a default one for the specified DataSource if none set.
 	 */
 	public void afterPropertiesSet() {
 		if (getDataSource() == null) {
 			throw new IllegalArgumentException("Property 'dataSource' is required");
 		}
 		if (!isLazyInit()) {
 			getExceptionTranslator();
 		}
 	}
 
 }

3 JdbcTemplate

public class JdbcTemplate extends JdbcAccessor implements JdbcOperations {
    }

JdbcTempate的基本使用方式

JdbcTemplate temp = new JdbcTempalte(datasource);
 public class ExecuteStatmentCallback implements StatementCallback<Object>,SqlProvider{
 
 	@Override
 	public String getSql() {
 		// TODO Auto-generated method stub
 		return null;
 	}
 
 	@Override
 	public Object doInStatement(Statement stmt) throws SQLException,
 			DataAccessException {
 		// TODO Auto-generated method stub
 		return null;
 	}
 
 }
 temp.setExecute(new ExecuteStatementCallback());

JdbcTemplate的execute调用方式

![SouthEast][]

代码：

参数是sql语句

public void execute(final String sql) throws DataAccessException {
 		if (logger.isDebugEnabled()) {
 			logger.debug("Executing SQL statement [" + sql + "]");
 		}
 		class ExecuteStatementCallback implements StatementCallback<Object>, SqlProvider {
 			public Object doInStatement(Statement stmt) throws SQLException {
 				stmt.execute(sql);
 				return null;
 			}
 			public String getSql() {
 				return sql;
 			}
 		}
 		execute(new ExecuteStatementCallback());
 	}

参数是回调函数

//-------------------------------------------------------------------------
 	// Methods dealing with static SQL (java.sql.Statement)
 	//-------------------------------------------------------------------------
 
 	public <T> T execute(StatementCallback<T> 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);
 			}
 			T 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());
 		}
 	}

查询源代码：

/**
 	 * Query using a prepared statement, allowing for a PreparedStatementCreator
 	 * and a PreparedStatementSetter. Most other query methods use this method,
 	 * but application code will always work with either a creator or a setter.
 	 * @param psc Callback handler that can create a PreparedStatement given a
 	 * Connection
 	 * @param pss object that knows how to set values on the prepared statement.
 	 * If this is null, the SQL will be assumed to contain no bind parameters.
 	 * @param rse object that will extract results.
 	 * @return an arbitrary result object, as returned by the ResultSetExtractor
 	 * @throws DataAccessException if there is any problem
 	 */
 	public <T> T query(
 			PreparedStatementCreator psc, final PreparedStatementSetter pss, final ResultSetExtractor<T> rse)
 			throws DataAccessException {
 
 		Assert.notNull(rse, "ResultSetExtractor must not be null");
 		logger.debug("Executing prepared SQL query");
 
 		return execute(psc, new PreparedStatementCallback<T>() {
 			public T doInPreparedStatement(PreparedStatement ps) throws SQLException {
 				ResultSet rs = null;
 				try {
 					if (pss != null) {
 						pss.setValues(ps);
 					}
 					rs = ps.executeQuery();
 					ResultSet rsToUse = rs;
 					if (nativeJdbcExtractor != null) {
 						rsToUse = nativeJdbcExtractor.getNativeResultSet(rs);
 					}
 					return rse.extractData(rsToUse);
 				}
 				finally {
 					JdbcUtils.closeResultSet(rs);
 					if (pss instanceof ParameterDisposer) {
 						((ParameterDisposer) pss).cleanupParameters();
 					}
 				}
 			}
 		});
 	}

//-------------------------------------------------------------------------
 	// Methods dealing with prepared statements
 	//-------------------------------------------------------------------------
 
 	public <T> T execute(PreparedStatementCreator psc, PreparedStatementCallback<T> 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);
 			}
 			T 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());
 		}
 	}

DataSourceUtils

\* Helper class that provides static methods for obtaining JDBC Connections from 
 \* a [\{@link][link] javax.sql.DataSource\}. Includes special support for Spring-managed 
 \* transactional Connections, e.g. managed by [ \{@link][link] DataSourceTransactionManager\} 
 \* or [\{@link][link] org.springframework.transaction.jta.JtaTransactionManager\}. 
 \* 
 \* Used internally by Spring's [\{@link][link] org.springframework.jdbc.core.JdbcTemplate\}, 
 \* Spring's JDBC operation objects and the JDBC [ \{@link][link] DataSourceTransactionManager\}. 
 \* Can also be used directly in application code.

/**
 	 * Obtain a Connection from the given DataSource. Translates SQLExceptions into
 	 * the Spring hierarchy of unchecked generic data access exceptions, simplifying
 	 * calling code and making any exception that is thrown more meaningful.
 	 * Is aware of a corresponding Connection bound to the current thread, for example
 	 * when using {@link DataSourceTransactionManager}. Will bind a Connection to the
 	 * thread if transaction synchronization is active, e.g. when running within a
 	 * {@link org.springframework.transaction.jta.JtaTransactionManager JTA} transaction).
 	 * @param dataSource the DataSource to obtain Connections from
 	 * @return a JDBC Connection from the given DataSource
 	 * @throws org.springframework.jdbc.CannotGetJdbcConnectionException
 	 * if the attempt to get a Connection failed
 	 * @see #releaseConnection
 	 */
 	public static Connection getConnection(DataSource dataSource) throws CannotGetJdbcConnectionException {
 		try {
 			return doGetConnection(dataSource);
 		}
 		catch (SQLException ex) {
 			throw new CannotGetJdbcConnectionException("Could not get JDBC Connection", ex);
 		}
 	}

/**
 	 * Actually obtain a JDBC Connection from the given DataSource.
 	 * Same as {@link #getConnection}, but throwing the original SQLException.
 	 * Is aware of a corresponding Connection bound to the current thread, for example
 	 * when using {@link DataSourceTransactionManager}. Will bind a Connection to the thread
 	 * if transaction synchronization is active (e.g. if in a JTA transaction).
 	 * Directly accessed by {@link TransactionAwareDataSourceProxy}.
 	 * @param dataSource the DataSource to obtain Connections from
 	 * @return a JDBC Connection from the given DataSource
 	 * @throws SQLException if thrown by JDBC methods
 	 * @see #doReleaseConnection
 	 */
 	public static Connection doGetConnection(DataSource dataSource) throws SQLException {
 		Assert.notNull(dataSource, "No DataSource specified");
 
 		ConnectionHolder conHolder = (ConnectionHolder) TransactionSynchronizationManager.getResource(dataSource);
 		if (conHolder != null && (conHolder.hasConnection() || conHolder.isSynchronizedWithTransaction())) {
 			conHolder.requested();
 			if (!conHolder.hasConnection()) {
 				logger.debug("Fetching resumed JDBC Connection from DataSource");
 				conHolder.setConnection(dataSource.getConnection());
 			}
 			return conHolder.getConnection();
 		}
 		// Else we either got no holder or an empty thread-bound holder here.
 
 		logger.debug("Fetching JDBC Connection from DataSource");
 		Connection con = dataSource.getConnection();
 
 		if (TransactionSynchronizationManager.isSynchronizationActive()) {
 			logger.debug("Registering transaction synchronization for JDBC Connection");
 			// Use same Connection for further JDBC actions within the transaction.
 			// Thread-bound object will get removed by synchronization at transaction completion.
 			ConnectionHolder holderToUse = conHolder;
 			if (holderToUse == null) {
 				holderToUse = new ConnectionHolder(con);
 			}
 			else {
 				holderToUse.setConnection(con);
 			}
 			holderToUse.requested();
 			TransactionSynchronizationManager.registerSynchronization(
 					new ConnectionSynchronization(holderToUse, dataSource));
 			holderToUse.setSynchronizedWithTransaction(true);
 			if (holderToUse != conHolder) {
 				TransactionSynchronizationManager.bindResource(dataSource, holderToUse);
 			}
 		}
 
 		return con;
 	}

[SouthEast]: /images/20220823/26dfa201f5f54938af7cdc234e39e549.png
[link]: mailto:%7b@link