數據庫連接池兩種配置方式詳解

數據庫連接池:
   負責分配、管理和釋放數據庫連接，它允許應用程序重復使用一個現有的數據庫連接，而再不是重新建立一個；釋放空閑時間超過最大空閑時間的數據庫連接來避免因為沒有釋放數據庫連接而引起的數據庫連接遺漏；
數據庫連接池原理:
   連接池基本的思想是在系統初始化的時候，將數據庫連接作為對象存儲在內存中，當用戶需要訪問數據庫時，並非建立一個新的連接，而是從連接池中取出一個已建立的空閑連接對象。使用完畢后，用戶也並非將連接關閉，而是將連接放回連接池中，以供下一個請求訪問使用。而連接的建立、斷開都由連接池自身來管理。同時，還可以通過設置連接池的參數來控制連接池中的初始連接數、連接的上下限數以及每個連接的最大使用次數、最大空閑時間等等；
分類：
1.Tomcat數據源連接池，依賴於web容器tomcat服務器，采用java的JNDI獲取DataSource對象；
2.C3P0是一個開放源代碼的JDBC連接池，它在lib目錄中與Hibernate一起發布,包括了實現jdbc3和jdbc2擴展規范說明的Connection 和Statement 池的DataSources 對象；
3.DBCP DBCP是一個依賴commons-pool對象池機制的數據庫連接池，DBCP可以直接的在應用程序用使用；
方式：

一傳統方式：
tomcat數據庫連接池配置：
1）首先將連接數據庫jar包拷貝到tomcat下的lib文件夾下；
2）更改tomcat/conf/context.xml文件，加入數據源配置；

<Resource name="myshop" auth="Container" type="javax.sql.DataSource" maxActive="25" maxIdle="3" maxWait="10000"
    username="sa" password="sa" driverClassName="com.microsoft.sqlserver.jdbc.SQLServerDriver"
    url="jdbc:sqlserver://localhost:1433;databaseName=yun4jbook"    />

首先利用tomcat的web管理配置數據源，resource配置項中屬性說明：  

 name：數據源連接池命名  

url：連接數據庫的URL

driverClassName： 數據庫驅動類
username：數據庫的用戶名 
password：是數據庫的密碼 

maxActive : 最大的活動連接數 

maxIdle：最大的空閑連接數

maxWait： 最大的等待時間，毫秒為單位
type：resource所屬的java類名
auth:指定由誰管理數據源

Container表示由容器管理
3）打開項目的web.xml加入數據源的配置；

<resource-ref>
        <!-- name屬性必須放在第一位 -->
        <res-ref-name>myshop</res-ref-name>
        <res-type>javax.sql.DataSource</res-type>
        <res-auth>Container</res-auth>
    </resource-ref>

4）編寫dao代碼，使用JNDI（java naming and Directory Interface）技術取得數據源以數據源的形式操作數據庫；

package com.jinzhi.db;

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

import javax.naming.Context;
import javax.naming.InitialContext;
import javax.naming.NamingException;
import javax.sql.DataSource;

/**
 * 2017-5-9
 * @author lin
 *
 */
public class DBManager {
	//上下文關系對象
	private static Context context;
	//數據源
	private static DataSource ds;
	//數據庫連接對象
	private Connection conn;
	//數據庫sql語句預編譯對象
	private PreparedStatement ps; 
	//查詢結果集
	protected ResultSet rs;
	/**
	 * 連接池負責連接數據庫
	 */
	static{
		try {
			context = new InitialContext();
			ds = (DataSource) context.lookup("java:comp/env/myshop");
		} catch (NamingException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}
	}
	
	{
		System.out.println("aa");
	}
	
	/**
	 * 獲得connection對象
	 * @return
	 */
	public Connection getConn(){
//		try {
//			Class.forName("com.microsoft.sqlserver.jdbc.SQLServerDriver");
//			conn = DriverManager.getConnection("jdbc:sqlserver://localhost:1433;dataBaseName=yun4jbook", "sa", "sa");
//		} catch (ClassNotFoundException e) {
//			// TODO Auto-generated catch block
//			e.printStackTrace();
//		} catch (SQLException e) {
//			// TODO Auto-generated catch block
//			e.printStackTrace();
//		}
		try {
			conn = ds.getConnection();
		} catch (SQLException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}
		return conn;
	}
	/**
	 * 關閉數據庫方法
	 */
	public void closeAll(){
		
		try {
			if(null!=rs){
				rs.close();
			}
			if(null!=ps){
				ps.close();
			}
			if(null!=conn){
				conn.close();
			}
		} catch (SQLException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}
	}
	
	/**
	 * 查詢結果集
	 * 注意：查詢結果集時不能關閉數據庫連接，否則拿不到連接
	 * @param sql
	 * @param obj
	 * @return
	 */
	public ResultSet query(String sql,Object [] obj){
		conn = getConn();
		try {
			ps = conn.prepareStatement(sql);
			if(obj!=null&&obj.length>0){
				for (int i = 0; i < obj.length; i++) {
					ps.setObject(i+1, obj[i]);
				}
				
			}
			rs = ps.executeQuery();
			
		} catch (SQLException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}
		return rs;
	}
	
	/**
	 * 更新數據的方法
	 * 注意：更新數據后應該關閉數據庫連接
	 * @param sql
	 * @param obj
	 * @return
	 */
	public int update(String sql,Object [] obj){
		conn = getConn();
		int count = 0;
		try {
			ps = conn.prepareStatement(sql);
			if(obj!=null&&obj.length>0){
				for (int i = 0; i < obj.length; i++) {
					ps.setObject(i+1, obj[i]);
				}
			}
			count = ps.executeUpdate();
		} catch (SQLException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}finally{
			closeAll();
		}
		return count;
	}
	
	/**
	 * 重寫了connection方法
	 * @param conn
	 * @param sql
	 * @param obj
	 * @return
	 * @throws SQLException
	 */
	public ResultSet queryNotClose(Connection conn,String sql,Object [] obj) throws SQLException{
		
		ps = conn.prepareStatement(sql);
		if(obj!=null&&obj.length>0){
			for (int i = 0; i < obj.length; i++) {
				ps.setObject(i+1, obj[i]);
			}
			
		}
		rs = ps.executeQuery();
		return rs;
	}
	
	/**
	 * 為后期保證操作在一個事務中，重寫了update方法，添加了connection
	 * @param conn
	 * @param sql
	 * @param obj
	 * @return
	 * @throws SQLException
	 */
	public int updateNotClose(Connection conn,String sql,Object [] obj) throws SQLException{
		int count = 0;
		ps = conn.prepareStatement(sql);
		if(obj!=null&&obj.length>0){
			for (int i = 0; i < obj.length; i++) {
				ps.setObject(i+1, obj[i]);
			}
		}
		count = ps.executeUpdate();
		return count;
	}
	
	/**
	 * 測試方法
	 * @param args
	 */
	public static void main(String[] args) {
		DBManager db = new DBManager();
		System.out.println(db.getConn());
	}
}

 二.Druid方式：
1.druid-0.2.15.jar包
2.編寫一個xx.properties文件

下面是一個oracle的配置文件

url = jdbc:oracle:thin:@127.0.0.1:1521/orcl
username = detection1
password = detection1
initialSize = 5
maxActive = 10
minIdle = 3
maxWait = 60000
removeAbandoned = true
removeAbandonedTimeout = 180
timeBetweenEvictionRunsMillis = 60000
minEvictableIdleTimeMillis = 300000
testWhileIdle = true 
testOnBorrow = false
testOnReturn = false
poolPreparedStatements = true
maxPoolPreparedStatementPerConnectionSize = 50
filters = stat

3.連接數據庫

package testDruid;

import java.io.InputStream;
import java.sql.Connection;
import java.sql.PreparedStatement;
import java.sql.ResultSet;
import java.sql.SQLException;
import java.text.DateFormat;
import java.text.SimpleDateFormat;
import java.util.Date;
import java.util.Properties;

import javax.sql.DataSource;

import com.alibaba.druid.pool.DruidDataSourceFactory;

public class OracleDB {

	private static DataSource ds = null;	
	
	private PreparedStatement ps;
	
	private ResultSet rs;
	
	private Connection conn;
	
	
	static {
		try{
				//讀取配置文件oracle.properties
			InputStream in = OracleDB.class.getClassLoader()
					               .getResourceAsStream("oracle.properties");
            Properties props = new Properties();
       //加載配置文件
			props.load(in);
			//創建數據源
			ds = DruidDataSourceFactory.createDataSource(props);
		}catch(Exception ex){
			ex.printStackTrace();
		}
	}
	//得到數據庫連接對象
	public Connection openConnection() throws SQLException{
		return ds.getConnection();
	}	

	//得到查詢結果集
	public ResultSet find(String sql,Object...objects){
		try {
			conn = ds.getConnection();
			ps = conn.prepareStatement(sql);
			if(objects!=null&&objects.length>0){
				for (int i = 0; i < objects.length; i++) {
					ps.setObject(i+1, objects[i]);
				}
			}
			rs = ps.executeQuery();
		} catch (SQLException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}
		return rs;
	}
	//進行數據更新
	public int update(String sql,Object...objects){
		int count = 0;
		try {
			conn = ds.getConnection();
			ps = conn.prepareStatement(sql);
			if(objects!=null&&objects.length>0){
				for (int i = 0; i < objects.length; i++) {
					ps.setObject(i+1, objects[i]);
				}
			}
			count = ps.executeUpdate();
		} catch (SQLException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}
		return count;
	}
	//關閉數據庫連接
	public void close(){
		try {
			if(rs!=null){
				rs.close();
			}
			if(ps!=null){
				ps.close();
			}
			if(conn!=null){
				conn.close();
			}
		} catch (SQLException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}
	}
	
}