JavaBean数据库连接池

主要由下面三个文件组成：

db.properties

driver=sun.jdbc.odbc.JdbcOdbcDriver
url=Jdbc:Odbc:catalog
username=catalog
password=catalog
size=2
maxsize=4

 

java 代码

package database;


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

//对数据库连接池进行管理与维护

public class ConnectionPool extends Thread
{
  //保存缓存的数据库连接对象
  private ArrayList pool=new ArrayList();

  private String driver;
  private String url;
  private String username;
  private String password;
  private int size;
  private int maxsize;


  private void initJDBC()
  {
    try
    {
      //从配置文件中加载数据库驱动程序信息
      InputStream fin=this.getClass().getResourceAsStream("/db.properties");
      Properties prop=new Properties();
      prop.load(fin);


      driver=prop.getProperty("driver","sun.jdbc.odbc.JdbcOdbcDriver");
      url=prop.getProperty("url","jdbc:odbc:catalog");
      username=prop.getProperty("username","catalog");
      password=prop.getProperty("password","catalog");
      size=Integer.parseInt(prop.getProperty("size","2"));
      maxsize=Integer.parseInt(prop.getProperty("maxsize","4"));

      Class.forName(driver);
    }
    catch(Exception e)
    {
      e.printStackTrace();
    }
  }
  //初始化数据库连接池
  private synchronized void initConnectionPool()
  {
    try
    {
      for(int i=0;i       {
        Connection con=DriverManager.getConnection(url,username,password);
        con.setAutoCommit(false);
        PooledConnection pcon=new PooledConnection(con);
        pcon.setInuse(false);


        pool.add(pcon);
      }
    }
    catch(Exception e)
    {
      e.printStackTrace();
    }
  }

  //申请数据库连接对象
  public synchronized Connection applyConnection()
  {
    Connection con=null;
    for(int i=pool.size()-1;i>=0;i--)
    {
      PooledConnection pcon=(PooledConnection)pool.get(i);
      if(!pcon.isInuse())
      {
        pcon.setInuse(true);
        return pcon.getConnection();
      }
    }
    try
    {
      con=DriverManager.getConnection(url,username,password);
      con.setAutoCommit(false);

      PooledConnection pcon=new PooledConnection(con);
      pcon.setInuse(true);

      pool.add(pcon);
    }
    catch(Exception e)
    {
      e.printStackTrace();
    }
    return con;
  }

  //释放数据库连接对象
  public synchronized void releaseConnection(Connection con)
  {
    for(int i=pool.size()-1;i>=0;i--)
    {
      PooledConnection pcon=(PooledConnection)pool.get(i);
      if(pcon.getConnection().equals(con))
      {
        pcon.setInuse(false);
        return;
      }
    }
  }


  //关闭数据库连接池
  public synchronized void closeConnectionPool()
  {
    try
    {
      for(int i=pool.size()-1;i>=0;i--)
      {
        PooledConnection pcon=(PooledConnection)pool.get(i);
        if(pcon.isInuse())
        {
          Thread.sleep(500);
        }
        pcon.close();
        pool.remove(pcon);
      }
    }
    catch(Exception e)
    {
      e.printStackTrace();
    }
  }

  public void run()
  {
    while(true)
    {
      try
      {
        synchronized(this)
        {
          while(pool.size()>maxsize)
          {
            PooledConnection pcon=null;

            for(int i=pool.size()-1;i>=0;i--)
            {
              PooledConnection pn=(PooledConnection) pool.get(i);
              if(!pn.isInuse())
              {
                pcon=pn;
              }
              if(pcon!=null)
              {
                pool.remove(pcon);
              }
              else
              {
                break;
              }
            }
          }
        }
        Thread.sleep(1000*60);
      }
      catch(Exception e)
      {
        e.printStackTrace();
      }
    }
  }

  private static ConnectionPool conPool=new ConnectionPool();
  private ConnectionPool()
  {
    this.initJDBC();
    this.initConnectionPool();

    this.start();
  }


  public static ConnectionPool getInstance()
  {
    return conPool;
  }
}

 

PooledConnection.java

java 代码

package database;

import java.sql.*;


public class PooledConnection
{
  //保存真实的数据库连接对象
  private Connection con;
  //设立一个标志位，表示此数据库连接对象是否处于空闲状态
  private boolean inuse;

  public PooledConnection(Connection con)
  {
    this.con=con;
  }
  public Connection getConnection()
  {
    return con;
  }
  //设置数据库连接对象处于使用状态
  public void setInuse(boolean inuse)
  {
    this.inuse=inuse;
  }
  //判断数据库连接对象是否为使用状态
  public boolean isInuse()
  {
    return this.inuse;
  }
  //关闭真实的数据库连接对象
  public void close()
  {
    try
    {
      if(con!=null)
      {
        con.close();
      }
      con=null;
    }
    catch(Exception e)
    {
      e.printStackTrace();
    }
  }
}


 ConnectionPool.java