Java數據庫鏈接池實現原理

時間 2019-11-09

標籤 java 數據庫鏈接實現原理欄目 Java 简体版

原文原文鏈接

通常來講，Java應用程序訪問數據庫的過程是：
　　①裝載數據庫驅動程序；
　　②經過jdbc創建數據庫鏈接；
　　③訪問數據庫，執行sql語句；

　　④斷開數據庫鏈接。java

[java] view plain copy

print ?

public class DBConnection {
private Connection con; //定義數據庫鏈接類對象
private PreparedStatement pstm;
private String user="root"; //鏈接數據庫用戶名
private String password="123456"; //鏈接數據庫密碼
private String driverName="com.mysql.jdbc.Driver"; //數據庫驅動
private String url="jdbc:mysql://localhost:3306/qingqingtuan";
//鏈接數據庫的URL,後面的是爲了防止插入數據庫出現亂碼，?useUnicode=true&characterEncoding=UTF-8
//構造函數
public DBConnection(){
}
/**建立數據庫鏈接*/
public Connection getConnection(){
try{
Class.forName("com.mysql.jdbc.Driver");
}catch(ClassNotFoundException e){
System.out.println("加載數據庫驅動失敗！");
e.printStackTrace();
}
try {
con=DriverManager.getConnection(url,user,password); //獲取數據庫鏈接
} catch (SQLException e) {
System.out.println("建立數據庫鏈接失敗！");
con=null;
e.printStackTrace();
}
return con; //返回數據庫鏈接對象
}
List<Shop> mShopList=new ArrayList<Shop>();
mConnection=new DBConnection().getConnection();
if(mConnection!=null){
try {
String sql="select * from shop";
PreparedStatement pstm=mConnection.prepareStatement(sql);
ResultSet rs=pstm.executeQuery();
while(rs.next()){
......//封裝PoPj的操做
}
rs.close();
pstm.close();
} catch (SQLException e) {
e.printStackTrace();
}finally{
try {
if(mConnection!=null){
mConnection.close();
}
} catch (SQLException e) {
e.printStackTrace();
}
}

程序開發過程當中，存在不少問題：mysql

首先，每一次web請求都要創建一次數據庫鏈接。創建鏈接是一個費時的活動，每次都得花費0.05s～1s的時間，並且系統還要分配內存資源。這個時間對於一次或幾回數據庫操做，或許感受不出系統有多大的開銷。web

但是對於如今的web應用，尤爲是大型電子商務網站，同時有幾百人甚至幾千人在線是很正常的事。在這種狀況下，頻繁的進行數據庫鏈接操做勢必佔用不少的系統資源，網站的響應速度一定降低，嚴重的甚至會形成服務器的崩潰。不是危言聳聽，這就是制約某些電子商務網站發展的技術瓶頸問題。其次，對於每一次數據庫鏈接，使用完後都得斷開。不然，若是程序出現異常而未能關閉，將會致使數據庫系統中的內存泄漏，最終將不得不重啓數據庫sql

經過上面的分析，咱們能夠看出來，「數據庫鏈接」是一種稀缺的資源，爲了保障網站的正常使用，應該對其進行妥善管理。實現getConnection()從鏈接庫中獲取一個可用的鏈接
③ returnConnection(conn) 提供將鏈接放回鏈接池中方法數據庫

ConnectionPool.java服務器

[java] view plain copy

print ?

//////////////////////////////// 數據庫鏈接池類 ConnectionPool.java ////////////////////////////////////////
/*
這個例子是根據POSTGRESQL數據庫寫的，
請用的時候根據實際的數據庫調整。
調用方法以下：
①　ConnectionPool connPool
= new ConnectionPool("com.microsoft.jdbc.sqlserver.SQLServerDriver"
,"jdbc:microsoft:sqlserver://localhost:1433;DatabaseName=MyDataForTest"
,"Username"
,"Password");
②　connPool .createPool();
Connection conn = connPool .getConnection();
connPool.returnConnection(conn);
connPool.refreshConnections();
connPool.closeConnectionPool();
*/
import java.sql.Connection;
import java.sql.DatabaseMetaData;
import java.sql.Driver;
import java.sql.DriverManager;
import java.sql.SQLException;
import java.sql.Statement;
import java.util.Enumeration;
import java.util.Vector;
public class ConnectionPool {
private String jdbcDriver = ""; // 數據庫驅動
private String dbUrl = ""; // 數據 URL
private String dbUsername = ""; // 數據庫用戶名
private String dbPassword = ""; // 數據庫用戶密碼
private String testTable = ""; // 測試鏈接是否可用的測試表名，默認沒有測試表
private int initialConnections = 10; // 鏈接池的初始大小
private int incrementalConnections = 5;// 鏈接池自動增長的大小
private int maxConnections = 50; // 鏈接池最大的大小
private Vector connections = null; // 存放鏈接池中數據庫鏈接的向量 , 初始時爲 null
// 它中存放的對象爲 PooledConnection 型
/**
* 構造函數
*
* @param jdbcDriver
* String JDBC 驅動類串
* @param dbUrl
* String 數據庫 URL
* @param dbUsername
* String 鏈接數據庫用戶名
* @param dbPassword
* String 鏈接數據庫用戶的密碼
*
*/
public ConnectionPool(String jdbcDriver, String dbUrl, String dbUsername,
String dbPassword) {
this.jdbcDriver = jdbcDriver;
this.dbUrl = dbUrl;
this.dbUsername = dbUsername;
this.dbPassword = dbPassword;
}
/**
* 返回鏈接池的初始大小
*
* @return 初始鏈接池中可得到的鏈接數量
*/
public int getInitialConnections() {
return this.initialConnections;
}
/**
* 設置鏈接池的初始大小
*
* @param 用於設置初始鏈接池中鏈接的數量
*/
public void setInitialConnections(int initialConnections) {
this.initialConnections = initialConnections;
}
/**
* 返回鏈接池自動增長的大小、
*
* @return 鏈接池自動增長的大小
*/
public int getIncrementalConnections() {
return this.incrementalConnections;
}
/**
* 設置鏈接池自動增長的大小
*
* @param 鏈接池自動增長的大小
*/
public void setIncrementalConnections(int incrementalConnections) {
this.incrementalConnections = incrementalConnections;
}
/**
* 返回鏈接池中最大的可用鏈接數量
*
* @return 鏈接池中最大的可用鏈接數量
*/
public int getMaxConnections() {
return this.maxConnections;
}
/**
* 設置鏈接池中最大可用的鏈接數量
*
* @param 設置鏈接池中最大可用的鏈接數量值
*/
public void setMaxConnections(int maxConnections) {
this.maxConnections = maxConnections;
}
/**
* 獲取測試數據庫表的名字
*
* @return 測試數據庫表的名字
*/
public String getTestTable() {
return this.testTable;
}
/**
* 設置測試表的名字
*
* @param testTable
* String 測試表的名字
*/
public void setTestTable(String testTable) {
this.testTable = testTable;
}
/**
*
* 建立一個數據庫鏈接池，鏈接池中的可用鏈接的數量採用類成員 initialConnections 中設置的值
*/
public synchronized void createPool() throws Exception {
// 確保鏈接池沒有建立
// 若是鏈接池己經建立了，保存鏈接的向量 connections 不會爲空
if (connections != null) {
return; // 若是己經建立，則返回
}
// 實例化 JDBC Driver 中指定的驅動類實例
Driver driver = (Driver) (Class.forName(this.jdbcDriver).newInstance());
DriverManager.registerDriver(driver); // 註冊 JDBC 驅動程序
// 建立保存鏈接的向量 , 初始時有 0 個元素
connections = new Vector();
// 根據 initialConnections 中設置的值，建立鏈接。
createConnections(this.initialConnections);
// System.out.println(" 數據庫鏈接池建立成功！ ");
}
/**
* 建立由 numConnections 指定數目的數據庫鏈接 , 並把這些鏈接放入 connections 向量中
*
* @param numConnections
* 要建立的數據庫鏈接的數目
*/
private void createConnections(int numConnections) throws SQLException {
// 循環建立指定數目的數據庫鏈接
for (int x = 0; x < numConnections; x++) {
// 是否鏈接池中的數據庫鏈接的數量己經達到最大？最大值由類成員 maxConnections
// 指出，若是 maxConnections 爲 0 或負數，表示鏈接數量沒有限制。
// 若是鏈接數己經達到最大，即退出。
if (this.maxConnections > 0
&& this.connections.size() >= this.maxConnections) {
break;
}
// add a new PooledConnection object to connections vector
// 增長一個鏈接到鏈接池中（向量 connections 中）
try {
connections.addElement(new PooledConnection(newConnection()));
} catch (SQLException e) {
System.out.println(" 建立數據庫鏈接失敗！ " + e.getMessage());
throw new SQLException();
}
// System.out.println(" 數據庫鏈接己建立 ......");
}
}
/**
* 建立一個新的數據庫鏈接並返回它
*
* @return 返回一個新建立的數據庫鏈接
*/
private Connection newConnection() throws SQLException {
// 建立一個數據庫鏈接
Connection conn = DriverManager.getConnection(dbUrl, dbUsername,
dbPassword);
// 若是這是第一次建立數據庫鏈接，即檢查數據庫，得到此數據庫容許支持的
// 最大客戶鏈接數目
// connections.size()==0 表示目前沒有鏈接己被建立
if (connections.size() == 0) {
DatabaseMetaData metaData = conn.getMetaData();
int driverMaxConnections = metaData.getMaxConnections();
// 數據庫返回的 driverMaxConnections 若爲 0 ，表示此數據庫沒有最大
// 鏈接限制，或數據庫的最大鏈接限制不知道
// driverMaxConnections 爲返回的一個整數，表示此數據庫容許客戶鏈接的數目
// 若是鏈接池中設置的最大鏈接數量大於數據庫容許的鏈接數目 , 則置鏈接池的最大
// 鏈接數目爲數據庫容許的最大數目
if (driverMaxConnections > 0
&& this.maxConnections > driverMaxConnections) {
this.maxConnections = driverMaxConnections;
}
}
return conn; // 返回建立的新的數據庫鏈接
}
/**
* 經過調用 getFreeConnection() 函數返回一個可用的數據庫鏈接 , 若是當前沒有可用的數據庫鏈接，而且更多的數據庫鏈接不能創
* 建（如鏈接池大小的限制），此函數等待一會再嘗試獲取。
*
* @return 返回一個可用的數據庫鏈接對象
*/
public synchronized Connection getConnection() throws SQLException {
// 確保鏈接池己被建立
if (connections == null) {
return null; // 鏈接池還沒建立，則返回 null
}
Connection conn = getFreeConnection(); // 得到一個可用的數據庫鏈接
// 若是目前沒有可使用的鏈接，即全部的鏈接都在使用中
while (conn == null) {
// 等一會再試
// System.out.println("Wait");
wait(250);
conn = getFreeConnection(); // 從新再試，直到得到可用的鏈接，若是
// getFreeConnection() 返回的爲 null
// 則代表建立一批鏈接後也不可得到可用鏈接
}
return conn;// 返回得到的可用的鏈接
}
/**
* 本函數從鏈接池向量 connections 中返回一個可用的的數據庫鏈接，若是當前沒有可用的數據庫鏈接，本函數則根據
* incrementalConnections 設置的值建立幾個數據庫鏈接，並放入鏈接池中。若是建立後，全部的鏈接仍都在使用中，則返回 null
*
* @return 返回一個可用的數據庫鏈接
*/
private Connection getFreeConnection() throws SQLException {
// 從鏈接池中得到一個可用的數據庫鏈接
Connection conn = findFreeConnection();
if (conn == null) {
// 若是目前鏈接池中沒有可用的鏈接
// 建立一些鏈接
createConnections(incrementalConnections);
// 從新從池中查找是否有可用鏈接
conn = findFreeConnection();
if (conn == null) {
// 若是建立鏈接後仍得到不到可用的鏈接，則返回 null
return null;
}
}
return conn;
}
/**
* 查找鏈接池中全部的鏈接，查找一個可用的數據庫鏈接，若是沒有可用的鏈接，返回 null
*
* @return 返回一個可用的數據庫鏈接
*/
private Connection findFreeConnection() throws SQLException {
Connection conn = null;
PooledConnection pConn = null;
// 得到鏈接池向量中全部的對象
Enumeration enumerate = connections.elements();
// 遍歷全部的對象，看是否有可用的鏈接
while (enumerate.hasMoreElements()) {
pConn = (PooledConnection) enumerate.nextElement();
if (!pConn.isBusy()) {
// 若是此對象不忙，則得到它的數據庫鏈接並把它設爲忙
conn = pConn.getConnection();
pConn.setBusy(true);
// 測試此鏈接是否可用
if (!testConnection(conn)) {
// 若是此鏈接不可再用了，則建立一個新的鏈接，
// 並替換此不可用的鏈接對象，若是建立失敗，返回 null
try {
conn = newConnection();
} catch (SQLException e) {
System.out.println(" 建立數據庫鏈接失敗！ " + e.getMessage());
return null;
}
pConn.setConnection(conn);
}
break; // 己經找到一個可用的鏈接，退出
}
}
return conn;// 返回找到到的可用鏈接
}
/**
* 測試一個鏈接是否可用，若是不可用，關掉它並返回 false 不然可用返回 true
*
* @param conn
* 須要測試的數據庫鏈接
* @return 返回 true 表示此鏈接可用， false 表示不可用
*/
private boolean testConnection(Connection conn) {
try {
// 判斷測試表是否存在
if (testTable.equals("")) {
// 若是測試表爲空，試着使用此鏈接的 setAutoCommit() 方法
// 來判斷鏈接否可用（此方法只在部分數據庫可用，若是不可用 ,
// 拋出異常）。注意：使用測試表的方法更可靠
conn.setAutoCommit(true);
} else {// 有測試表的時候使用測試表測試
// check if this connection is valid
Statement stmt = conn.createStatement();
stmt.execute("select count(*) from " + testTable);
}
} catch (SQLException e) {
// 上面拋出異常，此鏈接己不可用，關閉它，並返回 false;
closeConnection(conn);
return false;
}
// 鏈接可用，返回 true
return true;
}
/**
* 此函數返回一個數據庫鏈接到鏈接池中，並把此鏈接置爲空閒。全部使用鏈接池得到的數據庫鏈接均應在不使用此鏈接時返回它。
*
* @param 需返回到鏈接池中的鏈接對象
*/
public void returnConnection(Connection conn) {
// 確保鏈接池存在，若是鏈接沒有建立（不存在），直接返回
if (connections == null) {
System.out.println(" 鏈接池不存在，沒法返回此鏈接到鏈接池中 !");
return;
}
PooledConnection pConn = null;
Enumeration enumerate = connections.elements();
// 遍歷鏈接池中的全部鏈接，找到這個要返回的鏈接對象
while (enumerate.hasMoreElements()) {
pConn = (PooledConnection) enumerate.nextElement();
// 先找到鏈接池中的要返回的鏈接對象
if (conn == pConn.getConnection()) {
// 找到了 , 設置此鏈接爲空閒狀態
pConn.setBusy(false);
break;
}
}
}
/**
* 刷新鏈接池中全部的鏈接對象
*
*/
public synchronized void refreshConnections() throws SQLException {
// 確保鏈接池己創新存在
if (connections == null) {
System.out.println(" 鏈接池不存在，沒法刷新 !");
return;
}
PooledConnection pConn = null;
Enumeration enumerate = connections.elements();
while (enumerate.hasMoreElements()) {
// 得到一個鏈接對象
pConn = (PooledConnection) enumerate.nextElement();
// 若是對象忙則等 5 秒 ,5 秒後直接刷新
if (pConn.isBusy()) {
wait(5000); // 等 5 秒
}
// 關閉此鏈接，用一個新的鏈接代替它。
closeConnection(pConn.getConnection());
pConn.setConnection(newConnection());
pConn.setBusy(false);
}
}
/**
* 關閉鏈接池中全部的鏈接，並清空鏈接池。
*/
public synchronized void closeConnectionPool() throws SQLException {
// 確保鏈接池存在，若是不存在，返回
if (connections == null) {
System.out.println(" 鏈接池不存在，沒法關閉 !");
return;
}
PooledConnection pConn = null;
Enumeration enumerate = connections.elements();
while (enumerate.hasMoreElements()) {
pConn = (PooledConnection) enumerate.nextElement();
// 若是忙，等 5 秒
if (pConn.isBusy()) {
wait(5000); // 等 5 秒
}
// 5 秒後直接關閉它
closeConnection(pConn.getConnection());
// 從鏈接池向量中刪除它
connections.removeElement(pConn);
}
// 置鏈接池爲空
connections = null;
}
/**
* 關閉一個數據庫鏈接
*
* @param 須要關閉的數據庫鏈接
*/
private void closeConnection(Connection conn) {
try {
conn.close();
} catch (SQLException e) {
System.out.println(" 關閉數據庫鏈接出錯： " + e.getMessage());
}
}
/**
* 使程序等待給定的毫秒數
*
* @param 給定的毫秒數
*/
private void wait(int mSeconds) {
try {
Thread.sleep(mSeconds);
} catch (InterruptedException e) {
}
}
/**
*
* 內部使用的用於保存鏈接池中鏈接對象的類此類中有兩個成員，一個是數據庫的鏈接，另外一個是指示此鏈接是否正在使用的標誌。
*/
class PooledConnection {
Connection connection = null;// 數據庫鏈接
boolean busy = false; // 此鏈接是否正在使用的標誌，默認沒有正在使用
// 構造函數，根據一個 Connection 構告一個 PooledConnection 對象
public PooledConnection(Connection connection) {
this.connection = connection;
}
// 返回此對象中的鏈接
public Connection getConnection() {
return connection;
}
// 設置此對象的，鏈接
public void setConnection(Connection connection) {
this.connection = connection;
}
// 得到對象鏈接是否忙
public boolean isBusy() {
return busy;
}
// 設置對象的鏈接正在忙
public void setBusy(boolean busy) {
this.busy = busy;
}
}
}

//////////////////////////////// 數據庫鏈接池類 ConnectionPool.java ////////////////////////////////////////

ConnectionPoolUtils.java

[java] view plain copy

print ?

/*鏈接池工具類，返回惟一的一個數據庫鏈接池對象,單例模式*/
public class ConnectionPoolUtils {
private ConnectionPoolUtils(){};//私有靜態方法
private static ConnectionPool poolInstance = null;
public static ConnectionPool GetPoolInstance(){
if(poolInstance == null) {
poolInstance = new ConnectionPool(
"com.mysql.jdbc.Driver",
"jdbc:mysql://localhost:3306/test?useUnicode=true&characterEncoding=utf-8",
"root", "123456");
try {
poolInstance.createPool();
} catch (Exception e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
return poolInstance;
}
}

ConnectionPoolTest.java

[java] view plain copy

print ?

import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.ResultSet;
import java.sql.SQLException;
import java.sql.Statement;
public class ConnectionTest {
/**
* @param args
* @throws Exception
*/
public static void main(String[] args) throws Exception {
try {
/*使用鏈接池建立100個鏈接的時間*/
/*// 建立數據庫鏈接庫對象
ConnectionPool connPool = new ConnectionPool("com.mysql.jdbc.Driver","jdbc:mysql://localhost:3306/test", "root", "123456");
// 新建數據庫鏈接庫
connPool.createPool();*/
ConnectionPool connPool=ConnectionPoolUtils.GetPoolInstance();//單例模式建立鏈接池對象
// SQL測試語句
String sql = "Select * from pet";
// 設定程序運行起始時間
long start = System.currentTimeMillis();
// 循環測試100次數據庫鏈接
for (int i = 0; i < 100; i++) {
Connection conn = connPool.getConnection(); // 從鏈接庫中獲取一個可用的鏈接
Statement stmt = conn.createStatement();
ResultSet rs = stmt.executeQuery(sql);
while (rs.next()) {
String name = rs.getString("name");
// System.out.println("查詢結果" + name);
}
rs.close();
stmt.close();
connPool.returnConnection(conn);// 鏈接使用完後釋放鏈接到鏈接池
}
System.out.println("通過100次的循環調用，使用鏈接池花費的時間:"+ (System.currentTimeMillis() - start) + "ms");
// connPool.refreshConnections();//刷新數據庫鏈接池中全部鏈接，即無論鏈接是否正在運行，都把全部鏈接都釋放並放回到鏈接池。注意：這個耗時比較大。
connPool.closeConnectionPool();// 關閉數據庫鏈接池。注意：這個耗時比較大。
// 設定程序運行起始時間
start = System.currentTimeMillis();
/*不使用鏈接池建立100個鏈接的時間*/
// 導入驅動
Class.forName("com.mysql.jdbc.Driver");
for (int i = 0; i < 100; i++) {
// 建立鏈接
Connection conn = DriverManager.getConnection(
"jdbc:mysql://localhost:3306/test", "root", "123456");
Statement stmt = conn.createStatement();
ResultSet rs = stmt.executeQuery(sql);
while (rs.next()) {
}
rs.close();
stmt.close();
conn.close();// 關閉鏈接
}
System.out.println("通過100次的循環調用，不使用鏈接池花費的時間:"
+ (System.currentTimeMillis() - start) + "ms");
} catch (SQLException e) {
e.printStackTrace();
} catch (ClassNotFoundException e) {
e.printStackTrace();
}
}