从一个ConnectionPool的实现看design pattern的运用 (source code for Java 1.1)
ConnectionPool.java:public interface ConnectionPool{ Connection getConnection() throws test.res.ResourceNotAvailableException, SQLException; Connection getConnection(long timeout) throws test.res.ResourceTimeOutException, SQLException; void clear();}ConnectionHome.java:public interface ConnectionHome{ void releaseConnection(Connection conn);}ConnectionPooling.java:public interface ConnectionPooling extends ConnectionHome{ Connection getConnection() throws test.res.ResourceNotAvailableException, SQLException; Connection getConnection(long timeout) throws test.res.ResourceTimeOutException, SQLException; void clear(); void releaseConnection(Connection conn);}ConnectionFactory.java:public interface ConnectionFactory{ public Connection createConnection()throws SQLException;}PooledConnection.java: (for Connection in Java 1.1.8)public final class PooledConnection implements Connection{ private interface ConnectionState{ ConnectionState close(); boolean isClosed(); Connection getOpenConnection() throws SQLException; } private static class ClosedConnection implements ConnectionState{ public final ConnectionState close(){return this;} public final Connection getOpenConnection() throws SQLException{ throw new SQLException("Connection closed"); } public final boolean isClosed(){return true;} private ClosedConnection(){} private static final ConnectionState _instance = new ClosedConnection(); static ConnectionState instance(Connection conn, ConnectionHome home){return _instance;} } private static class OpenConnection implements ConnectionState{ private final ConnectionHome home; private final Connection conn; public final ConnectionState close(){ home.releaseConnection(conn); return ClosedConnection.instance(conn, home); } public final Connection getOpenConnection() {return conn;} public final boolean isClosed(){return false;} OpenConnection(Connection conn, ConnectionHome home){ this.conn = conn; this.home = home; } static ConnectionState instance(Connection conn, ConnectionHome home){ return new OpenConnection(conn, home); } } private ConnectionState state; public static Connection decorate(Connection conn, ConnectionHome home) throws SQLException{ return new PooledConnection(conn, home); } private PooledConnection(Connection conn, ConnectionHome home) throws SQLException{ if(conn.isClosed()){ state = ClosedConnection.instance(conn, home); } else{ state = OpenConnection.instance(conn, home); } } public final boolean isClosed(){ return state.isClosed(); } public final void close(){ state = state.close(); } protected void finalize(){ close(); } private final Connection getOpenConnection() throws SQLException {return state.getOpenConnection();} /*****then, delegate all the other methods****/ public final Statement createStatement() throws SQLException{ return getOpenConnection().createStatement(); } //.... public final void clearWarnings()throws SQLException{ getOpenConnection().clearWarnings(); } public final void commit()throws SQLException{ getOpenConnection().commit(); } /* public final Statement createStatement(int resultSetType, int resultSetConcurrency) throws SQLException{ return getOpenConnection().createStatement(resultSetType, resultSetConcurrency); }*/ /* public final Statement createStatement(int resultSetType, int resultSetConcurrency, int resultSetHoldability) throws SQLException{ return getOpenConnection().createStatement(resultSetType, resultSetConcurrency, resultSetHoldability); }*/ public final boolean getAutoCommit()throws SQLException{ return getOpenConnection().getAutoCommit(); } public final String getCatalog()throws SQLException{ return getOpenConnection().getCatalog(); } /* public final int getHoldability()throws SQLException{ return getOpenConnection().getHoldability(); }*/ public final DatabaseMetaData getMetaData()throws SQLException{ return getOpenConnection().getMetaData(); } public final int getTransactionIsolation()throws SQLException{ return getOpenConnection().getTransactionIsolation(); } /* public final Map getTypeMap()throws SQLException{ return getOpenConnection().getTypeMap(); }*/ public final SQLWarning getWarnings()throws SQLException{ return getOpenConnection().getWarnings(); } public final boolean isReadOnly()throws SQLException{ return getOpenConnection().isReadOnly(); } public final String nativeSQL(String sql)throws SQLException{ return getOpenConnection().nativeSQL(sql); } public final CallableStatement prepareCall(String sql)throws SQLException{ return getOpenConnection().prepareCall(sql); } /* public final CallableStatement prepareCall(String sql, int resultSetType, int resultSetConcurrency) throws SQLException{ return getOpenConnection().prepareCall(sql, resultSetType, resultSetConcurrency); } public final CallableStatement prepareCall(String sql, int resultSetType, int resultSetConcurrency, int resultSetHoldability) throws SQLException{ return getOpenConnection().prepareCall(sql, resultSetType, resultSetConcurrency, resultSetHoldability); }*/ public final PreparedStatement prepareStatement(String sql) throws SQLException{ return getOpenConnection().prepareStatement(sql); } /* public final PreparedStatement prepareStatement(String sql, int autoGeneratedKeys) throws SQLException{ return getOpenConnection().prepareStatement(sql, autoGeneratedKeys); } public final PreparedStatement prepareStatement(String sql, int[] columnIndexes) throws SQLException{ return getOpenConnection().prepareStatement(sql, columnIndexes); } public final PreparedStatement prepareStatement(String sql, int resultSetType, int resultSetConcurrency) throws SQLException{ return getOpenConnection().prepareStatement(sql, resultSetType, resultSetConcurrency); } public final PreparedStatement prepareStatement(String sql, int resultSetType, int resultSetConcurrency, int resultSetHoldability) throws SQLException{ return getOpenConnection().prepareStatement(sql, resultSetType, resultSetConcurrency, resultSetHoldability); } public final PreparedStatement prepareStatement(String sql, String[] columnNames) throws SQLException{ return getOpenConnection().prepareStatement(sql, columnNames); } public final void releaseSavepoint(Savepoint savepoint)throws SQLException{ getOpenConnection().releaseSavepoint(savepoint); }*/ public final void rollback()throws SQLException{ getOpenConnection().rollback(); } /* public final void rollback(Savepoint savepoint) throws SQLException{ getOpenConnection().rollback(savepoint); }*/ public final void setAutoCommit(boolean autoCommit) throws SQLException{ getOpenConnection().setAutoCommit(autoCommit); } public final void setCatalog(String catalog) throws SQLException{ getOpenConnection().setCatalog(catalog); } /* public final void setHoldability(int holdability) throws SQLException{ getOpenConnection().setHoldability(holdability); }*/ public final void setReadOnly(boolean readOnly) throws SQLException{ getOpenConnection().setReadOnly(readOnly); } /* public final Savepoint setSavepoint()throws SQLException{ return getOpenConnection().setSavepoint(); } public final Savepoint setSavepoint(String name) throws SQLException{ return getOpenConnection().setSavepoint(name); }*/ public final void setTransactionIsolation(int level) throws SQLException{ getOpenConnection().setTransactionIsolation(level); } /*public final void setTypeMap(Map map)throws SQLException{ getOpenConnection().setTypeMap(map);}*/ /*************************************************************************************************/ }ConnectionPooling2Pool.java:public class ConnectionPooling2Pool implements ConnectionPool{ public final Connection getConnection() throws test.res.ResourceNotAvailableException, SQLException{ return PooledConnection.decorate(pooling.getConnection(), pooling); } public final Connection getConnection(long timeout) throws test.res.ResourceTimeOutException, SQLException{ return PooledConnection.decorate(pooling.getConnection(timeout), pooling); } public final void clear(){ pooling.clear(); } private final ConnectionPooling pooling; private ConnectionPooling2Pool(ConnectionPooling pooling){ this.pooling = pooling; } public static ConnectionPool decorate(ConnectionPooling pooling){ return new ConnectionPooling2Pool(pooling); }}ConnectionPoolingImpl.java: (a simple implementation of ConnectionMan)public class ConnectionPoolingImpl implements ConnectionPooling{ private int client=0; private final Vector freeConn = new Vector(); private final int maxConn; private final ConnectionFactory factory; static public ConnectionPooling instance(ConnectionFactory factory, int max){ return new ConnectionPoolingImpl(factory, max); } private ConnectionPoolingImpl(ConnectionFactory factory, int max){ this.factory = factory; this.maxConn = max; } public final synchronized void releaseConnection(Connection conn) { freeConn.addElement(conn); client--; notify(); } public final synchronized Connection getConnection() throws ResourceNotAvailableException, SQLException { Connection conn = null; if(freeConn.size() > 0) { conn = (Connection)freeConn.lastElement(); freeConn.removeElementAt(freeConn.size()-1); } else if(client < maxConn) { conn = factory.createConnection(); } if(conn != null) { client++; return conn; } else { throw new ResourceNotAvailableException(); } } public final synchronized Connection getConnection(long timeout) throws ResourceTimeOutException, SQLException { for(long startTime = new java.util.Date().getTime();;) { try { return getConnection(); } catch(ResourceNotAvailableException e1) { try {wait(timeout); } catch(InterruptedException e2) {} if((new java.util.Date().getTime() - startTime) >= timeout) { throw new ResourceTimeOutException(); } } } } public final synchronized int getfreeconn(){ return freeConn.size(); } public final int getmaxConn(){ return maxConn; } public final synchronized int getclient(){ return client; } public final synchronized void setclient(){ client=0; } public final synchronized void clear(){ closeAll(); freeConn.removeAllElements(); } private final void closeAll(){ for(int i=0; i<freeConn.size();i++) { final Connection conn = (Connection)freeConn.elementAt(i); try{ conn.close(); } catch(SQLException sqlException){} } } protected void finalize(){ closeAll(); } }ConnectionFactoryImpl.java:public class ConnectionFactoryImpl{ private ConnectionFactoryImpl(){} static public ConnectionFactory instance(final String driver, final String url, final String user, final String pwd) throws SQLException, ClassNotFoundException{ final Class driverClass = Class.forName(driver); return new ConnectionFactory(){ private final Class keeper = driverClass; public final Connection createConnection() throws SQLException{ return DriverManager.getConnection(url,user,pwd); } }; } static public ConnectionFactory instance(final String driver, final String url) throws SQLException, ClassNotFoundException{ final Class driverClass = Class.forName(driver); return new ConnectionFactory(){ private final Class keeper = driverClass; public final Connection createConnection() throws SQLException{ return DriverManager.getConnection(url); } }; } }TestConnectionPool.java:public class TestConnectionPool{ public static void test(String driver, String url, String user, String pwd) throws java.sql.SQLException, test.res.ResourceNotAvailableException, test.res.ResourceTimeOutException, ClassNotFoundException{ final ConnectionPool pool = ConnectionPooling2Pool.decorate( ConnectionPoolingImpl.instance( ConnectionFactoryImpl.instance(driver, url, user, pwd), 1000) ); }}ResourceNotAvailableException.java:public class ResourceNotAvailableException extends RuntimeException{ public ResourceNotAvailableException(String msg){super(msg);} public ResourceNotAvailableException(){}}ResourceTimeOutException.java:public class ResourceTimeOutException extends Exception{ public ResourceTimeOutException(String msg){super(msg);} public ResourceTimeOutException(){}}