数据库连接池

  数据库连接池，what we need is a simple connection pool ,hibernate ，ibatis神马的还是很庞大。

  So,I plan to build my own connection poll.

  How does it work ,we can follow the steps following.

（1）建立数据库连接池对象（服务器启动）。
（2）按照事先指定的参数创建初始数量的数据库连接（即：空闲连接数）。
（3）对于一个数据库访问请求，直接从连接池中得到一个连接。如果数据库连接池对象中没有空闲的连接，且连接数没有达到最大（即：最大活跃连接数），创建一个新的数据库连接。
（4）存取数据库。
（5）关闭数据库，释放所有数据库连接（此时的关闭数据库连接，并非真正关闭，而是将其放入空闲队列中。如实际空闲连接数大于初始空闲连接数则释放连接）。
（6）释放数据库连接池对象（服务器停止、维护期间，释放数据库连接池对象，并释放所有连接）。

 

import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.SQLException;
import java.util.Enumeration;
import java.util.Vector;

public class ConnectionManager
{
    private int inUse = 0;

    private String dbid =  "jdbc:mysql://localhost:3306/teasystem";
    
    private String drivername = "";

    private String username = "root";

    private String password = "123";

    private int maxconn = 20;

    private static ConnectionManager cm = new ConnectionManager();

    private ConnectionManager()
    {
        pool = new Vector<Connection>(maxNum);
    }

    // 连接池最大数量
    private int maxNum = 20;

    // 保存连接对象
    private Vector<Connection> pool;

    public synchronized Connection getConnection()
    {
        Connection con = null;
        if (pool.size() > 0)
        {
            con = (Connection) pool.elementAt(0);
            pool.removeElementAt(0);
            try
            {
                if (con.isClosed())
                {
                    con = getConnection();
                }
            }
            catch (Exception e)
            {
                e.printStackTrace();
            }
        }
        else if (maxconn == 0 || inUse < maxconn)
        {
            con = newConnection();
        }
        if (con != null)
        {
            inUse++;
        }
        return con;
    }

    private Connection newConnection()
    {
        Connection con = null;
        try
        {
            Class.forName(drivername);
            con = DriverManager.getConnection(dbid, username, password);
        }
        catch (Exception e)
        {
            e.printStackTrace();
            return null;
        }
        return con;
    }

    public synchronized void closeConn()
    {
        Enumeration<Connection> allConnections = pool.elements();
        while (allConnections.hasMoreElements())
        {
            Connection con = (Connection) allConnections.nextElement();
            try
            {
                con.close();
            }
            catch (SQLException e)
            {
                e.printStackTrace();
            }
        }
    }

    public static ConnectionManager getInstance()
    {
        if (null == cm)
        {
            return new ConnectionManager();
        }

        return cm;
    }

    public synchronized void reConnection(Connection conn)
    {
        Connection con = conn;
        pool.addElement(con);
        inUse--;

    }
}