public BorrowedConnectionProxy(ConnectionManager connectionManager) 
{
	   
		this.connectionManager = connectionManager;
}

 public static Connection generateProxy(ConnectionManager connectionManager) 
{
		BorrowedConnectionProxy handler = new BorrowedConnectionProxy( connectionManager );
		return ( Connection ) Proxy.newProxyInstance(
				getProxyClassLoader(),
		        PROXY_INTERFACES,
		        handler
		);
}

Generates a Connection proxy wrapping the connection managed by the passed connection manager.

 public static ClassLoader getProxyClassLoader() 
{
		ClassLoader cl = Thread.currentThread().getContextClassLoader();
		if ( cl == null ) {
			cl = BorrowedConnectionProxy.class.getClassLoader();
		}
		return cl;
}

Determines the appropriate class loader to which the generated proxy should be scoped.

 public static Connection getWrappedConnection(Connection connection) 
{
		if ( connection != null && connection instanceof ConnectionWrapper ) {
			return ( ( ConnectionWrapper ) connection ).getWrappedConnection();
		}
		else {
			return connection;
		}
}

Convience method for unwrapping a connection proxy and getting a handle to an underlying connection.

 public Object invoke(Object proxy,
    Method method,
    Object[] args) throws Throwable 
{
		if ( "close".equals( method.getName() ) ) {
			connectionManager.releaseBorrowedConnection();
			return null;
		}
		// should probably no-op commit/rollback here, at least in JTA scenarios
		if ( !useable ) {
			throw new HibernateException( "connnection proxy not usable after transaction completion" );
		}
		if ( "getWrappedConnection".equals( method.getName() ) ) {
			return connectionManager.getConnection();
		}
		try {
			return method.invoke( connectionManager.getConnection(), args );
		}
		catch( InvocationTargetException e ) {
			throw e.getTargetException();
		}
}

{@inheritDoc}

 public static  void renderUnuseable(Connection connection) 
{
		if ( connection != null && Proxy.isProxyClass( connection.getClass() ) ) {
			InvocationHandler handler = Proxy.getInvocationHandler( connection );
			if ( BorrowedConnectionProxy.class.isAssignableFrom( handler.getClass() ) ) {
				( ( BorrowedConnectionProxy ) handler ).useable = false;
			}
		}
}

Marks a borrowed connection as no longer usable.