JDBC整合c3p0數據庫連接池 解決Too many connections錯誤

　　前段時間，接手一個項目使用的是原始的jdbc作為數據庫的訪問，發布到服務器上在運行了一段時間之后總是會出現無法訪問的情況，登錄到服務器，查看tomcat日志發現總是報如下的錯誤。

　　

Caused by: com.mysql.jdbc.exceptions.jdbc4.MySQLNonTransientConnectionException: Data source rejected establishment of connection,  message from server: "Too many connections"
    at sun.reflect.GeneratedConstructorAccessor43.newInstance(Unknown Source)
    at sun.reflect.DelegatingConstructorAccessorImpl.newInstance(DelegatingConstructorAccessorImpl.java:45)
    at java.lang.reflect.Constructor.newInstance(Constructor.java:526)
    at com.mysql.jdbc.Util.handleNewInstance(Util.java:406)
    at com.mysql.jdbc.Util.getInstance(Util.java:381)
    at com.mysql.jdbc.SQLError.createSQLException(SQLError.java:984)
    at com.mysql.jdbc.SQLError.createSQLException(SQLError.java:956)
    at com.mysql.jdbc.MysqlIO.doHandshake(MysqlIO.java:1095)
    at com.mysql.jdbc.ConnectionImpl.createNewIO(ConnectionImpl.java:2181)
    ... 32 more
com.mysql.jdbc.exceptions.jdbc4.MySQLNonTransientConnectionException: Could not create connection to database server. Attempted reconnect 3 times. Giving up.

　　

Data source rejected establishment of connection, message from server: "Too many connections"
通過對這句話的分析可以得知，是因為數據庫的連接太多了，數據庫連接被拒絕了，導致了項目的無法訪問。
於是先查看MySql最大連接數

show variables like "max_connections";

　顯示當前正在執行的MySql連接

show processlist ;

　通過這兩個數據的對比，發現MySql的連接數居然滿了，於是修改了MySql的最大連接數至2000，重啟項目之后發現一切正常，過了一段時間之后，繼續查詢MySql的連接狀態，發現MySql的連接數不停的在飆升，不一會的功夫連接數又滿了，這時候，我開始意識到是項目的代碼出現了問題，於是我開始審查代碼，發現項目中使用的JdbcUtils工具類並不是單例模式，在每次使用JdbcUtils的時候都會new一個JdbcUtils對象，在創建對象的時候會使用java.sql.Connection建立連接，但是在使用完JdbcUtils的時候，我們並沒有調用Connection的close()方法，這樣導致使用jdbc連接數據庫的時候會導致連接數越來越多，然而沒用的連接數卻沒有釋放掉，最終到時數據庫連接報錯，項目無法使用數據庫了。

　　於是我覺得應該使用數據庫連接池來整合jdbc，連接池的介紹如下：

　　對於共享資源，有一個很著名的設計模式：資源池（Resource Pool）。該模式正是為了解決資源的頻繁分配﹑釋放所造成的問題。為解決我們的問題，可以采用數據庫連接池技術。數據庫連接池的基本思想就是為數據庫連接建立一個“緩沖池”。預先在緩沖池中放入一定數量的連接，當需要建立數據庫連接時，只需從“緩沖池”中取出一個，使用完畢之后再放回去。我們可以通過設定連接池最大連接數來防止系統無盡的與數據庫連接。更為重要的是我們可以通過連接池的管理機制監視數據庫的連接的數量﹑使用情況，為系統開發﹑測試及性能調整提供依據。

　　

傳統的獲取連接方式如下圖所示：

 

用戶每次請求都需要向數據庫獲得鏈接，而數據庫創建連接通常需要消耗相對較大的資源，創建時間也較長。假設網站一天10萬訪問量，數據庫服務器就需要創建10萬次連接，極大的浪費數據庫的資源，並且極易造成數據庫服務器內存溢出、拓機。

 

采用連接池技術后的過程如下：

 

數據庫連接是一種關鍵的有限的昂貴的資源，這一點在多用戶的網頁應用程序中體現的尤為突出。對數據庫連接的管理能顯著影響到整個應用程序的伸縮性和健壯性，影響到程序的性能指標。數據庫連接池負責分配，管理和釋放數據庫連接，它允許應用程序重復使用一個現有的數據庫連接，而不是重新建立一個。

 

C3P0連接池

c3p0是一個開源的JDBC連接池，它實現了數據源和JNDI綁定，支持JDBC3規范和JDBC2的標准擴展。c3p0一般是與Hibernate，Spring等框架一塊使用的，當然也可以單獨使用。

dbcp沒有自動回收空閑連接的功能，c3p0有自動回收空閑連接功能。

使用c3p0需要導入c3p0.jar、mchange-commons-.jar，如果操作的是Oracle數據庫，那么還需要導入c3p0-oracle-thin-extras-pre1.jar。

下面開始使用C3P0整合JDBC

數據庫配置：

#Oracle Config
#jdbc.driver=oracle.jdbc.driver.OracleDriver
#jdbc.url=jdbc:oracle:thin:@localhost:1521:ora9i
#jdbc.username=qq
#jdbc.pwd=qq

#MySQL Config
jdbc.driver=com.mysql.jdbc.Driver
jdbc.url=jdbc:mysql://localhost:3306/test
jdbc.username=jdbctest
jdbc.pwd=123456

DBUtils，初始化連接池配置，設置數據庫的最大連接數和最小連接數

package hn.veryedu.jdbc.common.db;

import java.io.FileInputStream;

import java.io.FileNotFoundException;
import java.io.IOException;
import java.sql.Connection;
import java.sql.ResultSet;
import java.sql.SQLException;
import java.sql.Statement;
import java.util.HashMap;
import java.util.Map;
import java.util.Properties;

import javax.sql.DataSource;

import com.mchange.v2.c3p0.DataSources;

public class DBUtils {
    
    private static String url = null;
    
    private static String username = null;
    
    private static String pwd = null;
    
    private static DataSource ds_pooled;
    /** 
     *  加載數據庫連接的配置文件和驅動
     */
    static{
        FileInputStream fis = null;
        
        Properties env = new Properties();
        try {
            fis = new FileInputStream("dbconfig.properties");
            //加載屬性文件中的數據庫配置信息
            //以=左邊作為key值，右邊作為value值
            env.load(fis); 
            
            //1. 加載驅動類
            Class.forName(env.getProperty("jdbc.driver"));
            
            url = env.getProperty("jdbc.url");
            username = env.getProperty("jdbc.username");
            pwd = env.getProperty("jdbc.pwd");
            
            //設置連接數據庫的配置信息
            DataSource ds_unpooled = DataSources
                    .unpooledDataSource(url, username, pwd);
            
            
            
            Map<String, Object> pool_conf = new HashMap<String, Object>();
            //設置最大連接數
            pool_conf.put("maxPoolSize", 20);
            //連接池應該保有的最小連接的數量
            pool_conf.put("minPoolSize", 2);
            //初始化連接池時，獲取的連接個數
            pool_conf.put("initialPoolSize", 10);
            //當連接池中已經沒有連接時，連接池自動獲取連接時一次獲取的連接個數
            pool_conf.put("acquireIncrement", 3);
            ds_pooled = DataSources.pooledDataSource(ds_unpooled,
                    pool_conf);
        } catch (FileNotFoundException e) {
            e.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace();
        } catch (ClassNotFoundException e) {
            e.printStackTrace();
        } catch (SQLException e) {
            e.printStackTrace();
        }
    }
    
    /**
     *  獲取連接對象
     */
    public static Connection getConnection()  {
        // 2. 設置連接的url,username,pwd
        Connection connection = null;
        try {
            connection = ds_pooled.getConnection();
            //connection.prepareStatement("set names utf8mb4").executeQuery();
        } catch (SQLException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
        return connection;
    }
    
    /**
     * 釋放連接池資源
     */
    public static void clearup(){
        if(ds_pooled != null){
            try {
                DataSources.destroy(ds_pooled);
            } catch (SQLException e) {
                e.printStackTrace();
            }
        }
    }
    
    
    /**
     * 資源關閉
     * 
     * @param rs
     * @param stmt
     * @param conn
     */
    public static void close(ResultSet rs, Statement stmt
            , Connection conn) {
        if (rs != null) {
            try {
                rs.close();
            } catch (SQLException e) {
                e.printStackTrace();
            }
        }

        if (stmt != null) {
            try {
                stmt.close();
            } catch (SQLException e) {
                e.printStackTrace();
            }
        }

        if (conn != null) {
            try {
                conn.close();
            } catch (SQLException e) {
                e.printStackTrace();
            }
        }
    }
}

然后是JdbcUtils查詢各種數據List、Map等，通過DBUtils獲取數據庫連接，使用完成之后釋放所有的連接

package hn.veryedu.jdbc.common.db;

import java.lang.reflect.Field;  
import java.sql.Connection;   
import java.sql.PreparedStatement;  
import java.sql.ResultSet;  
import java.sql.ResultSetMetaData;  
import java.sql.SQLException;  
import java.util.ArrayList;  
import java.util.HashMap;  
import java.util.List;  
import java.util.Map;  
  
  
  
public class JdbcUtils {  
    private Connection connection;
    private PreparedStatement pstmt;
    private ResultSet resultSet;
    
      
    /** 
     * 獲得數據庫的連接 
     * @return 
     * @throws SQLException 
     */  
    public Connection getConnection() throws SQLException{  
        connection = DBUtils.getConnection(); 
        //如果數據庫支持utf8mb4 建立連接后需要使用下面的代碼
        //connection.prepareStatement("set names utf8mb4").executeQuery();
        return connection;  
    } 
    
      
      
      
    /** 
     * 增加、刪除、改 
     * @param sql 
     * @param params 
     * @return 
     * @throws SQLException 
     */  
    public boolean updateByPreparedStatement(String sql, List<Object> params)throws SQLException{
        boolean flag = false;
        int result = -1;
        this.getConnection();
        pstmt = connection.prepareStatement(sql);
        int index = 1;
        if(params != null && !params.isEmpty()){
            for(int i=0; i<params.size(); i++){
                pstmt.setObject(index++, params.get(i));
            }
        }
        result = pstmt.executeUpdate();
        flag = result > 0 ? true : false;
        this.releaseConn();
        return flag;  
    }
  
    /** 
     * 查詢單條記錄 
     * @param sql 
     * @param params 
     * @return 
     * @throws SQLException 
     */  
    public Map<String, Object> findSimpleResult(String sql, List<Object> params) throws SQLException{  
        Map<String, Object> map = new HashMap<String, Object>();  
        int index  = 1;
        this.getConnection();
        pstmt = connection.prepareStatement(sql);  
        if(params != null && !params.isEmpty()){  
            for(int i=0; i<params.size(); i++){  
                pstmt.setObject(index++, params.get(i));  
            }  
        }  
        resultSet = pstmt.executeQuery();//返回查詢結果  
        ResultSetMetaData metaData = resultSet.getMetaData();  
        int col_len = metaData.getColumnCount();  
        while(resultSet.next()){  
            for(int i=0; i<col_len; i++ ){  
                String cols_name = metaData.getColumnName(i+1);  
                Object cols_value = resultSet.getObject(cols_name);  
                if(cols_value == null){  
                    cols_value = "";  
                }  
                map.put(cols_name, cols_value);  
            }  
        }  
        this.releaseConn();
        return map;  
    }  
  
    /**
     * 查詢多條記錄 
     * @param sql 
     * @param params 
     * @return 
     * @throws SQLException 
     */  
    public List<Map<String, Object>> findModeResult(String sql, List<Object> params) throws SQLException{  
        List<Map<String, Object>> list = new ArrayList<Map<String, Object>>();  
        int index = 1; 
        this.getConnection();
        pstmt = connection.prepareStatement(sql);  
        if(params != null && !params.isEmpty()){  
            for(int i = 0; i<params.size(); i++){  
                pstmt.setObject(index++, params.get(i));  
            }  
        }  
        resultSet = pstmt.executeQuery();  
        ResultSetMetaData metaData = resultSet.getMetaData();  
        int cols_len = metaData.getColumnCount();  
        while(resultSet.next()){  
            Map<String, Object> map = new HashMap<String, Object>();  
            for(int i=0; i<cols_len; i++){  
                String cols_name = metaData.getColumnName(i+1);  
                Object cols_value = resultSet.getObject(cols_name);  
                if(cols_value == null){  
                    cols_value = "";  
                }  
                map.put(cols_name, cols_value);  
            }  
            list.add(map);  
        }
        this.releaseConn();
        return list;  
    }  
  
    /**
     * 通過反射機制查詢單條記錄 
     * @param sql 
     * @param params 
     * @param cls 
     * @return 
     * @throws Exception 
     */  
    public <T> T findSimpleRefResult(String sql, List<Object> params,  
            Class<T> cls )throws Exception{  
        T resultObject = null;  
        int index = 1;
        this.getConnection();
        pstmt = connection.prepareStatement(sql);  
        if(params != null && !params.isEmpty()){  
            for(int i = 0; i<params.size(); i++){  
                pstmt.setObject(index++, params.get(i));  
            }  
        }  
        resultSet = pstmt.executeQuery();  
        ResultSetMetaData metaData  = resultSet.getMetaData();  
        int cols_len = metaData.getColumnCount();  
        while(resultSet.next()){  
            //通過反射機制創建一個實例  
            resultObject = cls.newInstance();  
            for(int i = 0; i<cols_len; i++){  
                String cols_name = metaData.getColumnName(i+1);  
                Object cols_value = resultSet.getObject(cols_name);  
                if(cols_value == null){  
                    cols_value = "";  
                }  
                Field field = cls.getDeclaredField(cols_name);  
                field.setAccessible(true); //打開javabean的訪問權限  
                field.set(resultObject, cols_value);  
            }  
        } 
        this.releaseConn();
        return resultObject;  
    }  
  
    /**
     * 通過反射機制查詢多條記錄 
     * @param sql  
     * @param params 
     * @param cls 
     * @return 
     * @throws Exception 
     */  
    public <T> List<T> findMoreRefResult(String sql, List<Object> params,  
            Class<T> cls )throws Exception {  
        List<T> list = new ArrayList<T>();  
        int index = 1; 
        this.getConnection();
        pstmt = connection.prepareStatement(sql);  
        if(params != null && !params.isEmpty()){  
            for(int i = 0; i<params.size(); i++){  
                pstmt.setObject(index++, params.get(i));  
            }  
        }  
        resultSet = pstmt.executeQuery();  
        ResultSetMetaData metaData  = resultSet.getMetaData();  
        int cols_len = metaData.getColumnCount();  
        while(resultSet.next()){  
            //通過反射機制創建一個實例  
            T resultObject = cls.newInstance();  
            for(int i = 0; i<cols_len; i++){  
                String cols_name = metaData.getColumnName(i+1);  
                Object cols_value = resultSet.getObject(cols_name);  
                if(cols_value == null){  
                    cols_value = "";  
                }  
                Field field = cls.getDeclaredField(cols_name);  
                field.setAccessible(true); //打開javabean的訪問權限  
                field.set(resultObject, cols_value);  
            }  
            list.add(resultObject);  
        } 
        this.releaseConn();
        return list;  
    }  
  
    /** 
     * 返回單個結果值，如count\min\max等 
     *  
     * @param sql 
     *            sql語句 
     * @param paramters 
     *            參數列表 
     * @return 結果 
     * @throws SQLException 
     */  
    public  Integer queryForInt(String sql, Object... paramters)  
            throws SQLException {  
        Integer result = null;  
        
        try {  
            this.getConnection();
            pstmt = connection.prepareStatement(sql);  
   
            for (int i = 0; i < paramters.length; i++) {  
                pstmt.setObject(i + 1, paramters[i]); 
            }  
            resultSet = pstmt.executeQuery(); 
            
            ResultSetMetaData metaData = resultSet.getMetaData();  
            while(resultSet.next()){  
                String cols_name = metaData.getColumnName(0+1);  
                Object cols_value = resultSet.getObject(cols_name);  
                result = Integer.valueOf(cols_value.toString());
            } 
            return result;  
        } catch (SQLException e) {  
            throw new SQLException(e);  
        } finally {  
            releaseConn(); 
        }  
    } 
    
    /** 
     * 釋放數據庫連接 
     */  
    public void releaseConn(){  
        DBUtils.close(resultSet, pstmt, connection);  
    }  
  
}  

測試類TestMySQLConnection

package hn.veryedu.jdbc.mysql;

import hn.veryedu.jdbc.common.db.DBUtils;
import java.sql.Connection;
import java.sql.PreparedStatement;
import java.sql.ResultSet;
import java.sql.ResultSetMetaData;
import java.sql.SQLException;



public class TestMySQLConnection {
    private static Integer counter = 0;

    public static void main(String[] args){
        
        for (int i = 1; i <= 2000; i++) {
            new Thread(new Runnable() {
                public void run() {
                    Connection conn = null;
                    PreparedStatement pstmt= null;
                    ResultSet resultSet= null;
                    try {
                        conn = DBUtils.getConnection();
                        synchronized (counter) {
                            System.out.print(Thread.currentThread().getName());
                            System.out.print("    counter = " + counter++
                                    + "  conn = " + conn);
                            System.out.println();
                            
                            pstmt = conn.prepareStatement("select * from user_t");
                            resultSet = pstmt.executeQuery(); 
                            ResultSetMetaData metaData = resultSet.getMetaData();  
                            int cols_len = metaData.getColumnCount();  
                            while(resultSet.next()){  
                                for(int i=0; i<cols_len; i++){  
                                    String cols_name = metaData.getColumnName(i+1);  
                                    Object cols_value = resultSet.getObject(cols_name);  
                                    //System.out.println(cols_name+"---"+cols_value); 
                                }  
                            }
                            DBUtils.close(resultSet, pstmt, conn);
                            //conn.close();
                        }
                    } catch (SQLException e) {
                        e.printStackTrace();
                    }  
                }
            }).start();
        }
    }
}

測試類TestJdcb

package hn.veryedu.jdbc.mysql;

import java.sql.SQLException;
import java.util.List;
import java.util.Map;
import hn.veryedu.jdbc.common.db.JdbcUtils;

public class TestJdcb {

    /**
     * @param args
     * @throws SQLException 
     */
    public static void main(String[] args) throws SQLException {
        // TODO Auto-generated method stub
        for (int i = 1; i <= 20; i++){
            JdbcUtils jdbc = new JdbcUtils();
            String sql = "select * from user_t";
            List<Map<String, Object>> list = jdbc.findModeResult(sql, null);
            for (int j = 0; j < list.size(); j++) {
                System.out.println(list.get(j));
            }
        }
    }

}

通過這兩個測試進行數據庫訪問的測試，發現無論運行多少次，數據庫當前的連接數都是不變的，這樣就再也不用擔心數據庫的連接數會滿啦！

 

項目源碼地址：https://github.com/jiafuweiJava/jdbc_c3p0