java实现简单的数据库连接池

最新推荐文章于 2024-06-26 14:30:57 发布
最新推荐文章于 2024-06-26 14:30:57 发布
阅读量836 收藏
点赞数
文章标签： 数据库连接池 java exception null string object
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/LGJ__FF/article/details/580864
版权

import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.SQLException;

/**
 *  基本功能描述:
 * 数据库连接池类 DatabaseConnectionPool.提供如下的方法:
 * 1.从池中取得一个打开的连接;
 * 2.将一个连接返回池中;
 * 3.在关闭时释放所有的资源，并关闭所有的连接.
 * 4.DatabaseConnectionPool 还处理连接失败,比如超时,通讯失败等错误,并且根据预定义的参数限制池中的连接数.
 */

public class DatabaseConnectionPool extends Object {
 
 private String URL = null; //数据库URL
 private String user = null; //数据库登录名
 private String password = null; //数据库登录名
 
 private int capacityOfConnectionPool = 0; //数据库连接池最大连接数
 private int activeConnectionsOfConnectionPool = 0; //已经建立数据库连接的连接数

 
 private final int DEFAULT_CONNECTION_CAPACITY = 10;
 private final int DEFAULT_ACTIVE_CONNECTION = 1;
 
 private ObjectFIFOQueue idleGenericConnectionQueue = null; //空闲数据库连接队列
 private Connection[]  genericConnectionReferenceList = null; //所有已经建立连接的数据库连接引用列表,避免连接引用丢失(资源泄漏)
 
 public DatabaseConnectionPool(String driverName,String URL,String user,String password,
     int capacityOfConnectionPool,int activeConnectionsOfConnectionPool)
      throws Exception
 {
  
  this.URL = URL;
  this.user = user;
  this.password = password;
  
  this.capacityOfConnectionPool = capacityOfConnectionPool;
  
  this.capacityOfConnectionPool = (this.capacityOfConnectionPool > 0)? this.capacityOfConnectionPool:DEFAULT_CONNECTION_CAPACITY;
  activeConnectionsOfConnectionPool = (activeConnectionsOfConnectionPool > 0)? activeConnectionsOfConnectionPool:DEFAULT_ACTIVE_CONNECTION;  
  activeConnectionsOfConnectionPool = (this.capacityOfConnectionPool >= activeConnectionsOfConnectionPool)? activeConnectionsOfConnectionPool:this.capacityOfConnectionPool;    
  
  System.out.println("DatabaseConnectionPool : capacityOfConnectionPool = " + capacityOfConnectionPool);
  System.out.println("DatabaseConnectionPool : activeConnectionsOfConnectionPool = " + activeConnectionsOfConnectionPool);
  System.out.println("DatabaseConnectionPool : this.activeConnectionsOfConnectionPool = " + this.activeConnectionsOfConnectionPool);
  
  if (!loadDriver(driverName))
  {
   throw new Exception("Loading DataBase's Driver Failed.");
  }
  
  idleGenericConnectionQueue = new ObjectFIFOQueue(capacityOfConnectionPool);
  
  genericConnectionReferenceList = new Connection[capacityOfConnectionPool];
  
  int lengthOfgenericConnectionReferenceList = genericConnectionReferenceList.length;
  for (int index = 0; index < lengthOfgenericConnectionReferenceList; index++)
  {
   genericConnectionReferenceList[index] = null;
  }
  
  for (int index = 0; index < activeConnectionsOfConnectionPool; index++)
  {
   if (genericConnectionReferenceList[index] == null)
   {
    
    //genericConnectionReferenceList[index] = getConnection(URL,user,password);
    genericConnectionReferenceList[index] = establishConnection(URL,user,password);
    
    if (genericConnectionReferenceList[index] == null)
    {
     //this.activeConnectionsOfConnectionPool--;  //bug
     System.out.println("DatabaseConnectionPool : Initialize Active Connection Failed. Index = " + index);
    }
    else
    {
     this.activeConnectionsOfConnectionPool++;
     idleGenericConnectionQueue.add(genericConnectionReferenceList[index]);
     System.out.println("DatabaseConnectionPool : Initialize Active Connection OK. Index = " + index);
    }
    
   }
  }
  
 }
 
 
 private boolean loadDriver(String driverName)
 {
  
  boolean flags = false;
  
  try
  {
   Class.forName(driverName).newInstance();
   System.out.println("loadDriver : Driver Loading...");
   flags = true;
  }
  catch (InstantiationException ex)
  {
   ex.printStackTrace();
   flags = false;
  }
  catch (IllegalAccessException ex)
  {
   ex.printStackTrace();
   flags = false;
  }
  catch (ClassNotFoundException ex)
  {
   ex.printStackTrace();
   flags = false;
  }
  catch (Exception ex)
  {
   ex.printStackTrace();
   flags = false;
  }
  finally
  {
  }
  
  return flags;
 }
 
 //建立新连接
 private Connection establishConnection(String URL,String user,String password)
 {
  
  Connection genericConnection = null;

  try
  {
   genericConnection = DriverManager.getConnection(URL, user, password);
   System.out.println("establishConnection : Created a new Connection in DatabaseConnectionPool.");
  }
  catch (SQLException ex)
  {
   System.out.println("establishConnection : SQLException.");
   ex.printStackTrace();
   genericConnection = null;
  }
  catch (Exception ex)
  {
   System.out.println("establishConnection : Exception.");
   ex.printStackTrace();
   genericConnection = null;
  }
  finally
  {
  }
  
  return genericConnection;
  
 }
 
 //从池中打开/得到一个连接
 //public synchronized Connection getConnection(String URL,String user,String password)
 public synchronized Connection getConnection()
       throws Exception
 {

  Connection genericConnection = null;
  
  System.out.println("getConnection : capacityOfConnectionPool = " + capacityOfConnectionPool);
  System.out.println("DatabaseConnectionPool : this.activeConnectionsOfConnectionPool = " + this.activeConnectionsOfConnectionPool);
  
  if (activeConnectionsOfConnectionPool < capacityOfConnectionPool)
  {
    if (idleGenericConnectionQueue.isQueueEmpty())
    {
    System.out.println("getConnection : idleGenericConnectionQueue isQueueEmpty.");
    
     genericConnection = establishConnection(URL,user,password);
     
     System.out.println("getConnection : establishConnection Returned.");
     
     if (genericConnection != null)
     {
      activeConnectionsOfConnectionPool++;
      
      int lengthOfgenericConnectionReferenceList = genericConnectionReferenceList.length;
      for (int index = 0; index < lengthOfgenericConnectionReferenceList; index++)
      {
       if (genericConnectionReferenceList[index] == null)
       {
        System.out.println("getConnection : Creating Index = " + index);
        genericConnectionReferenceList[index] = genericConnection;
        break;
       }
      }

     }
     else
     {
      System.out.println("getConnection : establishConnection Returned Null.");
     }
     
    try
    {
     if (genericConnection != null)
     {
      if (genericConnection.isClosed())
      {
       System.out.println("getConnection : Creating -- genericConnection is Closed.");
      }
     }
    }
    catch (SQLException ex)
    {
    }
    catch (Exception ex)
    {
    }  
    finally
    {
    }     
     
    System.out.println("getConnection : Returning New Connection.");
    
     return genericConnection;
    }
  }
  
  //得到的连接可能已经关闭
  genericConnection = (Connection)idleGenericConnectionQueue.remove(); //block
  
  try
  {
   if (genericConnection.isClosed())
   {
    System.out.println("getConnection : Getting -- genericConnection is Closed.");
   }
  }
  catch (SQLException ex)
  {
  }
  catch (Exception ex)
  {
  }  
  finally
  {
  }
  
  System.out.println("getConnection : Returning Existing Connection.");
  return genericConnection;
  
 }
 
 //回收连接池中已经关闭的连接/空引用的连接
 public synchronized void collectInvalidateConnection()
 {
  
  int activeConnectionsOfConnectionPool = 0;
  int lengthOfgenericConnectionReferenceList = genericConnectionReferenceList.length;
  
  for (int index = 0; index < lengthOfgenericConnectionReferenceList; index++)
  {
   
   if (genericConnectionReferenceList[index] != null)
   {
    
    try
    {
     if (genericConnectionReferenceList[index].isClosed())
     {
      genericConnectionReferenceList[index] = null;
      System.out.println("collectInvalidateConnection : Collecting... Index = " + index);
     }
     else
     {
      activeConnectionsOfConnectionPool++;
     }
    }
    catch (SQLException ex)
    {
     System.out.println("collectInvalidationConnection : SQLException." );
     ex.printStackTrace();
    }    
    catch (Exception ex)
    {
     System.out.println("collectInvalidationConnection : Exception." );
     ex.printStackTrace();
    }
    finally
    {
    }
    
   }
   
  }
  
  this.activeConnectionsOfConnectionPool = activeConnectionsOfConnectionPool;
 }
 
 
 //将一个连接返回池中
 public synchronized void freeConnection(Connection genericConnection)
               throws Exception
 {
  idleGenericConnectionQueue.add(genericConnection);
  System.out.println("freeConnection : Freeing Connection.");
 }
 
 //释放数据库连接池资源
 public synchronized void releaseDatabaseConnectionPool()
              throws Exception
 {
  
  //release genericConnectionReferenceList
  int lengthOfgenericConnectionReferenceList = genericConnectionReferenceList.length;
   
  for (int index = 0;index < lengthOfgenericConnectionReferenceList;index++)
  {
   try
   {
    if (genericConnectionReferenceList[index] != null)
    {
     if (!genericConnectionReferenceList[index].isClosed())
     {
      genericConnectionReferenceList[index].close();
      genericConnectionReferenceList[index] = null;
      System.out.println("releaseDatabaseConnectionPool : Index = " + index);
     }
    }
   }
   catch (SQLException ex)
   {
    System.out.println("releaseDatabaseConnectionPool : SQLException." );
    ex.printStackTrace();
   }
   catch (Exception ex)
   {
    System.out.println("releaseDatabaseConnectionPool : Exception." );
    ex.printStackTrace();
   }
   finally
   {
   }
  }
  
  if (genericConnectionReferenceList != null)
  {
   genericConnectionReferenceList = null;
  }  
  
  
  //release idleGenericConnectionQueue
  if (!idleGenericConnectionQueue.isQueueEmpty())
  {
   idleGenericConnectionQueue.removeAll();
  }
  if (idleGenericConnectionQueue != null)
  {
   idleGenericConnectionQueue = null;
  }
  
 }

 
}

 

 

下面的FIFO队列程序引自: Java Thread Programming (Sams)


import java.sql.Driver;
import java.sql.DriverManager;
import java.sql.Connection;
import java.sql.SQLException;

import java.util.Properties;
import java.util.Hashtable;
import java.util.Enumeration;

 

public class ObjectFIFOQueue extends Object { 
 
   private Object[] queue; 
     private int capacity; 
 
    private int size; 
 
       private int head; 
 
        private int tail; 
       
   public ObjectFIFOQueue(int cap) { 
 
    capacity = ( cap > 0 ) ? cap : 1; // at least 1 
 
   queue = new Object[capacity]; 
 
     head = 0; 
 
      tail = 0; 
 
         size = 0; 
 
      } 


   public int getCapacity() { 
 
      return capacity; 
 
    } 
 


   public synchronized int getSize() { 
 
          return size; 
 
    } 
 

      public synchronized boolean isQueueEmpty() { 
 
          return ( size == 0 ); 
 
      } 
 

     public synchronized boolean isFull() { 
 
       return ( size == capacity ); 
 
    } 
 
  
     public synchronized void add(Object obj)  
 
            throws InterruptedException { 
 
 
 
        waitWhileFull(); 
 
 
 
          queue[head] = obj; 
 
           head = ( head + 1 ) % capacity; 
 
       size++; 
 
 
 
        notifyAll(); // let any waiting threads know about change 
 
    } 
 

  public synchronized void addEach(Object[] list)  
 
          throws InterruptedException { 
 
  for ( int i = 0; i < list.length; i++ ) { 
 
          add(list[i]); 
 
          } 
 
      } 

 
     public synchronized Object remove()  
 
         throws InterruptedException { 
 

 
         waitWhileEmpty(); 
 
 
 
     Object obj = queue[tail]; 
 
         queue[tail] = null;  
 

 
     tail = ( tail + 1 ) % capacity; 
 
         size--; 
 
  
 
      notifyAll(); // let any waiting threads know about change 
 
 
 
       return obj; 
 
     } 
 
 
    
     public synchronized Object[] removeAll()  
 
            throws InterruptedException { 
 
 
      Object[] list = new Object[size]; // use the current size 
 
 
 
       for ( int i = 0; i < list.length; i++ ) { 
 
           list[i] = remove(); 
 
        } 
 
 
 
       // if FIFO was empty, a zero-length array is returned 
 
         return list;  
   } 
 
    
     public synchronized Object[] removeAtLeastOne()  
 
               throws InterruptedException { 
 

           waitWhileEmpty(); // wait for at least one to be in FIFO 
      return removeAll(); 
 
    } 
 
     public synchronized boolean waitUntilEmpty(long msTimeout)  
 
              throws InterruptedException { 
 

 
        if ( msTimeout == 0L ) { 
 
              waitUntilEmpty();  // use other method 
 
           return true; 
 
         } 
 
        // wait only for the specified amount of time 
 
       long endTime = System.currentTimeMillis() + msTimeout; 
 
       long msRemaining = msTimeout; 
 
         while ( !isQueueEmpty() && ( msRemaining > 0L ) ) { 
 
             wait(msRemaining); 
 
              msRemaining = endTime - System.currentTimeMillis(); 
 
        } 
 
  
 
        // May have timed out, or may have met condition,  
 
          // calc return value. 
 
        return isQueueEmpty(); 
 
     } 
 
 
 
     public synchronized void waitUntilEmpty()  
 
            throws InterruptedException { 
 
 
 
        while ( !isQueueEmpty() ) { 
 
            wait(); 
 
         } 
      } 
 
  
 
       public synchronized void waitWhileEmpty()  
 
            throws InterruptedException { 
 
        while ( isQueueEmpty() ) { 
 
           wait(); 
 
          } 
 
     } 
 
 
       public synchronized void waitUntilFull()  
 
             throws InterruptedException { 
 
 
 
          while ( !isFull() ) { 
 
           wait(); 
 
           } 
 
      } 
 
   
 
     public synchronized void waitWhileFull()  
 
              throws InterruptedException { 
 
   
 
         while ( isFull() ) { 
 
            wait(); 
 
        } 
 
     } 
 
   }
 

LGJ__FF
关注
OKHttp开源框架学习十：ConnectionPool连接池
songzi1228的博客
06-27 4384
目录 系列文章： 简介： 以下是几个重要的参数： 接下来，我们来看ConnectionPool的构造方法： ConnectionPool的get方法： ConnectionPool的put方法： ConnectionPool的回收： 我们知道okhttp是可以通过连接池来减少请求延时的，那么这一点是怎么实现的呢？ 系列文章： OKHttp开源框架学习一：同步请求总结 OKH...
java mysql创建数据库连接池_Java数据库连接池
weixin_36383052的博客
01-27 910
一、关于数据库连接池一个普通的java程序，要查询数据库的数据，基本流程是这样的：查询数据基本流程.jpg可以看到，进行一次查询，要进行很多次网络交互，这样的缺点是：网络IO多；响应时间长，导致QPS降低；频繁创建连接和关闭连接，浪费数据库资源，影响服务器性能。什么是数据库连接池？顾名思义，就是一个池子，里面放着数据库连接，应用服务需要的时候就去池子里面拿，用完之后归还给池子。数据库连接池负责分配...
在Java中实现数据库连接池
最新发布
微赚开发者技术分享博客
06-26 320
大家好，我是免费搭建查券返利机器人省钱赚佣金就用微赚淘客系统3.0的小编，也是冬天不穿秋裤，天冷也要风度的程序猿！在Java应用程序中，有效管理数据库连接是提高性能和资源利用率的关键。数据库连接池是一种重要的设计模式，它可以帮助开发人员避免频繁地创建和销毁数据库连接，从而提高应用程序的响应速度和效率。本文将探讨如何在Java中实现数据库连接池，以及一些最佳实践和性能优化策略。
JAVA数据库连接池实现
Hello World
11-03 401
连接池的管理用了了享元模式，这里对连接池进行简单设计。 一、设计思路      1.连接池配置属性DBbean：里面存放可以配置的一些属性      2.连接池接口IConnectionPool：里面定义一些基本的获取连接的一些方法      3.接口实现ConnectionPool：对上面操作进行实现，并加入一些其他方法      4.连接池管理ConnectionPoolManag...
Java数据库连接池实现
weixin_34212762的博客
10-23 107
至于Java数据库连接池的原理就不细说了，百度一下大把。在这里只是把个人学习中的结果积累下来。 代码上也基本都有注释。 首先写一个读取本地数据库驱动，数据库用户名、数据库密码、连接数的类。 XML/HTML代码复制内容到剪贴板 packagecn.cate.utils; importjava.io.FileNot...
java 实现数据库连接池_java实现数据库连接池
weixin_39969976的博客
02-12 132
连接池管理类import java.sql.Connection;import java.sql.DriverManager;import java.sql.SQLException;import java.util.Vector;import com.mysql.jdbc.Driver;/*** ConnectionManager** 数据库连接** @author bzwm** @versio...
java实现 数据库连接池_java实现数据库连接池
weixin_36186183的博客
02-21 275
packagenju.iip.dao;importjava.sql.Connection;importjava.sql.DriverManager;importjava.util.Map;importjava.util.Map.Entry;importjava.util.concurrent.ConcurrentHashMap;importnju.iip.util.Config;importorg...
Java实现数据库连接池简易教程
09-02
Java实现数据库连接池简易教程主要涉及了如何在Java应用程序中创建并管理数据库连接池。数据库连接池是一种优化数据库操作的技术，通过复用已存在的数据库连接，减少频繁创建和关闭连接带来的性能开销。本文将介绍一...
JAVA实现数据库连接池代码
07-31
基于JAVA语言的一种有效的数据库连接池的实现代码。
java实现mongodb的数据库连接池
09-03
总结起来，Java实现MongoDB的数据库连接池主要是通过配置连接池参数，并利用MongoDB的Java驱动库创建和管理连接。这不仅能优化数据库性能，还能提升应用程序的稳定性。同时，合理设置连接池参数，以及适当地管理和...
java实现数据库连接池
新blog:http://www.blogjava.net/jnbzwm/
02-03 2134
连接池管理类 import java.sql.Connection;import java.sql.DriverManager;import java.sql.SQLException;import java.util.Vector;import com.mysql.jdbc.Driver;/** * ConnectionManager * * 数据库连接
Java数据库连接池原理代码
09-20 1178
package org.cgz.encodingfilter; import java.sql.Connection;import java.sql.DatabaseMetaData;import java.sql.Driver;import java.sql.DriverManager;import java.sql.SQLException;impo
Java 数据库连接池的实现
小坏蛋博客
07-25 408
连接池的实现 一般来说，Java应用程序访问数据库的过程是： ① 装载数据库驱动程序； ② 通过jdbc建立数据库连接； ③ 访问数据库，执行sql语句； ④ 断开数据库连接。 编写连接池需实现方法，定义了Connection getConnection()方法用于连接池实现和close()方法用于关闭连接。 实现连接池功能的步骤 ① 首先编写db.properties数据库配置文件 ② 在Ut...
Java自制数据库连接池实现详解
"Java数据库连接池简易教程" 在Java开发中，数据库连接池是优化数据库访问性能的重要工具。本文将简要介绍如何实现一个简单的数据库连接池，并探讨其设计原理和重要性。 一、数据库连接池的基本概念 数据库连接池...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值