Java tutorial
/* * Licensed to the Apache Software Foundation (ASF) under one or more * contributor license agreements. See the NOTICE file distributed with * this work for additional information regarding copyright ownership. * The ASF licenses this file to You 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.apache.commons.dbcp; import java.sql.Connection; import java.sql.SQLException; import org.apache.commons.pool.ObjectPool; /** * A delegating connection that, rather than closing the underlying * connection, returns itself to an {@link ObjectPool} when * closed. * * @author Rodney Waldhoff * @author Glenn L. Nielsen * @author James House * @version $Revision: 758745 $ $Date: 2009-03-26 13:02:20 -0400 (Thu, 26 Mar 2009) $ */ public class PoolableConnection extends DelegatingConnection { /** The pool to which I should return. */ // TODO: Correct use of the pool requires that this connection is only every returned to the pool once. protected ObjectPool _pool = null; /** * * @param conn my underlying connection * @param pool the pool to which I should return when closed */ public PoolableConnection(Connection conn, ObjectPool pool) { super(conn); _pool = pool; } /** * * @param conn my underlying connection * @param pool the pool to which I should return when closed * @param config the abandoned configuration settings */ public PoolableConnection(Connection conn, ObjectPool pool, AbandonedConfig config) { super(conn, config); _pool = pool; } /** * Returns me to my pool. */ public synchronized void close() throws SQLException { if (_closed) { // already closed return; } boolean isUnderlyingConectionClosed; try { isUnderlyingConectionClosed = _conn.isClosed(); } catch (SQLException e) { try { _pool.invalidateObject(this); // XXX should be guarded to happen at most once } catch (IllegalStateException ise) { // pool is closed, so close the connection passivate(); getInnermostDelegate().close(); } catch (Exception ie) { // DO NOTHING the original exception will be rethrown } throw (SQLException) new SQLException("Cannot close connection (isClosed check failed)").initCause(e); } if (!isUnderlyingConectionClosed) { // Normal close: underlying connection is still open, so we // simply need to return this proxy to the pool try { _pool.returnObject(this); // XXX should be guarded to happen at most once } catch (IllegalStateException e) { // pool is closed, so close the connection passivate(); getInnermostDelegate().close(); } catch (SQLException e) { throw e; } catch (RuntimeException e) { throw e; } catch (Exception e) { throw (SQLException) new SQLException("Cannot close connection (return to pool failed)") .initCause(e); } } else { // Abnormal close: underlying connection closed unexpectedly, so we // must destroy this proxy try { _pool.invalidateObject(this); // XXX should be guarded to happen at most once } catch (IllegalStateException e) { // pool is closed, so close the connection passivate(); getInnermostDelegate().close(); } catch (Exception ie) { // DO NOTHING, "Already closed" exception thrown below } throw new SQLException("Already closed."); } } /** * Actually close my underlying {@link Connection}. */ public void reallyClose() throws SQLException { super.close(); } }