Spring's JDBC support package. Includes DataSource setup support as well as JDBC access support.
libspring-java-3.0.6.RELEASE/projects/org.springframework.jdbc/src/main/java/org/ 0000755 0001750 0001750 00000000000 11623223526 027370 5 ustar drazzib drazzib libspring-java-3.0.6.RELEASE/projects/org.springframework.jdbc/src/main/java/org/springframework/ 0000755 0001750 0001750 00000000000 11623223526 032610 5 ustar drazzib drazzib ././@LongLink 0000000 0000000 0000000 00000000147 00000000000 011567 L ustar root root libspring-java-3.0.6.RELEASE/projects/org.springframework.jdbc/src/main/java/org/springframework/jdbc/ libspring-java-3.0.6.RELEASE/projects/org.springframework.jdbc/src/main/java/org/springframework/jdb0000755 0001750 0001750 00000000000 11623223530 033263 5 ustar drazzib drazzib ././@LongLink 0000000 0000000 0000000 00000000177 00000000000 011572 L ustar root root libspring-java-3.0.6.RELEASE/projects/org.springframework.jdbc/src/main/java/org/springframework/jdbc/SQLWarningException.java libspring-java-3.0.6.RELEASE/projects/org.springframework.jdbc/src/main/java/org/springframework/jdb0000644 0001750 0001750 00000003157 11623223530 033273 0 ustar drazzib drazzib /* * Copyright 2002-2006 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; import java.sql.SQLWarning; import org.springframework.dao.UncategorizedDataAccessException; /** * Exception thrown when we're not ignoring {@link java.sql.SQLWarning SQLWarnings}. * *If a SQLWarning is reported, the operation completed, so we will need * to explicitly roll it back if we're not happy when looking at the warning. * We might choose to ignore (and log) the warning, or to wrap and throw it * in the shape of this SQLWarningException instead. * * @author Rod Johnson * @author Juergen Hoeller * @see org.springframework.jdbc.core.JdbcTemplate#setIgnoreWarnings */ public class SQLWarningException extends UncategorizedDataAccessException { /** * Constructor for SQLWarningException. * @param msg the detail message * @param ex the JDBC warning */ public SQLWarningException(String msg, SQLWarning ex) { super(msg, ex); } /** * Return the underlying SQLWarning. */ public SQLWarning SQLWarning() { return (SQLWarning) getCause(); } } ././@LongLink 0000000 0000000 0000000 00000000222 00000000000 011561 L ustar root root libspring-java-3.0.6.RELEASE/projects/org.springframework.jdbc/src/main/java/org/springframework/jdbc/IncorrectResultSetColumnCountException.java libspring-java-3.0.6.RELEASE/projects/org.springframework.jdbc/src/main/java/org/springframework/jdb0000644 0001750 0001750 00000004230 11623223530 033264 0 ustar drazzib drazzib /* * Copyright 2002-2008 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; import org.springframework.dao.DataRetrievalFailureException; /** * Data access exception thrown when a result set did not have the correct column count, * for example when expecting a single column but getting 0 or more than 1 columns. * * @author Juergen Hoeller * @since 2.0 * @see org.springframework.dao.IncorrectResultSizeDataAccessException */ public class IncorrectResultSetColumnCountException extends DataRetrievalFailureException { private int expectedCount; private int actualCount; /** * Constructor for IncorrectResultSetColumnCountException. * @param expectedCount the expected column count * @param actualCount the actual column count */ public IncorrectResultSetColumnCountException(int expectedCount, int actualCount) { super("Incorrect column count: expected " + expectedCount + ", actual " + actualCount); this.expectedCount = expectedCount; this.actualCount = actualCount; } /** * Constructor for IncorrectResultCountDataAccessException. * @param msg the detail message * @param expectedCount the expected column count * @param actualCount the actual column count */ public IncorrectResultSetColumnCountException(String msg, int expectedCount, int actualCount) { super(msg); this.expectedCount = expectedCount; this.actualCount = actualCount; } /** * Return the expected column count. */ public int getExpectedCount() { return this.expectedCount; } /** * Return the actual column count. */ public int getActualCount() { return this.actualCount; } } ././@LongLink 0000000 0000000 0000000 00000000170 00000000000 011563 L ustar root root libspring-java-3.0.6.RELEASE/projects/org.springframework.jdbc/src/main/java/org/springframework/jdbc/package-info.java libspring-java-3.0.6.RELEASE/projects/org.springframework.jdbc/src/main/java/org/springframework/jdb0000644 0001750 0001750 00000001651 11623223530 033270 0 ustar drazzib drazzib /** * * The classes in this package make JDBC easier to use and * reduce the likelihood of common errors. In particular, they: *
This package and related packages are discussed in Chapter 9 of * Expert One-On-One J2EE Design and Development * by Rod Johnson (Wrox, 2002). * */ package org.springframework.jdbc; ././@LongLink 0000000 0000000 0000000 00000000162 00000000000 011564 L ustar root root libspring-java-3.0.6.RELEASE/projects/org.springframework.jdbc/src/main/java/org/springframework/jdbc/datasource/ libspring-java-3.0.6.RELEASE/projects/org.springframework.jdbc/src/main/java/org/springframework/jdb0000755 0001750 0001750 00000000000 11623223530 033263 5 ustar drazzib drazzib ././@LongLink 0000000 0000000 0000000 00000000173 00000000000 011566 L ustar root root libspring-java-3.0.6.RELEASE/projects/org.springframework.jdbc/src/main/java/org/springframework/jdbc/datasource/embedded/ libspring-java-3.0.6.RELEASE/projects/org.springframework.jdbc/src/main/java/org/springframework/jdb0000755 0001750 0001750 00000000000 11623223530 033263 5 ustar drazzib drazzib ././@LongLink 0000000 0000000 0000000 00000000214 00000000000 011562 L ustar root root libspring-java-3.0.6.RELEASE/projects/org.springframework.jdbc/src/main/java/org/springframework/jdbc/datasource/embedded/package-info.java libspring-java-3.0.6.RELEASE/projects/org.springframework.jdbc/src/main/java/org/springframework/jdb0000644 0001750 0001750 00000000217 11623223530 033265 0 ustar drazzib drazzib /** * * Provides extensible support for creating embedded database instances. * */ package org.springframework.jdbc.datasource.embedded; ././@LongLink 0000000 0000000 0000000 00000000233 00000000000 011563 L ustar root root libspring-java-3.0.6.RELEASE/projects/org.springframework.jdbc/src/main/java/org/springframework/jdbc/datasource/embedded/EmbeddedDatabaseFactoryBean.java libspring-java-3.0.6.RELEASE/projects/org.springframework.jdbc/src/main/java/org/springframework/jdb0000644 0001750 0001750 00000003601 11623223530 033265 0 ustar drazzib drazzib /* * Copyright 2002-2009 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.datasource.embedded; import javax.sql.DataSource; import org.springframework.beans.factory.DisposableBean; import org.springframework.beans.factory.FactoryBean; import org.springframework.beans.factory.InitializingBean; /** * A subclass of {@link EmbeddedDatabaseFactory} that implements {@link FactoryBean} for registration as a Spring bean. * Returns the actual {@link DataSource} that provides connectivity to the embedded database to Spring. * *
The target DataSource is returned instead of a {@link EmbeddedDatabase} proxy since the FactoryBean * will manage the initialization and destruction lifecycle of the database instance. * *
Implements DisposableBean to shutdown the embedded database when the managing Spring container is shutdown.
*
* @author Keith Donald
* @since 3.0
*/
public class EmbeddedDatabaseFactoryBean extends EmbeddedDatabaseFactory
implements FactoryBean Can be configured: Returns null if the DataSource has not been initialized or the database has been shut down.
* Subclasses may call to access the datasource instance directly.
*/
protected DataSource getDataSource() {
return this.dataSource;
}
/**
* Hook to shutdown the embedded database. Subclasses may call to force shutdown.
* After calling, {@link #getDataSource()} returns null. Does nothing if no embedded database has been initialized.
*/
protected void shutdownDatabase() {
if (this.dataSource != null) {
this.databaseConfigurer.shutdown(this.dataSource, this.databaseName);
this.dataSource = null;
}
}
private class EmbeddedDataSourceProxy implements EmbeddedDatabase {
private final DataSource dataSource;
public EmbeddedDataSourceProxy(DataSource dataSource) {
this.dataSource = dataSource;
}
public Connection getConnection() throws SQLException {
return this.dataSource.getConnection();
}
public Connection getConnection(String username, String password) throws SQLException {
return this.dataSource.getConnection(username, password);
}
public PrintWriter getLogWriter() throws SQLException {
return this.dataSource.getLogWriter();
}
public void setLogWriter(PrintWriter out) throws SQLException {
this.dataSource.setLogWriter(out);
}
public int getLoginTimeout() throws SQLException {
return this.dataSource.getLoginTimeout();
}
public void setLoginTimeout(int seconds) throws SQLException {
this.dataSource.setLoginTimeout(seconds);
}
public Call {@link #getConnectionProperties()} to configure normalized DataSource properties
* before calling {@link #getDataSource()} to actually get the configured DataSource instance.
*
* @author Keith Donald
* @since 3.0
*/
public interface DataSourceFactory {
/**
* Allows properties of the DataSource to be configured.
*/
ConnectionProperties getConnectionProperties();
/**
* Returns the DataSource with the connection properties applied.
*/
DataSource getDataSource();
}
././@LongLink 0000000 0000000 0000000 00000000224 00000000000 011563 L ustar root root libspring-java-3.0.6.RELEASE/projects/org.springframework.jdbc/src/main/java/org/springframework/jdbc/datasource/embedded/ConnectionProperties.java libspring-java-3.0.6.RELEASE/projects/org.springframework.jdbc/src/main/java/org/springframework/jdb0000644 0001750 0001750 00000003022 11623223530 033262 0 ustar drazzib drazzib /*
* Copyright 2002-2009 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.datasource.embedded;
import java.sql.Driver;
/**
* DataSourceFactory helper that allows essential JDBC connection properties to be configured consistently,
* independent of the actual DataSource implementation.
*
* @author Keith Donald
* @since 3.0
* @see DataSourceFactory
*/
public interface ConnectionProperties {
/**
* Set the JDBC driver to use to connect to the database.
* @param driverClass the jdbc driver class
*/
void setDriverClass(Class driverClass);
/**
* Sets the JDBC connection URL of the database.
* @param url the connection url
*/
void setUrl(String url);
/**
* Sets the username to use to connect to the database.
* @param username the username
*/
void setUsername(String username);
/**
* Sets the password to use to connect to the database.
* @param password the password
*/
void setPassword(String password);
}
././@LongLink 0000000 0000000 0000000 00000000227 00000000000 011566 L ustar root root libspring-java-3.0.6.RELEASE/projects/org.springframework.jdbc/src/main/java/org/springframework/jdbc/datasource/embedded/EmbeddedDatabaseBuilder.java libspring-java-3.0.6.RELEASE/projects/org.springframework.jdbc/src/main/java/org/springframework/jdb0000644 0001750 0001750 00000006722 11623223530 033274 0 ustar drazzib drazzib /*
* Copyright 2002-2009 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.datasource.embedded;
import org.springframework.core.io.DefaultResourceLoader;
import org.springframework.core.io.ResourceLoader;
import org.springframework.jdbc.datasource.init.ResourceDatabasePopulator;
/**
* A builder that provides a fluent API for constructing an embedded database.
*
* Usage example:
* Classes using this interface can query whether or not the Connection
* should be closed after an operation. Spring's DataSourceUtils and
* JdbcTemplate classes automatically perform such a check.
*
* @author Rod Johnson
* @author Juergen Hoeller
* @see SingleConnectionDataSource#shouldClose
* @see DataSourceUtils#releaseConnection
* @see org.springframework.jdbc.core.JdbcTemplate
*/
public interface SmartDataSource extends DataSource {
/**
* Should we close this Connection, obtained from this DataSource?
* Code that uses Connections from a SmartDataSource should always
* perform a check via this method before invoking Note that the JdbcTemplate class in the 'jdbc.core' package takes care of
* releasing JDBC Connections, freeing application code of this responsibility.
* @param con the Connection to check
* @return whether the given Connection should be closed
* @see java.sql.Connection#close()
*/
boolean shouldClose(Connection con);
}
././@LongLink 0000000 0000000 0000000 00000000203 00000000000 011560 L ustar root root libspring-java-3.0.6.RELEASE/projects/org.springframework.jdbc/src/main/java/org/springframework/jdbc/datasource/package-info.java libspring-java-3.0.6.RELEASE/projects/org.springframework.jdbc/src/main/java/org/springframework/jdb0000644 0001750 0001750 00000000340 11623223530 033262 0 ustar drazzib drazzib
/**
*
* Provides a utility class for easy DataSource access,
* a PlatformTransactionManager for a single DataSource,
* and various simple DataSource implementations.
*
*/
package org.springframework.jdbc.datasource;
././@LongLink 0000000 0000000 0000000 00000000221 00000000000 011560 L ustar root root libspring-java-3.0.6.RELEASE/projects/org.springframework.jdbc/src/main/java/org/springframework/jdbc/datasource/SingleConnectionDataSource.java libspring-java-3.0.6.RELEASE/projects/org.springframework.jdbc/src/main/java/org/springframework/jdb0000644 0001750 0001750 00000027632 11623223530 033277 0 ustar drazzib drazzib /*
* Copyright 2002-2010 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.datasource;
import java.lang.reflect.InvocationHandler;
import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;
import java.lang.reflect.Proxy;
import java.sql.Connection;
import java.sql.SQLException;
import org.springframework.beans.factory.DisposableBean;
import org.springframework.util.Assert;
import org.springframework.util.ObjectUtils;
/**
* Implementation of {@link SmartDataSource} that wraps a single JDBC Connection
* which is not closed after use. Obviously, this is not multi-threading capable.
*
* Note that at shutdown, someone should close the underlying Connection
* via the If client code will call This is primarily intended for testing. For example, it enables easy testing
* outside an application server, for code that expects to work on a DataSource.
* In contrast to {@link DriverManagerDataSource}, it reuses the same Connection
* all the time, avoiding excessive creation of physical Connections.
*
* @author Rod Johnson
* @author Juergen Hoeller
* @see #getConnection()
* @see java.sql.Connection#close()
* @see DataSourceUtils#releaseConnection
* @see org.springframework.jdbc.support.nativejdbc.NativeJdbcExtractor
*/
public class SingleConnectionDataSource extends DriverManagerDataSource
implements SmartDataSource, DisposableBean {
/** Create a close-suppressing proxy? */
private boolean suppressClose;
/** Override auto-commit state? */
private Boolean autoCommit;
/** Wrapped Connection */
private Connection target;
/** Proxy Connection */
private Connection connection;
/** Synchronization monitor for the shared Connection */
private final Object connectionMonitor = new Object();
/**
* Constructor for bean-style configuration.
*/
public SingleConnectionDataSource() {
}
/**
* Create a new SingleConnectionDataSource with the given standard
* DriverManager parameters.
* @param driverClassName the JDBC driver class name
* @param url the JDBC URL to use for accessing the DriverManager
* @param username the JDBC username to use for accessing the DriverManager
* @param password the JDBC password to use for accessing the DriverManager
* @param suppressClose if the returned Connection should be a
* close-suppressing proxy or the physical Connection
* @deprecated since Spring 2.5. Driver parameter usage is generally not recommended
* for a SingleConnectionDataSource. If you insist on using driver parameters
* directly, set up the Driver class manually before invoking this DataSource.
* @see java.sql.DriverManager#getConnection(String, String, String)
*/
@Deprecated
public SingleConnectionDataSource(
String driverClassName, String url, String username, String password, boolean suppressClose) {
super(driverClassName, url, username, password);
this.suppressClose = suppressClose;
}
/**
* Create a new SingleConnectionDataSource with the given standard
* DriverManager parameters.
* @param url the JDBC URL to use for accessing the DriverManager
* @param username the JDBC username to use for accessing the DriverManager
* @param password the JDBC password to use for accessing the DriverManager
* @param suppressClose if the returned Connection should be a
* close-suppressing proxy or the physical Connection
* @see java.sql.DriverManager#getConnection(String, String, String)
*/
public SingleConnectionDataSource(String url, String username, String password, boolean suppressClose) {
super(url, username, password);
this.suppressClose = suppressClose;
}
/**
* Create a new SingleConnectionDataSource with the given standard
* DriverManager parameters.
* @param url the JDBC URL to use for accessing the DriverManager
* @param suppressClose if the returned Connection should be a
* close-suppressing proxy or the physical Connection
* @see java.sql.DriverManager#getConnection(String, String, String)
*/
public SingleConnectionDataSource(String url, boolean suppressClose) {
super(url);
this.suppressClose = suppressClose;
}
/**
* Create a new SingleConnectionDataSource with a given Connection.
* @param target underlying target Connection
* @param suppressClose if the Connection should be wrapped with a Connection that
* suppresses As this bean implements DisposableBean, a bean factory will
* automatically invoke this on destruction of its cached singletons.
*/
public void destroy() {
synchronized (this.connectionMonitor) {
closeConnection();
}
}
/**
* Initialize the underlying Connection via the DriverManager.
*/
public void initConnection() throws SQLException {
if (getUrl() == null) {
throw new IllegalStateException("'url' property is required for lazily initializing a Connection");
}
synchronized (this.connectionMonitor) {
closeConnection();
this.target = getConnectionFromDriver(getUsername(), getPassword());
prepareConnection(this.target);
if (logger.isInfoEnabled()) {
logger.info("Established shared JDBC Connection: " + this.target);
}
this.connection = (isSuppressClose() ? getCloseSuppressingConnectionProxy(this.target) : this.target);
}
}
/**
* Reset the underlying shared Connection, to be reinitialized on next access.
*/
public void resetConnection() {
synchronized (this.connectionMonitor) {
closeConnection();
this.target = null;
this.connection = null;
}
}
/**
* Prepare the given Connection before it is exposed.
* The default implementation applies the auto-commit flag, if necessary.
* Can be overridden in subclasses.
* @param con the Connection to prepare
* @see #setAutoCommit
*/
protected void prepareConnection(Connection con) throws SQLException {
Boolean autoCommit = getAutoCommitValue();
if (autoCommit != null && con.getAutoCommit() != autoCommit) {
con.setAutoCommit(autoCommit);
}
}
/**
* Close the underlying shared Connection.
*/
private void closeConnection() {
if (this.target != null) {
try {
this.target.close();
}
catch (Throwable ex) {
logger.warn("Could not close shared JDBC Connection", ex);
}
}
}
/**
* Wrap the given Connection with a proxy that delegates every method call to it
* but suppresses close calls.
* @param target the original Connection to wrap
* @return the wrapped Connection
*/
protected Connection getCloseSuppressingConnectionProxy(Connection target) {
return (Connection) Proxy.newProxyInstance(
ConnectionProxy.class.getClassLoader(),
new Class[] {ConnectionProxy.class},
new CloseSuppressingInvocationHandler(target));
}
/**
* Invocation handler that suppresses close calls on JDBC Connections.
*/
private static class CloseSuppressingInvocationHandler implements InvocationHandler {
private final Connection target;
public CloseSuppressingInvocationHandler(Connection target) {
this.target = target;
}
public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
// Invocation on ConnectionProxy interface coming in...
if (method.getName().equals("equals")) {
// Only consider equal when proxies are identical.
return (proxy == args[0]);
}
else if (method.getName().equals("hashCode")) {
// Use hashCode of Connection proxy.
return System.identityHashCode(proxy);
}
else if (method.getName().equals("unwrap")) {
if (((Class) args[0]).isInstance(proxy)) {
return proxy;
}
}
else if (method.getName().equals("isWrapperFor")) {
if (((Class) args[0]).isInstance(proxy)) {
return true;
}
}
else if (method.getName().equals("close")) {
// Handle close method: don't pass the call on.
return null;
}
else if (method.getName().equals("isClosed")) {
return false;
}
else if (method.getName().equals("getTargetConnection")) {
// Handle getTargetConnection method: return underlying Connection.
return this.target;
}
// Invoke method on target Connection.
try {
return method.invoke(this.target, args);
}
catch (InvocationTargetException ex) {
throw ex.getTargetException();
}
}
}
}
././@LongLink 0000000 0000000 0000000 00000000206 00000000000 011563 L ustar root root libspring-java-3.0.6.RELEASE/projects/org.springframework.jdbc/src/main/java/org/springframework/jdbc/datasource/DataSourceUtils.java libspring-java-3.0.6.RELEASE/projects/org.springframework.jdbc/src/main/java/org/springframework/jdb0000644 0001750 0001750 00000044506 11623223530 033276 0 ustar drazzib drazzib /*
* Copyright 2002-2010 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.datasource;
import java.sql.Connection;
import java.sql.SQLException;
import java.sql.Statement;
import javax.sql.DataSource;
import org.apache.commons.logging.Log;
import org.apache.commons.logging.LogFactory;
import org.springframework.jdbc.CannotGetJdbcConnectionException;
import org.springframework.transaction.TransactionDefinition;
import org.springframework.transaction.support.TransactionSynchronizationAdapter;
import org.springframework.transaction.support.TransactionSynchronizationManager;
import org.springframework.util.Assert;
/**
* Helper class that provides static methods for obtaining JDBC Connections from
* a {@link javax.sql.DataSource}. Includes special support for Spring-managed
* transactional Connections, e.g. managed by {@link DataSourceTransactionManager}
* or {@link org.springframework.transaction.jta.JtaTransactionManager}.
*
* Used internally by Spring's {@link org.springframework.jdbc.core.JdbcTemplate},
* Spring's JDBC operation objects and the JDBC {@link DataSourceTransactionManager}.
* Can also be used directly in application code.
*
* @author Rod Johnson
* @author Juergen Hoeller
* @see #getConnection
* @see #releaseConnection
* @see DataSourceTransactionManager
* @see org.springframework.transaction.jta.JtaTransactionManager
* @see org.springframework.transaction.support.TransactionSynchronizationManager
*/
public abstract class DataSourceUtils {
/**
* Order value for TransactionSynchronization objects that clean up JDBC Connections.
*/
public static final int CONNECTION_SYNCHRONIZATION_ORDER = 1000;
private static final Log logger = LogFactory.getLog(DataSourceUtils.class);
/**
* 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;
}
/**
* Prepare the given Connection with the given transaction semantics.
* @param con the Connection to prepare
* @param definition the transaction definition to apply
* @return the previous isolation level, if any
* @throws SQLException if thrown by JDBC methods
* @see #resetConnectionAfterTransaction
*/
public static Integer prepareConnectionForTransaction(Connection con, TransactionDefinition definition)
throws SQLException {
Assert.notNull(con, "No Connection specified");
// Set read-only flag.
if (definition != null && definition.isReadOnly()) {
try {
if (logger.isDebugEnabled()) {
logger.debug("Setting JDBC Connection [" + con + "] read-only");
}
con.setReadOnly(true);
}
catch (SQLException ex) {
Throwable exToCheck = ex;
while (exToCheck != null) {
if (exToCheck.getClass().getSimpleName().contains("Timeout")) {
// Assume it's a connection timeout that would otherwise get lost: e.g. from JDBC 4.0
throw ex;
}
exToCheck = exToCheck.getCause();
}
// "read-only not supported" SQLException -> ignore, it's just a hint anyway
logger.debug("Could not set JDBC Connection read-only", ex);
}
catch (RuntimeException ex) {
Throwable exToCheck = ex;
while (exToCheck != null) {
if (exToCheck.getClass().getSimpleName().contains("Timeout")) {
// Assume it's a connection timeout that would otherwise get lost: e.g. from Hibernate
throw ex;
}
exToCheck = exToCheck.getCause();
}
// "read-only not supported" UnsupportedOperationException -> ignore, it's just a hint anyway
logger.debug("Could not set JDBC Connection read-only", ex);
}
}
// Apply specific isolation level, if any.
Integer previousIsolationLevel = null;
if (definition != null && definition.getIsolationLevel() != TransactionDefinition.ISOLATION_DEFAULT) {
if (logger.isDebugEnabled()) {
logger.debug("Changing isolation level of JDBC Connection [" + con + "] to " +
definition.getIsolationLevel());
}
int currentIsolation = con.getTransactionIsolation();
if (currentIsolation != definition.getIsolationLevel()) {
previousIsolationLevel = currentIsolation;
con.setTransactionIsolation(definition.getIsolationLevel());
}
}
return previousIsolationLevel;
}
/**
* Reset the given Connection after a transaction,
* regarding read-only flag and isolation level.
* @param con the Connection to reset
* @param previousIsolationLevel the isolation level to restore, if any
* @see #prepareConnectionForTransaction
*/
public static void resetConnectionAfterTransaction(Connection con, Integer previousIsolationLevel) {
Assert.notNull(con, "No Connection specified");
try {
// Reset transaction isolation to previous value, if changed for the transaction.
if (previousIsolationLevel != null) {
if (logger.isDebugEnabled()) {
logger.debug("Resetting isolation level of JDBC Connection [" +
con + "] to " + previousIsolationLevel);
}
con.setTransactionIsolation(previousIsolationLevel);
}
// Reset read-only flag.
if (con.isReadOnly()) {
if (logger.isDebugEnabled()) {
logger.debug("Resetting read-only flag of JDBC Connection [" + con + "]");
}
con.setReadOnly(false);
}
}
catch (Throwable ex) {
logger.debug("Could not reset JDBC Connection after transaction", ex);
}
}
/**
* Determine whether the given JDBC Connection is transactional, that is,
* bound to the current thread by Spring's transaction facilities.
* @param con the Connection to check
* @param dataSource the DataSource that the Connection was obtained from
* (may be Directly accessed by {@link TransactionAwareDataSourceProxy}.
* @param con the Connection to close if necessary
* (if this is Can also contain "user" and "password" properties. However,
* any "username" and "password" bean properties specified on this
* DataSource will override the corresponding connection properties.
* @see java.sql.Driver#connect(String, java.util.Properties)
*/
public void setConnectionProperties(Properties connectionProperties) {
this.connectionProperties = connectionProperties;
}
/**
* Return the connection properties to be passed to the Driver, if any.
*/
public Properties getConnectionProperties() {
return this.connectionProperties;
}
/**
* This implementation delegates to Template method to be implemented by subclasses.
* @param props the merged connection properties
* @return the obtained Connection
* @throws SQLException in case of failure
*/
protected abstract Connection getConnectionFromDriver(Properties props) throws SQLException;
}
././@LongLink 0000000 0000000 0000000 00000000171 00000000000 011564 L ustar root root libspring-java-3.0.6.RELEASE/projects/org.springframework.jdbc/src/main/java/org/springframework/jdbc/datasource/lookup/ libspring-java-3.0.6.RELEASE/projects/org.springframework.jdbc/src/main/java/org/springframework/jdb0000755 0001750 0001750 00000000000 11623223530 033263 5 ustar drazzib drazzib ././@LongLink 0000000 0000000 0000000 00000000212 00000000000 011560 L ustar root root libspring-java-3.0.6.RELEASE/projects/org.springframework.jdbc/src/main/java/org/springframework/jdbc/datasource/lookup/package-info.java libspring-java-3.0.6.RELEASE/projects/org.springframework.jdbc/src/main/java/org/springframework/jdb0000644 0001750 0001750 00000000204 11623223526 033266 0 ustar drazzib drazzib
/**
*
* Provides a strategy for looking up JDBC DataSources by name.
*
*/
package org.springframework.jdbc.datasource.lookup;
././@LongLink 0000000 0000000 0000000 00000000236 00000000000 011566 L ustar root root libspring-java-3.0.6.RELEASE/projects/org.springframework.jdbc/src/main/java/org/springframework/jdbc/datasource/lookup/DataSourceLookupFailureException.java libspring-java-3.0.6.RELEASE/projects/org.springframework.jdbc/src/main/java/org/springframework/jdb0000644 0001750 0001750 00000002702 11623223530 033266 0 ustar drazzib drazzib /*
* Copyright 2002-2006 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.datasource.lookup;
import org.springframework.dao.NonTransientDataAccessException;
/**
* Exception to be thrown by a DataSourceLookup implementation,
* indicating that the specified DataSource could not be obtained.
*
* @author Juergen Hoeller
* @since 2.0
*/
public class DataSourceLookupFailureException extends NonTransientDataAccessException {
/**
* Constructor for DataSourceLookupFailureException.
* @param msg the detail message
*/
public DataSourceLookupFailureException(String msg) {
super(msg);
}
/**
* Constructor for DataSourceLookupFailureException.
* @param msg the detail message
* @param cause the root cause (usually from using a underlying
* lookup API such as JNDI)
*/
public DataSourceLookupFailureException(String msg, Throwable cause) {
super(msg, cause);
}
}
././@LongLink 0000000 0000000 0000000 00000000221 00000000000 011560 L ustar root root libspring-java-3.0.6.RELEASE/projects/org.springframework.jdbc/src/main/java/org/springframework/jdbc/datasource/lookup/MapDataSourceLookup.java libspring-java-3.0.6.RELEASE/projects/org.springframework.jdbc/src/main/java/org/springframework/jdb0000644 0001750 0001750 00000007577 11623223530 033305 0 ustar drazzib drazzib /*
* Copyright 2002-2008 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.datasource.lookup;
import java.util.Collections;
import java.util.HashMap;
import java.util.Map;
import javax.sql.DataSource;
import org.springframework.util.Assert;
/**
* Simple {@link DataSourceLookup} implementation that relies on a map for doing lookups.
*
* Useful for testing environments or applications that need to match arbitrary
* {@link String} names to target {@link DataSource} objects.
*
* @author Costin Leau
* @author Juergen Hoeller
* @author Rick Evans
* @since 2.0
*/
public class MapDataSourceLookup implements DataSourceLookup {
private final Map If the supplied {@link Map} is The returned {@link Map} is {@link Collections#unmodifiableMap(java.util.Map) unmodifiable}.
* @return said {@link Map} of {@link DataSource DataSources} (never Used, for example, to resolve data source names in JPA
* The key can be of arbitrary type; this class implements the
* generic lookup process only. The concrete key representation will
* be handled by {@link #resolveSpecifiedLookupKey(Object)} and
* {@link #determineCurrentLookupKey()}.
*/
public void setTargetDataSources(Map The mapped value can either be a corresponding {@link javax.sql.DataSource}
* instance or a data source name String (to be resolved via a
* {@link #setDataSourceLookup DataSourceLookup}).
* This DataSource will be used as target if none of the keyed
* {@link #setTargetDataSources targetDataSources} match the
* {@link #determineCurrentLookupKey()} current lookup key.
*/
public void setDefaultTargetDataSource(Object defaultTargetDataSource) {
this.defaultTargetDataSource = defaultTargetDataSource;
}
/**
* Specify whether to apply a lenient fallback to the default DataSource
* if no specific DataSource could be found for the current lookup key.
* Default is "true", accepting lookup keys without a corresponding entry
* in the target DataSource map - simply falling back to the default DataSource
* in that case.
* Switch this flag to "false" if you would prefer the fallback to only apply
* if the lookup key was Default is a {@link JndiDataSourceLookup}, allowing the JNDI names
* of application server DataSources to be specified directly.
*/
public void setDataSourceLookup(DataSourceLookup dataSourceLookup) {
this.dataSourceLookup = (dataSourceLookup != null ? dataSourceLookup : new JndiDataSourceLookup());
}
public void afterPropertiesSet() {
if (this.targetDataSources == null) {
throw new IllegalArgumentException("Property 'targetDataSources' is required");
}
this.resolvedDataSources = new HashMap The default implementation handles DataSource instances and data source
* names (to be resolved via a {@link #setDataSourceLookup DataSourceLookup}).
* @param dataSource the data source value object as specified in the
* {@link #setTargetDataSources targetDataSources} map
* @return the resolved DataSource (never The default implementation simply returns the given key as-is.
* @param lookupKey the lookup key object as specified by the user
* @return the lookup key as needed for matching
*/
protected Object resolveSpecifiedLookupKey(Object lookupKey) {
return lookupKey;
}
/**
* Determine the current lookup key. This will typically be
* implemented to check a thread-bound transaction context.
* Allows for arbitrary keys. The returned key needs
* to match the stored lookup key type, as resolved by the
* {@link #resolveSpecifiedLookupKey} method.
*/
protected abstract Object determineCurrentLookupKey();
}
././@LongLink 0000000 0000000 0000000 00000000231 00000000000 011561 L ustar root root libspring-java-3.0.6.RELEASE/projects/org.springframework.jdbc/src/main/java/org/springframework/jdbc/datasource/lookup/BeanFactoryDataSourceLookup.java libspring-java-3.0.6.RELEASE/projects/org.springframework.jdbc/src/main/java/org/springframework/jdb0000644 0001750 0001750 00000005432 11623223526 033276 0 ustar drazzib drazzib /*
* Copyright 2002-2007 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.datasource.lookup;
import javax.sql.DataSource;
import org.springframework.beans.BeansException;
import org.springframework.beans.factory.BeanFactory;
import org.springframework.beans.factory.BeanFactoryAware;
import org.springframework.util.Assert;
/**
* {@link DataSourceLookup} implementation based on a Spring {@link BeanFactory}.
*
* Will lookup Spring managed beans identified by bean name,
* expecting them to be of type The BeanFactory to access must be set via Use of this constructor is redundant if this object is being created
* by a Spring IoC container, as the supplied {@link BeanFactory} will be
* replaced by the {@link BeanFactory} that creates it (c.f. the
* {@link BeanFactoryAware} contract). So only use this constructor if you
* are using this class outside the context of a Spring IoC container.
* @param beanFactory the bean factory to be used to lookup {@link DataSource DataSources}
*/
public BeanFactoryDataSourceLookup(BeanFactory beanFactory) {
Assert.notNull(beanFactory, "BeanFactory is required");
this.beanFactory = beanFactory;
}
public void setBeanFactory(BeanFactory beanFactory) {
this.beanFactory = beanFactory;
}
public DataSource getDataSource(String dataSourceName) throws DataSourceLookupFailureException {
Assert.state(this.beanFactory != null, "BeanFactory is required");
try {
return (DataSource) this.beanFactory.getBean(dataSourceName, DataSource.class);
}
catch (BeansException ex) {
throw new DataSourceLookupFailureException(
"Failed to look up DataSource bean with name '" + dataSourceName + "'", ex);
}
}
}
././@LongLink 0000000 0000000 0000000 00000000234 00000000000 011564 L ustar root root libspring-java-3.0.6.RELEASE/projects/org.springframework.jdbc/src/main/java/org/springframework/jdbc/datasource/lookup/IsolationLevelDataSourceRouter.java libspring-java-3.0.6.RELEASE/projects/org.springframework.jdbc/src/main/java/org/springframework/jdb0000644 0001750 0001750 00000013436 11623223530 033274 0 ustar drazzib drazzib /*
* Copyright 2002-2010 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.datasource.lookup;
import org.springframework.core.Constants;
import org.springframework.transaction.TransactionDefinition;
import org.springframework.transaction.support.DefaultTransactionDefinition;
import org.springframework.transaction.support.TransactionSynchronizationManager;
/**
* DataSource that routes to one of various target DataSources based on the
* current transaction isolation level. The target DataSources need to be
* configured with the isolation level name as key, as defined on the
* {@link org.springframework.transaction.TransactionDefinition TransactionDefinition interface}.
*
* This is particularly useful in combination with JTA transaction management
* (typically through Spring's {@link org.springframework.transaction.jta.JtaTransactionManager}).
* Standard JTA does not support transaction-specific isolation levels. Some JTA
* providers support isolation levels as a vendor-specific extension (e.g. WebLogic),
* which is the preferred way of addressing this. As alternative (e.g. on WebSphere),
* the target database can be represented through multiple JNDI DataSources, each
* configured with a different isolation level (for the entire DataSource).
* The present DataSource router allows to transparently switch to the
* appropriate DataSource based on the current transaction's isolation level.
*
* The configuration can for example look like this, assuming that the target
* DataSources are defined as individual Spring beans with names
* "myRepeatableReadDataSource", "mySerializableDataSource" and "myDefaultDataSource":
*
* For specific JNDI configuration, it is recommended to configure
* the "jndiEnvironment"/"jndiTemplate" properties.
*
* @author Costin Leau
* @author Juergen Hoeller
* @since 2.0
* @see #setJndiEnvironment
* @see #setJndiTemplate
*/
public class JndiDataSourceLookup extends JndiLocatorSupport implements DataSourceLookup {
public JndiDataSourceLookup() {
setResourceRef(true);
}
public DataSource getDataSource(String dataSourceName) throws DataSourceLookupFailureException {
try {
return lookup(dataSourceName, DataSource.class);
}
catch (NamingException ex) {
throw new DataSourceLookupFailureException(
"Failed to look up JNDI DataSource with name '" + dataSourceName + "'", ex);
}
}
}
././@LongLink 0000000 0000000 0000000 00000000226 00000000000 011565 L ustar root root libspring-java-3.0.6.RELEASE/projects/org.springframework.jdbc/src/main/java/org/springframework/jdbc/datasource/IsolationLevelDataSourceAdapter.java libspring-java-3.0.6.RELEASE/projects/org.springframework.jdbc/src/main/java/org/springframework/jdb0000644 0001750 0001750 00000016177 11623223530 033301 0 ustar drazzib drazzib /*
* Copyright 2002-2008 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.datasource;
import java.sql.Connection;
import java.sql.SQLException;
import org.springframework.core.Constants;
import org.springframework.transaction.TransactionDefinition;
import org.springframework.transaction.support.DefaultTransactionDefinition;
import org.springframework.transaction.support.TransactionSynchronizationManager;
/**
* An adapter for a target {@link javax.sql.DataSource}, applying the current
* Spring transaction's isolation level (and potentially specified user credentials)
* to every Can be used to proxy a target JNDI DataSource that does not have the
* desired isolation level (and user credentials) configured. Client code
* can work with this DataSource as usual, not worrying about such settings.
*
* Inherits the capability to apply specific user credentials from its superclass
* {@link UserCredentialsDataSourceAdapter}; see the latter's javadoc for details
* on that functionality (e.g. {@link #setCredentialsForCurrentThread}).
*
* WARNING: This adapter simply calls
* {@link java.sql.Connection#setTransactionIsolation} and/or
* {@link java.sql.Connection#setReadOnly} for every Connection obtained from it.
* It does, however, not reset those settings; it rather expects the target
* DataSource to perform such resetting as part of its connection pool handling.
* Make sure that the target DataSource properly cleans up such transaction state.
*
* @author Juergen Hoeller
* @since 2.0.3
* @see #setIsolationLevel
* @see #setIsolationLevelName
* @see #setUsername
* @see #setPassword
*/
public class IsolationLevelDataSourceAdapter extends UserCredentialsDataSourceAdapter {
/** Constants instance for TransactionDefinition */
private static final Constants constants = new Constants(TransactionDefinition.class);
private Integer isolationLevel;
/**
* Set the default isolation level by the name of the corresponding constant
* in {@link org.springframework.transaction.TransactionDefinition}, e.g.
* "ISOLATION_SERIALIZABLE".
* If not specified, the target DataSource's default will be used.
* Note that a transaction-specific isolation value will always override
* any isolation setting specified at the DataSource level.
* @param constantName name of the constant
* @see org.springframework.transaction.TransactionDefinition#ISOLATION_READ_UNCOMMITTED
* @see org.springframework.transaction.TransactionDefinition#ISOLATION_READ_COMMITTED
* @see org.springframework.transaction.TransactionDefinition#ISOLATION_REPEATABLE_READ
* @see org.springframework.transaction.TransactionDefinition#ISOLATION_SERIALIZABLE
* @see #setIsolationLevel
*/
public final void setIsolationLevelName(String constantName) throws IllegalArgumentException {
if (constantName == null || !constantName.startsWith(DefaultTransactionDefinition.PREFIX_ISOLATION)) {
throw new IllegalArgumentException("Only isolation constants allowed");
}
setIsolationLevel(constants.asNumber(constantName).intValue());
}
/**
* Specify the default isolation level to use for Connection retrieval,
* according to the JDBC {@link java.sql.Connection} constants
* (equivalent to the corresponding Spring
* {@link org.springframework.transaction.TransactionDefinition} constants).
* If not specified, the target DataSource's default will be used.
* Note that a transaction-specific isolation value will always override
* any isolation setting specified at the DataSource level.
* @see java.sql.Connection#TRANSACTION_READ_UNCOMMITTED
* @see java.sql.Connection#TRANSACTION_READ_COMMITTED
* @see java.sql.Connection#TRANSACTION_REPEATABLE_READ
* @see java.sql.Connection#TRANSACTION_SERIALIZABLE
* @see org.springframework.transaction.TransactionDefinition#ISOLATION_READ_UNCOMMITTED
* @see org.springframework.transaction.TransactionDefinition#ISOLATION_READ_COMMITTED
* @see org.springframework.transaction.TransactionDefinition#ISOLATION_REPEATABLE_READ
* @see org.springframework.transaction.TransactionDefinition#ISOLATION_SERIALIZABLE
* @see org.springframework.transaction.TransactionDefinition#getIsolationLevel()
* @see org.springframework.transaction.support.TransactionSynchronizationManager#getCurrentTransactionIsolationLevel()
*/
public void setIsolationLevel(int isolationLevel) {
if (!constants.getValues(DefaultTransactionDefinition.PREFIX_ISOLATION).contains(isolationLevel)) {
throw new IllegalArgumentException("Only values of isolation constants allowed");
}
this.isolationLevel = (isolationLevel != TransactionDefinition.ISOLATION_DEFAULT ? isolationLevel : null);
}
/**
* Return the statically specified isolation level,
* or Can be used to proxy a target JNDI DataSource that does not have user
* credentials configured. Client code can work with this DataSource as usual,
* using the standard In the following example, client code can simply transparently work with
* the preconfigured "myDataSource", implicitly accessing "myTargetDataSource"
* with the specified user credentials.
*
* If the "username" is empty, this proxy will simply delegate to the
* standard Default is no specific user. Note that an explicitly specified username
* will always override any username/password specified at the DataSource level.
* @see #setPassword
* @see #setCredentialsForCurrentThread(String, String)
* @see #getConnection(String, String)
*/
public void setUsername(String username) {
this.username = username;
}
/**
* Set the default user's password that this adapter should use for retrieving Connections.
* Default is no specific password. Note that an explicitly specified username
* will always override any username/password specified at the DataSource level.
* @see #setUsername
* @see #setCredentialsForCurrentThread(String, String)
* @see #getConnection(String, String)
*/
public void setPassword(String password) {
this.password = password;
}
/**
* Set user credententials for this proxy and the current thread.
* The given username and password will be applied to all subsequent
* This will override any statically specified user credentials,
* that is, values of the "username" and "password" bean properties.
* @param username the username to apply
* @param password the password to apply
* @see #removeCredentialsFromCurrentThread
*/
public void setCredentialsForCurrentThread(String username, String password) {
this.threadBoundCredentials.set(new JdbcUserCredentials(username, password));
}
/**
* Remove any user credentials for this proxy from the current thread.
* Statically specified user credentials apply again afterwards.
* @see #setCredentialsForCurrentThread
*/
public void removeCredentialsFromCurrentThread() {
this.threadBoundCredentials.remove();
}
/**
* Determine whether there are currently thread-bound credentials,
* using them if available, falling back to the statically specified
* username and password (i.e. values of the bean properties) else.
* Delegates to {@link #doGetConnection(String, String)} with the
* determined credentials as parameters.
*/
@Override
public Connection getConnection() throws SQLException {
JdbcUserCredentials threadCredentials = this.threadBoundCredentials.get();
if (threadCredentials != null) {
return doGetConnection(threadCredentials.username, threadCredentials.password);
}
else {
return doGetConnection(this.username, this.password);
}
}
/**
* Simply delegates to {@link #doGetConnection(String, String)},
* keeping the given user credentials as-is.
*/
@Override
public Connection getConnection(String username, String password) throws SQLException {
return doGetConnection(username, password);
}
/**
* This implementation delegates to the Call {@link #addScript(Resource)} to add a SQL script location.
* Call {@link #setSqlScriptEncoding(String)} to set the encoding for all added scripts.
*
* @author Keith Donald
* @author Dave Syer
* @author Juergen Hoeller
* @since 3.0
*/
public class ResourceDatabasePopulator implements DatabasePopulator {
private static String DEFAULT_COMMENT_PREFIX = "--";
private static final Log logger = LogFactory.getLog(ResourceDatabasePopulator.class);
private List This is useful for non-embedded databases whose SQL dialect does not support an
* The script will normally be loaded by classpath. There should be one statement per line.
* Any semicolons will be removed.
* Do not use this method to execute DDL if you expect rollback.
* @param connection the JDBC Connection with which to perform JDBC operations
* @param resource the resource (potentially associated with a specific encoding) to load the SQL script from
* @param continueOnError whether or not to continue without throwing an exception in the event of an error
* @param ignoreFailedDrops whether of not to continue in the event of specifically an error on a NOTE: This class is not an actual connection pool; it does not actually
* pool Connections. It just serves as simple replacement for a full-blown
* connection pool, implementing the same standard interface, but creating new
* Connections on every call.
*
* Useful for test or standalone environments outside of a J2EE container, either
* as a DataSource bean in a corresponding ApplicationContext or in conjunction with
* a simple JNDI environment. Pool-assuming NOTE: Within special class loading environments such as OSGi, this class
* is effectively superseded by {@link SimpleDriverDataSource} due to general class
* loading issues with the JDBC DriverManager that be resolved through direct Driver
* usage (which is exactly what SimpleDriverDataSource does).
*
* In a J2EE container, it is recommended to use a JNDI DataSource provided by
* the container. Such a DataSource can be exposed as a DataSource bean in a Spring
* ApplicationContext via {@link org.springframework.jndi.JndiObjectFactoryBean},
* for seamless switching to and from a local DataSource bean like this class.
* For tests, you can then either set up a mock JNDI environment through Spring's
* {@link org.springframework.mock.jndi.SimpleNamingContextBuilder}, or switch the
* bean definition to a local DataSource (which is simpler and thus recommended).
*
* If you need a "real" connection pool outside of a J2EE container, consider
* Apache's Jakarta Commons DBCP
* or C3P0.
* Commons DBCP's BasicDataSource and C3P0's ComboPooledDataSource are full
* connection pool beans, supporting the same basic properties as this class
* plus specific settings (such as minimal/maximal pool size etc).
*
* @author Juergen Hoeller
* @since 14.03.2003
* @see SimpleDriverDataSource
*/
public class DriverManagerDataSource extends AbstractDriverBasedDataSource {
/**
* Constructor for bean-style configuration.
*/
public DriverManagerDataSource() {
}
/**
* Create a new DriverManagerDataSource with the given JDBC URL,
* not specifying a username or password for JDBC access.
* @param url the JDBC URL to use for accessing the DriverManager
* @see java.sql.DriverManager#getConnection(String)
*/
public DriverManagerDataSource(String url) {
setUrl(url);
}
/**
* Create a new DriverManagerDataSource with the given standard
* DriverManager parameters.
* @param url the JDBC URL to use for accessing the DriverManager
* @param username the JDBC username to use for accessing the DriverManager
* @param password the JDBC password to use for accessing the DriverManager
* @see java.sql.DriverManager#getConnection(String, String, String)
*/
public DriverManagerDataSource(String url, String username, String password) {
setUrl(url);
setUsername(username);
setPassword(password);
}
/**
* Create a new DriverManagerDataSource with the given JDBC URL,
* not specifying a username or password for JDBC access.
* @param url the JDBC URL to use for accessing the DriverManager
* @param conProps JDBC connection properties
* @see java.sql.DriverManager#getConnection(String)
*/
public DriverManagerDataSource(String url, Properties conProps) {
setUrl(url);
setConnectionProperties(conProps);
}
/**
* Create a new DriverManagerDataSource with the given standard
* DriverManager parameters.
* @param driverClassName the JDBC driver class name
* @param url the JDBC URL to use for accessing the DriverManager
* @param username the JDBC username to use for accessing the DriverManager
* @param password the JDBC password to use for accessing the DriverManager
* @deprecated since Spring 2.5. DriverManagerDataSource is primarily
* intended for accessing pre-registered JDBC drivers.
* If you need to register a new driver, consider using
* {@link SimpleDriverDataSource} instead.
*/
@Deprecated
public DriverManagerDataSource(String driverClassName, String url, String username, String password) {
setDriverClassName(driverClassName);
setUrl(url);
setUsername(username);
setPassword(password);
}
/**
* Set the JDBC driver class name. This driver will get initialized
* on startup, registering itself with the JDK's DriverManager.
* NOTE: DriverManagerDataSource is primarily intended for accessing
* pre-registered JDBC drivers. If you need to register a new driver,
* consider using {@link SimpleDriverDataSource} instead. Alternatively, consider
* initializing the JDBC driver yourself before instantiating this DataSource.
* The "driverClassName" property is mainly preserved for backwards compatibility,
* as well as for migrating between Commons DBCP and this DataSource.
* @see java.sql.DriverManager#registerDriver(java.sql.Driver)
* @see SimpleDriverDataSource
*/
public void setDriverClassName(String driverClassName) {
Assert.hasText(driverClassName, "Property 'driverClassName' must not be empty");
String driverClassNameToUse = driverClassName.trim();
try {
Class.forName(driverClassNameToUse, true, ClassUtils.getDefaultClassLoader());
}
catch (ClassNotFoundException ex) {
throw new IllegalStateException("Could not load JDBC driver class [" + driverClassNameToUse + "]", ex);
}
if (logger.isInfoEnabled()) {
logger.info("Loaded JDBC driver: " + driverClassNameToUse);
}
}
@Override
protected Connection getConnectionFromDriver(Properties props) throws SQLException {
String url = getUrl();
if (logger.isDebugEnabled()) {
logger.debug("Creating new JDBC DriverManager Connection to [" + url + "]");
}
return getConnectionFromDriverManager(url, props);
}
/**
* Getting a Connection using the nasty static from DriverManager is extracted
* into a protected method to allow for easy unit testing.
* @see java.sql.DriverManager#getConnection(String, java.util.Properties)
*/
protected Connection getConnectionFromDriverManager(String url, Properties props) throws SQLException {
return DriverManager.getConnection(url, props);
}
}
././@LongLink 0000000 0000000 0000000 00000000221 00000000000 011560 L ustar root root libspring-java-3.0.6.RELEASE/projects/org.springframework.jdbc/src/main/java/org/springframework/jdbc/datasource/WebSphereDataSourceAdapter.java libspring-java-3.0.6.RELEASE/projects/org.springframework.jdbc/src/main/java/org/springframework/jdb0000644 0001750 0001750 00000020146 11623223526 033275 0 ustar drazzib drazzib /*
* Copyright 2002-2008 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.datasource;
import java.lang.reflect.Method;
import java.sql.Connection;
import java.sql.SQLException;
import javax.sql.DataSource;
import org.apache.commons.logging.Log;
import org.apache.commons.logging.LogFactory;
import org.springframework.util.ReflectionUtils;
import org.springframework.util.StringUtils;
/**
* {@link DataSource} implementation that delegates all calls to a WebSphere
* target {@link DataSource}, typically obtained from JNDI, applying a current
* isolation level and/or current user credentials to every Connection obtained
* from it.
*
* Uses IBM-specific API to get a JDBC Connection with a specific isolation
* level (and read-only flag) from a WebSphere DataSource
* (IBM code example).
* Supports the transaction-specific isolation level exposed by
* {@link org.springframework.transaction.support.TransactionSynchronizationManager#getCurrentTransactionIsolationLevel()}.
* It's also possible to specify a default isolation level, to be applied when the
* current Spring-managed transaction does not define a specific isolation level.
*
* Usage example, defining the target DataSource as an inner-bean JNDI lookup
* (of course, you can link to any WebSphere DataSource through a bean reference):
*
* The default implementation uses reflection to apply the given settings.
* Can be overridden in subclasses to customize the JDBCConnectionSpec object
* (JDBCConnectionSpec javadoc;
* IBM developerWorks article).
* @param isolationLevel the isolation level to apply (or NOTE: This class is not an actual connection pool; it does not actually
* pool Connections. It just serves as simple replacement for a full-blown
* connection pool, implementing the same standard interface, but creating new
* Connections on every call.
*
* In a J2EE container, it is recommended to use a JNDI DataSource provided by
* the container. Such a DataSource can be exposed as a DataSource bean in a Spring
* ApplicationContext via {@link org.springframework.jndi.JndiObjectFactoryBean},
* for seamless switching to and from a local DataSource bean like this class.
*
* If you need a "real" connection pool outside of a J2EE container, consider
* Apache's Jakarta Commons DBCP
* or C3P0.
* Commons DBCP's BasicDataSource and C3P0's ComboPooledDataSource are full
* connection pool beans, supporting the same basic properties as this class
* plus specific settings (such as minimal/maximal pool size etc).
*
* @author Juergen Hoeller
* @since 2.5.5
* @see DriverManagerDataSource
*/
public class SimpleDriverDataSource extends AbstractDriverBasedDataSource {
private Driver driver;
/**
* Constructor for bean-style configuration.
*/
public SimpleDriverDataSource() {
}
/**
* Create a new DriverManagerDataSource with the given standard Driver parameters.
* @param driver the JDBC Driver object
* @param url the JDBC URL to use for accessing the DriverManager
* @see java.sql.Driver#connect(String, java.util.Properties)
*/
public SimpleDriverDataSource(Driver driver, String url) {
setDriver(driver);
setUrl(url);
}
/**
* Create a new DriverManagerDataSource with the given standard Driver parameters.
* @param driver the JDBC Driver object
* @param url the JDBC URL to use for accessing the DriverManager
* @param username the JDBC username to use for accessing the DriverManager
* @param password the JDBC password to use for accessing the DriverManager
* @see java.sql.Driver#connect(String, java.util.Properties)
*/
public SimpleDriverDataSource(Driver driver, String url, String username, String password) {
setDriver(driver);
setUrl(url);
setUsername(username);
setPassword(password);
}
/**
* Create a new DriverManagerDataSource with the given standard Driver parameters.
* @param driver the JDBC Driver object
* @param url the JDBC URL to use for accessing the DriverManager
* @param conProps JDBC connection properties
* @see java.sql.Driver#connect(String, java.util.Properties)
*/
public SimpleDriverDataSource(Driver driver, String url, Properties conProps) {
setDriver(driver);
setUrl(url);
setConnectionProperties(conProps);
}
/**
* Specify the JDBC Driver implementation class to use.
* An instance of this Driver class will be created and held
* within the SimpleDriverDataSource.
* @see #setDriver
*/
public void setDriverClass(Class driverClass) {
this.driver = BeanUtils.instantiateClass(driverClass);
}
/**
* Specify the JDBC Driver instance to use.
* This allows for passing in a shared, possibly pre-configured
* Driver instance.
* @see #setDriverClass
*/
public void setDriver(Driver driver) {
this.driver = driver;
}
/**
* Return the JDBC Driver instance to use.
*/
public Driver getDriver() {
return this.driver;
}
@Override
protected Connection getConnectionFromDriver(Properties props) throws SQLException {
Driver driver = getDriver();
String url = getUrl();
Assert.notNull(driver, "Driver must not be null");
if (logger.isDebugEnabled()) {
logger.debug("Creating new JDBC Driver Connection to [" + url + "]");
}
return driver.connect(url, props);
}
}
././@LongLink 0000000 0000000 0000000 00000000211 00000000000 011557 L ustar root root libspring-java-3.0.6.RELEASE/projects/org.springframework.jdbc/src/main/java/org/springframework/jdbc/datasource/AbstractDataSource.java libspring-java-3.0.6.RELEASE/projects/org.springframework.jdbc/src/main/java/org/springframework/jdb0000644 0001750 0001750 00000005433 11623223526 033277 0 ustar drazzib drazzib /*
* Copyright 2002-2008 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.datasource;
import java.io.PrintWriter;
import java.sql.SQLException;
import javax.sql.DataSource;
import org.apache.commons.logging.Log;
import org.apache.commons.logging.LogFactory;
import org.springframework.util.Assert;
/**
* Abstract base class for Spring's {@link javax.sql.DataSource}
* implementations, taking care of the padding.
*
* 'Padding' in the context of this class means default implementations
* for certain methods from the Inherits rollback-only support for nested JDBC transactions
* and reference count functionality from the base class.
*
* Note: This is an SPI class, not intended to be used by applications.
*
* @author Juergen Hoeller
* @since 06.05.2003
* @see DataSourceTransactionManager
* @see DataSourceUtils
*/
public class ConnectionHolder extends ResourceHolderSupport {
public static final String SAVEPOINT_NAME_PREFIX = "SAVEPOINT_";
private ConnectionHandle connectionHandle;
private Connection currentConnection;
private boolean transactionActive = false;
private Boolean savepointsSupported;
private int savepointCounter = 0;
/**
* Create a new ConnectionHolder for the given ConnectionHandle.
* @param connectionHandle the ConnectionHandle to hold
*/
public ConnectionHolder(ConnectionHandle connectionHandle) {
Assert.notNull(connectionHandle, "ConnectionHandle must not be null");
this.connectionHandle = connectionHandle;
}
/**
* Create a new ConnectionHolder for the given JDBC Connection,
* wrapping it with a {@link SimpleConnectionHandle},
* assuming that there is no ongoing transaction.
* @param connection the JDBC Connection to hold
* @see SimpleConnectionHandle
* @see #ConnectionHolder(java.sql.Connection, boolean)
*/
public ConnectionHolder(Connection connection) {
this.connectionHandle = new SimpleConnectionHandle(connection);
}
/**
* Create a new ConnectionHolder for the given JDBC Connection,
* wrapping it with a {@link SimpleConnectionHandle}.
* @param connection the JDBC Connection to hold
* @param transactionActive whether the given Connection is involved
* in an ongoing transaction
* @see SimpleConnectionHandle
*/
public ConnectionHolder(Connection connection, boolean transactionActive) {
this(connection);
this.transactionActive = transactionActive;
}
/**
* Return the ConnectionHandle held by this ConnectionHolder.
*/
public ConnectionHandle getConnectionHandle() {
return this.connectionHandle;
}
/**
* Return whether this holder currently has a Connection.
*/
protected boolean hasConnection() {
return (this.connectionHandle != null);
}
/**
* Set whether this holder represents an active, JDBC-managed transaction.
* @see DataSourceTransactionManager
*/
protected void setTransactionActive(boolean transactionActive) {
this.transactionActive = transactionActive;
}
/**
* Return whether this holder represents an active, JDBC-managed transaction.
*/
protected boolean isTransactionActive() {
return this.transactionActive;
}
/**
* Override the existing Connection handle with the given Connection.
* Reset the handle if given Used for releasing the Connection on suspend (with a This will be the same Connection until This is necessary for ConnectionHandles that expect "Connection borrowing",
* where each returned Connection is only temporarily leased and needs to be
* returned once the data operation is done, to make the Connection available
* for other operations within the same transaction. This is the case with
* JDO 2.0 DataStoreConnections, for example.
* @see org.springframework.orm.jdo.DefaultJdoDialect#getJdbcConnection
*/
@Override
public void released() {
super.released();
if (!isOpen() && this.currentConnection != null) {
this.connectionHandle.releaseConnection(this.currentConnection);
this.currentConnection = null;
}
}
@Override
public void clear() {
super.clear();
this.transactionActive = false;
this.savepointsSupported = null;
this.savepointCounter = 0;
}
}
././@LongLink 0000000 0000000 0000000 00000000223 00000000000 011562 L ustar root root libspring-java-3.0.6.RELEASE/projects/org.springframework.jdbc/src/main/java/org/springframework/jdbc/datasource/JdbcTransactionObjectSupport.java libspring-java-3.0.6.RELEASE/projects/org.springframework.jdbc/src/main/java/org/springframework/jdb0000644 0001750 0001750 00000012243 11623223530 033267 0 ustar drazzib drazzib /*
* Copyright 2002-2009 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.datasource;
import java.sql.Savepoint;
import org.apache.commons.logging.Log;
import org.apache.commons.logging.LogFactory;
import org.springframework.transaction.CannotCreateTransactionException;
import org.springframework.transaction.NestedTransactionNotSupportedException;
import org.springframework.transaction.SavepointManager;
import org.springframework.transaction.TransactionException;
import org.springframework.transaction.TransactionSystemException;
import org.springframework.transaction.TransactionUsageException;
import org.springframework.transaction.support.SmartTransactionObject;
/**
* Convenient base class for JDBC-aware transaction objects.
* Can contain a {@link ConnectionHolder}, and implements the
* {@link org.springframework.transaction.SavepointManager}
* interface based on that ConnectionHolder.
*
* Allows for programmatic management of JDBC 3.0
* {@link java.sql.Savepoint Savepoints}. Spring's
* {@link org.springframework.transaction.support.DefaultTransactionStatus}
* will automatically delegate to this, as it autodetects transaction
* objects that implement the SavepointManager interface.
*
* Note that savepoints are only supported for drivers which
* support JDBC 3.0 or higher.
*
* @author Juergen Hoeller
* @since 1.1
*/
public abstract class JdbcTransactionObjectSupport implements SavepointManager, SmartTransactionObject {
private static final Log logger = LogFactory.getLog(JdbcTransactionObjectSupport.class);
private ConnectionHolder connectionHolder;
private Integer previousIsolationLevel;
private boolean savepointAllowed = false;
public void setConnectionHolder(ConnectionHolder connectionHolder) {
this.connectionHolder = connectionHolder;
}
public ConnectionHolder getConnectionHolder() {
return this.connectionHolder;
}
public boolean hasConnectionHolder() {
return (this.connectionHolder != null);
}
public void setPreviousIsolationLevel(Integer previousIsolationLevel) {
this.previousIsolationLevel = previousIsolationLevel;
}
public Integer getPreviousIsolationLevel() {
return this.previousIsolationLevel;
}
public void setSavepointAllowed(boolean savepointAllowed) {
this.savepointAllowed = savepointAllowed;
}
public boolean isSavepointAllowed() {
return this.savepointAllowed;
}
public void flush() {
// no-op
}
//---------------------------------------------------------------------
// Implementation of SavepointManager
//---------------------------------------------------------------------
/**
* This implementation creates a JDBC 3.0 Savepoint and returns it.
* @see java.sql.Connection#setSavepoint
*/
public Object createSavepoint() throws TransactionException {
ConnectionHolder conHolder = getConnectionHolderForSavepoint();
try {
if (!conHolder.supportsSavepoints()) {
throw new NestedTransactionNotSupportedException(
"Cannot create a nested transaction because savepoints are not supported by your JDBC driver");
}
}
catch (Throwable ex) {
throw new NestedTransactionNotSupportedException(
"Cannot create a nested transaction because your JDBC driver is not a JDBC 3.0 driver", ex);
}
try {
return conHolder.createSavepoint();
}
catch (Throwable ex) {
throw new CannotCreateTransactionException("Could not create JDBC savepoint", ex);
}
}
/**
* This implementation rolls back to the given JDBC 3.0 Savepoint.
* @see java.sql.Connection#rollback(java.sql.Savepoint)
*/
public void rollbackToSavepoint(Object savepoint) throws TransactionException {
try {
getConnectionHolderForSavepoint().getConnection().rollback((Savepoint) savepoint);
}
catch (Throwable ex) {
throw new TransactionSystemException("Could not roll back to JDBC savepoint", ex);
}
}
/**
* This implementation releases the given JDBC 3.0 Savepoint.
* @see java.sql.Connection#releaseSavepoint
*/
public void releaseSavepoint(Object savepoint) throws TransactionException {
try {
getConnectionHolderForSavepoint().getConnection().releaseSavepoint((Savepoint) savepoint);
}
catch (Throwable ex) {
logger.debug("Could not explicitly release JDBC savepoint", ex);
}
}
protected ConnectionHolder getConnectionHolderForSavepoint() throws TransactionException {
if (!isSavepointAllowed()) {
throw new NestedTransactionNotSupportedException(
"Transaction manager does not allow nested transactions");
}
if (!hasConnectionHolder()) {
throw new TransactionUsageException(
"Cannot create nested transaction if not exposing a JDBC transaction");
}
return getConnectionHolder();
}
}
././@LongLink 0000000 0000000 0000000 00000000224 00000000000 011563 L ustar root root libspring-java-3.0.6.RELEASE/projects/org.springframework.jdbc/src/main/java/org/springframework/jdbc/datasource/LazyConnectionDataSourceProxy.java libspring-java-3.0.6.RELEASE/projects/org.springframework.jdbc/src/main/java/org/springframework/jdb0000644 0001750 0001750 00000036574 11623223530 033304 0 ustar drazzib drazzib /*
* Copyright 2002-2010 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.datasource;
import java.lang.reflect.InvocationHandler;
import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;
import java.lang.reflect.Proxy;
import java.sql.Connection;
import java.sql.SQLException;
import javax.sql.DataSource;
import org.apache.commons.logging.Log;
import org.apache.commons.logging.LogFactory;
import org.springframework.core.Constants;
/**
* Proxy for a target DataSource, fetching actual JDBC Connections lazily,
* i.e. not until first creation of a Statement. Connection initialization
* properties like auto-commit mode, transaction isolation and read-only mode
* will be kept and applied to the actual JDBC Connection as soon as an
* actual Connection is fetched (if ever). Consequently, commit and rollback
* calls will be ignored if no Statements have been created.
*
* This DataSource proxy allows to avoid fetching JDBC Connections from
* a pool unless actually necessary. JDBC transaction control can happen
* without fetching a Connection from the pool or communicating with the
* database; this will be done lazily on first creation of a JDBC Statement.
*
* If you configure both a LazyConnectionDataSourceProxy and a
* TransactionAwareDataSourceProxy, make sure that the latter is the outermost
* DataSource. In such a scenario, data access code will talk to the
* transaction-aware DataSource, which will in turn work with the
* LazyConnectionDataSourceProxy.
*
* Lazy fetching of physical JDBC Connections is particularly beneficial
* in a generic transaction demarcation environment. It allows you to demarcate
* transactions on all methods that could potentially perform data access,
* without paying a performance penalty if no actual data access happens.
*
* This DataSource proxy gives you behavior analogous to JTA and a
* transactional JNDI DataSource (as provided by the J2EE server), even
* with a local transaction strategy like DataSourceTransactionManager or
* HibernateTransactionManager. It does not add value with Spring's
* JtaTransactionManager as transaction strategy.
*
* Lazy fetching of JDBC Connections is also recommended for read-only
* operations with Hibernate, in particular if the chances of resolving the
* result in the second-level cache are high. This avoids the need to
* communicate with the database at all for such read-only operations.
* You will get the same effect with non-transactional reads, but lazy fetching
* of JDBC Connections allows you to still perform reads in transactions.
*
* NOTE: This DataSource proxy needs to return wrapped Connections to
* handle lazy fetching of an actual JDBC Connection. Therefore, the returned
* Connections cannot be cast to a native JDBC Connection type like OracleConnection,
* or to a connection pool implementation type. Use a corresponding
* NativeJdbcExtractor to retrieve the native JDBC Connection.
*
* @author Juergen Hoeller
* @since 1.1.4
* @see ConnectionProxy
* @see DataSourceTransactionManager
* @see org.springframework.orm.hibernate3.HibernateTransactionManager
* @see org.springframework.jdbc.support.nativejdbc.NativeJdbcExtractor
*/
public class LazyConnectionDataSourceProxy extends DelegatingDataSource {
/** Constants instance for TransactionDefinition */
private static final Constants constants = new Constants(Connection.class);
private static final Log logger = LogFactory.getLog(LazyConnectionDataSourceProxy.class);
private Boolean defaultAutoCommit;
private Integer defaultTransactionIsolation;
/**
* Create a new LazyConnectionDataSourceProxy.
* @see #setTargetDataSource
*/
public LazyConnectionDataSourceProxy() {
}
/**
* Create a new LazyConnectionDataSourceProxy.
* @param targetDataSource the target DataSource
*/
public LazyConnectionDataSourceProxy(DataSource targetDataSource) {
setTargetDataSource(targetDataSource);
afterPropertiesSet();
}
/**
* Set the default auto-commit mode to expose when no target Connection
* has been fetched yet (-> actual JDBC Connection default not known yet).
* If not specified, the default gets determined by checking a target
* Connection on startup. If that check fails, the default will be determined
* lazily on first access of a Connection.
* @see java.sql.Connection#setAutoCommit
*/
public void setDefaultAutoCommit(boolean defaultAutoCommit) {
this.defaultAutoCommit = defaultAutoCommit;
}
/**
* Set the default transaction isolation level to expose when no target Connection
* has been fetched yet (-> actual JDBC Connection default not known yet).
* This property accepts the int constant value (e.g. 8) as defined in the
* {@link java.sql.Connection} interface; it is mainly intended for programmatic
* use. Consider using the "defaultTransactionIsolationName" property for setting
* the value by name (e.g. "TRANSACTION_SERIALIZABLE").
* If not specified, the default gets determined by checking a target
* Connection on startup. If that check fails, the default will be determined
* lazily on first access of a Connection.
* @see #setDefaultTransactionIsolationName
* @see java.sql.Connection#setTransactionIsolation
*/
public void setDefaultTransactionIsolation(int defaultTransactionIsolation) {
this.defaultTransactionIsolation = defaultTransactionIsolation;
}
/**
* Set the default transaction isolation level by the name of the corresponding
* constant in {@link java.sql.Connection}, e.g. "TRANSACTION_SERIALIZABLE".
* @param constantName name of the constant
* @see #setDefaultTransactionIsolation
* @see java.sql.Connection#TRANSACTION_READ_UNCOMMITTED
* @see java.sql.Connection#TRANSACTION_READ_COMMITTED
* @see java.sql.Connection#TRANSACTION_REPEATABLE_READ
* @see java.sql.Connection#TRANSACTION_SERIALIZABLE
*/
public void setDefaultTransactionIsolationName(String constantName) {
setDefaultTransactionIsolation(constants.asNumber(constantName).intValue());
}
@Override
public void afterPropertiesSet() {
super.afterPropertiesSet();
// Determine default auto-commit and transaction isolation
// via a Connection from the target DataSource, if possible.
if (this.defaultAutoCommit == null || this.defaultTransactionIsolation == null) {
try {
Connection con = getTargetDataSource().getConnection();
try {
checkDefaultConnectionProperties(con);
}
finally {
con.close();
}
}
catch (SQLException ex) {
logger.warn("Could not retrieve default auto-commit and transaction isolation settings", ex);
}
}
}
/**
* Check the default connection properties (auto-commit, transaction isolation),
* keeping them to be able to expose them correctly without fetching an actual
* JDBC Connection from the target DataSource.
* This will be invoked once on startup, but also for each retrieval of a
* target Connection. If the check failed on startup (because the database was
* down), we'll lazily retrieve those settings.
* @param con the Connection to use for checking
* @throws SQLException if thrown by Connection methods
*/
protected synchronized void checkDefaultConnectionProperties(Connection con) throws SQLException {
if (this.defaultAutoCommit == null) {
this.defaultAutoCommit = con.getAutoCommit();
}
if (this.defaultTransactionIsolation == null) {
this.defaultTransactionIsolation = con.getTransactionIsolation();
}
}
/**
* Expose the default auto-commit value.
*/
protected Boolean defaultAutoCommit() {
return this.defaultAutoCommit;
}
/**
* Expose the default transaction isolation value.
*/
protected Integer defaultTransactionIsolation() {
return this.defaultTransactionIsolation;
}
/**
* Return a Connection handle that lazily fetches an actual JDBC Connection
* when asked for a Statement (or PreparedStatement or CallableStatement).
* The returned Connection handle implements the ConnectionProxy interface,
* allowing to retrieve the underlying target Connection.
* @return a lazy Connection handle
* @see ConnectionProxy#getTargetConnection()
*/
@Override
public Connection getConnection() throws SQLException {
return (Connection) Proxy.newProxyInstance(
ConnectionProxy.class.getClassLoader(),
new Class[] {ConnectionProxy.class},
new LazyConnectionInvocationHandler());
}
/**
* Return a Connection handle that lazily fetches an actual JDBC Connection
* when asked for a Statement (or PreparedStatement or CallableStatement).
* The returned Connection handle implements the ConnectionProxy interface,
* allowing to retrieve the underlying target Connection.
* @param username the per-Connection username
* @param password the per-Connection password
* @return a lazy Connection handle
* @see ConnectionProxy#getTargetConnection()
*/
@Override
public Connection getConnection(String username, String password) throws SQLException {
return (Connection) Proxy.newProxyInstance(
ConnectionProxy.class.getClassLoader(),
new Class[] {ConnectionProxy.class},
new LazyConnectionInvocationHandler(username, password));
}
/**
* Invocation handler that defers fetching an actual JDBC Connection
* until first creation of a Statement.
*/
private class LazyConnectionInvocationHandler implements InvocationHandler {
private String username;
private String password;
private Boolean readOnly = Boolean.FALSE;
private Integer transactionIsolation;
private Boolean autoCommit;
private boolean closed = false;
private Connection target;
public LazyConnectionInvocationHandler() {
this.autoCommit = defaultAutoCommit();
this.transactionIsolation = defaultTransactionIsolation();
}
public LazyConnectionInvocationHandler(String username, String password) {
this();
this.username = username;
this.password = password;
}
public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
// Invocation on ConnectionProxy interface coming in...
if (method.getName().equals("equals")) {
// We must avoid fetching a target Connection for "equals".
// Only consider equal when proxies are identical.
return (proxy == args[0]);
}
else if (method.getName().equals("hashCode")) {
// We must avoid fetching a target Connection for "hashCode",
// and we must return the same hash code even when the target
// Connection has been fetched: use hashCode of Connection proxy.
return System.identityHashCode(proxy);
}
else if (method.getName().equals("unwrap")) {
if (((Class) args[0]).isInstance(proxy)) {
return proxy;
}
}
else if (method.getName().equals("isWrapperFor")) {
if (((Class) args[0]).isInstance(proxy)) {
return true;
}
}
else if (method.getName().equals("getTargetConnection")) {
// Handle getTargetConnection method: return underlying connection.
return getTargetConnection(method);
}
if (!hasTargetConnection()) {
// No physical target Connection kept yet ->
// resolve transaction demarcation methods without fetching
// a physical JDBC Connection until absolutely necessary.
if (method.getName().equals("toString")) {
return "Lazy Connection proxy for target DataSource [" + getTargetDataSource() + "]";
}
else if (method.getName().equals("isReadOnly")) {
return this.readOnly;
}
else if (method.getName().equals("setReadOnly")) {
this.readOnly = (Boolean) args[0];
return null;
}
else if (method.getName().equals("getTransactionIsolation")) {
if (this.transactionIsolation != null) {
return this.transactionIsolation;
}
// Else fetch actual Connection and check there,
// because we didn't have a default specified.
}
else if (method.getName().equals("setTransactionIsolation")) {
this.transactionIsolation = (Integer) args[0];
return null;
}
else if (method.getName().equals("getAutoCommit")) {
if (this.autoCommit != null) {
return this.autoCommit;
}
// Else fetch actual Connection and check there,
// because we didn't have a default specified.
}
else if (method.getName().equals("setAutoCommit")) {
this.autoCommit = (Boolean) args[0];
return null;
}
else if (method.getName().equals("commit")) {
// Ignore: no statements created yet.
return null;
}
else if (method.getName().equals("rollback")) {
// Ignore: no statements created yet.
return null;
}
else if (method.getName().equals("getWarnings")) {
return null;
}
else if (method.getName().equals("clearWarnings")) {
return null;
}
else if (method.getName().equals("close")) {
// Ignore: no target connection yet.
this.closed = true;
return null;
}
else if (method.getName().equals("isClosed")) {
return this.closed;
}
else if (this.closed) {
// Connection proxy closed, without ever having fetched a
// physical JDBC Connection: throw corresponding SQLException.
throw new SQLException("Illegal operation: connection is closed");
}
}
// Target Connection already fetched,
// or target Connection necessary for current operation ->
// invoke method on target connection.
try {
return method.invoke(getTargetConnection(method), args);
}
catch (InvocationTargetException ex) {
throw ex.getTargetException();
}
}
/**
* Return whether the proxy currently holds a target Connection.
*/
private boolean hasTargetConnection() {
return (this.target != null);
}
/**
* Return the target Connection, fetching it and initializing it if necessary.
*/
private Connection getTargetConnection(Method operation) throws SQLException {
if (this.target == null) {
// No target Connection held -> fetch one.
if (logger.isDebugEnabled()) {
logger.debug("Connecting to database for operation '" + operation.getName() + "'");
}
// Fetch physical Connection from DataSource.
this.target = (this.username != null) ?
getTargetDataSource().getConnection(this.username, this.password) :
getTargetDataSource().getConnection();
// If we still lack default connection properties, check them now.
checkDefaultConnectionProperties(this.target);
// Apply kept transaction settings, if any.
if (this.readOnly) {
this.target.setReadOnly(this.readOnly);
}
if (this.transactionIsolation != null &&
!this.transactionIsolation.equals(defaultTransactionIsolation())) {
this.target.setTransactionIsolation(this.transactionIsolation);
}
if (this.autoCommit != null && this.autoCommit != this.target.getAutoCommit()) {
this.target.setAutoCommit(this.autoCommit);
}
}
else {
// Target Connection already held -> return it.
if (logger.isDebugEnabled()) {
logger.debug("Using existing database connection for operation '" + operation.getName() + "'");
}
}
return this.target;
}
}
}
././@LongLink 0000000 0000000 0000000 00000000226 00000000000 011565 L ustar root root libspring-java-3.0.6.RELEASE/projects/org.springframework.jdbc/src/main/java/org/springframework/jdbc/datasource/TransactionAwareDataSourceProxy.java libspring-java-3.0.6.RELEASE/projects/org.springframework.jdbc/src/main/java/org/springframework/jdb0000644 0001750 0001750 00000023667 11623223530 033303 0 ustar drazzib drazzib /*
* Copyright 2002-2010 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.datasource;
import java.lang.reflect.InvocationHandler;
import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;
import java.lang.reflect.Proxy;
import java.sql.Connection;
import java.sql.SQLException;
import java.sql.Statement;
import javax.sql.DataSource;
import org.springframework.transaction.support.TransactionSynchronizationManager;
import org.springframework.util.Assert;
/**
* Proxy for a target JDBC {@link javax.sql.DataSource}, adding awareness of
* Spring-managed transactions. Similar to a transactional JNDI DataSource
* as provided by a J2EE server.
*
* Data access code that should remain unaware of Spring's data access support
* can work with this proxy to seamlessly participate in Spring-managed transactions.
* Note that the transaction manager, for example {@link DataSourceTransactionManager},
* still needs to work with the underlying DataSource, not with this proxy.
*
* Make sure that TransactionAwareDataSourceProxy is the outermost DataSource
* of a chain of DataSource proxies/adapters. TransactionAwareDataSourceProxy
* can delegate either directly to the target connection pool or to some
* intermediary proxy/adapter like {@link LazyConnectionDataSourceProxy} or
* {@link UserCredentialsDataSourceAdapter}.
*
* Delegates to {@link DataSourceUtils} for automatically participating in
* thread-bound transactions, for example managed by {@link DataSourceTransactionManager}.
* This proxy allows data access code to work with the plain JDBC API and still
* participate in Spring-managed transactions, similar to JDBC code in a J2EE/JTA
* environment. However, if possible, use Spring's DataSourceUtils, JdbcTemplate or
* JDBC operation objects to get transaction participation even without a proxy for
* the target DataSource, avoiding the need to define such a proxy in the first place.
*
* As a further effect, using a transaction-aware DataSource will apply remaining
* transaction timeouts to all created JDBC (Prepared/Callable)Statement. This means
* that all operations performed through standard JDBC will automatically participate
* in Spring-managed transaction timeouts.
*
* NOTE: This DataSource proxy needs to return wrapped Connections
* (which implement the {@link ConnectionProxy} interface) in order to handle
* close calls properly. Therefore, the returned Connections cannot be cast
* to a native JDBC Connection type like OracleConnection or to a connection
* pool implementation type. Use a corresponding
* {@link org.springframework.jdbc.support.nativejdbc.NativeJdbcExtractor}
* to retrieve the native JDBC Connection.
*
* @author Juergen Hoeller
* @since 1.1
* @see javax.sql.DataSource#getConnection()
* @see java.sql.Connection#close()
* @see DataSourceUtils#doGetConnection
* @see DataSourceUtils#applyTransactionTimeout
* @see DataSourceUtils#doReleaseConnection
*/
public class TransactionAwareDataSourceProxy extends DelegatingDataSource {
private boolean reobtainTransactionalConnections = false;
/**
* Create a new TransactionAwareDataSourceProxy.
* @see #setTargetDataSource
*/
public TransactionAwareDataSourceProxy() {
}
/**
* Create a new TransactionAwareDataSourceProxy.
* @param targetDataSource the target DataSource
*/
public TransactionAwareDataSourceProxy(DataSource targetDataSource) {
super(targetDataSource);
}
/**
* Specify whether to reobtain the target Connection for each operation
* performed within a transaction.
* The default is "false". Specify "true" to reobtain transactional
* Connections for every call on the Connection proxy; this is advisable
* on JBoss if you hold on to a Connection handle across transaction boundaries.
* The effect of this setting is similar to the
* "hibernate.connection.release_mode" value "after_statement".
*/
public void setReobtainTransactionalConnections(boolean reobtainTransactionalConnections) {
this.reobtainTransactionalConnections = reobtainTransactionalConnections;
}
/**
* Delegates to DataSourceUtils for automatically participating in Spring-managed
* transactions. Throws the original SQLException, if any.
* The returned Connection handle implements the ConnectionProxy interface,
* allowing to retrieve the underlying target Connection.
* @return a transactional Connection if any, a new one else
* @see DataSourceUtils#doGetConnection
* @see ConnectionProxy#getTargetConnection
*/
@Override
public Connection getConnection() throws SQLException {
DataSource ds = getTargetDataSource();
Assert.state(ds != null, "'targetDataSource' is required");
return getTransactionAwareConnectionProxy(ds);
}
/**
* Wraps the given Connection with a proxy that delegates every method call to it
* but delegates The default implementation returns This interface can be checked when there is a need to cast to a
* native JDBC Connection such as Oracle's OracleConnection. Spring's
* {@link org.springframework.jdbc.support.nativejdbc.NativeJdbcExtractorAdapter}
* automatically detects such proxies before delegating to the actual
* unwrapping for a specific connection pool.
*
* @author Juergen Hoeller
* @since 1.1
* @see TransactionAwareDataSourceProxy
* @see LazyConnectionDataSourceProxy
* @see DataSourceUtils#getTargetConnection(java.sql.Connection)
*/
public interface ConnectionProxy extends Connection {
/**
* Return the target Connection of this proxy.
* This will typically be the native driver Connection
* or a wrapper from a connection pool.
* @return the underlying Connection (never This class is meant to be subclassed, with subclasses overriding only
* those methods (such as {@link #getConnection()}) that should not simply
* delegate to the target DataSource.
*
* @author Juergen Hoeller
* @since 1.1
* @see #getConnection
*/
public class DelegatingDataSource implements DataSource, InitializingBean {
private DataSource targetDataSource;
/**
* Create a new DelegatingDataSource.
* @see #setTargetDataSource
*/
public DelegatingDataSource() {
}
/**
* Create a new DelegatingDataSource.
* @param targetDataSource the target DataSource
*/
public DelegatingDataSource(DataSource targetDataSource) {
setTargetDataSource(targetDataSource);
}
/**
* Set the target DataSource that this DataSource should delegate to.
*/
public void setTargetDataSource(DataSource targetDataSource) {
Assert.notNull(targetDataSource, "'targetDataSource' must not be null");
this.targetDataSource = targetDataSource;
}
/**
* Return the target DataSource that this DataSource should delegate to.
*/
public DataSource getTargetDataSource() {
return this.targetDataSource;
}
public void afterPropertiesSet() {
if (getTargetDataSource() == null) {
throw new IllegalArgumentException("Property 'targetDataSource' is required");
}
}
public Connection getConnection() throws SQLException {
return getTargetDataSource().getConnection();
}
public Connection getConnection(String username, String password) throws SQLException {
return getTargetDataSource().getConnection(username, password);
}
public PrintWriter getLogWriter() throws SQLException {
return getTargetDataSource().getLogWriter();
}
public void setLogWriter(PrintWriter out) throws SQLException {
getTargetDataSource().setLogWriter(out);
}
public int getLoginTimeout() throws SQLException {
return getTargetDataSource().getLoginTimeout();
}
public void setLoginTimeout(int seconds) throws SQLException {
getTargetDataSource().setLoginTimeout(seconds);
}
//---------------------------------------------------------------------
// Implementation of JDBC 4.0's Wrapper interface
//---------------------------------------------------------------------
@SuppressWarnings("unchecked")
public Note: The DataSource that this transaction manager operates on needs
* to return independent Connections. The Connections may come from a pool
* (the typical case), but the DataSource must not return thread-scoped /
* request-scoped Connections or the like. This transaction manager will
* associate Connections with thread-bound transactions itself, according
* to the specified propagation behavior. It assumes that a separate,
* independent Connection can be obtained even during an ongoing transaction.
*
* Application code is required to retrieve the JDBC Connection via
* {@link DataSourceUtils#getConnection(DataSource)} instead of a standard
* J2EE-style {@link DataSource#getConnection()} call. Spring classes such as
* {@link org.springframework.jdbc.core.JdbcTemplate} use this strategy implicitly.
* If not used in combination with this transaction manager, the
* {@link DataSourceUtils} lookup strategy behaves exactly like the native
* DataSource lookup; it can thus be used in a portable fashion.
*
* Alternatively, you can allow application code to work with the standard
* J2EE-style lookup pattern {@link DataSource#getConnection()}, for example for
* legacy code that is not aware of Spring at all. In that case, define a
* {@link TransactionAwareDataSourceProxy} for your target DataSource, and pass
* that proxy DataSource to your DAOs, which will automatically participate in
* Spring-managed transactions when accessing it.
*
* Supports custom isolation levels, and timeouts which get applied as
* appropriate JDBC statement timeouts. To support the latter, application code
* must either use {@link org.springframework.jdbc.core.JdbcTemplate}, call
* {@link DataSourceUtils#applyTransactionTimeout} for each created JDBC Statement,
* or go through a {@link TransactionAwareDataSourceProxy} which will create
* timeout-aware JDBC Connections and Statements automatically.
*
* Consider defining a {@link LazyConnectionDataSourceProxy} for your target
* DataSource, pointing both this transaction manager and your DAOs to it.
* This will lead to optimized handling of "empty" transactions, i.e. of transactions
* without any JDBC statements executed. A LazyConnectionDataSourceProxy will not fetch
* an actual JDBC Connection from the target DataSource until a Statement gets executed,
* lazily applying the specified transaction settings to the target Connection.
*
* On JDBC 3.0, this transaction manager supports nested transactions via the
* JDBC 3.0 {@link java.sql.Savepoint} mechanism. The
* {@link #setNestedTransactionAllowed "nestedTransactionAllowed"} flag defaults
* to "true", since nested transactions will work without restrictions on JDBC
* drivers that support savepoints (such as the Oracle JDBC driver).
*
* This transaction manager can be used as a replacement for the
* {@link org.springframework.transaction.jta.JtaTransactionManager} in the single
* resource case, as it does not require a container that supports JTA, typically
* in combination with a locally defined JDBC DataSource (e.g. a Jakarta Commons
* DBCP connection pool). Switching between this local strategy and a JTA
* environment is just a matter of configuration!
*
* @author Juergen Hoeller
* @since 02.05.2003
* @see #setNestedTransactionAllowed
* @see java.sql.Savepoint
* @see DataSourceUtils#getConnection(javax.sql.DataSource)
* @see DataSourceUtils#applyTransactionTimeout
* @see DataSourceUtils#releaseConnection
* @see TransactionAwareDataSourceProxy
* @see LazyConnectionDataSourceProxy
* @see org.springframework.jdbc.core.JdbcTemplate
*/
public class DataSourceTransactionManager extends AbstractPlatformTransactionManager
implements ResourceTransactionManager, InitializingBean {
private DataSource dataSource;
/**
* Create a new DataSourceTransactionManager instance.
* A DataSource has to be set to be able to use it.
* @see #setDataSource
*/
public DataSourceTransactionManager() {
setNestedTransactionAllowed(true);
}
/**
* Create a new DataSourceTransactionManager instance.
* @param dataSource JDBC DataSource to manage transactions for
*/
public DataSourceTransactionManager(DataSource dataSource) {
this();
setDataSource(dataSource);
afterPropertiesSet();
}
/**
* Set the JDBC DataSource that this instance should manage transactions for.
* This will typically be a locally defined DataSource, for example a
* Jakarta Commons DBCP connection pool. Alternatively, you can also drive
* transactions for a non-XA J2EE DataSource fetched from JNDI. For an XA
* DataSource, use JtaTransactionManager.
* The DataSource specified here should be the target DataSource to manage
* transactions for, not a TransactionAwareDataSourceProxy. Only data access
* code may work with TransactionAwareDataSourceProxy, while the transaction
* manager needs to work on the underlying target DataSource. If there's
* nevertheless a TransactionAwareDataSourceProxy passed in, it will be
* unwrapped to extract its target DataSource.
* The DataSource passed in here needs to return independent Connections.
* The Connections may come from a pool (the typical case), but the DataSource
* must not return thread-scoped / request-scoped Connections or the like.
* @see TransactionAwareDataSourceProxy
* @see org.springframework.transaction.jta.JtaTransactionManager
*/
public void setDataSource(DataSource dataSource) {
if (dataSource instanceof TransactionAwareDataSourceProxy) {
// If we got a TransactionAwareDataSourceProxy, we need to perform transactions
// for its underlying target DataSource, else data access code won't see
// properly exposed transactions (i.e. transactions for the target DataSource).
this.dataSource = ((TransactionAwareDataSourceProxy) dataSource).getTargetDataSource();
}
else {
this.dataSource = dataSource;
}
}
/**
* Return the JDBC DataSource that this instance manages transactions for.
*/
public DataSource getDataSource() {
return this.dataSource;
}
public void afterPropertiesSet() {
if (getDataSource() == null) {
throw new IllegalArgumentException("Property 'dataSource' is required");
}
}
public Object getResourceFactory() {
return getDataSource();
}
@Override
protected Object doGetTransaction() {
DataSourceTransactionObject txObject = new DataSourceTransactionObject();
txObject.setSavepointAllowed(isNestedTransactionAllowed());
ConnectionHolder conHolder =
(ConnectionHolder) TransactionSynchronizationManager.getResource(this.dataSource);
txObject.setConnectionHolder(conHolder, false);
return txObject;
}
@Override
protected boolean isExistingTransaction(Object transaction) {
DataSourceTransactionObject txObject = (DataSourceTransactionObject) transaction;
return (txObject.getConnectionHolder() != null && txObject.getConnectionHolder().isTransactionActive());
}
/**
* This implementation sets the isolation level but ignores the timeout.
*/
@Override
protected void doBegin(Object transaction, TransactionDefinition definition) {
DataSourceTransactionObject txObject = (DataSourceTransactionObject) transaction;
Connection con = null;
try {
if (txObject.getConnectionHolder() == null ||
txObject.getConnectionHolder().isSynchronizedWithTransaction()) {
Connection newCon = this.dataSource.getConnection();
if (logger.isDebugEnabled()) {
logger.debug("Acquired Connection [" + newCon + "] for JDBC transaction");
}
txObject.setConnectionHolder(new ConnectionHolder(newCon), true);
}
txObject.getConnectionHolder().setSynchronizedWithTransaction(true);
con = txObject.getConnectionHolder().getConnection();
Integer previousIsolationLevel = DataSourceUtils.prepareConnectionForTransaction(con, definition);
txObject.setPreviousIsolationLevel(previousIsolationLevel);
// Switch to manual commit if necessary. This is very expensive in some JDBC drivers,
// so we don't want to do it unnecessarily (for example if we've explicitly
// configured the connection pool to set it already).
if (con.getAutoCommit()) {
txObject.setMustRestoreAutoCommit(true);
if (logger.isDebugEnabled()) {
logger.debug("Switching JDBC Connection [" + con + "] to manual commit");
}
con.setAutoCommit(false);
}
txObject.getConnectionHolder().setTransactionActive(true);
int timeout = determineTimeout(definition);
if (timeout != TransactionDefinition.TIMEOUT_DEFAULT) {
txObject.getConnectionHolder().setTimeoutInSeconds(timeout);
}
// Bind the session holder to the thread.
if (txObject.isNewConnectionHolder()) {
TransactionSynchronizationManager.bindResource(getDataSource(), txObject.getConnectionHolder());
}
}
catch (Exception ex) {
DataSourceUtils.releaseConnection(con, this.dataSource);
throw new CannotCreateTransactionException("Could not open JDBC Connection for transaction", ex);
}
}
@Override
protected Object doSuspend(Object transaction) {
DataSourceTransactionObject txObject = (DataSourceTransactionObject) transaction;
txObject.setConnectionHolder(null);
ConnectionHolder conHolder = (ConnectionHolder)
TransactionSynchronizationManager.unbindResource(this.dataSource);
return conHolder;
}
@Override
protected void doResume(Object transaction, Object suspendedResources) {
ConnectionHolder conHolder = (ConnectionHolder) suspendedResources;
TransactionSynchronizationManager.bindResource(this.dataSource, conHolder);
}
@Override
protected void doCommit(DefaultTransactionStatus status) {
DataSourceTransactionObject txObject = (DataSourceTransactionObject) status.getTransaction();
Connection con = txObject.getConnectionHolder().getConnection();
if (status.isDebug()) {
logger.debug("Committing JDBC transaction on Connection [" + con + "]");
}
try {
con.commit();
}
catch (SQLException ex) {
throw new TransactionSystemException("Could not commit JDBC transaction", ex);
}
}
@Override
protected void doRollback(DefaultTransactionStatus status) {
DataSourceTransactionObject txObject = (DataSourceTransactionObject) status.getTransaction();
Connection con = txObject.getConnectionHolder().getConnection();
if (status.isDebug()) {
logger.debug("Rolling back JDBC transaction on Connection [" + con + "]");
}
try {
con.rollback();
}
catch (SQLException ex) {
throw new TransactionSystemException("Could not roll back JDBC transaction", ex);
}
}
@Override
protected void doSetRollbackOnly(DefaultTransactionStatus status) {
DataSourceTransactionObject txObject = (DataSourceTransactionObject) status.getTransaction();
if (status.isDebug()) {
logger.debug("Setting JDBC transaction [" + txObject.getConnectionHolder().getConnection() +
"] rollback-only");
}
txObject.setRollbackOnly();
}
@Override
protected void doCleanupAfterCompletion(Object transaction) {
DataSourceTransactionObject txObject = (DataSourceTransactionObject) transaction;
// Remove the connection holder from the thread, if exposed.
if (txObject.isNewConnectionHolder()) {
TransactionSynchronizationManager.unbindResource(this.dataSource);
}
// Reset connection.
Connection con = txObject.getConnectionHolder().getConnection();
try {
if (txObject.isMustRestoreAutoCommit()) {
con.setAutoCommit(true);
}
DataSourceUtils.resetConnectionAfterTransaction(con, txObject.getPreviousIsolationLevel());
}
catch (Throwable ex) {
logger.debug("Could not reset JDBC Connection after transaction", ex);
}
if (txObject.isNewConnectionHolder()) {
if (logger.isDebugEnabled()) {
logger.debug("Releasing JDBC Connection [" + con + "] after transaction");
}
DataSourceUtils.releaseConnection(con, this.dataSource);
}
txObject.getConnectionHolder().clear();
}
/**
* DataSource transaction object, representing a ConnectionHolder.
* Used as transaction object by DataSourceTransactionManager.
*/
private static class DataSourceTransactionObject extends JdbcTransactionObjectSupport {
private boolean newConnectionHolder;
private boolean mustRestoreAutoCommit;
public void setConnectionHolder(ConnectionHolder connectionHolder, boolean newConnectionHolder) {
super.setConnectionHolder(connectionHolder);
this.newConnectionHolder = newConnectionHolder;
}
public boolean isNewConnectionHolder() {
return this.newConnectionHolder;
}
public boolean hasTransaction() {
return (getConnectionHolder() != null && getConnectionHolder().isTransactionActive());
}
public void setMustRestoreAutoCommit(boolean mustRestoreAutoCommit) {
this.mustRestoreAutoCommit = mustRestoreAutoCommit;
}
public boolean isMustRestoreAutoCommit() {
return this.mustRestoreAutoCommit;
}
public void setRollbackOnly() {
getConnectionHolder().setRollbackOnly();
}
public boolean isRollbackOnly() {
return getConnectionHolder().isRollbackOnly();
}
}
}
././@LongLink 0000000 0000000 0000000 00000000156 00000000000 011567 L ustar root root libspring-java-3.0.6.RELEASE/projects/org.springframework.jdbc/src/main/java/org/springframework/jdbc/object/ libspring-java-3.0.6.RELEASE/projects/org.springframework.jdbc/src/main/java/org/springframework/jdb0000755 0001750 0001750 00000000000 11623223530 033263 5 ustar drazzib drazzib ././@LongLink 0000000 0000000 0000000 00000000177 00000000000 011572 L ustar root root libspring-java-3.0.6.RELEASE/projects/org.springframework.jdbc/src/main/java/org/springframework/jdbc/object/package-info.java libspring-java-3.0.6.RELEASE/projects/org.springframework.jdbc/src/main/java/org/springframework/jdb0000644 0001750 0001750 00000001547 11623223526 033301 0 ustar drazzib drazzib
/**
*
* The classes in this package represent RDBMS queries, updates,
* and stored procedures as threadsafe, reusable objects. This approach
* is modelled by JDO, although of course objects returned by queries
* are "disconnected" from the database.
*
* This higher level of JDBC abstraction depends on the lower-level
* abstraction in the This package and related packages are discussed in Chapter 9 of
* Expert One-On-One J2EE Design and Development
* by Rod Johnson (Wrox, 2002).
*
*/
package org.springframework.jdbc.object;
././@LongLink 0000000 0000000 0000000 00000000172 00000000000 011565 L ustar root root libspring-java-3.0.6.RELEASE/projects/org.springframework.jdbc/src/main/java/org/springframework/jdbc/object/SqlCall.java libspring-java-3.0.6.RELEASE/projects/org.springframework.jdbc/src/main/java/org/springframework/jdb0000644 0001750 0001750 00000012724 11623223530 033273 0 ustar drazzib drazzib /*
* Copyright 2002-2008 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.object;
import java.util.List;
import java.util.Map;
import javax.sql.DataSource;
import org.springframework.jdbc.core.CallableStatementCreator;
import org.springframework.jdbc.core.CallableStatementCreatorFactory;
import org.springframework.jdbc.core.ParameterMapper;
import org.springframework.jdbc.core.SqlParameter;
/**
* RdbmsOperation using a JdbcTemplate and representing a SQL-based
* call such as a stored procedure or a stored function.
*
* Configures a CallableStatementCreatorFactory based on the declared
* parameters.
*
* @author Rod Johnson
* @author Thomas Risberg
* @see CallableStatementCreatorFactory
*/
public abstract class SqlCall extends RdbmsOperation {
/**
* Object enabling us to create CallableStatementCreators
* efficiently, based on this class's declared parameters.
*/
private CallableStatementCreatorFactory callableStatementFactory;
/**
* Flag used to indicate that this call is for a function and to
* use the {? = call get_invoice_count(?)} syntax.
*/
private boolean function = false;
/**
* Flag used to indicate that the sql for this call should be used exactly as it is
* defined. No need to add the escape syntax and parameter place holders.
*/
private boolean sqlReadyForUse = false;
/**
* Call string as defined in java.sql.CallableStatement.
* String of form {call add_invoice(?, ?, ?)}
* or {? = call get_invoice_count(?)} if isFunction is set to true
* Updated after each parameter is added.
*/
private String callString;
/**
* Constructor to allow use as a JavaBean.
* A DataSource, SQL and any parameters must be supplied before
* invoking the
* This implementation does not provide a typed method for invocation so executions
* must use one of the generic {@link StoredProcedure#execute(java.util.Map)} or
* {@link StoredProcedure#execute(org.springframework.jdbc.core.ParameterMapper)} methods.
*
* @author Thomas Risberg
* @see org.springframework.jdbc.object.StoredProcedure
*/
public class GenericStoredProcedure extends StoredProcedure {
}
././@LongLink 0000000 0000000 0000000 00000000201 00000000000 011556 L ustar root root libspring-java-3.0.6.RELEASE/projects/org.springframework.jdbc/src/main/java/org/springframework/jdbc/object/RdbmsOperation.java libspring-java-3.0.6.RELEASE/projects/org.springframework.jdbc/src/main/java/org/springframework/jdb0000644 0001750 0001750 00000040053 11623223530 033267 0 ustar drazzib drazzib /*
* Copyright 2002-2008 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.object;
import java.sql.ResultSet;
import java.sql.Types;
import java.util.Arrays;
import java.util.Collections;
import java.util.LinkedList;
import java.util.List;
import java.util.Map;
import javax.sql.DataSource;
import org.apache.commons.logging.Log;
import org.apache.commons.logging.LogFactory;
import org.springframework.beans.factory.InitializingBean;
import org.springframework.dao.InvalidDataAccessApiUsageException;
import org.springframework.jdbc.core.JdbcTemplate;
import org.springframework.jdbc.core.SqlParameter;
/**
* An "RDBMS operation" is a multi-threaded, reusable object representing a query,
* update, or stored procedure call. An RDBMS operation is not a command,
* as a command is not reusable. However, execute methods may take commands as
* arguments. Subclasses should be JavaBeans, allowing easy configuration.
*
* This class and subclasses throw runtime exceptions, defined in the
* Subclasses should set SQL and add parameters before invoking the
* {@link #compile()} method. The order in which parameters are added is
* significant. The appropriate Default is 0, indicating to use the driver's default.
* @see org.springframework.jdbc.core.JdbcTemplate#setFetchSize
*/
public void setFetchSize(int fetchSize) {
this.jdbcTemplate.setFetchSize(fetchSize);
}
/**
* Set the maximum number of rows for this RDBMS operation. This is important
* for processing subsets of large result sets, avoiding to read and hold
* the entire result set in the database or in the JDBC driver.
* Default is 0, indicating to use the driver's default.
* @see org.springframework.jdbc.core.JdbcTemplate#setMaxRows
*/
public void setMaxRows(int maxRows) {
this.jdbcTemplate.setMaxRows(maxRows);
}
/**
* Set the query timeout for statements that this RDBMS operation executes.
* Default is 0, indicating to use the JDBC driver's default.
* Note: Any timeout specified here will be overridden by the remaining
* transaction timeout when executing within a transaction that has a
* timeout specified at the transaction level.
*/
public void setQueryTimeout(int queryTimeout) {
this.jdbcTemplate.setQueryTimeout(queryTimeout);
}
/**
* Set whether to use statements that return a specific type of ResultSet.
* @param resultSetType the ResultSet type
* @see java.sql.ResultSet#TYPE_FORWARD_ONLY
* @see java.sql.ResultSet#TYPE_SCROLL_INSENSITIVE
* @see java.sql.ResultSet#TYPE_SCROLL_SENSITIVE
* @see java.sql.Connection#prepareStatement(String, int, int)
*/
public void setResultSetType(int resultSetType) {
this.resultSetType = resultSetType;
}
/**
* Return whether statements will return a specific type of ResultSet.
*/
public int getResultSetType() {
return this.resultSetType;
}
/**
* Set whether to use statements that are capable of returning
* updatable ResultSets.
* @see java.sql.Connection#prepareStatement(String, int, int)
*/
public void setUpdatableResults(boolean updatableResults) {
if (isCompiled()) {
throw new InvalidDataAccessApiUsageException(
"The updateableResults flag must be set before the operation is compiled");
}
this.updatableResults = updatableResults;
}
/**
* Return whether statements will return updatable ResultSets.
*/
public boolean isUpdatableResults() {
return this.updatableResults;
}
/**
* Set whether prepared statements should be capable of returning
* auto-generated keys.
* @see java.sql.Connection#prepareStatement(String, int)
*/
public void setReturnGeneratedKeys(boolean returnGeneratedKeys) {
if (isCompiled()) {
throw new InvalidDataAccessApiUsageException(
"The returnGeneratedKeys flag must be set before the operation is compiled");
}
this.returnGeneratedKeys = returnGeneratedKeys;
}
/**
* Return whether statements should be capable of returning
* auto-generated keys.
*/
public boolean isReturnGeneratedKeys() {
return this.returnGeneratedKeys;
}
/**
* Set the column names of the auto-generated keys.
* @see java.sql.Connection#prepareStatement(String, String[])
*/
public void setGeneratedKeysColumnNames(String[] names) {
if (isCompiled()) {
throw new InvalidDataAccessApiUsageException(
"The column names for the generated keys must be set before the operation is compiled");
}
this.generatedKeysColumnNames = names;
}
/**
* Return the column names of the auto generated keys.
*/
public String[] getGeneratedKeysColumnNames() {
return this.generatedKeysColumnNames;
}
/**
* Set the SQL executed by this operation.
*/
public void setSql(String sql) {
this.sql = sql;
}
/**
* Subclasses can override this to supply dynamic SQL if they wish,
* but SQL is normally set by calling the setSql() method
* or in a subclass constructor.
*/
public String getSql() {
return this.sql;
}
/**
* Add anonymous parameters, specifying only their SQL types
* as defined in the Parameter ordering is significant. This method is an alternative
* to the {@link #declareParameter} method, which should normally be preferred.
* @param types array of SQL types as defined in the
* The order in which this method is called is significant when using
* positional parameters. It is not significant when using named parameters
* with named SqlParameter objects here; it remains significant when using
* named parameters in combination with unnamed SqlParameter objects here.
* @param param the SqlParameter to add. This will specify SQL type and (optionally)
* the parameter's name. Note that you typically use the {@link SqlParameter} class
* itself here, not any of its subclasses.
* @throws InvalidDataAccessApiUsageException if the operation is already compiled,
* and hence cannot be configured further
*/
public void declareParameter(SqlParameter param) throws InvalidDataAccessApiUsageException {
if (isCompiled()) {
throw new InvalidDataAccessApiUsageException("Cannot add parameters once the query is compiled");
}
this.declaredParameters.add(param);
}
/**
* Add one or more declared parameters. Used for configuring this operation
* when used in a bean factory. Each parameter will specify SQL type and (optionally)
* the parameter's name.
* @param parameters Array containing the declared {@link SqlParameter} objects
* @see #declaredParameters
*/
public void setParameters(SqlParameter[] parameters) {
if (isCompiled()) {
throw new InvalidDataAccessApiUsageException("Cannot add parameters once the query is compiled");
}
for (int i = 0; i < parameters.length; i++) {
if (parameters[i] != null) {
this.declaredParameters.add(parameters[i]);
}
else {
throw new InvalidDataAccessApiUsageException("Cannot add parameter at index " + i + " from " +
Arrays.asList(parameters) + " since it is 'null'");
}
}
}
/**
* Return a list of the declared {@link SqlParameter} objects.
*/
protected List Automatically called by Subclasses can assume that SQL and a DataSource have been supplied.
* @throws InvalidDataAccessApiUsageException if the subclass hasn't been
* properly configured
*/
protected abstract void compileInternal() throws InvalidDataAccessApiUsageException;
/**
* Return whether BLOB/CLOB parameters are supported for this kind of operation.
* The default is The default is Intended to use to call SQL functions that return a single result using a
* query like "select user()" or "select sysdate from dual". It is not intended
* for calling more complex stored functions or for using a CallableStatement to
* invoke a stored procedure or stored function. Use StoredProcedure or SqlCall
* for this type of processing.
*
* This is a concrete class, which there is often no need to subclass.
* Code using this package can create an object of this type, declaring SQL
* and parameters, and then invoke the appropriate Like all RdbmsOperation objects, SqlFunction objects are thread-safe.
*
* @author Rod Johnson
* @author Juergen Hoeller
* @author Jean-Pierre Pawlak
* @see org.springframework.jdbc.object.StoredProcedure
*/
public class SqlFunction If not specified, the result value will be exposed as
* returned by the JDBC driver.
*/
public void setResultType(Class Subclasses must implement the {@link #newRowMapper} method to provide
* an object that can extract the results of iterating over the
* This class provides a number of public Like all The This can be used to ensure efficient storage of results. The
* default behavior is not to expect any specific number of rows.
*/
public void setRowsExpected(int rowsExpected) {
this.rowsExpected = rowsExpected;
}
/**
* Get the number of rows expected.
*/
public int getRowsExpected() {
return this.rowsExpected;
}
/**
* Central execution method. All un-named parameter execution goes through this method.
* @param params parameters, similar to JDO query parameters.
* Primitive parameters must be represented by their Object wrapper type.
* The ordering of parameters is significant.
* @param context contextual information passed to the Note that this class is a non-thread-safe object, in contrast
* to all other JDBC operations objects in this package. You need to create
* a new instance of it for each use, or call You can also flush already queued statements with an explicit
* Default is "true". Turn this off to save the memory needed for
* the list of row counts.
* @see #getRowsAffected()
*/
public void setTrackRowsAffected(boolean trackRowsAffected) {
this.trackRowsAffected = trackRowsAffected;
}
/**
* BatchSqlUpdate does not support BLOB or CLOB parameters.
*/
@Override
protected boolean supportsLobParameters() {
return false;
}
/**
* Overridden version of You need to call Configures a {@link org.springframework.jdbc.core.PreparedStatementCreatorFactory}
* based on the declared parameters.
*
* @author Rod Johnson
* @author Juergen Hoeller
*/
public abstract class SqlOperation extends RdbmsOperation {
/**
* Object enabling us to create PreparedStatementCreators efficiently,
* based on this class's declared parameters.
*/
private PreparedStatementCreatorFactory preparedStatementFactory;
/** Parsed representation of the SQL statement */
private ParsedSql cachedSql;
/** Monitor for locking the cached representation of the parsed SQL statement */
private final Object parsedSqlMonitor = new Object();
/**
* Overridden method to configure the PreparedStatementCreatorFactory
* based on our declared parameters.
*/
@Override
protected final void compileInternal() {
this.preparedStatementFactory = new PreparedStatementCreatorFactory(getSql(), getDeclaredParameters());
this.preparedStatementFactory.setResultSetType(getResultSetType());
this.preparedStatementFactory.setUpdatableResults(isUpdatableResults());
this.preparedStatementFactory.setReturnGeneratedKeys(isReturnGeneratedKeys());
if (getGeneratedKeysColumnNames() != null) {
this.preparedStatementFactory.setGeneratedKeysColumnNames(getGeneratedKeysColumnNames());
}
this.preparedStatementFactory.setNativeJdbcExtractor(getJdbcTemplate().getNativeJdbcExtractor());
onCompileInternal();
}
/**
* Hook method that subclasses may override to post-process compilation.
* This implementation does nothing.
* @see #compileInternal
*/
protected void onCompileInternal() {
}
/**
* Obtain a parsed representation of this operation's SQL statement.
* Typically used for named parameter parsing.
*/
protected ParsedSql getParsedSql() {
synchronized (this.parsedSqlMonitor) {
if (this.cachedSql == null) {
this.cachedSql = NamedParameterUtils.parseSqlStatement(getSql());
}
return this.cachedSql;
}
}
/**
* Return a PreparedStatementSetter to perform an operation
* with the given parameters.
* @param params the parameter array (may be Such manual mapping is usually preferable to "automatic"
* mapping using reflection, which can become complex in non-trivial
* cases. For example, the present class allows different objects
* to be used for different rows (for example, if a subclass is indicated).
* It allows computed fields to be set. And there's no need for
* ResultSet columns to have the same names as bean properties.
* The Pareto Principle in action: going the extra mile to automate
* the extraction process makes the framework much more complex
* and delivers little real benefit.
*
* Subclasses can be constructed providing SQL, parameter types
* and a DataSource. SQL will often vary between subclasses.
*
* @author Rod Johnson
* @author Thomas Risberg
* @author Jean-Pierre Pawlak
* @see org.springframework.jdbc.object.MappingSqlQuery
* @see org.springframework.jdbc.object.SqlQuery
*/
public abstract class MappingSqlQueryWithParameters The inherited This class provides a number of This class is concrete. Although it can be subclassed (for example
* to add a custom update method) it can easily be parameterized by setting
* SQL and declaring parameters.
*
* Like all This is an alternative to setting the maximum number of rows
* that may be affected.
* @param requiredRowsAffected the exact number of rows that must be affected
* by this update without this class's update method considering it an error
*/
public void setRequiredRowsAffected(int requiredRowsAffected) {
this.requiredRowsAffected = requiredRowsAffected;
}
/**
* Check the given number of affected rows against the
* specified maximum number or required number.
* @param rowsAffected the number of affected rows
* @throws JdbcUpdateAffectedIncorrectNumberOfRowsException
* if the actually affected rows are out of bounds
* @see #setMaxRowsAffected
* @see #setRequiredRowsAffected
*/
protected void checkRowsAffected(int rowsAffected) throws JdbcUpdateAffectedIncorrectNumberOfRowsException {
if (this.maxRowsAffected > 0 && rowsAffected > this.maxRowsAffected) {
throw new JdbcUpdateAffectedIncorrectNumberOfRowsException(getSql(), this.maxRowsAffected, rowsAffected);
}
if (this.requiredRowsAffected > 0 && rowsAffected != this.requiredRowsAffected) {
throw new JdbcUpdateAffectedIncorrectNumberOfRowsException(getSql(), this.requiredRowsAffected, rowsAffected);
}
}
/**
* Generic method to execute the update given parameters.
* All other update methods invoke this method.
* @param params array of parameters objects
* @return the number of rows affected by the update
*/
public int update(Object... params) throws DataAccessException {
validateParameters(params);
int rowsAffected = getJdbcTemplate().update(newPreparedStatementCreator(params));
checkRowsAffected(rowsAffected);
return rowsAffected;
}
/**
* Method to execute the update given arguments and
* retrieve the generated keys using a KeyHolder.
* @param params array of parameter objects
* @param generatedKeyHolder KeyHolder that will hold the generated keys
* @return the number of rows affected by the update
*/
public int update(Object[] params, KeyHolder generatedKeyHolder) throws DataAccessException {
validateParameters(params);
int rowsAffected = getJdbcTemplate().update(newPreparedStatementCreator(params), generatedKeyHolder);
checkRowsAffected(rowsAffected);
return rowsAffected;
}
/**
* Convenience method to execute an update with no parameters.
*/
public int update() throws DataAccessException {
return update((Object[]) null);
}
/**
* Convenient method to execute an update given one int arg.
*/
public int update(int p1) throws DataAccessException {
return update(new Object[] {p1});
}
/**
* Convenient method to execute an update given two int args.
*/
public int update(int p1, int p2) throws DataAccessException {
return update(new Object[] {p1, p2});
}
/**
* Convenient method to execute an update given one long arg.
*/
public int update(long p1) throws DataAccessException {
return update(new Object[] {p1});
}
/**
* Convenient method to execute an update given two long args.
*/
public int update(long p1, long p2) throws DataAccessException {
return update(new Object[] {p1, p2});
}
/**
* Convenient method to execute an update given one String arg.
*/
public int update(String p) throws DataAccessException {
return update(new Object[] {p});
}
/**
* Convenient method to execute an update given two String args.
*/
public int update(String p1, String p2) throws DataAccessException {
return update(new Object[] {p1, p2});
}
/**
* Generic method to execute the update given named parameters.
* All other update methods invoke this method.
* @param paramMap Map of parameter name to parameter object,
* matching named parameters specified in the SQL statement
* @return the number of rows affected by the update
*/
public int updateByNamedParam(Map Subclasses can be constructed providing SQL, parameter types
* and a DataSource. SQL will often vary between subclasses.
*
* @author Thomas Risberg
* @see org.springframework.jdbc.object.SqlQuery
*/
public abstract class UpdatableSqlQuery Simplifies MappingSqlQueryWithParameters API by dropping parameters and
* context. Most subclasses won't care about parameters. If you don't use
* contextual information, subclass this instead of MappingSqlQueryWithParameters.
*
* @author Rod Johnson
* @author Thomas Risberg
* @author Jean-Pierre Pawlak
* @see MappingSqlQueryWithParameters
*/
public abstract class MappingSqlQuery Subclasses of this class, as opposed to direct subclasses of
* MappingSqlQueryWithParameters, don't need to concern themselves
* with the parameters to the execute method of the query object.
* @param rs ResultSet we're working through
* @param rowNum row number (from 0) we're up to
* @return an object of the result type
* @throws SQLException if there's an error extracting data.
* Subclasses can simply not catch SQLExceptions, relying on the
* framework to clean up.
*/
protected abstract T mapRow(ResultSet rs, int rowNum) throws SQLException;
}
././@LongLink 0000000 0000000 0000000 00000000156 00000000000 011567 L ustar root root libspring-java-3.0.6.RELEASE/projects/org.springframework.jdbc/src/main/java/org/springframework/jdbc/config/ libspring-java-3.0.6.RELEASE/projects/org.springframework.jdbc/src/main/java/org/springframework/jdb0000755 0001750 0001750 00000000000 11623223530 033263 5 ustar drazzib drazzib ././@LongLink 0000000 0000000 0000000 00000000177 00000000000 011572 L ustar root root libspring-java-3.0.6.RELEASE/projects/org.springframework.jdbc/src/main/java/org/springframework/jdbc/config/package-info.java libspring-java-3.0.6.RELEASE/projects/org.springframework.jdbc/src/main/java/org/springframework/jdb0000644 0001750 0001750 00000000147 11623223530 033267 0 ustar drazzib drazzib
/**
* Defines the Spring JDBC configuration namespace.
*/
package org.springframework.jdbc.config;
././@LongLink 0000000 0000000 0000000 00000000231 00000000000 011561 L ustar root root libspring-java-3.0.6.RELEASE/projects/org.springframework.jdbc/src/main/java/org/springframework/jdbc/config/InitializeDatabaseBeanDefinitionParser.java libspring-java-3.0.6.RELEASE/projects/org.springframework.jdbc/src/main/java/org/springframework/jdb0000644 0001750 0001750 00000007163 11623223526 033301 0 ustar drazzib drazzib /*
* Copyright 2002-2011 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.config;
import java.util.ArrayList;
import java.util.List;
import org.w3c.dom.Element;
import org.springframework.beans.factory.config.BeanDefinition;
import org.springframework.beans.factory.support.AbstractBeanDefinition;
import org.springframework.beans.factory.support.BeanDefinitionBuilder;
import org.springframework.beans.factory.xml.AbstractBeanDefinitionParser;
import org.springframework.beans.factory.xml.ParserContext;
import org.springframework.jdbc.datasource.init.DataSourceInitializer;
import org.springframework.jdbc.datasource.init.ResourceDatabasePopulator;
import org.springframework.util.xml.DomUtils;
/**
* {@link org.springframework.beans.factory.xml.BeanDefinitionParser} that parses an {@code initialize-database}
* element and creates a {@link BeanDefinition} of type {@link DataSourceInitializer}. Picks up nested
* {@code script} elements and configures a {@link ResourceDatabasePopulator} for them.
*
* @author Dave Syer
* @since 3.0
*/
public class InitializeDatabaseBeanDefinitionParser extends AbstractBeanDefinitionParser {
@Override
protected AbstractBeanDefinition parseInternal(Element element, ParserContext parserContext) {
BeanDefinitionBuilder builder = BeanDefinitionBuilder.genericBeanDefinition(DataSourceInitializer.class);
builder.addPropertyReference("dataSource", element.getAttribute("data-source"));
builder.addPropertyValue("enabled", element.getAttribute("enabled"));
setDatabasePopulator(element, builder);
builder.getRawBeanDefinition().setSource(parserContext.extractSource(element));
return builder.getBeanDefinition();
}
@Override
protected boolean shouldGenerateId() {
return true;
}
private void setDatabasePopulator(Element element, BeanDefinitionBuilder builder) {
List This interface sets values on a {@link java.sql.PreparedStatement} provided
* by the JdbcTemplate class, for each of a number of updates in a batch using the
* same SQL. Implementations are responsible for setting any necessary parameters.
* SQL with placeholders will already have been supplied.
*
* Implementations do not need to concern themselves with SQLExceptions
* that may be thrown from operations they attempt. The JdbcTemplate class will
* catch and handle SQLExceptions appropriately.
*
* @author Rod Johnson
* @since March 2, 2003
* @see JdbcTemplate#batchUpdate(String, BatchPreparedStatementSetter)
* @see InterruptibleBatchPreparedStatementSetter
*/
public interface BatchPreparedStatementSetter {
/**
* Set parameter values on the given PreparedStatement.
* @param ps the PreparedStatement to invoke setter methods on
* @param i index of the statement we're issuing in the batch, starting from 0
* @throws SQLException if a SQLException is encountered
* (i.e. there is no need to catch SQLException)
*/
void setValues(PreparedStatement ps, int i) throws SQLException;
/**
* Return the size of the batch.
* @return the number of statements in the batch
*/
int getBatchSize();
}
././@LongLink 0000000 0000000 0000000 00000000175 00000000000 011570 L ustar root root libspring-java-3.0.6.RELEASE/projects/org.springframework.jdbc/src/main/java/org/springframework/jdbc/core/package-info.java libspring-java-3.0.6.RELEASE/projects/org.springframework.jdbc/src/main/java/org/springframework/jdb0000644 0001750 0001750 00000000260 11623223526 033270 0 ustar drazzib drazzib
/**
*
* Provides the core JDBC framework, based on JdbcTemplate
* and its associated callback interfaces and helper objects.
*
*/
package org.springframework.jdbc.core;
././@LongLink 0000000 0000000 0000000 00000000207 00000000000 011564 L ustar root root libspring-java-3.0.6.RELEASE/projects/org.springframework.jdbc/src/main/java/org/springframework/jdbc/core/DisposableSqlTypeValue.java libspring-java-3.0.6.RELEASE/projects/org.springframework.jdbc/src/main/java/org/springframework/jdb0000644 0001750 0001750 00000002367 11623223530 033275 0 ustar drazzib drazzib /*
* Copyright 2002-2008 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.core;
/**
* Subinterface of {@link SqlTypeValue} that adds a cleanup callback,
* to be invoked after the value has been set and the corresponding
* statement has been executed.
*
* @author Juergen Hoeller
* @since 1.1
* @see org.springframework.jdbc.core.support.SqlLobValue
*/
public interface DisposableSqlTypeValue extends SqlTypeValue {
/**
* Clean up resources held by this type value,
* for example the LobCreator in case of a SqlLobValue.
* @see org.springframework.jdbc.core.support.SqlLobValue#cleanup()
* @see org.springframework.jdbc.support.SqlValue#cleanup()
*/
void cleanup();
}
././@LongLink 0000000 0000000 0000000 00000000176 00000000000 011571 L ustar root root libspring-java-3.0.6.RELEASE/projects/org.springframework.jdbc/src/main/java/org/springframework/jdbc/core/SqlReturnType.java libspring-java-3.0.6.RELEASE/projects/org.springframework.jdbc/src/main/java/org/springframework/jdb0000644 0001750 0001750 00000004666 11623223526 033306 0 ustar drazzib drazzib /*
* Copyright 2002-2007 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.core;
import java.sql.CallableStatement;
import java.sql.SQLException;
/**
* Interface to be implemented for retrieving values for more complex database-specific
* types not supported by the standard Implementations perform the actual work of getting the actual values. They must
* implement the callback method Returned update counts - like all stored procedure
* parameters - must have names.
*
* @author Thomas Risberg
*/
public class SqlReturnUpdateCount extends SqlParameter {
/**
* Create a new instance of the {@link SqlReturnUpdateCount} class.
* @param name name of the parameter, as used in input and output maps
*/
public SqlReturnUpdateCount(String name) {
super(name, Types.INTEGER);
}
/**
* Return whether this parameter holds input values that should be set
* before execution even if they are This implementation always returns This implementation always returns Automatically called by SimpleJdbcTemplate is a wrapper around JdbcTemplate that takes advantage
* of varargs and autoboxing. It also offers only a subset of the methods
* available on JdbcTemplate: Hence, it does not implement the JdbcOperations
* interface or extend JdbcTemplate, but implements the dedicated
* SimpleJdbcOperations interface.
*
* If you need the full power of Spring JDBC for less common operations,
* use the The meta data processing is based on the DatabaseMetaData provided by the
* JDBC driver. As long as the JBDC driver can provide the names of the columns
* for a specified table than we can rely on this auto-detection feature. If that
* is not the case then the column names must be specified explicitly.
*
* The actual insert is being handled using Spring's
* {@link org.springframework.jdbc.core.JdbcTemplate}.
*
* Many of the configuration methods return the current instance of the SimpleJdbcInsert
* to provide the ability to string multiple ones together in a "fluid" interface style.
*
* @author Thomas Risberg
* @since 2.5
* @see java.sql.DatabaseMetaData
* @see org.springframework.jdbc.core.JdbcTemplate
*/
public class SimpleJdbcInsert extends AbstractJdbcInsert implements SimpleJdbcInsertOperations {
/**
* Constructor that takes one parameter with the JDBC DataSource to use when creating the
* JdbcTemplate.
* @param dataSource the The meta data processing is based on the DatabaseMetaData provided by
* the JDBC driver. Since we rely on the JDBC driver this "auto-detection"
* can only be used for databases that are known to provide accurate meta data.
* These currently include Derby, MySQL, Microsoft SQL Server, Oracle, DB2,
* Sybase and PostgreSQL. For any other databases you are required to declare all
* parameters explicitly. You can of course declare all parameters explicitly even
* if the database provides the necessary meta data. In that case your declared
* parameters will take precedence. You can also turn off any mete data processing
* if you want to use parameter names that do not match what is declared during
* the stored procedure compilation.
*
* The actual insert is being handled using Spring's
* {@link org.springframework.jdbc.core.JdbcTemplate}.
*
* Many of the configuration methods return the current instance of the SimpleJdbcCall
* to provide the ability to string multiple ones together in a "fluid" interface style.
*
* @author Thomas Risberg
* @since 2.5
* @see java.sql.DatabaseMetaData
* @see org.springframework.jdbc.core.JdbcTemplate
*/
public class SimpleJdbcCall extends AbstractJdbcCall implements SimpleJdbcCallOperations {
/**
* Constructor that takes one parameter with the JDBC DataSource to use when creating the
* JdbcTemplate.
* @param dataSource the The query is expected to be a single row query; the result row will be
* mapped to a Map The query is expected to be a single row query; the result row will be
* mapped to a Map The query is expected to be a single row query; the result row will be
* mapped to a Map
* Call {@link #setDatabaseName(String)} to change the name of the database.
* Call {@link #setDatabaseType(EmbeddedDatabaseType)} to set the database type if you wish to use one of the supported types.
* Call {@link #setDatabaseConfigurer(EmbeddedDatabaseConfigurer)} to configure support for your own embedded database type.
* Call {@link #setDatabasePopulator(DatabasePopulator)} to change the algorithm used to populate the database.
* Call {@link #setDataSourceFactory(DataSourceFactory)} to change the type of DataSource used to connect to the database.
* Call {@link #getDatabase()} to get the {@link EmbeddedDatabase} instance.
*
* @author Keith Donald
* @author Juergen Hoeller
* @since 3.0
*/
public class EmbeddedDatabaseFactory {
private static Log logger = LogFactory.getLog(EmbeddedDatabaseFactory.class);
private String databaseName = "testdb";
private DataSourceFactory dataSourceFactory = new SimpleDriverDataSourceFactory();
private EmbeddedDatabaseConfigurer databaseConfigurer;
private DatabasePopulator databasePopulator;
private DataSource dataSource;
/**
* Set the name of the database. Defaults to "testdb".
* @param databaseName name of the test database
*/
public void setDatabaseName(String databaseName) {
Assert.notNull(databaseName, "Database name is required");
this.databaseName = databaseName;
}
/**
* Set the factory to use to create the DataSource instance that connects to the embedded database.
* Defaults to {@link SimpleDriverDataSourceFactory}.
* @param dataSourceFactory the data source factory
*/
public void setDataSourceFactory(DataSourceFactory dataSourceFactory) {
Assert.notNull(dataSourceFactory, "DataSourceFactory is required");
this.dataSourceFactory = dataSourceFactory;
}
/**
* Set the type of embedded database to use. Call this when you wish to configure
* one of the pre-supported types. Defaults to HSQL.
* @param type the test database type
*/
public void setDatabaseType(EmbeddedDatabaseType type) {
this.databaseConfigurer = EmbeddedDatabaseConfigurerFactory.getConfigurer(type);
}
/**
* Set the strategy that will be used to configure the embedded database instance.
* Call this when you wish to use an embedded database type not already supported.
* @param configurer the embedded database configurer
*/
public void setDatabaseConfigurer(EmbeddedDatabaseConfigurer configurer) {
this.databaseConfigurer = configurer;
}
/**
* Set the strategy that will be used to populate the embedded database. Defaults to null.
* @param populator the database populator
*/
public void setDatabasePopulator(DatabasePopulator populator) {
this.databasePopulator = populator;
}
/**
* Factory method that returns the embedded database instance.
*/
public EmbeddedDatabase getDatabase() {
if (this.dataSource == null) {
initDatabase();
}
return new EmbeddedDataSourceProxy(this.dataSource);
}
/**
* Hook to initialize the embedded database. Subclasses may call to force initialization. After calling this method,
* {@link #getDataSource()} returns the DataSource providing connectivity to the db.
*/
protected void initDatabase() {
// Create the embedded database source first
if (logger.isInfoEnabled()) {
logger.info("Creating embedded database '" + this.databaseName + "'");
}
if (this.databaseConfigurer == null) {
this.databaseConfigurer = EmbeddedDatabaseConfigurerFactory.getConfigurer(EmbeddedDatabaseType.HSQL);
}
this.databaseConfigurer.configureConnectionProperties(
this.dataSourceFactory.getConnectionProperties(), this.databaseName);
this.dataSource = this.dataSourceFactory.getDataSource();
// Now populate the database
if (this.databasePopulator != null) {
try {
populateDatabase();
}
catch (RuntimeException ex) {
// failed to populate, so leave it as not initialized
shutdownDatabase();
throw ex;
}
}
}
private void populateDatabase() {
try {
Connection connection = this.dataSource.getConnection();
try {
this.databasePopulator.populate(connection);
}
finally {
try {
connection.close();
}
catch (SQLException ex) {
// ignore
}
}
}
catch (Exception ex) {
throw new DataAccessResourceFailureException("Failed to populate database", ex);
}
}
/**
* Hook that gets the DataSource that provides the connectivity to the embedded database.
*
* EmbeddedDatabaseBuilder builder = new EmbeddedDatabaseBuilder();
* EmbeddedDatabase db = builder.setType(H2).addScript("schema.sql").addScript("data.sql").build();
* db.shutdown();
*
*
* @author Keith Donald
* @author Juergen Hoeller
* @author Dave Syer
* @since 3.0
*/
public class EmbeddedDatabaseBuilder {
private final EmbeddedDatabaseFactory databaseFactory;
private final ResourceDatabasePopulator databasePopulator;
private final ResourceLoader resourceLoader;
/**
* Create a new embedded database builder.
*/
public EmbeddedDatabaseBuilder() {
this(new DefaultResourceLoader());
}
/**
* Create a new embedded database builder with the given ResourceLoader.
* @param resourceLoader the ResourceLoader to delegate to
*/
public EmbeddedDatabaseBuilder(ResourceLoader resourceLoader) {
this.databaseFactory = new EmbeddedDatabaseFactory();
this.databasePopulator = new ResourceDatabasePopulator();
this.databaseFactory.setDatabasePopulator(this.databasePopulator);
this.resourceLoader = resourceLoader;
}
/**
* Sets the name of the embedded database
* Defaults to 'testdb' if not called.
* @param databaseName the database name
* @return this, for fluent call chaining
*/
public EmbeddedDatabaseBuilder setName(String databaseName) {
this.databaseFactory.setDatabaseName(databaseName);
return this;
}
/**
* Sets the type of embedded database.
* Defaults to HSQL if not called.
* @param databaseType the database type
* @return this, for fluent call chaining
*/
public EmbeddedDatabaseBuilder setType(EmbeddedDatabaseType databaseType) {
this.databaseFactory.setDatabaseType(databaseType);
return this;
}
/**
* Adds a SQL script to execute to populate the database.
* @param sqlResource the sql resource location
* @return this, for fluent call chaining
*/
public EmbeddedDatabaseBuilder addScript(String sqlResource) {
this.databasePopulator.addScript(this.resourceLoader.getResource(sqlResource));
return this;
}
/**
* Add default scripts to execute to populate the database.
* The default scripts are schema.sql to create the db schema and data.sql to populate the db with data.
* @return this, for fluent call chaining
*/
public EmbeddedDatabaseBuilder addDefaultScripts() {
addScript("schema.sql");
addScript("data.sql");
return this;
}
/**
* Build the embedded database.
* @return the embedded database
*/
public EmbeddedDatabase build() {
return this.databaseFactory.getDatabase();
}
}
././@LongLink 0000000 0000000 0000000 00000000220 00000000000 011557 L ustar root root libspring-java-3.0.6.RELEASE/projects/org.springframework.jdbc/src/main/java/org/springframework/jdbc/datasource/embedded/EmbeddedDatabase.java libspring-java-3.0.6.RELEASE/projects/org.springframework.jdbc/src/main/java/org/springframework/jdb0000644 0001750 0001750 00000002011 11623223530 033257 0 ustar drazzib drazzib /*
* Copyright 2002-2009 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.datasource.embedded;
import javax.sql.DataSource;
/**
* A handle to an EmbeddedDatabase instance.
* Is a {@link DataSource}.
* Adds a shutdown operation so the embedded database instance can be shutdown.
*
* @author Keith Donald
* @since 3.0
*/
public interface EmbeddedDatabase extends DataSource {
/**
* Shutdown this embedded database.
*/
void shutdown();
}
././@LongLink 0000000 0000000 0000000 00000000237 00000000000 011567 L ustar root root libspring-java-3.0.6.RELEASE/projects/org.springframework.jdbc/src/main/java/org/springframework/jdbc/datasource/embedded/DerbyEmbeddedDatabaseConfigurer.java libspring-java-3.0.6.RELEASE/projects/org.springframework.jdbc/src/main/java/org/springframework/jdb0000644 0001750 0001750 00000006467 11623223530 033302 0 ustar drazzib drazzib /*
* Copyright 2002-2010 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.datasource.embedded;
import java.io.File;
import java.io.IOException;
import java.sql.SQLException;
import java.util.Properties;
import javax.sql.DataSource;
import org.apache.commons.logging.Log;
import org.apache.commons.logging.LogFactory;
import org.apache.derby.impl.io.VFMemoryStorageFactory;
import org.apache.derby.jdbc.EmbeddedDriver;
/**
* {@link EmbeddedDatabaseConfigurer} for the Apache Derby database.
*
* @author Oliver Gierke
* @author Juergen Hoeller
* @since 3.0
*/
final class DerbyEmbeddedDatabaseConfigurer implements EmbeddedDatabaseConfigurer {
private static final Log logger = LogFactory.getLog(DerbyEmbeddedDatabaseConfigurer.class);
private static final String URL_TEMPLATE = "jdbc:derby:memory:%s;%s";
// Error code that indicates successful shutdown
private static final String SHUTDOWN_CODE = "08006";
private static final boolean IS_AT_LEAST_DOT_SIX = new EmbeddedDriver().getMinorVersion() >= 6;
private static final String SHUTDOWN_COMMAND =
String.format("%s=true", IS_AT_LEAST_DOT_SIX ? "drop" : "shutdown");
private static DerbyEmbeddedDatabaseConfigurer INSTANCE;
/**
* Get the singleton {@link DerbyEmbeddedDatabaseConfigurer} instance.
* @return the configurer
* @throws ClassNotFoundException if Derby is not on the classpath
*/
public static synchronized DerbyEmbeddedDatabaseConfigurer getInstance() throws ClassNotFoundException {
if (INSTANCE == null) {
// disable log file
System.setProperty("derby.stream.error.method",
OutputStreamFactory.class.getName() + ".getNoopOutputStream");
INSTANCE = new DerbyEmbeddedDatabaseConfigurer();
}
return INSTANCE;
}
private DerbyEmbeddedDatabaseConfigurer() {
}
public void configureConnectionProperties(ConnectionProperties properties, String databaseName) {
properties.setDriverClass(EmbeddedDriver.class);
properties.setUrl(String.format(URL_TEMPLATE, databaseName, "create=true"));
properties.setUsername("sa");
properties.setPassword("");
}
public void shutdown(DataSource dataSource, String databaseName) {
try {
new EmbeddedDriver().connect(
String.format(URL_TEMPLATE, databaseName, SHUTDOWN_COMMAND), new Properties());
}
catch (SQLException ex) {
if (!SHUTDOWN_CODE.equals(ex.getSQLState())) {
logger.warn("Could not shutdown in-memory Derby database", ex);
return;
}
if (!IS_AT_LEAST_DOT_SIX) {
// Explicitly purge the in-memory database, to prevent it
// from hanging around after being shut down.
try {
VFMemoryStorageFactory.purgeDatabase(new File(databaseName).getCanonicalPath());
}
catch (IOException ex2) {
logger.warn("Could not purge in-memory Derby database", ex2);
}
}
}
}
}
././@LongLink 0000000 0000000 0000000 00000000206 00000000000 011563 L ustar root root libspring-java-3.0.6.RELEASE/projects/org.springframework.jdbc/src/main/java/org/springframework/jdbc/datasource/SmartDataSource.java libspring-java-3.0.6.RELEASE/projects/org.springframework.jdbc/src/main/java/org/springframework/jdb0000644 0001750 0001750 00000003577 11623223530 033301 0 ustar drazzib drazzib /*
* Copyright 2002-2007 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.datasource;
import java.sql.Connection;
import javax.sql.DataSource;
/**
* Extension of the javax.sql.DataSource interface, to be
* implemented by special DataSources that return JDBC Connections
* in an unwrapped fashion.
*
* close().
* close() method. Client code will never call close
* on the Connection handle if it is SmartDataSource-aware (e.g. uses
* DataSourceUtils.releaseConnection).
*
* close() in the assumption of a pooled
* Connection, like when using persistence tools, set "suppressClose" to "true".
* This will return a close-suppressing proxy instead of the physical Connection.
* Be aware that you will not be able to cast this to a native
* OracleConnection or the like anymore; you need to use a
* {@link org.springframework.jdbc.support.nativejdbc.NativeJdbcExtractor} then.
*
* close() calls (to allow for normal close()
* usage in applications that expect a pooled Connection but do not know our
* SmartDataSource interface)
*/
public SingleConnectionDataSource(Connection target, boolean suppressClose) {
Assert.notNull(target, "Connection must not be null");
this.target = target;
this.suppressClose = suppressClose;
this.connection = (suppressClose ? getCloseSuppressingConnectionProxy(target) : target);
}
/**
* Set whether the returned Connection should be a close-suppressing proxy
* or the physical Connection.
*/
public void setSuppressClose(boolean suppressClose) {
this.suppressClose = suppressClose;
}
/**
* Return whether the returned Connection will be a close-suppressing proxy
* or the physical Connection.
*/
protected boolean isSuppressClose() {
return this.suppressClose;
}
/**
* Set whether the returned Connection's "autoCommit" setting should be overridden.
*/
public void setAutoCommit(boolean autoCommit) {
this.autoCommit = (autoCommit);
}
/**
* Return whether the returned Connection's "autoCommit" setting should be overridden.
* @return the "autoCommit" value, or null if none to be applied
*/
protected Boolean getAutoCommitValue() {
return this.autoCommit;
}
@Override
public Connection getConnection() throws SQLException {
synchronized (this.connectionMonitor) {
if (this.connection == null) {
// No underlying Connection -> lazy init via DriverManager.
initConnection();
}
if (this.connection.isClosed()) {
throw new SQLException(
"Connection was closed in SingleConnectionDataSource. Check that user code checks " +
"shouldClose() before closing Connections, or set 'suppressClose' to 'true'");
}
return this.connection;
}
}
/**
* Specifying a custom username and password doesn't make sense
* with a single Connection. Returns the single Connection if given
* the same username and password; throws a SQLException else.
*/
@Override
public Connection getConnection(String username, String password) throws SQLException {
if (ObjectUtils.nullSafeEquals(username, getUsername()) &&
ObjectUtils.nullSafeEquals(password, getPassword())) {
return getConnection();
}
else {
throw new SQLException("SingleConnectionDataSource does not support custom username and password");
}
}
/**
* This is a single Connection: Do not close it when returning to the "pool".
*/
public boolean shouldClose(Connection con) {
synchronized (this.connectionMonitor) {
return (con != this.connection && con != this.target);
}
}
/**
* Close the underlying Connection.
* The provider of this DataSource needs to care for proper shutdown.
* null)
* @return whether the Connection is transactional
*/
public static boolean isConnectionTransactional(Connection con, DataSource dataSource) {
if (dataSource == null) {
return false;
}
ConnectionHolder conHolder = (ConnectionHolder) TransactionSynchronizationManager.getResource(dataSource);
return (conHolder != null && connectionEquals(conHolder, con));
}
/**
* Apply the current transaction timeout, if any,
* to the given JDBC Statement object.
* @param stmt the JDBC Statement object
* @param dataSource the DataSource that the Connection was obtained from
* @throws SQLException if thrown by JDBC methods
* @see java.sql.Statement#setQueryTimeout
*/
public static void applyTransactionTimeout(Statement stmt, DataSource dataSource) throws SQLException {
applyTimeout(stmt, dataSource, 0);
}
/**
* Apply the specified timeout - overridden by the current transaction timeout,
* if any - to the given JDBC Statement object.
* @param stmt the JDBC Statement object
* @param dataSource the DataSource that the Connection was obtained from
* @param timeout the timeout to apply (or 0 for no timeout outside of a transaction)
* @throws SQLException if thrown by JDBC methods
* @see java.sql.Statement#setQueryTimeout
*/
public static void applyTimeout(Statement stmt, DataSource dataSource, int timeout) throws SQLException {
Assert.notNull(stmt, "No Statement specified");
Assert.notNull(dataSource, "No DataSource specified");
ConnectionHolder holder = (ConnectionHolder) TransactionSynchronizationManager.getResource(dataSource);
if (holder != null && holder.hasTimeout()) {
// Remaining transaction timeout overrides specified value.
stmt.setQueryTimeout(holder.getTimeToLiveInSeconds());
}
else if (timeout > 0) {
// No current transaction timeout -> apply specified value.
stmt.setQueryTimeout(timeout);
}
}
/**
* Close the given Connection, obtained from the given DataSource,
* if it is not managed externally (that is, not bound to the thread).
* @param con the Connection to close if necessary
* (if this is null, the call will be ignored)
* @param dataSource the DataSource that the Connection was obtained from
* (may be null)
* @see #getConnection
*/
public static void releaseConnection(Connection con, DataSource dataSource) {
try {
doReleaseConnection(con, dataSource);
}
catch (SQLException ex) {
logger.debug("Could not close JDBC Connection", ex);
}
catch (Throwable ex) {
logger.debug("Unexpected exception on closing JDBC Connection", ex);
}
}
/**
* Actually close the given Connection, obtained from the given DataSource.
* Same as {@link #releaseConnection}, but throwing the original SQLException.
* null, the call will be ignored)
* @param dataSource the DataSource that the Connection was obtained from
* (may be null)
* @throws SQLException if thrown by JDBC methods
* @see #doGetConnection
*/
public static void doReleaseConnection(Connection con, DataSource dataSource) throws SQLException {
if (con == null) {
return;
}
if (dataSource != null) {
ConnectionHolder conHolder = (ConnectionHolder) TransactionSynchronizationManager.getResource(dataSource);
if (conHolder != null && connectionEquals(conHolder, con)) {
// It's the transactional Connection: Don't close it.
conHolder.released();
return;
}
}
// Leave the Connection open only if the DataSource is our
// special SmartDataSoruce and it wants the Connection left open.
if (!(dataSource instanceof SmartDataSource) || ((SmartDataSource) dataSource).shouldClose(con)) {
logger.debug("Returning JDBC Connection to DataSource");
con.close();
}
}
/**
* Determine whether the given two Connections are equal, asking the target
* Connection in case of a proxy. Used to detect equality even if the
* user passed in a raw target Connection while the held one is a proxy.
* @param conHolder the ConnectionHolder for the held Connection (potentially a proxy)
* @param passedInCon the Connection passed-in by the user
* (potentially a target Connection without proxy)
* @return whether the given Connections are equal
* @see #getTargetConnection
*/
private static boolean connectionEquals(ConnectionHolder conHolder, Connection passedInCon) {
if (!conHolder.hasConnection()) {
return false;
}
Connection heldCon = conHolder.getConnection();
// Explicitly check for identity too: for Connection handles that do not implement
// "equals" properly, such as the ones Commons DBCP exposes).
return (heldCon == passedInCon || heldCon.equals(passedInCon) ||
getTargetConnection(heldCon).equals(passedInCon));
}
/**
* Return the innermost target Connection of the given Connection. If the given
* Connection is a proxy, it will be unwrapped until a non-proxy Connection is
* found. Otherwise, the passed-in Connection will be returned as-is.
* @param con the Connection proxy to unwrap
* @return the innermost target Connection, or the passed-in one if no proxy
* @see ConnectionProxy#getTargetConnection()
*/
public static Connection getTargetConnection(Connection con) {
Connection conToUse = con;
while (conToUse instanceof ConnectionProxy) {
conToUse = ((ConnectionProxy) conToUse).getTargetConnection();
}
return conToUse;
}
/**
* Determine the connection synchronization order to use for the given
* DataSource. Decreased for every level of nesting that a DataSource
* has, checked through the level of DelegatingDataSource nesting.
* @param dataSource the DataSource to check
* @return the connection synchronization order to use
* @see #CONNECTION_SYNCHRONIZATION_ORDER
*/
private static int getConnectionSynchronizationOrder(DataSource dataSource) {
int order = CONNECTION_SYNCHRONIZATION_ORDER;
DataSource currDs = dataSource;
while (currDs instanceof DelegatingDataSource) {
order--;
currDs = ((DelegatingDataSource) currDs).getTargetDataSource();
}
return order;
}
/**
* Callback for resource cleanup at the end of a non-native JDBC transaction
* (e.g. when participating in a JtaTransactionManager transaction).
* @see org.springframework.transaction.jta.JtaTransactionManager
*/
private static class ConnectionSynchronization extends TransactionSynchronizationAdapter {
private final ConnectionHolder connectionHolder;
private final DataSource dataSource;
private int order;
private boolean holderActive = true;
public ConnectionSynchronization(ConnectionHolder connectionHolder, DataSource dataSource) {
this.connectionHolder = connectionHolder;
this.dataSource = dataSource;
this.order = getConnectionSynchronizationOrder(dataSource);
}
@Override
public int getOrder() {
return this.order;
}
@Override
public void suspend() {
if (this.holderActive) {
TransactionSynchronizationManager.unbindResource(this.dataSource);
if (this.connectionHolder.hasConnection() && !this.connectionHolder.isOpen()) {
// Release Connection on suspend if the application doesn't keep
// a handle to it anymore. We will fetch a fresh Connection if the
// application accesses the ConnectionHolder again after resume,
// assuming that it will participate in the same transaction.
releaseConnection(this.connectionHolder.getConnection(), this.dataSource);
this.connectionHolder.setConnection(null);
}
}
}
@Override
public void resume() {
if (this.holderActive) {
TransactionSynchronizationManager.bindResource(this.dataSource, this.connectionHolder);
}
}
@Override
public void beforeCompletion() {
// Release Connection early if the holder is not open anymore
// (that is, not used by another resource like a Hibernate Session
// that has its own cleanup via transaction synchronization),
// to avoid issues with strict JTA implementations that expect
// the close call before transaction completion.
if (!this.connectionHolder.isOpen()) {
TransactionSynchronizationManager.unbindResource(this.dataSource);
this.holderActive = false;
if (this.connectionHolder.hasConnection()) {
releaseConnection(this.connectionHolder.getConnection(), this.dataSource);
}
}
}
@Override
public void afterCompletion(int status) {
// If we haven't closed the Connection in beforeCompletion,
// close it now. The holder might have been used for other
// cleanup in the meantime, for example by a Hibernate Session.
if (this.holderActive) {
// The thread-bound ConnectionHolder might not be available anymore,
// since afterCompletion might get called from a different thread.
TransactionSynchronizationManager.unbindResourceIfPossible(this.dataSource);
this.holderActive = false;
if (this.connectionHolder.hasConnection()) {
releaseConnection(this.connectionHolder.getConnection(), this.dataSource);
// Reset the ConnectionHolder: It might remain bound to the thread.
this.connectionHolder.setConnection(null);
}
}
this.connectionHolder.reset();
}
}
}
././@LongLink 0000000 0000000 0000000 00000000215 00000000000 011563 L ustar root root libspring-java-3.0.6.RELEASE/projects/org.springframework.jdbc/src/main/java/org/springframework/jdbc/datasource/SimpleConnectionHandle.java libspring-java-3.0.6.RELEASE/projects/org.springframework.jdbc/src/main/java/org/springframework/jdb0000644 0001750 0001750 00000003214 11623223530 033265 0 ustar drazzib drazzib /*
* Copyright 2002-2007 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.datasource;
import java.sql.Connection;
import org.springframework.util.Assert;
/**
* Simple implementation of the {@link ConnectionHandle} interface,
* containing a given JDBC Connection.
*
* @author Juergen Hoeller
* @since 1.1
*/
public class SimpleConnectionHandle implements ConnectionHandle {
private final Connection connection;
/**
* Create a new SimpleConnectionHandle for the given Connection.
* @param connection the JDBC Connection
*/
public SimpleConnectionHandle(Connection connection) {
Assert.notNull(connection, "Connection must not be null");
this.connection = connection;
}
/**
* Return the specified Connection as-is.
*/
public Connection getConnection() {
return this.connection;
}
/**
* This implementation is empty, as we're using a standard
* Connection handle that does not have to be released.
*/
public void releaseConnection(Connection con) {
}
@Override
public String toString() {
return "SimpleConnectionHandle: " + this.connection;
}
}
././@LongLink 0000000 0000000 0000000 00000000224 00000000000 011563 L ustar root root libspring-java-3.0.6.RELEASE/projects/org.springframework.jdbc/src/main/java/org/springframework/jdbc/datasource/AbstractDriverBasedDataSource.java libspring-java-3.0.6.RELEASE/projects/org.springframework.jdbc/src/main/java/org/springframework/jdb0000644 0001750 0001750 00000011246 11623223530 033271 0 ustar drazzib drazzib /*
* Copyright 2002-2008 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.datasource;
import java.sql.Connection;
import java.sql.SQLException;
import java.util.Properties;
import org.springframework.util.Assert;
/**
* Abstract base class for JDBC {@link javax.sql.DataSource} implementations
* that operate on a JDBC {@link java.sql.Driver}.
*
* @author Juergen Hoeller
* @since 2.5.5
* @see SimpleDriverDataSource
* @see DriverManagerDataSource
*/
public abstract class AbstractDriverBasedDataSource extends AbstractDataSource {
private String url;
private String username;
private String password;
private Properties connectionProperties;
/**
* Set the JDBC URL to use for connecting through the Driver.
* @see java.sql.Driver#connect(String, java.util.Properties)
*/
public void setUrl(String url) {
Assert.hasText(url, "Property 'url' must not be empty");
this.url = url.trim();
}
/**
* Return the JDBC URL to use for connecting through the Driver.
*/
public String getUrl() {
return this.url;
}
/**
* Set the JDBC username to use for connecting through the Driver.
* @see java.sql.Driver#connect(String, java.util.Properties)
*/
public void setUsername(String username) {
this.username = username;
}
/**
* Return the JDBC username to use for connecting through the Driver.
*/
public String getUsername() {
return this.username;
}
/**
* Set the JDBC password to use for connecting through the Driver.
* @see java.sql.Driver#connect(String, java.util.Properties)
*/
public void setPassword(String password) {
this.password = password;
}
/**
* Return the JDBC password to use for connecting through the Driver.
*/
public String getPassword() {
return this.password;
}
/**
* Specify arbitrary connection properties as key/value pairs,
* to be passed to the Driver.
* getConnectionFromDriver,
* using the default username and password of this DataSource.
* @see #getConnectionFromDriver(String, String)
* @see #setUsername
* @see #setPassword
*/
public Connection getConnection() throws SQLException {
return getConnectionFromDriver(getUsername(), getPassword());
}
/**
* This implementation delegates to getConnectionFromDriver,
* using the given username and password.
* @see #getConnectionFromDriver(String, String)
*/
public Connection getConnection(String username, String password) throws SQLException {
return getConnectionFromDriver(username, password);
}
/**
* Build properties for the Driver, including the given username and password (if any),
* and obtain a corresponding Connection.
* @param username the name of the user
* @param password the password to use
* @return the obtained Connection
* @throws SQLException in case of failure
* @see java.sql.Driver#connect(String, java.util.Properties)
*/
protected Connection getConnectionFromDriver(String username, String password) throws SQLException {
Properties props = new Properties(getConnectionProperties());
if (username != null) {
props.setProperty("user", username);
}
if (password != null) {
props.setProperty("password", password);
}
return getConnectionFromDriver(props);
}
/**
* Obtain a Connection using the given properties.
* null, then this method
* call effectively has no effect.
* @param dataSources said {@link Map} of {@link DataSource DataSources}
*/
public void setDataSources(Mapnull)
*/
public Mappersistence.xml files.
*
* @author Costin Leau
* @author Juergen Hoeller
* @since 2.0
* @see org.springframework.orm.jpa.persistenceunit.DefaultPersistenceUnitManager#setDataSourceLookup
*/
public interface DataSourceLookup {
/**
* Retrieve the DataSource identified by the given name.
* @param dataSourceName the name of the DataSource
* @return the DataSource (never null)
* @throws DataSourceLookupFailureException if the lookup failed
*/
DataSource getDataSource(String dataSourceName) throws DataSourceLookupFailureException;
}
././@LongLink 0000000 0000000 0000000 00000000224 00000000000 011563 L ustar root root libspring-java-3.0.6.RELEASE/projects/org.springframework.jdbc/src/main/java/org/springframework/jdbc/datasource/lookup/SingleDataSourceLookup.java libspring-java-3.0.6.RELEASE/projects/org.springframework.jdbc/src/main/java/org/springframework/jdb0000644 0001750 0001750 00000002612 11623223526 033273 0 ustar drazzib drazzib /*
* Copyright 2002-2006 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.datasource.lookup;
import javax.sql.DataSource;
import org.springframework.util.Assert;
/**
* An implementation of the DataSourceLookup that simply wraps a
* single given DataSource, returned for any data source name.
*
* @author Juergen Hoeller
* @since 2.0
*/
public class SingleDataSourceLookup implements DataSourceLookup {
private final DataSource dataSource;
/**
* Create a new instance of the {@link SingleDataSourceLookup} class.
* @param dataSource the single {@link DataSource} to wrap
*/
public SingleDataSourceLookup(DataSource dataSource) {
Assert.notNull(dataSource, "DataSource must not be null");
this.dataSource = dataSource;
}
public DataSource getDataSource(String dataSourceName) {
return this.dataSource;
}
}
././@LongLink 0000000 0000000 0000000 00000000227 00000000000 011566 L ustar root root libspring-java-3.0.6.RELEASE/projects/org.springframework.jdbc/src/main/java/org/springframework/jdbc/datasource/lookup/AbstractRoutingDataSource.java libspring-java-3.0.6.RELEASE/projects/org.springframework.jdbc/src/main/java/org/springframework/jdb0000644 0001750 0001750 00000017453 11623223526 033304 0 ustar drazzib drazzib /*
* Copyright 2002-2010 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.datasource.lookup;
import java.sql.Connection;
import java.sql.SQLException;
import java.util.HashMap;
import java.util.Map;
import javax.sql.DataSource;
import org.springframework.beans.factory.InitializingBean;
import org.springframework.jdbc.datasource.AbstractDataSource;
import org.springframework.util.Assert;
/**
* Abstract {@link javax.sql.DataSource} implementation that routes {@link #getConnection()}
* calls to one of various target DataSources based on a lookup key. The latter is usually
* (but not necessarily) determined through some thread-bound transaction context.
*
* @author Juergen Hoeller
* @since 2.0.1
* @see #setTargetDataSources
* @see #setDefaultTargetDataSource
* @see #determineCurrentLookupKey()
*/
public abstract class AbstractRoutingDataSource extends AbstractDataSource implements InitializingBean {
private Mapnull. Lookup keys without a DataSource
* entry will then lead to an IllegalStateException.
* @see #setTargetDataSources
* @see #setDefaultTargetDataSource
* @see #determineCurrentLookupKey()
*/
public void setLenientFallback(boolean lenientFallback) {
this.lenientFallback = lenientFallback;
}
/**
* Set the DataSourceLookup implementation to use for resolving data source
* name Strings in the {@link #setTargetDataSources targetDataSources} map.
* null)
* @throws IllegalArgumentException in case of an unsupported value type
*/
protected DataSource resolveSpecifiedDataSource(Object dataSource) throws IllegalArgumentException {
if (dataSource instanceof DataSource) {
return (DataSource) dataSource;
}
else if (dataSource instanceof String) {
return this.dataSourceLookup.getDataSource((String) dataSource);
}
else {
throw new IllegalArgumentException(
"Illegal data source value - only [javax.sql.DataSource] and String supported: " + dataSource);
}
}
public Connection getConnection() throws SQLException {
return determineTargetDataSource().getConnection();
}
public Connection getConnection(String username, String password) throws SQLException {
return determineTargetDataSource().getConnection(username, password);
}
/**
* Retrieve the current target DataSource. Determines the
* {@link #determineCurrentLookupKey() current lookup key}, performs
* a lookup in the {@link #setTargetDataSources targetDataSources} map,
* falls back to the specified
* {@link #setDefaultTargetDataSource default target DataSource} if necessary.
* @see #determineCurrentLookupKey()
*/
protected DataSource determineTargetDataSource() {
Assert.notNull(this.resolvedDataSources, "DataSource router not initialized");
Object lookupKey = determineCurrentLookupKey();
DataSource dataSource = this.resolvedDataSources.get(lookupKey);
if (dataSource == null && (this.lenientFallback || lookupKey == null)) {
dataSource = this.resolvedDefaultDataSource;
}
if (dataSource == null) {
throw new IllegalStateException("Cannot determine target DataSource for lookup key [" + lookupKey + "]");
}
return dataSource;
}
/**
* Resolve the given lookup key object, as specified in the
* {@link #setTargetDataSources targetDataSources} map, into
* the actual lookup key to be used for matching with the
* {@link #determineCurrentLookupKey() current lookup key}.
* javax.sql.DataSource.
*
* @author Costin Leau
* @author Juergen Hoeller
* @since 2.0
* @see org.springframework.beans.factory.BeanFactory
*/
public class BeanFactoryDataSourceLookup implements DataSourceLookup, BeanFactoryAware {
private BeanFactory beanFactory;
/**
* Create a new instance of the {@link BeanFactoryDataSourceLookup} class.
* setBeanFactory.
* @see #setBeanFactory
*/
public BeanFactoryDataSourceLookup() {
}
/**
* Create a new instance of the {@link BeanFactoryDataSourceLookup} class.
*
* <bean id="dataSourceRouter" class="org.springframework.jdbc.datasource.lookup.IsolationLevelDataSourceRouter">
* <property name="targetDataSources">
* <map>
* <entry key="ISOLATION_REPEATABLE_READ" value-ref="myRepeatableReadDataSource"/>
* <entry key="ISOLATION_SERIALIZABLE" value-ref="mySerializableDataSource"/>
* </map>
* </property>
* <property name="defaultTargetDataSource" ref="myDefaultDataSource"/>
* </bean>
*
* Alternatively, the keyed values can also be data source names, to be resolved
* through a {@link #setDataSourceLookup DataSourceLookup}: by default, JNDI
* names for a standard JNDI lookup. This allows for a single concise definition
* without the need for separate DataSource bean definitions.
*
*
* <bean id="dataSourceRouter" class="org.springframework.jdbc.datasource.lookup.IsolationLevelDataSourceRouter">
* <property name="targetDataSources">
* <map>
* <entry key="ISOLATION_REPEATABLE_READ" value="java:comp/env/jdbc/myrrds"/>
* <entry key="ISOLATION_SERIALIZABLE" value="java:comp/env/jdbc/myserds"/>
* </map>
* </property>
* <property name="defaultTargetDataSource" value="java:comp/env/jdbc/mydefds"/>
* </bean>
*
* Note: If you are using this router in combination with Spring's
* {@link org.springframework.transaction.jta.JtaTransactionManager},
* don't forget to switch the "allowCustomIsolationLevels" flag to "true".
* (By default, JtaTransactionManager will only accept a default isolation level
* because of the lack of isolation level support in standard JTA itself.)
*
*
* <bean id="transactionManager" class="org.springframework.transaction.jta.JtaTransactionManager">
* <property name="allowCustomIsolationLevels" value="true"/>
* </bean>
*
* @author Juergen Hoeller
* @since 2.0.1
* @see #setTargetDataSources
* @see #setDefaultTargetDataSource
* @see org.springframework.transaction.TransactionDefinition#ISOLATION_READ_UNCOMMITTED
* @see org.springframework.transaction.TransactionDefinition#ISOLATION_READ_COMMITTED
* @see org.springframework.transaction.TransactionDefinition#ISOLATION_REPEATABLE_READ
* @see org.springframework.transaction.TransactionDefinition#ISOLATION_SERIALIZABLE
* @see org.springframework.transaction.jta.JtaTransactionManager
*/
public class IsolationLevelDataSourceRouter extends AbstractRoutingDataSource {
/** Constants instance for TransactionDefinition */
private static final Constants constants = new Constants(TransactionDefinition.class);
/**
* Supports Integer values for the isolation level constants
* as well as isolation level names as defined on the
* {@link org.springframework.transaction.TransactionDefinition TransactionDefinition interface}.
*/
@Override
protected Object resolveSpecifiedLookupKey(Object lookupKey) {
if (lookupKey instanceof Integer) {
return lookupKey;
}
else if (lookupKey instanceof String) {
String constantName = (String) lookupKey;
if (!constantName.startsWith(DefaultTransactionDefinition.PREFIX_ISOLATION)) {
throw new IllegalArgumentException("Only isolation constants allowed");
}
return constants.asNumber(constantName);
}
else {
throw new IllegalArgumentException(
"Invalid lookup key - needs to be isolation level Integer or isolation level name String: " + lookupKey);
}
}
@Override
protected Object determineCurrentLookupKey() {
return TransactionSynchronizationManager.getCurrentTransactionIsolationLevel();
}
}
././@LongLink 0000000 0000000 0000000 00000000222 00000000000 011561 L ustar root root libspring-java-3.0.6.RELEASE/projects/org.springframework.jdbc/src/main/java/org/springframework/jdbc/datasource/lookup/JndiDataSourceLookup.java libspring-java-3.0.6.RELEASE/projects/org.springframework.jdbc/src/main/java/org/springframework/jdb0000644 0001750 0001750 00000003065 11623223526 033276 0 ustar drazzib drazzib /*
* Copyright 2002-2009 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.datasource.lookup;
import javax.naming.NamingException;
import javax.sql.DataSource;
import org.springframework.jndi.JndiLocatorSupport;
/**
* JNDI-based {@link DataSourceLookup} implementation.
*
* getConnection call. Also applies the read-only flag,
* if specified.
*
* null if none.
*/
protected Integer getIsolationLevel() {
return this.isolationLevel;
}
/**
* Applies the current isolation level value and read-only flag
* to the returned Connection.
* @see #getCurrentIsolationLevel()
* @see #getCurrentReadOnlyFlag()
*/
@Override
protected Connection doGetConnection(String username, String password) throws SQLException {
Connection con = super.doGetConnection(username, password);
Boolean readOnlyToUse = getCurrentReadOnlyFlag();
if (readOnlyToUse != null) {
con.setReadOnly(readOnlyToUse);
}
Integer isolationLevelToUse = getCurrentIsolationLevel();
if (isolationLevelToUse != null) {
con.setTransactionIsolation(isolationLevelToUse);
}
return con;
}
/**
* Determine the current isolation level: either the transaction's
* isolation level or a statically defined isolation level.
* @return the current isolation level, or null if none
* @see org.springframework.transaction.support.TransactionSynchronizationManager#getCurrentTransactionIsolationLevel()
* @see #setIsolationLevel
*/
protected Integer getCurrentIsolationLevel() {
Integer isolationLevelToUse = TransactionSynchronizationManager.getCurrentTransactionIsolationLevel();
if (isolationLevelToUse == null) {
isolationLevelToUse = getIsolationLevel();
}
return isolationLevelToUse;
}
/**
* Determine the current read-only flag: by default,
* the transaction's read-only hint.
* @return whether there is a read-only hint for the current scope
* @see org.springframework.transaction.support.TransactionSynchronizationManager#isCurrentTransactionReadOnly()
*/
protected Boolean getCurrentReadOnlyFlag() {
boolean txReadOnly = TransactionSynchronizationManager.isCurrentTransactionReadOnly();
return (txReadOnly ? Boolean.TRUE : null);
}
}
././@LongLink 0000000 0000000 0000000 00000000227 00000000000 011566 L ustar root root libspring-java-3.0.6.RELEASE/projects/org.springframework.jdbc/src/main/java/org/springframework/jdbc/datasource/UserCredentialsDataSourceAdapter.java libspring-java-3.0.6.RELEASE/projects/org.springframework.jdbc/src/main/java/org/springframework/jdb0000644 0001750 0001750 00000015512 11623223526 033276 0 ustar drazzib drazzib /*
* Copyright 2002-2010 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.datasource;
import java.sql.Connection;
import java.sql.SQLException;
import org.springframework.core.NamedThreadLocal;
import org.springframework.util.Assert;
import org.springframework.util.StringUtils;
/**
* An adapter for a target JDBC {@link javax.sql.DataSource}, applying the specified
* user credentials to every standard getConnection() call, implicitly
* invoking getConnection(username, password) on the target.
* All other methods simply delegate to the corresponding methods of the
* target DataSource.
*
* getConnection() call.
*
*
* <bean id="myTargetDataSource" class="org.springframework.jndi.JndiObjectFactoryBean">
* <property name="jndiName" value="java:comp/env/jdbc/myds"/>
* </bean>
*
* <bean id="myDataSource" class="org.springframework.jdbc.datasource.UserCredentialsDataSourceAdapter">
* <property name="targetDataSource" ref="myTargetDataSource"/>
* <property name="username" value="myusername"/>
* <property name="password" value="mypassword"/>
* </bean>
*
* getConnection() method of the target DataSource.
* This can be used to keep a UserCredentialsDataSourceAdapter bean definition
* just for the option of implicitly passing in user credentials if
* the particular target DataSource requires it.
*
* @author Juergen Hoeller
* @since 1.0.2
* @see #getConnection
*/
public class UserCredentialsDataSourceAdapter extends DelegatingDataSource {
private String username;
private String password;
private final ThreadLocalgetConnection() calls on this DataSource proxy.
* getConnection(username, password)
* method of the target DataSource, passing in the specified user credentials.
* If the specified username is empty, it will simply delegate to the standard
* getConnection() method of the target DataSource.
* @param username the username to use
* @param password the password to use
* @return the Connection
* @see javax.sql.DataSource#getConnection(String, String)
* @see javax.sql.DataSource#getConnection()
*/
protected Connection doGetConnection(String username, String password) throws SQLException {
Assert.state(getTargetDataSource() != null, "'targetDataSource' is required");
if (StringUtils.hasLength(username)) {
return getTargetDataSource().getConnection(username, password);
}
else {
return getTargetDataSource().getConnection();
}
}
/**
* Inner class used as ThreadLocal value.
*/
private static class JdbcUserCredentials {
public final String username;
public final String password;
private JdbcUserCredentials(String username, String password) {
this.username = username;
this.password = password;
}
@Override
public String toString() {
return "JdbcUserCredentials[username='" + this.username + "',password='" + this.password + "']";
}
}
}
././@LongLink 0000000 0000000 0000000 00000000207 00000000000 011564 L ustar root root libspring-java-3.0.6.RELEASE/projects/org.springframework.jdbc/src/main/java/org/springframework/jdbc/datasource/ConnectionHandle.java libspring-java-3.0.6.RELEASE/projects/org.springframework.jdbc/src/main/java/org/springframework/jdb0000644 0001750 0001750 00000002371 11623223530 033270 0 ustar drazzib drazzib /*
* Copyright 2002-2005 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.datasource;
import java.sql.Connection;
/**
* Simple interface to be implemented by handles for a JDBC Connection.
* Used by JdoDialect, for example.
*
* @author Juergen Hoeller
* @since 1.1
* @see SimpleConnectionHandle
* @see ConnectionHolder
* @see org.springframework.orm.jdo.JdoDialect#getJdbcConnection
*/
public interface ConnectionHandle {
/**
* Fetch the JDBC Connection that this handle refers to.
*/
Connection getConnection();
/**
* Release the JDBC Connection that this handle refers to.
* @param con the JDBC Connection to release
*/
void releaseConnection(Connection con);
}
././@LongLink 0000000 0000000 0000000 00000000167 00000000000 011571 L ustar root root libspring-java-3.0.6.RELEASE/projects/org.springframework.jdbc/src/main/java/org/springframework/jdbc/datasource/init/ libspring-java-3.0.6.RELEASE/projects/org.springframework.jdbc/src/main/java/org/springframework/jdb0000755 0001750 0001750 00000000000 11623223530 033263 5 ustar drazzib drazzib ././@LongLink 0000000 0000000 0000000 00000000225 00000000000 011564 L ustar root root libspring-java-3.0.6.RELEASE/projects/org.springframework.jdbc/src/main/java/org/springframework/jdbc/datasource/init/CannotReadScriptException.java libspring-java-3.0.6.RELEASE/projects/org.springframework.jdbc/src/main/java/org/springframework/jdb0000644 0001750 0001750 00000002420 11623223526 033270 0 ustar drazzib drazzib /*
* Copyright 2002-2009 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.datasource.init;
import org.springframework.core.io.support.EncodedResource;
/**
* Thrown by {@link ResourceDatabasePopulator} if one of its SQL scripts could
* not be read during population.
*
* @author Keith Donald
* @since 3.0
*/
public class CannotReadScriptException extends RuntimeException {
/**
* Constructor a new CannotReadScriptException.
* @param resource the resource that could not be read from
* @param cause the underlying cause of the resource access failure
*/
public CannotReadScriptException(EncodedResource resource, Throwable cause) {
super("Cannot read SQL script from " + resource, cause);
}
}
././@LongLink 0000000 0000000 0000000 00000000210 00000000000 011556 L ustar root root libspring-java-3.0.6.RELEASE/projects/org.springframework.jdbc/src/main/java/org/springframework/jdbc/datasource/init/package-info.java libspring-java-3.0.6.RELEASE/projects/org.springframework.jdbc/src/main/java/org/springframework/jdb0000644 0001750 0001750 00000000225 11623223526 033271 0 ustar drazzib drazzib
/**
*
* Provides extensible support for initializing databases through scripts.
*
*/
package org.springframework.jdbc.datasource.init;
././@LongLink 0000000 0000000 0000000 00000000221 00000000000 011560 L ustar root root libspring-java-3.0.6.RELEASE/projects/org.springframework.jdbc/src/main/java/org/springframework/jdbc/datasource/init/DataSourceInitializer.java libspring-java-3.0.6.RELEASE/projects/org.springframework.jdbc/src/main/java/org/springframework/jdb0000644 0001750 0001750 00000005172 11623223530 033272 0 ustar drazzib drazzib /*
* Copyright 2002-2010 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.datasource.init;
import java.sql.Connection;
import java.sql.SQLException;
import javax.sql.DataSource;
import org.springframework.beans.factory.InitializingBean;
import org.springframework.dao.DataAccessResourceFailureException;
import org.springframework.util.Assert;
/**
* Used to populate a database during initialization.
*
* @author Dave Syer
* @since 3.0
* @see DatabasePopulator
*/
public class DataSourceInitializer implements InitializingBean {
private DataSource dataSource;
private DatabasePopulator databasePopulator;
private boolean enabled = true;
/**
* The {@link DataSource} to populate when this component is initialized.
* Mandatory with no default.
* @param dataSource the DataSource
*/
public void setDataSource(DataSource dataSource) {
this.dataSource = dataSource;
}
/**
* The {@link DatabasePopulator} to use to populate the data source.
* Mandatory with no default.
* @param databasePopulator the database populator to use.
*/
public void setDatabasePopulator(DatabasePopulator databasePopulator) {
this.databasePopulator = databasePopulator;
}
/**
* Flag to explicitly enable or disable the database populator.
* @param enabled true if the database populator will be called on startup
*/
public void setEnabled(boolean enabled) {
this.enabled = enabled;
}
/**
* Use the populator to set up data in the data source.
*/
public void afterPropertiesSet() throws Exception {
if (this.enabled) {
Assert.state(this.dataSource != null, "DataSource must be provided");
Assert.state(this.databasePopulator != null, "DatabasePopulator must be provided");
try {
Connection connection = this.dataSource.getConnection();
try {
this.databasePopulator.populate(connection);
}
finally {
try {
connection.close();
}
catch (SQLException ex) {
// ignore
}
}
}
catch (Exception ex) {
throw new DataAccessResourceFailureException("Failed to populate database", ex);
}
}
}
}
././@LongLink 0000000 0000000 0000000 00000000225 00000000000 011564 L ustar root root libspring-java-3.0.6.RELEASE/projects/org.springframework.jdbc/src/main/java/org/springframework/jdbc/datasource/init/ResourceDatabasePopulator.java libspring-java-3.0.6.RELEASE/projects/org.springframework.jdbc/src/main/java/org/springframework/jdb0000644 0001750 0001750 00000021412 11623223526 033272 0 ustar drazzib drazzib /*
* Copyright 2002-2010 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.datasource.init;
import java.io.IOException;
import java.io.LineNumberReader;
import java.sql.Connection;
import java.sql.SQLException;
import java.sql.Statement;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.LinkedList;
import java.util.List;
import org.apache.commons.logging.Log;
import org.apache.commons.logging.LogFactory;
import org.springframework.core.io.Resource;
import org.springframework.core.io.support.EncodedResource;
import org.springframework.util.StringUtils;
/**
* Populates a database from SQL scripts defined in external resources.
*
* DROP statement can be ignored.
* IF EXISTS clause in a DROP. The default is false so that if the
* populator runs accidentally, it will fail fast when the script starts with a DROP.
*/
public void setIgnoreFailedDrops(boolean ignoreFailedDrops) {
this.ignoreFailedDrops = ignoreFailedDrops;
}
public void populate(Connection connection) throws SQLException {
for (Resource script : this.scripts) {
executeSqlScript(connection, applyEncodingIfNecessary(script), this.continueOnError, this.ignoreFailedDrops);
}
}
private EncodedResource applyEncodingIfNecessary(Resource script) {
if (script instanceof EncodedResource) {
return (EncodedResource) script;
}
else {
return new EncodedResource(script, this.sqlScriptEncoding);
}
}
/**
* Execute the given SQL script.
* DROP
*/
private void executeSqlScript(Connection connection, EncodedResource resource,
boolean continueOnError, boolean ignoreFailedDrops) throws SQLException {
if (logger.isInfoEnabled()) {
logger.info("Executing SQL script from " + resource);
}
long startTime = System.currentTimeMillis();
ListString containing the script lines
* @throws IOException in case of I/O errors
*/
private String readScript(EncodedResource resource) throws IOException {
LineNumberReader lnr = new LineNumberReader(resource.getReader());
String currentStatement = lnr.readLine();
StringBuilder scriptBuilder = new StringBuilder();
while (currentStatement != null) {
if (StringUtils.hasText(currentStatement) &&
(this.commentPrefix != null && !currentStatement.startsWith(this.commentPrefix))) {
if (scriptBuilder.length() > 0) {
scriptBuilder.append('\n');
}
scriptBuilder.append(currentStatement);
}
currentStatement = lnr.readLine();
}
return scriptBuilder.toString();
}
/**
* Does the provided SQL script contain the specified delimiter?
* @param script the SQL script
* @param delim character delimiting each statement - typically a ';' character
*/
private boolean containsSqlScriptDelimiters(String script, char delim) {
boolean inLiteral = false;
char[] content = script.toCharArray();
for (int i = 0; i < script.length(); i++) {
if (content[i] == '\'') {
inLiteral = !inLiteral;
}
if (content[i] == delim && !inLiteral) {
return true;
}
}
return false;
}
/**
* Split an SQL script into separate statements delimited with the provided delimiter character.
* Each individual statement will be added to the provided List.
* @param script the SQL script
* @param delim character delimiting each statement (typically a ';' character)
* @param statements the List that will contain the individual statements
*/
private void splitSqlScript(String script, char delim, ListgetConnection call.
*
* Connection.close() calls will
* simply close the Connection, so any DataSource-aware persistence code should work.
*
*
* <bean id="myDataSource" class="org.springframework.jdbc.datasource.WebSphereDataSourceAdapter">
* <property name="targetDataSource">
* <bean class="org.springframework.jndi.JndiObjectFactoryBean">
* <property name="jndiName" value="jdbc/myds"/>
* </bean>
* </property>
* </bean>
*
* Thanks to Ricardo Olivieri for submitting the original implementation
* of this approach!
*
* @author Juergen Hoeller
* @author Lari Hotari
* @author Ricardo N. Olivieri
* @since 2.0.3
* @see com.ibm.websphere.rsadapter.JDBCConnectionSpec
* @see com.ibm.websphere.rsadapter.WSDataSource#getConnection(com.ibm.websphere.rsadapter.JDBCConnectionSpec)
* @see org.springframework.transaction.support.TransactionSynchronizationManager#getCurrentTransactionIsolationLevel()
* @see org.springframework.transaction.support.TransactionSynchronizationManager#isCurrentTransactionReadOnly()
*/
public class WebSphereDataSourceAdapter extends IsolationLevelDataSourceAdapter {
protected final Log logger = LogFactory.getLog(getClass());
private Class wsDataSourceClass;
private Method newJdbcConnSpecMethod;
private Method wsDataSourceGetConnectionMethod;
private Method setTransactionIsolationMethod;
private Method setReadOnlyMethod;
private Method setUserNameMethod;
private Method setPasswordMethod;
/**
* This constructor retrieves the WebSphere JDBC connection spec API,
* so we can get obtain specific WebSphere Connections using reflection.
*/
public WebSphereDataSourceAdapter() {
try {
this.wsDataSourceClass = getClass().getClassLoader().loadClass("com.ibm.websphere.rsadapter.WSDataSource");
Class jdbcConnSpecClass = getClass().getClassLoader().loadClass("com.ibm.websphere.rsadapter.JDBCConnectionSpec");
Class wsrraFactoryClass = getClass().getClassLoader().loadClass("com.ibm.websphere.rsadapter.WSRRAFactory");
this.newJdbcConnSpecMethod = wsrraFactoryClass.getMethod("createJDBCConnectionSpec", (Class[]) null);
this.wsDataSourceGetConnectionMethod =
this.wsDataSourceClass.getMethod("getConnection", new Class[] {jdbcConnSpecClass});
this.setTransactionIsolationMethod =
jdbcConnSpecClass.getMethod("setTransactionIsolation", new Class[] {int.class});
this.setReadOnlyMethod = jdbcConnSpecClass.getMethod("setReadOnly", new Class[] {Boolean.class});
this.setUserNameMethod = jdbcConnSpecClass.getMethod("setUserName", new Class[] {String.class});
this.setPasswordMethod = jdbcConnSpecClass.getMethod("setPassword", new Class[] {String.class});
}
catch (Exception ex) {
throw new IllegalStateException(
"Could not initialize WebSphereDataSourceAdapter because WebSphere API classes are not available: " + ex);
}
}
/**
* Checks that the specified 'targetDataSource' actually is
* a WebSphere WSDataSource.
*/
@Override
public void afterPropertiesSet() {
super.afterPropertiesSet();
if (!this.wsDataSourceClass.isInstance(getTargetDataSource())) {
throw new IllegalStateException(
"Specified 'targetDataSource' is not a WebSphere WSDataSource: " + getTargetDataSource());
}
}
/**
* Builds a WebSphere JDBCConnectionSpec object for the current settings
* and calls WSDataSource.getConnection(JDBCConnectionSpec).
* @see #createConnectionSpec
* @see com.ibm.websphere.rsadapter.WSDataSource#getConnection(com.ibm.websphere.rsadapter.JDBCConnectionSpec)
*/
@Override
protected Connection doGetConnection(String username, String password) throws SQLException {
// Create JDBCConnectionSpec using current isolation level value and read-only flag.
Object connSpec = createConnectionSpec(
getCurrentIsolationLevel(), getCurrentReadOnlyFlag(), username, password);
if (logger.isDebugEnabled()) {
logger.debug("Obtaining JDBC Connection from WebSphere DataSource [" +
getTargetDataSource() + "], using ConnectionSpec [" + connSpec + "]");
}
// Create Connection through invoking WSDataSource.getConnection(JDBCConnectionSpec)
return (Connection) ReflectionUtils.invokeJdbcMethod(
this.wsDataSourceGetConnectionMethod, getTargetDataSource(), new Object[] {connSpec});
}
/**
* Create a WebSphere JDBCConnectionSpec object for the given charateristics.
* null if none)
* @param readOnlyFlag the read-only flag to apply (or null if none)
* @param username the username to apply (null or empty indicates the default)
* @param password the password to apply (may be null or empty)
* @throws SQLException if thrown by JDBCConnectionSpec API methods
* @see com.ibm.websphere.rsadapter.JDBCConnectionSpec
*/
protected Object createConnectionSpec(
Integer isolationLevel, Boolean readOnlyFlag, String username, String password) throws SQLException {
Object connSpec = ReflectionUtils.invokeJdbcMethod(this.newJdbcConnSpecMethod, null);
if (isolationLevel != null) {
ReflectionUtils.invokeJdbcMethod(this.setTransactionIsolationMethod, connSpec, new Object[] {isolationLevel});
}
if (readOnlyFlag != null) {
ReflectionUtils.invokeJdbcMethod(this.setReadOnlyMethod, connSpec, new Object[] {readOnlyFlag});
}
// If the username is empty, we'll simply let the target DataSource
// use its default credentials.
if (StringUtils.hasLength(username)) {
ReflectionUtils.invokeJdbcMethod(this.setUserNameMethod, connSpec, new Object[] {username});
ReflectionUtils.invokeJdbcMethod(this.setPasswordMethod, connSpec, new Object[] {password});
}
return connSpec;
}
}
././@LongLink 0000000 0000000 0000000 00000000215 00000000000 011563 L ustar root root libspring-java-3.0.6.RELEASE/projects/org.springframework.jdbc/src/main/java/org/springframework/jdbc/datasource/SimpleDriverDataSource.java libspring-java-3.0.6.RELEASE/projects/org.springframework.jdbc/src/main/java/org/springframework/jdb0000644 0001750 0001750 00000011476 11623223530 033276 0 ustar drazzib drazzib /*
* Copyright 2002-2009 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.datasource;
import java.sql.Connection;
import java.sql.Driver;
import java.sql.SQLException;
import java.util.Properties;
import org.springframework.beans.BeanUtils;
import org.springframework.util.Assert;
/**
* Simple implementation of the standard JDBC {@link javax.sql.DataSource} interface,
* configuring a plain old JDBC {@link java.sql.Driver} via bean properties, and returning
* a new {@link java.sql.Connection} from every getConnection call.
*
* DataSource interface, such as
* {@link #getLoginTimeout()}, {@link #setLoginTimeout(int)}, and so forth.
*
* @author Juergen Hoeller
* @since 07.05.2003
* @see DriverManagerDataSource
*/
public abstract class AbstractDataSource implements DataSource {
/** Logger available to subclasses */
protected final Log logger = LogFactory.getLog(getClass());
/**
* Returns 0, indicating the default system timeout is to be used.
*/
public int getLoginTimeout() throws SQLException {
return 0;
}
/**
* Setting a login timeout is not supported.
*/
public void setLoginTimeout(int timeout) throws SQLException {
throw new UnsupportedOperationException("setLoginTimeout");
}
/**
* LogWriter methods are not supported.
*/
public PrintWriter getLogWriter() {
throw new UnsupportedOperationException("getLogWriter");
}
/**
* LogWriter methods are not supported.
*/
public void setLogWriter(PrintWriter pw) throws SQLException {
throw new UnsupportedOperationException("setLogWriter");
}
//---------------------------------------------------------------------
// Implementation of JDBC 4.0's Wrapper interface
//---------------------------------------------------------------------
@SuppressWarnings("unchecked")
public null.
* null
* argument) and setting a fresh Connection on resume.
*/
protected void setConnection(Connection connection) {
if (this.currentConnection != null) {
this.connectionHandle.releaseConnection(this.currentConnection);
this.currentConnection = null;
}
if (connection != null) {
this.connectionHandle = new SimpleConnectionHandle(connection);
}
else {
this.connectionHandle = null;
}
}
/**
* Return the current Connection held by this ConnectionHolder.
* released
* gets called on the ConnectionHolder, which will reset the
* held Connection, fetching a new Connection on demand.
* @see ConnectionHandle#getConnection()
* @see #released()
*/
public Connection getConnection() {
Assert.notNull(this.connectionHandle, "Active Connection is required");
if (this.currentConnection == null) {
this.currentConnection = this.connectionHandle.getConnection();
}
return this.currentConnection;
}
/**
* Return whether JDBC 3.0 Savepoints are supported.
* Caches the flag for the lifetime of this ConnectionHolder.
* @throws SQLException if thrown by the JDBC driver
*/
public boolean supportsSavepoints() throws SQLException {
if (this.savepointsSupported == null) {
this.savepointsSupported = new Boolean(getConnection().getMetaData().supportsSavepoints());
}
return this.savepointsSupported.booleanValue();
}
/**
* Create a new JDBC 3.0 Savepoint for the current Connection,
* using generated savepoint names that are unique for the Connection.
* @return the new Savepoint
* @throws SQLException if thrown by the JDBC driver
*/
public Savepoint createSavepoint() throws SQLException {
this.savepointCounter++;
return getConnection().setSavepoint(SAVEPOINT_NAME_PREFIX + this.savepointCounter);
}
/**
* Releases the current Connection held by this ConnectionHolder.
* getConnection calls and close calls on returned Connections
* will behave properly within a transaction, i.e. always operate on the transactional
* Connection. If not within a transaction, normal DataSource behavior applies.
*
* close() calls to DataSourceUtils.
* @param targetDataSource DataSource that the Connection came from
* @return the wrapped Connection
* @see java.sql.Connection#close()
* @see DataSourceUtils#doReleaseConnection
*/
protected Connection getTransactionAwareConnectionProxy(DataSource targetDataSource) {
return (Connection) Proxy.newProxyInstance(
ConnectionProxy.class.getClassLoader(),
new Class[] {ConnectionProxy.class},
new TransactionAwareInvocationHandler(targetDataSource));
}
/**
* Determine whether to obtain a fixed target Connection for the proxy
* or to reobtain the target Connection for each operation.
* true for all
* standard cases. This can be overridden through the
* {@link #setReobtainTransactionalConnections "reobtainTransactionalConnections"}
* flag, which enforces a non-fixed target Connection within an active transaction.
* Note that non-transactional access will always use a fixed Connection.
* @param targetDataSource the target DataSource
*/
protected boolean shouldObtainFixedConnection(DataSource targetDataSource) {
return (!TransactionSynchronizationManager.isSynchronizationActive() ||
!this.reobtainTransactionalConnections);
}
/**
* Invocation handler that delegates close calls on JDBC Connections
* to DataSourceUtils for being aware of thread-bound transactions.
*/
private class TransactionAwareInvocationHandler implements InvocationHandler {
private final DataSource targetDataSource;
private Connection target;
private boolean closed = false;
public TransactionAwareInvocationHandler(DataSource targetDataSource) {
this.targetDataSource = targetDataSource;
}
public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
// Invocation on ConnectionProxy interface coming in...
if (method.getName().equals("equals")) {
// Only considered as equal when proxies are identical.
return (proxy == args[0]);
}
else if (method.getName().equals("hashCode")) {
// Use hashCode of Connection proxy.
return System.identityHashCode(proxy);
}
else if (method.getName().equals("toString")) {
// Allow for differentiating between the proxy and the raw Connection.
StringBuilder sb = new StringBuilder("Transaction-aware proxy for target Connection ");
if (this.target != null) {
sb.append("[").append(this.target.toString()).append("]");
}
else {
sb.append(" from DataSource [").append(this.targetDataSource).append("]");
}
return sb.toString();
}
else if (method.getName().equals("unwrap")) {
if (((Class) args[0]).isInstance(proxy)) {
return proxy;
}
}
else if (method.getName().equals("isWrapperFor")) {
if (((Class) args[0]).isInstance(proxy)) {
return true;
}
}
else if (method.getName().equals("close")) {
// Handle close method: only close if not within a transaction.
DataSourceUtils.doReleaseConnection(this.target, this.targetDataSource);
this.closed = true;
return null;
}
else if (method.getName().equals("isClosed")) {
return this.closed;
}
if (this.target == null) {
if (this.closed) {
throw new SQLException("Connection handle already closed");
}
if (shouldObtainFixedConnection(this.targetDataSource)) {
this.target = DataSourceUtils.doGetConnection(this.targetDataSource);
}
}
Connection actualTarget = this.target;
if (actualTarget == null) {
actualTarget = DataSourceUtils.doGetConnection(this.targetDataSource);
}
if (method.getName().equals("getTargetConnection")) {
// Handle getTargetConnection method: return underlying Connection.
return actualTarget;
}
// Invoke method on target Connection.
try {
Object retVal = method.invoke(actualTarget, args);
// If return value is a Statement, apply transaction timeout.
// Applies to createStatement, prepareStatement, prepareCall.
if (retVal instanceof Statement) {
DataSourceUtils.applyTransactionTimeout((Statement) retVal, this.targetDataSource);
}
return retVal;
}
catch (InvocationTargetException ex) {
throw ex.getTargetException();
}
finally {
if (actualTarget != this.target) {
DataSourceUtils.doReleaseConnection(actualTarget, this.targetDataSource);
}
}
}
}
}
././@LongLink 0000000 0000000 0000000 00000000206 00000000000 011563 L ustar root root libspring-java-3.0.6.RELEASE/projects/org.springframework.jdbc/src/main/java/org/springframework/jdbc/datasource/ConnectionProxy.java libspring-java-3.0.6.RELEASE/projects/org.springframework.jdbc/src/main/java/org/springframework/jdb0000644 0001750 0001750 00000003232 11623223530 033265 0 ustar drazzib drazzib /*
* Copyright 2002-2008 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.datasource;
import java.sql.Connection;
/**
* Subinterface of {@link java.sql.Connection} to be implemented by
* Connection proxies. Allows access to the underlying target Connection.
*
* null)
*/
Connection getTargetConnection();
}
././@LongLink 0000000 0000000 0000000 00000000213 00000000000 011561 L ustar root root libspring-java-3.0.6.RELEASE/projects/org.springframework.jdbc/src/main/java/org/springframework/jdbc/datasource/DelegatingDataSource.java libspring-java-3.0.6.RELEASE/projects/org.springframework.jdbc/src/main/java/org/springframework/jdb0000644 0001750 0001750 00000006644 11623223526 033304 0 ustar drazzib drazzib /*
* Copyright 2002-2008 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.datasource;
import java.io.PrintWriter;
import java.sql.Connection;
import java.sql.SQLException;
import javax.sql.DataSource;
import org.springframework.beans.factory.InitializingBean;
import org.springframework.util.Assert;
/**
* JDBC {@link javax.sql.DataSource} implementation that delegates all calls
* to a given target {@link javax.sql.DataSource}.
*
* javax.sql.DataSource
* as its Connection factory mechanism. Binds a JDBC Connection from the specified
* DataSource to the current thread, potentially allowing for one thread-bound
* Connection per DataSource.
*
* org.springframework.jdbc.core package.
* Exceptions thrown are as in the org.springframework.dao package,
* meaning that code using this package does not need to implement JDBC or
* RDBMS-specific error handling.
*
* compile method and using this object.
* @see #setDataSource
* @see #setSql
* @see #compile
*/
public SqlCall() {
}
/**
* Create a new SqlCall object with SQL, but without parameters.
* Must add parameters or settle with none.
* @param ds DataSource to obtain connections from
* @param sql SQL to execute
*/
public SqlCall(DataSource ds, String sql) {
setDataSource(ds);
setSql(sql);
}
/**
* Set whether this call is for a function.
*/
public void setFunction(boolean function) {
this.function = function;
}
/**
* Return whether this call is for a function.
*/
public boolean isFunction() {
return function;
}
/**
* Set whether the SQL can be used as is.
*/
public void setSqlReadyForUse(boolean sqlReadyForUse) {
this.sqlReadyForUse = sqlReadyForUse;
}
/**
* Return whether the SQL can be used as is.
*/
public boolean isSqlReadyForUse() {
return sqlReadyForUse;
}
/**
* Overridden method to configure the CallableStatementCreatorFactory
* based on our declared parameters.
* @see RdbmsOperation#compileInternal()
*/
@Override
protected final void compileInternal() {
if (isSqlReadyForUse()) {
this.callString = getSql();
}
else {
Listnull.
*/
protected CallableStatementCreator newCallableStatementCreator(Mapnull.
*/
protected CallableStatementCreator newCallableStatementCreator(ParameterMapper inParamMapper) {
return this.callableStatementFactory.newCallableStatementCreator(inParamMapper);
}
}
././@LongLink 0000000 0000000 0000000 00000000211 00000000000 011557 L ustar root root libspring-java-3.0.6.RELEASE/projects/org.springframework.jdbc/src/main/java/org/springframework/jdbc/object/GenericStoredProcedure.java libspring-java-3.0.6.RELEASE/projects/org.springframework.jdbc/src/main/java/org/springframework/jdb0000644 0001750 0001750 00000002345 11623223530 033271 0 ustar drazzib drazzib /*
* Copyright 2002-2009 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.object;
/**
* Concrete implementation making it possible to define the RDBMS stored procedures
* in an application context without writing a custom Java implementation class.
* org.springframework.jdbc.core package, which the classes
* in this package use under the hood to perform raw JDBC operations).
*
* execute or update
* method can then be invoked.
*
* @author Rod Johnson
* @author Juergen Hoeller
* @see SqlQuery
* @see SqlUpdate
* @see StoredProcedure
* @see org.springframework.jdbc.core.JdbcTemplate
*/
public abstract class RdbmsOperation implements InitializingBean {
/** Logger available to subclasses */
protected final Log logger = LogFactory.getLog(getClass());
/** Lower-level class used to execute SQL */
private JdbcTemplate jdbcTemplate = new JdbcTemplate();
private int resultSetType = ResultSet.TYPE_FORWARD_ONLY;
private boolean updatableResults = false;
private boolean returnGeneratedKeys = false;
private String[] generatedKeysColumnNames = null;
private String sql;
private final Listjava.sql.Types class.
* java.sql.Types class
* @throws InvalidDataAccessApiUsageException if the operation is already compiled
*/
public void setTypes(int[] types) throws InvalidDataAccessApiUsageException {
if (isCompiled()) {
throw new InvalidDataAccessApiUsageException("Cannot add parameters once query is compiled");
}
if (types != null) {
for (int type : types) {
declareParameter(new SqlParameter(type));
}
}
}
/**
* Declare a parameter for this operation.
* validateParameters.
* @see #validateParameters
*/
protected void checkCompiled() {
if (!isCompiled()) {
logger.debug("SQL operation not compiled before execution - invoking compile");
compile();
}
}
/**
* Validate the parameters passed to an execute method based on declared parameters.
* Subclasses should invoke this method before every executeQuery()
* or update() method.
* @param parameters parameters supplied (may be null)
* @throws InvalidDataAccessApiUsageException if the parameters are invalid
*/
protected void validateParameters(Object[] parameters) throws InvalidDataAccessApiUsageException {
checkCompiled();
int declaredInParameters = 0;
for (SqlParameter param : this.declaredParameters) {
if (param.isInputValueProvided()) {
if (!supportsLobParameters() &&
(param.getSqlType() == Types.BLOB || param.getSqlType() == Types.CLOB)) {
throw new InvalidDataAccessApiUsageException(
"BLOB or CLOB parameters are not allowed for this kind of operation");
}
declaredInParameters++;
}
}
validateParameterCount((parameters != null ? parameters.length : 0), declaredInParameters);
}
/**
* Validate the named parameters passed to an execute method based on declared parameters.
* Subclasses should invoke this method before every executeQuery() or
* update() method.
* @param parameters parameter Map supplied. May be null.
* @throws InvalidDataAccessApiUsageException if the parameters are invalid
*/
protected void validateNamedParameters(Maptrue.
*/
protected boolean supportsLobParameters() {
return true;
}
/**
* Return whether this operation accepts additional parameters that are
* given but not actually used. Applies in particular to parameter Maps.
* false.
* @see StoredProcedure
*/
protected boolean allowsUnusedParameters() {
return false;
}
}
././@LongLink 0000000 0000000 0000000 00000000176 00000000000 011571 L ustar root root libspring-java-3.0.6.RELEASE/projects/org.springframework.jdbc/src/main/java/org/springframework/jdbc/object/SqlFunction.java libspring-java-3.0.6.RELEASE/projects/org.springframework.jdbc/src/main/java/org/springframework/jdb0000644 0001750 0001750 00000014224 11623223526 033275 0 ustar drazzib drazzib /*
* Copyright 2002-2008 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.object;
import java.sql.ResultSet;
import java.sql.SQLException;
import javax.sql.DataSource;
import org.springframework.dao.TypeMismatchDataAccessException;
import org.springframework.jdbc.core.SingleColumnRowMapper;
/**
* SQL "function" wrapper for a query that returns a single row of results.
* The default behavior is to return an int, but that can be overridden by
* using the constructor with an extra return type parameter.
*
* run method
* repeatedly to execute the function. Subclasses are only supposed to add
* specialized run methods for specific parameter and return types.
*
* compile method and using this object.
* @see #setDataSource
* @see #setSql
* @see #compile
*/
public SqlFunction() {
setRowsExpected(1);
}
/**
* Create a new SqlFunction object with SQL, but without parameters.
* Must add parameters or settle with none.
* @param ds DataSource to obtain connections from
* @param sql SQL to execute
*/
public SqlFunction(DataSource ds, String sql) {
setRowsExpected(1);
setDataSource(ds);
setSql(sql);
}
/**
* Create a new SqlFunction object with SQL and parameters.
* @param ds DataSource to obtain connections from
* @param sql SQL to execute
* @param types SQL types of the parameters, as defined in the
* java.sql.Types class
* @see java.sql.Types
*/
public SqlFunction(DataSource ds, String sql, int[] types) {
setRowsExpected(1);
setDataSource(ds);
setSql(sql);
setTypes(types);
}
/**
* Create a new SqlFunction object with SQL, parameters and a result type.
* @param ds DataSource to obtain connections from
* @param sql SQL to execute
* @param types SQL types of the parameters, as defined in the
* java.sql.Types class
* @param resultType the type that the result object is required to match
* @see #setResultType(Class)
* @see java.sql.Types
*/
public SqlFunction(DataSource ds, String sql, int[] types, ClassSqlQuery.findObject(Object[]) method.
* This is a generic method to execute a query, taken a number of arguments.
* @param parameters array of parameters. These will be objects or
* object wrapper types for primitives.
* @return the value of the function, as an Object
* @see #execute(Object[])
*/
public Object runGeneric(Object[] parameters) {
return findObject(parameters);
}
}
././@LongLink 0000000 0000000 0000000 00000000173 00000000000 011566 L ustar root root libspring-java-3.0.6.RELEASE/projects/org.springframework.jdbc/src/main/java/org/springframework/jdbc/object/SqlQuery.java libspring-java-3.0.6.RELEASE/projects/org.springframework.jdbc/src/main/java/org/springframework/jdb0000644 0001750 0001750 00000031641 11623223530 033272 0 ustar drazzib drazzib /*
* Copyright 2002-2008 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.object;
import java.util.List;
import java.util.Map;
import javax.sql.DataSource;
import org.springframework.dao.DataAccessException;
import org.springframework.dao.support.DataAccessUtils;
import org.springframework.jdbc.core.RowMapper;
import org.springframework.jdbc.core.namedparam.MapSqlParameterSource;
import org.springframework.jdbc.core.namedparam.NamedParameterUtils;
import org.springframework.jdbc.core.namedparam.ParsedSql;
/**
* Reusable operation object representing a SQL query.
*
* ResultSet created during the execution of the query.
*
* execute methods that are
* analogous to the different convenient JDO query execute methods. Subclasses
* can either rely on one of these inherited methods, or can add their own
* custom execution methods, with meaningful names and typed parameters
* (definitely a best practice). Each custom query method will invoke one of
* this class's untyped query methods.
*
* RdbmsOperation classes that ship with the Spring
* Framework, SqlQuery instances are thread-safe after their
* initialization is complete. That is, after they are constructed and configured
* via their setter methods, they can be used safely from multiple threads.
*
* @author Rod Johnson
* @author Juergen Hoeller
* @author Thomas Risberg
* @see SqlUpdate
*/
public abstract class SqlQueryDataSource and SQL must be supplied before
* compilation and use.
*/
public SqlQuery() {
}
/**
* Convenient constructor with a DataSource and SQL string.
* @param ds the DataSource to use to get connections
* @param sql the SQL to execute; SQL can also be supplied at runtime
* by overriding the {@link #getSql()} method.
*/
public SqlQuery(DataSource ds, String sql) {
setDataSource(ds);
setSql(sql);
}
/**
* Set the number of rows expected.
* mapRow
* callback method. The JDBC operation itself doesn't rely on this parameter,
* but it can be useful for creating the objects of the result list.
* @return a List of objects, one per row of the ResultSet. Normally all these
* will be of the same class, although it is possible to use different types.
*/
public ListmapRow
* callback method. The JDBC operation itself doesn't rely on this parameter,
* but it can be useful for creating the objects of the result list.
* @return a List of objects, one per row of the ResultSet. Normally all these
* will be of the same class, although it is possible to use different types.
*/
public ListfindObject methods.
* Object finder methods are like EJB entity bean finders, in that it is
* considered an error if they return more than one result.
* @return the result object, or null if not found. Subclasses may
* choose to treat this as an error and throw an exception.
* @see org.springframework.dao.support.DataAccessUtils#singleResult
*/
public T findObject(Object[] params, Map context) throws DataAccessException {
ListmapRow
* callback method. The JDBC operation itself doesn't rely on this parameter,
* but it can be useful for creating the objects of the result list.
* @return a List of objects, one per row of the ResultSet. Normally all these
* will be of the same class, although it is possible to use different types.
*/
public T findObjectByNamedParam(Mapexecute() method,
* in case subclass is interested; may be null if there
* were no parameters.
* @param context contextual information passed to the mapRow
* callback method. The JDBC operation itself doesn't rely on this parameter,
* but it can be useful for creating the objects of the result list.
* @see #execute
*/
protected abstract RowMapperflush is called or the given batch size has been met.
*
* reset before
* reuse within the same thread.
*
* @author Keith Donald
* @author Juergen Hoeller
* @since 1.1
* @see #flush
* @see #reset
*/
public class BatchSqlUpdate extends SqlUpdate {
/**
* Default number of inserts to accumulate before commiting a batch (5000).
*/
public static int DEFAULT_BATCH_SIZE = 5000;
private int batchSize = DEFAULT_BATCH_SIZE;
private boolean trackRowsAffected = true;
private final LinkedListjava.sql.Types class
* @see java.sql.Types
*/
public BatchSqlUpdate(DataSource ds, String sql, int[] types) {
super(ds, sql, types);
}
/**
* Construct an update object with a given DataSource, SQL,
* anonymous parameters and specifying the maximum number of rows
* that may be affected.
* @param ds DataSource to use to obtain connections
* @param sql SQL statement to execute
* @param types SQL types of the parameters, as defined in the
* java.sql.Types class
* @param batchSize the number of statements that will trigger
* an automatic intermediate flush
* @see java.sql.Types
*/
public BatchSqlUpdate(DataSource ds, String sql, int[] types, int batchSize) {
super(ds, sql, types);
setBatchSize(batchSize);
}
/**
* Set the number of statements that will trigger an automatic intermediate
* flush. update calls or the given statement parameters will
* be queued until the batch size is met, at which point it will empty the
* queue and execute the batch.
* flush call. Note that you need to this after queueing
* all parameters to guarantee that all statements have been flushed.
*/
public void setBatchSize(int batchSize) {
this.batchSize = batchSize;
}
/**
* Set whether to track the rows affected by batch updates performed
* by this operation object.
* update that adds the given statement
* parameters to the queue rather than executing them immediately.
* All other update methods of the SqlUpdate base class go
* through this method and will thus behave similarly.
* flush to actually execute the batch.
* If the specified batch size is reached, an implicit flush will happen;
* you still need to finally call flush to flush all statements.
* @param params array of parameter objects
* @return the number of rows affected by the update (always -1,
* meaning "not applicable", as the statement is not actually
* executed by this method)
* @see #flush
*/
@Override
public int update(Object... params) throws DataAccessException {
validateParameters(params);
this.parameterQueue.add(params.clone());
if (this.parameterQueue.size() == this.batchSize) {
if (logger.isDebugEnabled()) {
logger.debug("Triggering auto-flush because queue reached batch size of " + this.batchSize);
}
flush();
}
return -1;
}
/**
* Trigger any queued update operations to be added as a final batch.
* @return an array of the number of rows affected by each statement
*/
public int[] flush() {
if (this.parameterQueue.isEmpty()) {
return new int[0];
}
int[] rowsAffected = getJdbcTemplate().batchUpdate(
getSql(),
new BatchPreparedStatementSetter() {
public int getBatchSize() {
return parameterQueue.size();
}
public void setValues(PreparedStatement ps, int index) throws SQLException {
Object[] params = parameterQueue.removeFirst();
newPreparedStatementSetter(params).setValues(ps);
}
});
for (int rowCount : rowsAffected) {
checkRowsAffected(rowCount);
if (this.trackRowsAffected) {
this.rowsAffected.add(rowCount);
}
}
return rowsAffected;
}
/**
* Return the current number of statements or statement parameters
* in the queue.
*/
public int getQueueCount() {
return this.parameterQueue.size();
}
/**
* Return the number of already executed statements.
*/
public int getExecutionCount() {
return this.rowsAffected.size();
}
/**
* Return the number of affected rows for all already executed statements.
* Accumulates all of flush's return values until
* reset is invoked.
* @return an array of the number of rows affected by each statement
* @see #reset
*/
public int[] getRowsAffected() {
int[] result = new int[this.rowsAffected.size()];
int i = 0;
for (Iteratornull)
*/
protected final PreparedStatementSetter newPreparedStatementSetter(Object[] params) {
return this.preparedStatementFactory.newPreparedStatementSetter(params);
}
/**
* Return a PreparedStatementCreator to perform an operation
* with the given parameters.
* @param params the parameter array (may be null)
*/
protected final PreparedStatementCreator newPreparedStatementCreator(Object[] params) {
return this.preparedStatementFactory.newPreparedStatementCreator(params);
}
/**
* Return a PreparedStatementCreator to perform an operation
* with the given parameters.
* @param sqlToUse the actual SQL statement to use (if different from
* the factory's, for example because of named parameter expanding)
* @param params the parameter array (may be null)
*/
protected final PreparedStatementCreator newPreparedStatementCreator(String sqlToUse, Object[] params) {
return this.preparedStatementFactory.newPreparedStatementCreator(sqlToUse, params);
}
}
././@LongLink 0000000 0000000 0000000 00000000220 00000000000 011557 L ustar root root libspring-java-3.0.6.RELEASE/projects/org.springframework.jdbc/src/main/java/org/springframework/jdbc/object/MappingSqlQueryWithParameters.java libspring-java-3.0.6.RELEASE/projects/org.springframework.jdbc/src/main/java/org/springframework/jdb0000644 0001750 0001750 00000007674 11623223526 033310 0 ustar drazzib drazzib /*
* Copyright 2002-2008 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.object;
import java.sql.ResultSet;
import java.sql.SQLException;
import java.util.Map;
import javax.sql.DataSource;
import org.springframework.jdbc.core.RowMapper;
/**
* Reusable RDBMS query in which concrete subclasses must implement
* the abstract mapRow(ResultSet, int) method to map each row of
* the JDBC ResultSet into an object.
*
* null if there are no parameters.
* @param context passed to the execute() method.
* It can be null if no contextual information is need.
* @return an object of the result type
* @throws SQLException if there's an error extracting data.
* Subclasses can simply not catch SQLExceptions, relying on the
* framework to clean up.
*/
protected abstract T mapRow(ResultSet rs, int rowNum, Object[] parameters, Map context)
throws SQLException;
/**
* Implementation of RowMapper that calls the enclosing
* class's mapRow method for each row.
*/
protected class RowMapperImpl implements RowMappersql property is the name of the stored
* procedure in the RDBMS. Note that JDBC 3.0 introduces named parameters,
* although the other features provided by this class are still necessary
* in JDBC 3.0.
*
* @author Rod Johnson
* @author Thomas Risberg
* @see #setSql
*/
public abstract class StoredProcedure extends SqlCall {
/**
* Allow use as a bean.
*/
protected StoredProcedure() {
}
/**
* Create a new object wrapper for a stored procedure.
* @param ds DataSource to use throughout the lifetime
* of this object to obtain connections
* @param name name of the stored procedure in the database
*/
protected StoredProcedure(DataSource ds, String name) {
setDataSource(ds);
setSql(name);
}
/**
* Create a new object wrapper for a stored procedure.
* @param jdbcTemplate JdbcTemplate which wraps DataSource
* @param name name of the stored procedure in the database
*/
protected StoredProcedure(JdbcTemplate jdbcTemplate, String name) {
setJdbcTemplate(jdbcTemplate);
setSql(name);
}
/**
* StoredProcedure parameter Maps are by default allowed to contain
* additional entries that are not actually used as parameters.
*/
@Override
protected boolean allowsUnusedParameters() {
return true;
}
/**
* Declare a parameter. Overridden method.
* Parameters declared as SqlParameter and SqlInOutParameter
* will always be used to provide input values. In addition to this any parameter declared
* as SqlOutParameter where an non-null input value is provided will also be used
* as an input paraneter.
* Note: Calls to declareParameter must be made in the same order as
* they appear in the database's stored procedure parameter list.
* Names are purely used to help mapping.
* @param param parameter object
*/
@Override
public void declareParameter(SqlParameter param) throws InvalidDataAccessApiUsageException {
if (param.getName() == null) {
throw new InvalidDataAccessApiUsageException("Parameters to stored procedures must have names as well as types");
}
super.declareParameter(param);
}
/**
* Execute the stored procedure with the provided parameter values. This is
* a convenience method where the order of the passed in parameter values
* must match the order that the parameters where declared in.
* @param inParams variable number of input parameters. Output parameters should
* not be included in this map.
* It is legal for values to be null, and this will produce the
* correct behavior using a NULL argument to the stored procedure.
* @return map of output params, keyed by name as in parameter declarations.
* Output parameters will appear here, with their values after the
* stored procedure has been called.
*/
public Mapnull, and this will produce the
* correct behavior using a NULL argument to the stored procedure.
* @return map of output params, keyed by name as in parameter declarations.
* Output parameters will appear here, with their values after the
* stored procedure has been called.
*/
public Mapnull, and this will produce the correct
* behavior using a NULL argument to the stored procedure.
* @return map of output params, keyed by name as in parameter declarations.
* Output parameters will appear here, with their values after the
* stored procedure has been called.
*/
public Mapupdate methods,
* analogous to the execute methods of query objects.
*
* RdbmsOperation classes that ship with the Spring
* Framework, SqlQuery instances are thread-safe after their
* initialization is complete. That is, after they are constructed and configured
* via their setter methods, they can be used safely from multiple threads.
*
* @author Rod Johnson
* @author Thomas Risberg
* @author Juergen Hoeller
* @see SqlQuery
*/
public class SqlUpdate extends SqlOperation {
/**
* Maximum number of rows the update may affect. If more are
* affected, an exception will be thrown. Ignored if 0.
*/
private int maxRowsAffected = 0;
/**
* An exact number of rows that must be affected.
* Ignored if 0.
*/
private int requiredRowsAffected = 0;
/**
* Constructor to allow use as a JavaBean. DataSource and SQL
* must be supplied before compilation and use.
* @see #setDataSource
* @see #setSql
*/
public SqlUpdate() {
}
/**
* Constructs an update object with a given DataSource and SQL.
* @param ds DataSource to use to obtain connections
* @param sql SQL statement to execute
*/
public SqlUpdate(DataSource ds, String sql) {
setDataSource(ds);
setSql(sql);
}
/**
* Construct an update object with a given DataSource, SQL
* and anonymous parameters.
* @param ds DataSource to use to obtain connections
* @param sql SQL statement to execute
* @param types SQL types of the parameters, as defined in the
* java.sql.Types class
* @see java.sql.Types
*/
public SqlUpdate(DataSource ds, String sql, int[] types) {
setDataSource(ds);
setSql(sql);
setTypes(types);
}
/**
* Construct an update object with a given DataSource, SQL,
* anonymous parameters and specifying the maximum number of rows
* that may be affected.
* @param ds DataSource to use to obtain connections
* @param sql SQL statement to execute
* @param types SQL types of the parameters, as defined in the
* java.sql.Types class
* @param maxRowsAffected the maximum number of rows that may
* be affected by the update
* @see java.sql.Types
*/
public SqlUpdate(DataSource ds, String sql, int[] types, int maxRowsAffected) {
setDataSource(ds);
setSql(sql);
setTypes(types);
this.maxRowsAffected = maxRowsAffected;
}
/**
* Set the maximum number of rows that may be affected by this update.
* The default value is 0, which does not limit the number of rows affected.
* @param maxRowsAffected the maximum number of rows that can be affected by
* this update without this class's update method considering it an error
*/
public void setMaxRowsAffected(int maxRowsAffected) {
this.maxRowsAffected = maxRowsAffected;
}
/**
* Set the exact number of rows that must be affected by this update.
* The default value is 0, which allows any number of rows to be affected.
* updateRow() method.
*/
@Override
protected RowMappernull if no contextual information is need. If you
* need to pass in data for each row, you can pass in a HashMap with
* the primary key of the row being the key for the HashMap. That way
* it is easy to locate the updates for each row
* @return an object of the result type
* @throws SQLException if there's an error updateing data.
* Subclasses can simply not catch SQLExceptions, relying on the
* framework to clean up.
*/
protected abstract T updateRow(ResultSet rs, int rowNum, Map context) throws SQLException;
/**
* Implementation of RowMapper that calls the enclosing
* class's updateRow() method for each row.
*/
protected class RowMapperImpl implements RowMapperCallableStatement.getObject method.
*
* getTypeValue which can throw SQLExceptions
* that will be caught and translated by the calling code. This callback method has
* access to the underlying Connection via the given CallableStatement object, if that
* should be needed to create any database-specific objects.
*
* @author Thomas Risberg
* @since 1.1
* @see java.sql.Types
* @see java.sql.CallableStatement#getObject
* @see org.springframework.jdbc.object.StoredProcedure#execute(java.util.Map)
*/
public interface SqlReturnType {
/**
* Constant that indicates an unknown (or unspecified) SQL type.
* Passed into setTypeValue if the original operation method does
* not specify a SQL type.
* @see java.sql.Types
* @see JdbcOperations#update(String, Object[])
*/
int TYPE_UNKNOWN = Integer.MIN_VALUE;
/**
* Get the type value from the specific object.
* @param cs the CallableStatement to operate on
* @param paramIndex the index of the parameter for which we need to set the value
* @param sqlType SQL type of the parameter we are setting
* @param typeName the type name of the parameter
* @return the target value
* @throws SQLException if a SQLException is encountered setting parameter values
* (that is, there's no need to catch SQLException)
* @see java.sql.Types
* @see java.sql.CallableStatement#getObject
*/
Object getTypeValue(CallableStatement cs, int paramIndex, int sqlType, String typeName)
throws SQLException;
}
././@LongLink 0000000 0000000 0000000 00000000205 00000000000 011562 L ustar root root libspring-java-3.0.6.RELEASE/projects/org.springframework.jdbc/src/main/java/org/springframework/jdbc/core/SqlReturnUpdateCount.java libspring-java-3.0.6.RELEASE/projects/org.springframework.jdbc/src/main/java/org/springframework/jdb0000644 0001750 0001750 00000002155 11623223526 033275 0 ustar drazzib drazzib package org.springframework.jdbc.core;
import java.sql.Types;
/**
* Represents a returned update count from a stored procedure call.
*
* null.
* false.
*/
@Override
public boolean isInputValueProvided() {
return false;
}
/**
* Return whether this parameter is an implicit return parameter used during the
* results preocessing of the CallableStatement.getMoreResults/getUpdateCount.
* true.
*/
@Override
public boolean isResultsParameter() {
return true;
}
}
././@LongLink 0000000 0000000 0000000 00000000163 00000000000 011565 L ustar root root libspring-java-3.0.6.RELEASE/projects/org.springframework.jdbc/src/main/java/org/springframework/jdbc/core/simple/ libspring-java-3.0.6.RELEASE/projects/org.springframework.jdbc/src/main/java/org/springframework/jdb0000755 0001750 0001750 00000000000 11623223530 033263 5 ustar drazzib drazzib ././@LongLink 0000000 0000000 0000000 00000000210 00000000000 011556 L ustar root root libspring-java-3.0.6.RELEASE/projects/org.springframework.jdbc/src/main/java/org/springframework/jdbc/core/simple/AbstractJdbcCall.java libspring-java-3.0.6.RELEASE/projects/org.springframework.jdbc/src/main/java/org/springframework/jdb0000644 0001750 0001750 00000035014 11623223530 033270 0 ustar drazzib drazzib /*
* Copyright 2002-2010 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.core.simple;
import java.util.ArrayList;
import java.util.LinkedHashMap;
import java.util.List;
import java.util.Map;
import java.util.Set;
import javax.sql.DataSource;
import org.apache.commons.logging.Log;
import org.apache.commons.logging.LogFactory;
import org.springframework.dao.InvalidDataAccessApiUsageException;
import org.springframework.jdbc.core.CallableStatementCreator;
import org.springframework.jdbc.core.CallableStatementCreatorFactory;
import org.springframework.jdbc.core.JdbcTemplate;
import org.springframework.jdbc.core.RowMapper;
import org.springframework.jdbc.core.SqlParameter;
import org.springframework.jdbc.core.metadata.CallMetaDataContext;
import org.springframework.jdbc.core.namedparam.SqlParameterSource;
import org.springframework.util.Assert;
import org.springframework.util.StringUtils;
/**
* Abstract class to provide base functionality for easy stored procedure calls
* based on configuration options and database metadata.
* This class provides the base SPI for {@link SimpleJdbcCall}.
*
* @author Thomas Risberg
* @since 2.5
*/
public abstract class AbstractJdbcCall {
/** Logger available to subclasses */
protected final Log logger = LogFactory.getLog(getClass());
/** Lower-level class used to execute SQL */
private final JdbcTemplate jdbcTemplate;
/** List of SqlParameter objects */
private final ListSqlParameter and SqlInOutParameter
* will be used to provide input values. This is different from the StoredProcedure class
* which for backwards compatibility reasons allows input values to be provided for parameters declared
* as SqlOutParameter.
* @param parameter the {@link SqlParameter} to add
*/
public void addDeclaredParameter(SqlParameter parameter) {
Assert.notNull(parameter, "The supplied parameter must not be null");
if (!StringUtils.hasText(parameter.getName())) {
throw new InvalidDataAccessApiUsageException(
"You must specify a parameter name when declaring parameters for \"" + getProcedureName() + "\"");
}
this.declaredParameters.add(parameter);
if (logger.isDebugEnabled()) {
logger.debug("Added declared parameter for [" + getProcedureName() + "]: " + parameter.getName());
}
}
/**
* Add a {@link org.springframework.jdbc.core.RowMapper} for the specified parameter or column.
* @param parameterName name of parameter or column
* @param rowMapper the RowMapper implementation to use
*/
public void addDeclaredRowMapper(String parameterName, RowMapper rowMapper) {
this.declaredRowMappers.put(parameterName, rowMapper);
if (logger.isDebugEnabled()) {
logger.debug("Added row mapper for [" + getProcedureName() + "]: " + parameterName);
}
}
/**
* Add a {@link org.springframework.jdbc.core.RowMapper} for the specified parameter or column.
* @deprecated in favor of {@link #addDeclaredRowMapper(String, org.springframework.jdbc.core.RowMapper)}
*/
@Deprecated
public void addDeclaredRowMapper(String parameterName, ParameterizedRowMapper rowMapper) {
addDeclaredRowMapper(parameterName, (RowMapper) rowMapper);
}
/**
* Get the call string that should be used based on parameters and meta data
*/
public String getCallString() {
return this.callString;
}
/**
* Specify whether the parameter metadata for the call should be used. The default is true.
*/
public void setAccessCallParameterMetaData(boolean accessCallParameterMetaData) {
this.callMetaDataContext.setAccessCallParameterMetaData(accessCallParameterMetaData);
}
//-------------------------------------------------------------------------
// Methods handling compilation issues
//-------------------------------------------------------------------------
/**
* Compile this JdbcCall using provided parameters and meta data plus other settings. This
* finalizes the configuration for this object and subsequent attempts to compile are ignored.
* This will be implicitly called the first time an un-compiled call is executed.
* @throws org.springframework.dao.InvalidDataAccessApiUsageException if the object hasn't
* been correctly initialized, for example if no DataSource has been provided
*/
public synchronized final void compile() throws InvalidDataAccessApiUsageException {
if (!isCompiled()) {
if (getProcedureName() == null) {
throw new InvalidDataAccessApiUsageException("Procedure or Function name is required");
}
try {
this.jdbcTemplate.afterPropertiesSet();
}
catch (IllegalArgumentException ex) {
throw new InvalidDataAccessApiUsageException(ex.getMessage());
}
compileInternal();
this.compiled = true;
if (logger.isDebugEnabled()) {
logger.debug("SqlCall for " + (isFunction() ? "function" : "procedure") + " [" + getProcedureName() + "] compiled");
}
}
}
/**
* Method to perform the actual compilation. Subclasses can override this template method to perform
* their own compilation. Invoked after this base class's compilation is complete.
*/
protected void compileInternal() {
this.callMetaDataContext.initializeMetaData(getJdbcTemplate().getDataSource());
// iterate over the declared RowMappers and register the corresponding SqlParameter
for (Map.EntrydoExecute.
*/
protected void checkCompiled() {
if (!isCompiled()) {
logger.debug("JdbcCall call not compiled before execution - invoking compile");
compile();
}
}
//-------------------------------------------------------------------------
// Methods handling execution
//-------------------------------------------------------------------------
/**
* Method that provides execution of the call using the passed in {@link SqlParameterSource}
* @param parameterSource parameter names and values to be used in call
* @return Map of out parameters
*/
protected MapSqlParameter and SqlInOutParameter
* will be used to provide input values. This is different from the StoredProcedure class
* which for backwards compatibility reasons allows input values to be provided for parameters declared
* as SqlOutParameter.
* @param sqlParameters the parameters to use
* @return the instance of this SimpleJdbcCall
*/
SimpleJdbcCallOperations declareParameters(SqlParameter... sqlParameters);
/** Not used yet */
SimpleJdbcCallOperations useInParameterNames(String... inParameterNames);
/**
* Used to specify when a ResultSet is returned by the stored procedure and you want it mapped
* by a RowMapper. The results will be returned using the parameter name specified. Multiple
* ResultSets must be declared in the correct order. If the database you are using uses ref cursors
* then the name specified must match the name of the parameter declared for the procedure in the
* database.
* @param parameterName the name of the returned results and/or the name of the ref cursor parameter
* @param rowMapper the RowMapper implementation that will map the data returned for each row
* */
SimpleJdbcCallOperations returningResultSet(String parameterName, RowMapper rowMapper);
/**
* Used to specify when a ResultSet is returned by the stored procedure and you want it mapped
* by a RowMapper. The results will be returned using the parameter name specified. Multiple
* ResultSets must be declared in the correct order. If the database you are using uses ref cursors
* then the name specified must match the name of the parameter declared for the procedure in the
* database.
* @deprecated in favor of {@link #returningResultSet(String, org.springframework.jdbc.core.RowMapper)}
*/
@Deprecated
SimpleJdbcCallOperations returningResultSet(String parameterName, ParameterizedRowMapper rowMapper);
/**
* Turn off any processing of parameter meta data information obtained via JDBC.
* @return the instance of this SimpleJdbcCall
*/
SimpleJdbcCallOperations withoutProcedureColumnMetaDataAccess();
/**
* Execute the stored function and return the results obtained as an Object of the specified return type.
* @param returnType the type of the value to return
* @param args optional array containing the in parameter values to be used in the call.
* Parameter values must be provided in the same order as the parameters are defined
* for the stored procedure.
*/
getJdbcOperations() method of SimpleJdbcTemplate and work
* with the returned classic template, or use a JdbcTemplate instance directly.
*
*/
package org.springframework.jdbc.core.simple;
././@LongLink 0000000 0000000 0000000 00000000210 00000000000 011556 L ustar root root libspring-java-3.0.6.RELEASE/projects/org.springframework.jdbc/src/main/java/org/springframework/jdbc/core/simple/SimpleJdbcInsert.java libspring-java-3.0.6.RELEASE/projects/org.springframework.jdbc/src/main/java/org/springframework/jdb0000644 0001750 0001750 00000011107 11623223530 033265 0 ustar drazzib drazzib /*
* Copyright 2002-2008 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.core.simple;
import java.util.Arrays;
import java.util.Map;
import javax.sql.DataSource;
import org.springframework.jdbc.core.JdbcTemplate;
import org.springframework.jdbc.core.namedparam.SqlParameterSource;
import org.springframework.jdbc.support.KeyHolder;
import org.springframework.jdbc.support.nativejdbc.NativeJdbcExtractor;
/**
* A SimpleJdbcInsert is a multi-threaded, reusable object providing easy insert
* capabilities for a table. It provides meta data processing to simplify the code
* needed to construct a basic insert statement. All you need to provide is the
* name of the table and a Map containing the column names and the column values.
*
* DataSource to use
* @see org.springframework.jdbc.core.JdbcTemplate#setDataSource
*/
public SimpleJdbcInsert(DataSource dataSource) {
super(dataSource);
}
/**
* Alternative Constructor that takes one parameter with the JdbcTemplate to be used.
* @param jdbcTemplate the JdbcTemplate to use
* @see org.springframework.jdbc.core.JdbcTemplate#setDataSource
*/
public SimpleJdbcInsert(JdbcTemplate jdbcTemplate) {
super(jdbcTemplate);
}
public SimpleJdbcInsert withTableName(String tableName) {
setTableName(tableName);
return this;
}
public SimpleJdbcInsert withSchemaName(String schemaName) {
setSchemaName(schemaName);
return this;
}
public SimpleJdbcInsert withCatalogName(String catalogName) {
setCatalogName(catalogName);
return this;
}
public SimpleJdbcInsert usingColumns(String... columnNames) {
setColumnNames(Arrays.asList(columnNames));
return this;
}
public SimpleJdbcInsert usingGeneratedKeyColumns(String... columnNames) {
setGeneratedKeyNames(columnNames);
return this;
}
public SimpleJdbcInsertOperations withoutTableColumnMetaDataAccess() {
setAccessTableColumnMetaData(false);
return this;
}
public SimpleJdbcInsertOperations includeSynonymsForTableColumnMetaData() {
setOverrideIncludeSynonymsDefault(true);
return this;
}
public SimpleJdbcInsertOperations useNativeJdbcExtractorForMetaData(NativeJdbcExtractor nativeJdbcExtractor) {
setNativeJdbcExtractor(nativeJdbcExtractor);
return this;
}
public int execute(MapDataSource to use
* @see org.springframework.jdbc.core.JdbcTemplate#setDataSource
*/
public SimpleJdbcCall(DataSource dataSource) {
super(dataSource);
}
/**
* Alternative Constructor that takes one parameter with the JdbcTemplate to be used.
* @param jdbcTemplate the JdbcTemplate to use
* @see org.springframework.jdbc.core.JdbcTemplate#setDataSource
*/
public SimpleJdbcCall(JdbcTemplate jdbcTemplate) {
super(jdbcTemplate);
}
public SimpleJdbcCall withProcedureName(String procedureName) {
setProcedureName(procedureName);
setFunction(false);
return this;
}
public SimpleJdbcCall withFunctionName(String functionName) {
setProcedureName(functionName);
setFunction(true);
return this;
}
public SimpleJdbcCall withSchemaName(String schemaName) {
setSchemaName(schemaName);
return this;
}
public SimpleJdbcCall withCatalogName(String catalogName) {
setCatalogName(catalogName);
return this;
}
public SimpleJdbcCall withReturnValue() {
setReturnValueRequired(true);
return this;
}
public SimpleJdbcCall declareParameters(SqlParameter... sqlParameters) {
for (SqlParameter sqlParameter : sqlParameters) {
if (sqlParameter != null) {
addDeclaredParameter(sqlParameter);
}
}
return this;
}
public SimpleJdbcCall useInParameterNames(String... inParameterNames) {
setInParameterNames(new HashSetint passing in a SQL query
* using the named parameter support provided by the
* {@link org.springframework.jdbc.core.namedparam.NamedParameterJdbcTemplate}
* and a map containing the arguments.
* @param sql the SQL query to run.
* @param args the map containing the arguments for the query
*/
int queryForInt(String sql, Mapint passing in a SQL query
* using the named parameter support provided by the
* {@link org.springframework.jdbc.core.namedparam.NamedParameterJdbcTemplate}
* and a SqlParameterSource containing the arguments.
* @param sql the SQL query to run.
* @param args the SqlParameterSource containing the arguments for the query.
*/
int queryForInt(String sql, SqlParameterSource args) throws DataAccessException;
/**
* Query for an int passing in a SQL query
* using the standard '?' placeholders for parameters
* and a variable number of arguments.
* @param sql the SQL query to run.
* @param args the variable number of arguments for the query
*/
int queryForInt(String sql, Object... args) throws DataAccessException;
/**
* Query for an long passing in a SQL query
* using the named parameter support provided by the
* {@link org.springframework.jdbc.core.namedparam.NamedParameterJdbcTemplate}
* and a map containing the arguments.
* @param sql the SQL query to run.
* @param args the map containing the arguments for the query
*/
long queryForLong(String sql, Maplong passing in a SQL query
* using the named parameter support provided by the
* {@link org.springframework.jdbc.core.namedparam.NamedParameterJdbcTemplate}
* and a SqlParameterSource containing the arguments.
* @param sql the SQL query to run.
* @param args the SqlParameterSource containing the arguments for the query
*/
long queryForLong(String sql, SqlParameterSource args) throws DataAccessException;
/**
* Query for an long passing in a SQL query
* using the standard '?' placeholders for parameters
* and a variable number of arguments.
* @param sql the SQL query to run.
* @param args the variable number of arguments for the query
*/
long queryForLong(String sql, Object... args) throws DataAccessException;
/**
* Query for an object of type T identified by the supplied @{@link Class}.
* Uses sql with the named parameter support provided by the
* {@link org.springframework.jdbc.core.namedparam.NamedParameterJdbcTemplate}
* @param sql the SQL query to run
* @param requiredType the required type of the return value
* @param args the map containing the arguments for the query
* @see JdbcOperations#queryForObject(String, Class)
* @see JdbcOperations#queryForObject(String, Object[], Class)
*/
T identified by the supplied @{@link Class}.
* Uses sql with the named parameter support provided by the
* {@link org.springframework.jdbc.core.namedparam.NamedParameterJdbcTemplate}
* @param sql the SQL query to run
* @param requiredType the required type of the return value
* @param args the SqlParameterSource containing the arguments for the query
* @see JdbcOperations#queryForObject(String, Class)
* @see JdbcOperations#queryForObject(String, Object[], Class)
*/
T identified by the supplied @{@link Class}.
* Uses sql with the standard '?' placeholders for parameters
* @param sql the SQL query to run
* @param requiredType the required type of the return value
* @param args the variable number of arguments for the query
* @see JdbcOperations#queryForObject(String, Class)
* @see JdbcOperations#queryForObject(String, Object[], Class)
*/
T using the supplied
* {@link RowMapper} to the query results to the object.
* Uses sql with the named parameter support provided by the
* {@link org.springframework.jdbc.core.namedparam.NamedParameterJdbcTemplate}
* @param sql the SQL query to run
* @param rm the @{@link RowMapper} to use for result mapping
* @param args the map containing the arguments for the query
* @see JdbcOperations#queryForObject(String, org.springframework.jdbc.core.RowMapper)
* @see JdbcOperations#queryForObject(String, Object[], org.springframework.jdbc.core.RowMapper)
*/
T using the supplied
* {@link ParameterizedRowMapper} to the query results to the object.
* Uses sql with the named parameter support provided by the
* {@link org.springframework.jdbc.core.namedparam.NamedParameterJdbcTemplate}
* @param sql the SQL query to run
* @param rm the @{@link ParameterizedRowMapper} to use for result mapping
* @param args the map containing the arguments for the query
* @see JdbcOperations#queryForObject(String, org.springframework.jdbc.core.RowMapper)
* @see JdbcOperations#queryForObject(String, Object[], org.springframework.jdbc.core.RowMapper)
* @deprecated as of Spring 3.0: Use the method using the newly genericized RowMapper interface
* instead since the RowMapper and ParameterizedRowMapper interfaces are equivalent now.
*/
@Deprecated
T using the supplied
* {@link RowMapper} to the query results to the object.
* Uses sql with the named parameter support provided by the
* {@link org.springframework.jdbc.core.namedparam.NamedParameterJdbcTemplate}
* @param sql the SQL query to run
* @param rm the @{@link RowMapper} to use for result mapping
* @param args the SqlParameterSource containing the arguments for the query
* @see JdbcOperations#queryForObject(String, org.springframework.jdbc.core.RowMapper)
* @see JdbcOperations#queryForObject(String, Object[], org.springframework.jdbc.core.RowMapper)
*/
T using the supplied
* {@link ParameterizedRowMapper} to the query results to the object.
* Uses sql with the named parameter support provided by the
* {@link org.springframework.jdbc.core.namedparam.NamedParameterJdbcTemplate}
* @param sql the SQL query to run
* @param rm the @{@link ParameterizedRowMapper} to use for result mapping
* @param args the SqlParameterSource containing the arguments for the query
* @see JdbcOperations#queryForObject(String, org.springframework.jdbc.core.RowMapper)
* @see JdbcOperations#queryForObject(String, Object[], org.springframework.jdbc.core.RowMapper)
* @deprecated as of Spring 3.0: Use the method using the newly genericized RowMapper interface
* instead since the RowMapper and ParameterizedRowMapper interfaces are equivalent now.
*/
@Deprecated
T using the supplied
* {@link RowMapper} to the query results to the object.
* Uses sql with the standard '?' placeholders for parameters
* @param sql the SQL query to run
* @param rm the @{@link RowMapper} to use for result mapping
* @param args the variable number of arguments for the query
* @see JdbcOperations#queryForObject(String, org.springframework.jdbc.core.RowMapper)
* @see JdbcOperations#queryForObject(String, Object[], org.springframework.jdbc.core.RowMapper)
*/
T using the supplied
* {@link ParameterizedRowMapper} to the query results to the object.
* Uses sql with the standard '?' placeholders for parameters
* @param sql the SQL query to run
* @param rm the @{@link ParameterizedRowMapper} to use for result mapping
* @param args the variable number of arguments for the query
* @see JdbcOperations#queryForObject(String, org.springframework.jdbc.core.RowMapper)
* @see JdbcOperations#queryForObject(String, Object[], org.springframework.jdbc.core.RowMapper)
* @deprecated as of Spring 3.0: Use the method using the newly genericized RowMapper interface
* instead since the RowMapper and ParameterizedRowMapper interfaces are equivalent now.
*/
@Deprecated
Objects of type T using
* the supplied {@link RowMapper} to the query results to the object.
* Uses sql with the named parameter support provided by the
* {@link org.springframework.jdbc.core.namedparam.NamedParameterJdbcTemplate}
* @param sql the SQL query to run
* @param rm the @{@link RowMapper} to use for result mapping
* @param args the map containing the arguments for the query
* @see JdbcOperations#queryForObject(String, org.springframework.jdbc.core.RowMapper)
* @see JdbcOperations#queryForObject(String, Object[], org.springframework.jdbc.core.RowMapper)
*/
Objects of type T using
* the supplied {@link ParameterizedRowMapper} to the query results to the object.
* Uses sql with the named parameter support provided by the
* {@link org.springframework.jdbc.core.namedparam.NamedParameterJdbcTemplate}
* @param sql the SQL query to run
* @param rm the @{@link ParameterizedRowMapper} to use for result mapping
* @param args the map containing the arguments for the query
* @see JdbcOperations#queryForObject(String, org.springframework.jdbc.core.RowMapper)
* @see JdbcOperations#queryForObject(String, Object[], org.springframework.jdbc.core.RowMapper)
* @deprecated as of Spring 3.0: Use the method using the newly genericized RowMapper interface
* instead since the RowMapper and ParameterizedRowMapper interfaces are equivalent now.
*/
@Deprecated
Objects of type T using
* the supplied {@link RowMapper} to the query results to the object.
* Uses sql with the named parameter support provided by the
* {@link org.springframework.jdbc.core.namedparam.NamedParameterJdbcTemplate}
* @param sql the SQL query to run
* @param rm the @{@link RowMapper} to use for result mapping
* @param args the SqlParameterSource containing the arguments for the query
* @see JdbcOperations#queryForObject(String, org.springframework.jdbc.core.RowMapper)
* @see JdbcOperations#queryForObject(String, Object[], org.springframework.jdbc.core.RowMapper)
*/
Objects of type T using
* the supplied {@link ParameterizedRowMapper} to the query results to the object.
* Uses sql with the named parameter support provided by the
* {@link org.springframework.jdbc.core.namedparam.NamedParameterJdbcTemplate}
* @param sql the SQL query to run
* @param rm the @{@link ParameterizedRowMapper} to use for result mapping
* @param args the SqlParameterSource containing the arguments for the query
* @see JdbcOperations#queryForObject(String, org.springframework.jdbc.core.RowMapper)
* @see JdbcOperations#queryForObject(String, Object[], org.springframework.jdbc.core.RowMapper)
* @deprecated as of Spring 3.0: Use the method using the newly genericized RowMapper interface
* instead since the RowMapper and ParameterizedRowMapper interfaces are equivalent now.
*/
@Deprecated
Objects of type T using
* the supplied {@link RowMapper} to the query results to the object.
* Uses sql with the standard '?' placeholders for parameters
* @param sql the SQL query to run
* @param rm the @{@link RowMapper} to use for result mapping
* @param args the variable number of arguments for the query
* @see JdbcOperations#queryForObject(String, org.springframework.jdbc.core.RowMapper)
* @see JdbcOperations#queryForObject(String, Object[], org.springframework.jdbc.core.RowMapper)
*/
Objects of type T using
* the supplied {@link ParameterizedRowMapper} to the query results to the object.
* Uses sql with the standard '?' placeholders for parameters
* @param sql the SQL query to run
* @param rm the @{@link ParameterizedRowMapper} to use for result mapping
* @param args the variable number of arguments for the query
* @see JdbcOperations#queryForObject(String, org.springframework.jdbc.core.RowMapper)
* @see JdbcOperations#queryForObject(String, Object[], org.springframework.jdbc.core.RowMapper)
* @deprecated as of Spring 3.0: Use the method using the newly genericized RowMapper interface
* instead since the RowMapper and ParameterizedRowMapper interfaces are equivalent now.
*/
@Deprecated
SqlParameterSource containing the arguments for the query
* @see JdbcOperations#queryForMap(String)
* @see JdbcOperations#queryForMap(String, Object[])
*/
Map