connectionpoolmanager.java

管理 MySQL 的工具, 相當方便好用

/**
 * Copyright(c) 2001 iSavvix Corporation (http://www.isavvix.com/)
 *
 *                        All rights reserved
 *
 * Permission to use, copy, modify and distribute this material for
 * any purpose and without fee is hereby granted, provided that the
 * above copyright notice and this permission notice appear in all
 * copies, and that the name of iSavvix Corporation not be used in
 * advertising or publicity pertaining to this material without the
 * specific, prior written permission of an authorized representative of
 * iSavvix Corporation.
 *
 * ISAVVIX CORPORATION MAKES NO REPRESENTATIONS AND EXTENDS NO WARRANTIES,
 * EXPRESS OR IMPLIED, WITH RESPECT TO THE SOFTWARE, INCLUDING, BUT
 * NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND
 * FITNESS FOR ANY PARTICULAR PURPOSE, AND THE WARRANTY AGAINST
 * INFRINGEMENT OF PATENTS OR OTHER INTELLECTUAL PROPERTY RIGHTS.  THE
 * SOFTWARE IS PROVIDED "AS IS", AND IN NO EVENT SHALL ISAVVIX CORPORATION OR
 * ANY OF ITS AFFILIATES BE LIABLE FOR ANY DAMAGES, INCLUDING ANY
 * LOST PROFITS OR OTHER INCIDENTAL OR CONSEQUENTIAL DAMAGES RELATING
 * TO THE SOFTWARE.
 *
 */


package com.jspmyadmin;

import java.util.*;
import java.sql.*;


/**
  * Manages a java.sql.Connection pool.
  *
  * @author  Anil Hemrajani
  */
public class ConnectionPoolManager
{
    private Vector connections = new Vector(10);
    private Vector urls = new Vector(10);
    private String _driver   = null,
                   _url      = null,
                   _user     = null,
                   _password = null;
    private boolean _traceOn = false;
    private boolean initialized = false;
    private int _openConnections = 10;
    
    public ConnectionPoolManager() {}
    
    public void setDriver(String driver)
    {
        _driver = driver;
    }
    
    public void setDbURL(String url)
    {
        _url = url;
    }
    
    public void setUser(String user)
    {
        _user = user;
    }
    
    public void setPassword(String password)
    {
        _password = password;
    }
    
    /** Use this method to set the maximum number of open connections before 
        unused connections are closed.
      */
    public void setOpenConnectionCount(int count)
    {
        _openConnections = count;
    }
    
    
    public void setEnableTrace(boolean enable)
    {
       _traceOn = enable;
    }
    
    
    /** Returns a Vector of java.sql.Connection objects */
    public Vector getConnectionList()
    {
        return connections;
    }

     public Vector getUrlList()
    {
        return urls;
    }
    
    
    /** Opens specified "count" of connections and adds them to the existing pool */
    public synchronized void setInitOpenConnections(int count)
           throws SQLException
    {
        Connection c        = null;
        ConnectionObject co = null;
        
        for (int i=0; i < count; i++)
        {
            c  = createConnection();
            co = new ConnectionObject(c, false);
            
            connections.addElement(co);
            urls.addElement(this._url);
            trace("ConnectionPoolManager: Adding new DB connection to pool (" + connections.size() + ")");
        }
    }
    
    
    /** Returns a count of open connections */
    public int getConnectionCount()
    {
        return connections.size();
    }


    /** Returns an unused existing or new connection.  */
    public synchronized Connection getConnection()
           throws Exception
    {
        if (!initialized)
        {
            Class c = Class.forName(_driver);
            DriverManager.registerDriver((Driver)c.newInstance());
            
            initialized = true;
        }
        
        
        Connection c          = null;
        ConnectionObject co   = null;
        boolean badConnection = false;
        

        for (int i=0; i < connections.size(); i++)
        {
            co = (ConnectionObject)connections.elementAt(i);
            
            // If connection is not in use, test to ensure it's still valid!
            if (!co.inUse)
            {
                try
                {
                    badConnection = co.connection.isClosed();
                    if (!badConnection)
                        badConnection = (co.connection.getWarnings() != null);
                }
                catch (Exception e)
                {
                    badConnection = true;
                    e.printStackTrace();
                }
                    
                // Connection is bad, remove from pool
                if (badConnection)
                {
                    connections.removeElementAt(i);
                    trace("ConnectionPoolManager: Remove disconnected DB connection #" + i);
                    continue;
                }
                
                c = co.connection;
                co.inUse = true;
            
                trace("ConnectionPoolManager: Using existing DB connection #" + (i+1));
                break;
            }
        }

        if (c == null)
        {
            c = createConnection();
            co = new ConnectionObject(c, true);
            connections.addElement(co);
            urls.addElement(_url);
            
            trace("ConnectionPoolManager: Creating new DB connection #" + connections.size());
        }

        return c;
    }


    /** Marks a flag in the ConnectionObject to indicate this connection is no longer in use */
    public synchronized void releaseConnection(Connection c)
    {
        if (c == null)
            return;
            
        ConnectionObject co = null;

        for (int i=0; i < connections.size(); i++)
        {
            co = (ConnectionObject)connections.elementAt(i);
            if (c == co.connection)
            {
                co.inUse = false;
                break;
            }
        }

        for (int i=0; i < connections.size(); i++)
        {
            co = (ConnectionObject)connections.elementAt(i);
            if ((i+1) > _openConnections && !co.inUse)
               removeConnection(co.connection);
        }
    }


    /** Marks a flag in the ConnectionObject to indicate this connection is no longer in use */
    public synchronized void removeConnection(Connection c)
    {
        if (c == null)
            return;
            
        ConnectionObject co = null;
        for (int i=0; i < connections.size(); i++)
        {
            co = (ConnectionObject)connections.elementAt(i);
            if (c == co.connection)
            {
                try
                {
                    c.close();
                    connections.removeElementAt(i);
                    trace("Removed " + c.toString());
                }
                catch (Exception e)
                {
                    e.printStackTrace();
                }
                
                break;
            }
        }
    }


    private Connection createConnection()
            throws SQLException
    {
        Connection con = null;

        try
        {
            if (_user == null)
                _user = "";
            if (_password == null)
                _password ="";
            
            Properties props = new Properties();
            props.put("user",     _user);
            props.put("password", _password);

            con = DriverManager.getConnection(_url, props);
        }
        catch (Throwable t)
        {
            throw new SQLException(t.getMessage());
        }

        return con;
    }
    

    /** Closes all connections and clears out the connection pool */
    public void releaseFreeConnections()
    {
        trace("ConnectionPoolManager.releaseFreeConnections()");
        
        Connection c        = null;
        ConnectionObject co = null;
        
        for (int i=0; i < connections.size(); i++)
        {
            co = (ConnectionObject)connections.elementAt(i);
            if (!co.inUse)
                removeConnection(co.connection);
        }
    }
    

    /** Closes all connections and clears out the connection pool */
    public void finalize()
    {
        trace("ConnectionPoolManager.finalize()");
        
        Connection c        = null;
        ConnectionObject co = null;
        
        for (int i=0; i < connections.size(); i++)
        {
            co = (ConnectionObject)connections.elementAt(i);
            try
            {
                co.connection.close();
            }
            catch (Exception e)
            {
                e.printStackTrace();
            }
            
            co = null;
        }
        
        connections.removeAllElements();
    }
    
    
    private void trace(String s)
    {
       if (_traceOn)
           System.err.println(s);
    }


    /** Test driver. */
  /*  public static void main(String args[]) throws Exception
    {
        String dbDriver   = "org.gjt.mm.mysql.Driver",
               dbURL      = "jdbc:mysql://localhost/test",
               dbUser     = "root",
               dbPassword = "";
          
        ConnectionPoolManager cm = new ConnectionPoolManager();
        cm.setDriver(dbDriver);
        cm.setDbURL(dbURL);
        cm.setUser(dbUser);
        cm.setPassword(dbPassword);
        cm.setEnableTrace(true);
        cm.setOpenConnectionCount(2);
        
        Connection c  = cm.getConnection(), 
                   c2 = cm.getConnection(), 
                   c3 = cm.getConnection(),
                   c4 = cm.getConnection();
                   
        cm.releaseConnection(c2);
        cm.releaseConnection(c3);
        cm.releaseConnection(c4);
        
        System.out.println("Connection count = " + cm.getConnectionCount());
        
        Statement s   = c.createStatement();
        ResultSet rs  = s.executeQuery("SHOW DATABASES");

        while(rs.next())
           System.out.println(rs.getString(1));

        rs.close();
        s.close();
        cm.releaseConnection(c);
    }*/
}


class ConnectionObject
{
    public java.sql.Connection connection = null;
    public boolean inUse = false;
    
    public ConnectionObject(Connection c, boolean useFlag)
    {
        connection = c;
        inUse      = useFlag;
    }
}