java数据库连接池实例

  本文数据库连接池参考网络文章并做了一定修改，下面贴出全部代码，使用时直接调用即可。

package MySqlUtil;


import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.ResultSet;
import java.sql.ResultSetMetaData;
import java.sql.SQLException;
import java.sql.Statement;
import java.text.SimpleDateFormat;
import java.util.ArrayList;
import java.util.Date;
import java.util.HashMap;
import java.util.LinkedList;
import java.util.List;
import java.util.Map;


public class MySqlUtil {
// 驱动程序名
    String driver = "com.mysql.jdbc.Driver";
    // URL指向要访问的数据库名
    String url = "jdbc:mysql://127.0.0.1:3306/mypk?characterEncoding=utf-8"; //在加载jdbc驱动的时候设置字符集
    // MySQL配置时的用户名
    String user = "root"; 
    // MySQL配置时的密码
    String password = "root";
    
    int initialConnections = 2; // 连接池的初始大小
    int incrementalConnections = 2; // 连接池自动增加的大小
    int maxConnections = 10; // 连接池最大的大小
    static int sumConnections=0; // 创建的数据库连接总数
    static List<Connection> connections = null; // 存放连接池中数据库连接的list , 初始时为 null
    
    // 获取系统当前时间
  SimpleDateFormat df = new SimpleDateFormat("yyyy/MM/dd HH:mm:ss");//设置日期格式
  String nowtime=df.format(new Date());    
 
  // 创建连接池
  public synchronized void createPool() throws Exception {
  // 假如连接池己经创建了，保存连接的向量 connections 不会为空
        if (connections != null) {
            return; // 假如己经创建，则返回
        }
        
        // 创建保存连接的向量 , 初始时有 0 个元素
        connections = new LinkedList<Connection>();
        
        // 根据 initialConnections 中设置的值，创建连接。
        createConnections(initialConnections);
        
        System.out.println(" 数据库连接池创建成功！");
  }
 
  private void createConnections(int numConnections) throws SQLException {
  // 循环创建指定数目的数据库连接
        for (int i = 0; i < numConnections; i++) {
        // 假如连接数己经达到最大，即退出
        if(sumConnections>=maxConnections){
        break;
        }
        // 增加一个连接到连接池中（向量 connections 中）
            try {
            connections.add(newConnection());                
            } catch (Exception e) {
                System.out.println(" 数据库连接"+i+"创建失败！ " + e.getMessage());
                e.printStackTrace();
            }
            sumConnections++; // 数据库连接总数           
            System.out.println(" 数据库连接"+i+"己创建 ......");
        }
  }
 
  // 创建一个数据库连接 
  private Connection newConnection(){
  Connection conn=null;
  try{
  Class.forName(driver); // 加载驱动程序        
  conn = DriverManager.getConnection(url, user, password); // 连接数据库
  }
  catch(ClassNotFoundException e) {
        System.out.println("***************************************"); 
        System.out.println(nowtime+" Sorry, can't find the Driver!");
        System.out.println("***************************************"); 
            e.printStackTrace();
        } 
    catch(SQLException e) {
        e.printStackTrace();
        } 
    catch(Exception e) {
        e.printStackTrace();
        }
 
  return conn; // 返回创建的新的数据库连接
  }
 
  public synchronized Connection getConnection() throws SQLException {
        // 确保连接池己被创建
  if (connections == null) {
try {
createPool();
} 
catch (Exception ex) {
ex.printStackTrace();
}
     }
        Connection conn = getFreeConnection(); // 获得一个可用的数据库连接
        // 假如目前没有可以使用的连接，即所有的连接都在使用中
        try{
       while (conn == null) {
           // 暂停一会再试
        Thread.sleep(100);
           conn = getFreeConnection(); // 重新再试，直到获得可用的连接，假如
       }
        }
        catch(Exception e){
        e.printStackTrace();
        }
        return conn; // 返回获得的可用的连接
    }
 
  private Connection getFreeConnection() throws SQLException {
        // 从连接池中获得一个可用的数据库连接
        Connection conn = null;
        
        do{        
       // 遍历所有的对象，看是否有可用的连接
       if(connections.size()>0){
        conn=connections.get(0);
        connections.remove(0);        
       }
       else{
        // 创建一些连接
           createConnections(incrementalConnections);
           // 重新获得connection
           conn=connections.get(0);
        connections.remove(0);
       }
        }while(!conn.isValid(0));
        
        return conn;
    }
 
    public List<Map<String,String>> mysqlSelect(String sqlStr){
    List<Map<String, String>> list = new ArrayList<Map<String, String>>();
   
    try { 
            // 从连接池中找到可用连接
            Connection conn=getConnection();
            
            if(!conn.isClosed()){ 
            System.out.println(nowtime+" Succeeded selecting from the Database!");
            }
            // statement用来执行SQL语句
            Statement statement = conn.createStatement();            
            // 结果集
            ResultSet rs = statement.executeQuery(sqlStr);
            ResultSetMetaData md = rs.getMetaData(); //得到结果集(rs)的结构信息，比如字段数、字段名等 
            int columnCount = md.getColumnCount(); //返回此 ResultSet 对象中的列数  
            while(rs.next()){
            Map<String,String> map=new HashMap<String,String>();  
                for (int i = 1; i <= columnCount; i++) {   
                        map.put(md.getColumnName(i), rs.getObject(i).toString());   
                }   
            list.add(map);
            }            
            //关闭连接
            rs.close();            
            
            //使用完连接后，如果连接池数量大于初始值则关闭连接，否则扔回连接池中
            if(connections.size()>=initialConnections){            
            conn.close(); 
            sumConnections--;
            //System.out.println("关闭连接 sumConnections= "+sumConnections+"; connections.size()="+connections.size());
            }
            else{            
            connections.add(conn);
            //System.out.println("扔回连接池 sumConnections= "+sumConnections+"; connections.size()="+connections.size());
            }
        }
    catch(SQLException e) {
        e.printStackTrace();
        } 
    catch(Exception e) {
        e.printStackTrace();
        }
    //返回查询结果
    return list;
    }
    
    public int mysqlInsert(String sqlStr){
    int row=0;
    try{
    // 从连接池中找到可用连接
            Connection conn=getConnection();
   
            if(!conn.isClosed()){ 
            System.out.println(nowtime+" Succeeded inserting to the Database!");
            }
            // statement用来执行SQL语句
            Statement statement = conn.createStatement();
            // 执行插入操作
            row=statement.executeUpdate(sqlStr);
            conn.commit();
            
            //使用完连接后，如果连接池数量大于初始值则关闭连接，否则扔回连接池中
            if(connections.size()>=initialConnections){            
            conn.close();
            sumConnections--;
            }
            else{
            connections.add(conn);            
            }
    }    
    catch(SQLException e) {
        e.printStackTrace();
        } 
    catch(Exception e) {
        e.printStackTrace();
        }  
   
    return row;
    }
    
    public int mysqlUpdate(String sqlStr){
    int row=0;
    try{
    // 从连接池中找到可用连接
            Connection conn=getConnection();
            
            if(!conn.isClosed()){ 
            System.out.println(nowtime+" Succeeded updating to the Database!");
            }
            // statement用来执行SQL语句
            Statement statement = conn.createStatement();
            // 执行插入操作
            row=statement.executeUpdate(sqlStr);
            conn.commit();
            
            //使用完连接后，如果连接池数量大于初始值则关闭连接，否则扔回连接池中
            if(connections.size()>=initialConnections){
            conn.close(); 
            sumConnections--;
            }
            else{
            connections.add(conn);            
            }
    }
   
    catch(SQLException e) {
        e.printStackTrace();
        } 
    catch(Exception e) {
        e.printStackTrace();
        }
   
    return row;
    }
    
}