public SingleConnectionFactory() 
{

}

Create a new SingleConnectionFactory for bean-style usage.

Also see:

setTargetConnectionFactory

 public SingleConnectionFactory(Connection target) 
{
		Assert.notNull(target, "Target Connection must not be null");
		this.target = target;
		this.connection = getCloseSuppressingConnectionProxy(target);
}

Create a new SingleConnectionFactory that always returns the given Connection.

Parameters:

target - the single Connection

 public SingleConnectionFactory(ConnectionFactory targetConnectionFactory) 
{
		Assert.notNull(targetConnectionFactory, "Target ConnectionFactory must not be null");
		setTargetConnectionFactory(targetConnectionFactory);
}

Create a new SingleConnectionFactory that always returns a single Connection which it will lazily create via the given target ConnectionFactory.

Parameters:

targetConnectionFactory - the target ConnectionFactory

 public  void afterPropertiesSet() 
{
		if (this.connection == null && getTargetConnectionFactory() == null) {
			throw new IllegalArgumentException("Connection or 'targetConnectionFactory' is required");
		}
}

Make sure a Connection or ConnectionFactory has been set.

 protected  void closeConnection(Connection con) 
{
		try {
			con.close();
		}
		catch (Throwable ex) {
			logger.warn("Could not close shared CCI Connection", ex);
		}
}

Close the given Connection.

 public  void destroy() 
{
		resetConnection();
}

Close the underlying Connection. The provider of this ConnectionFactory needs to care for proper shutdown.

As this bean implements DisposableBean, a bean factory will automatically invoke this on destruction of its cached singletons.

 protected Connection doCreateConnection() throws ResourceException 
{
		return getTargetConnectionFactory().getConnection();
}

Create a CCI Connection via this template's ConnectionFactory.

 protected Connection getCloseSuppressingConnectionProxy(Connection target) 
{
		return (Connection) Proxy.newProxyInstance(
				Connection.class.getClassLoader(),
				new Class[] {Connection.class},
				new CloseSuppressingInvocationHandler(target));
}

Wrap the given Connection with a proxy that delegates every method call to it but suppresses close calls. This is useful for allowing application code to handle a special framework Connection just like an ordinary Connection from a CCI ConnectionFactory.

 public Connection getConnection() throws ResourceException 
{
		synchronized (this.connectionMonitor) {
			if (this.connection == null) {
				initConnection();
			}
			return this.connection;
		}
}

 public Connection getConnection(ConnectionSpec connectionSpec) throws ResourceException 
{
		throw new NotSupportedException(
				"SingleConnectionFactory does not support custom ConnectionSpec");
}

 public  void initConnection() throws ResourceException 
{
		if (getTargetConnectionFactory() == null) {
			throw new IllegalStateException(
					"'targetConnectionFactory' is required for lazily initializing a Connection");
		}
		synchronized (this.connectionMonitor) {
			if (this.target != null) {
				closeConnection(this.target);
			}
			this.target = doCreateConnection();
			prepareConnection(this.target);
			if (logger.isInfoEnabled()) {
				logger.info("Established shared CCI Connection: " + this.target);
			}
			this.connection = getCloseSuppressingConnectionProxy(this.target);
		}
}

Initialize the single underlying Connection.

Closes and reinitializes the Connection if an underlying Connection is present already.

 protected  void prepareConnection(Connection con) throws ResourceException 
{

}

Prepare the given Connection before it is exposed.

The default implementation is empty. Can be overridden in subclasses.

 public  void resetConnection() 
{
		synchronized (this.connectionMonitor) {
			if (this.target != null) {
				closeConnection(this.target);
			}
			this.target = null;
			this.connection = null;
		}
}

Reset the underlying shared Connection, to be reinitialized on next access.