BasicDataSource的池配置屬性

  BasicDataSource的池配置屬性

池配置屬性	指定的內容
initialSize	池啟動時創建的連接數量
maxActive	同一時間可以從池分配的最多連接數量。設置為0時表示無限制。
maxIdle	池里不會被釋放的最多空閑連接數量。設置為0時表示無限制。
maxOpenPreparedStatements	同一時間能夠從語句池里分配的已備語句的最大數量。設置為0時表示無限制。
maxWait	在拋出異常之前，池等待連接被回收的最長時間（當沒有可用連接時）。設置為-1表示無限等待。
minEvictableIdleTimeMillis	連接保持空閑而不被驅逐的最長時間。
minIdle	在不新建連接的條件下，池中保持空閑的最少連接數。
poolPreparedStatements	是否對已備語句進行池管理（布爾值）。

 

jdbc.properties文件

jdbc.driverClassName=com.mysql.jdbc.Driver
jdbc.url=jdbc:mysql://localhost:3306/vbox?rewriteBatchedStatements=true&characterEncoding=utf8
jdbc.username=root
jdbc.password=root
#<!--initialSize: 初始化連接-->  
jdbc.initialSize=10
#<!--maxActive: 最大連接數量-->  
jdbc.maxActive=500
tcp.PORT=28577
#<!-- 設置多少毫秒的間隔-->
baidu.pinglv=5
#<!-- 初始化連接 -->
dataSource.initialSize=10
#<!-- 最大空閑連接 -->
dataSource.maxIdle=20
#<!-- 最小空閑連接 -->
dataSource.minIdle=5
#<!--最大連接數量 -->
dataSource.maxActive=50
#<!--是否在自動回收超時連接的時候打印連接的超時錯誤 -->
dataSource.logAbandoned=true
#<!--是否自動回收超時連接 -->
dataSource.removeAbandoned=true
#<!--超時時間(以秒數為單位) -->
dataSource.removeAbandonedTimeout=180
#<!--超時等待時間以毫秒為單位 6000毫秒/1000等於60秒 -->
dataSource.maxWait=1000
#<!--取得連接時是否進行有效性驗證（即是否還和數據庫連通的）-->
dataSource.testOnBorrow=true
#<!--返回連接時是否進行有效性驗證（即是否還和數據庫連通的）-->
dataSource.testOnReturn=true
#<!--連接空閑時是否進行有效性驗證（即是否還和數據庫連通的）-->
dataSource.testWhileIdle=true
#<!--他們兩個配合，可以持續更新連接池中的連接對象，當timeBetweenEvictionRunsMillis 大於0時，-->
#<!--每過timeBetweenEvictionRunsMillis 時間，就會啟動一個線程，校驗連接池中閑置時間超過minEvictableIdleTimeMillis的連接對象。-->
dataSource.timeBetweenEvictionRunsMillis=3
dataSource.minEvictableIdleTimeMillis=12

java類的書寫：

/**
 * HttpClient練習
 * studyHttpClient
 * cn.yuchao.httpclient
 * BasicDataSourceDemo.java
 * 創建人:yuchao
 * 時間：2015-11-6-上午09:56:03 
 * 2015-版權個人所有
 */
package cn.yuchao.httpclient;

import java.io.IOException;
import java.sql.Connection;
import java.sql.SQLException;
import java.util.Properties;

import org.apache.commons.dbcp.BasicDataSource;
import org.apache.commons.lang.StringUtils;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

/**
 * 
 * BasicDataSourceDemo
 * 創建人:yuchao
 * 時間：2015-11-6-上午09:56:03 
 * @version 1.0.0
 * 
 */
public class BasicDataSourceDemo {
    
    private static final Logger log  = LoggerFactory.getLogger(BasicDataSourceDemo.class);
    
    public static void main(String[] args) {
         
          Properties dbProps =new Properties();
          Connection connection =null;
            try {
                 dbProps.load(BasicDataSourceDemo.class.getResourceAsStream("/jdbc.properties"));
                 System.setProperty("javax.xml.parsers.DocumentBuilderFactory","com.sun.org.apache.xerces.internal.jaxp.DocumentBuilderFactoryImpl"); 
                 String driverClassName = dbProps.getProperty("jdbc.driverClassName");
                 String url = dbProps.getProperty("jdbc.url");
                 String username = dbProps.getProperty("jdbc.username");
                 String password = dbProps.getProperty("jdbc.password");
                 
                 String initialSize = dbProps.getProperty("dataSource.initialSize");
                 String minIdle = dbProps.getProperty("dataSource.minIdle");
                 String maxIdle = dbProps.getProperty("dataSource.maxIdle");
                 String maxWait = dbProps.getProperty("dataSource.maxWait");
                 String maxActive = dbProps.getProperty("dataSource.maxActive"); 
                 String timeBetweenEvictionRunsMillis =dbProps.getProperty("dataSource.timeBetweenEvictionRunsMillis");
                 String minEvictableIdleTimeMillis =dbProps.getProperty("dataSource.minEvictableIdleTimeMillis");
                 
                 //取得連接時是否進行有效性驗證（即是否還和數據庫連通的）
                 boolean testOnBorrow = Boolean.valueOf(dbProps.getProperty("dataSource.testOnBorrow","true")).booleanValue();
                 //返回連接時是否進行有效性驗證（即是否還和數據庫連通的）
                 boolean testOnReturn = Boolean.valueOf(dbProps.getProperty("dataSource.testOnReturn","true")).booleanValue();
                 //連接空閑時是否進行有效性驗證（即是否還和數據庫連通的）
                 boolean testWhileIdle = Boolean.valueOf(dbProps.getProperty("dataSource.testWhileIdle","true")).booleanValue();
                 //是否在自動回收超時連接的時候打印連接的超時錯誤
                 boolean logAbandoned = Boolean.valueOf(dbProps.getProperty("dataSource.logAbandoned","false")).booleanValue();
                //是否自動回收超時連接
                 boolean removeAbandoned = (Boolean.valueOf(dbProps.getProperty("dataSource.removeAbandoned","false"))).booleanValue();
                 //超時時間(以秒數為單位)
                 int removeAbandonedTimeout = Integer.parseInt(dbProps.getProperty("dataSource.removeAbandonedTimeout","300"));
                
                 BasicDataSource dataSource = new BasicDataSource();
                 dataSource.setDriverClassName(driverClassName);
                 dataSource.setUrl(url);
                 dataSource.setUsername(username);
                 dataSource.setPassword(password);
                 
                 //初始化連接數
                 if (StringUtils.isNotBlank(initialSize)) {
                    dataSource.setInitialSize(Integer.parseInt(initialSize));
                }
                //最小空閑連接數
                if (StringUtils.isNotBlank(minIdle)) {
                    dataSource.setMinIdle(Integer.parseInt(minIdle));
                }
                 //最大空閑連接數
                if (StringUtils.isNotBlank(maxIdle)) {
                    dataSource.setMinIdle(Integer.parseInt(maxIdle));
                }
                //超時回收時間（以毫秒為單位）
                if (StringUtils.isNotBlank(maxWait)) {
                    dataSource.setMinIdle(Integer.parseInt(minIdle));
                }
                //最大連接數
                if (StringUtils.isNotBlank(maxActive)) {
                    dataSource.setMinIdle(Integer.parseInt(minIdle));
                }
                
                if (StringUtils.isNotBlank(minEvictableIdleTimeMillis)) {
                    
                }
                //是否在自動回收超時連接的時候打印連接的超時錯誤
                dataSource.setLogAbandoned(logAbandoned);
                //是否自動回收超時連接
                dataSource.setRemoveAbandoned(removeAbandoned);
                //超時時間(以秒數為單位)
                dataSource.setRemoveAbandonedTimeout(removeAbandonedTimeout);
                //取得連接時是否進行有效性驗證（即是否還和數據庫連通的）
                dataSource.setTestOnBorrow(testOnBorrow);
                //返回連接時是否進行有效性驗證（即是否還和數據庫連通的）
                dataSource.setTestOnReturn(testOnReturn);
                //連接空閑時是否進行有效性驗證（即是否還和數據庫連通的）
                dataSource.setTestWhileIdle(testWhileIdle);
                
                if(StringUtils.isNotBlank(timeBetweenEvictionRunsMillis)){
                     dataSource.setTimeBetweenEvictionRunsMillis(Long.parseLong(timeBetweenEvictionRunsMillis));
                }
                
                /** 
                 * 他們兩個配合，可以持續更新連接池中的連接對象，當timeBetweenEvictionRunsMillis 大於0時，每過timeBetweenEvictionRunsMillis 時間，
                 * 就會啟動一個線程，校驗連接池中閑置時間超過minEvictableIdleTimeMillis的連接對象。
                 * */
                if(StringUtils.isNotBlank(timeBetweenEvictionRunsMillis)){
                     dataSource.setTimeBetweenEvictionRunsMillis(Long.parseLong(timeBetweenEvictionRunsMillis));
                }
                
                if(StringUtils.isNotBlank(minEvictableIdleTimeMillis)){
                    
                     dataSource.setMinEvictableIdleTimeMillis(Long.parseLong(minEvictableIdleTimeMillis));
                }
              
                try {
                     connection = dataSource.getConnection();
                     System.out.println("從BasicDataSource池中獲取連接："+connection);
                } catch (SQLException e) {
                    e.printStackTrace();
                    log.info("對不起連接數據庫失敗，請查看您的配置.......");
                }
                
            } catch (IOException e) {
                
                e.printStackTrace();
                
            }finally{
                
                try {
                    if (null!=connection) {
                        //將連接釋放到 BasicDataSource池中
                        connection.close();
                    }
                } catch (SQLException e) {
                    e.printStackTrace();
                }
            }
    }
}