2. 程式人生 > >java建立資料庫連線池程式碼

java建立資料庫連線池程式碼

阿新 • • 發佈：2019-01-23

       資料庫連線池（Connection pooling）是程式啟動時建立足夠的資料庫連線，並將這些連線組成一個連線池，由程式動態地對池中的連線進行申請，使用，釋放。

       大家可以想一下，如果專案中沒有資料庫連線池會是一個什麼樣的結果？每訪問一次資料庫都會新建一個數據庫連線，如果同事有成百上千的請求需要訪問資料庫那麼專案會慘不忍睹。

       資料庫連線池就是在專案啟動是就已經建立了一定數量的資料庫連線，有請求訪問資料庫時，不需要新建資料庫連線，直接在連線池中拿就可以，用完了記得放到池子裡面就行。這樣的話，連線池中的資料庫連線會不斷的重複利用，大大提高了對資料庫操作的效能。

資料庫連線池的執行機制有以下幾點：

1.程式啟動時建立資料庫連線池。

2.使用連線時，從連線池中拿可用的資料庫連線。

3.使用完，將資料庫連線放入資料庫中。

那麼要想手動程式碼實現資料庫連線池，需要哪些步驟了？下面會貼出原始碼以及簡單的註釋。

首先需要一個數據庫連線池的配置檔案jdbc.properties，內容如下：

#驅動名稱  
jdbcDriver=com.mysql.jdbc.Driver  
#連線URL  
jdbcUrl=jdbc:mysql://localhost:3306/lcma  
#資料庫賬戶名  
userName=root  
#資料庫密碼  
password=iflytek  
#初始化連線數  
initCount=10  
#步進數量  
stepSize=4  
#最大連線池個數  
poolMaxSize=150
       既然是資料連線池，那麼池子裡面放的肯定是很多個數據庫連線，一個數據庫連線就是一個物件，建一個數據庫連線類 PooledConnection.java代表資料庫連線物件。類裡面有個isBusy屬性，用來表示該連線物件是否正在使用，若使用中用true表示，反之為false。程式碼如下：
既然是資料連線池，那麼池子裡面放的肯定是很多個數據庫連線，一個數據庫連線就是一個物件，建一個數據庫連線類 PooledConnection.java代表資料庫連線物件。類裡面有個isBusy屬性，用來表示該連線物件是否正在使用，若使用中用true表示，反之為false。程式碼如下：
package com.lcma.conn;

import java.sql.Connection;
import java.sql.ResultSet;
import java.sql.SQLException;
import java.sql.Statement;

/**
 * <p>Title      : 儲存連線池中物件屬性</p>
 * <p>Description: [子應用名]_[模組名]</p>
 * <p>Copyright  : Copyright (c) 2016</p>
 * <p>Company    : 科大訊飛</p>
 * @author       : lcma
 * @version      : 1.0
 */
public class PooledConnection {
	
	/**
	 * 連線管道物件
	 */
	private Connection conn;
	
	/**
	 * 連線狀態，true-繁忙，false-空閒
	 */
	private boolean isBusy = false;
	
	public PooledConnection(Connection conn, boolean isBusy){
		this.conn = conn;
		this.isBusy = isBusy;
	}
	
	public void close(){
		this.isBusy = false;
	}

	public Connection getConn() {
		return conn;
	}

	public void setConn(Connection conn) {
		this.conn = conn;
	}

	public boolean isBusy() {
		return isBusy;
	}

	public void setBusy(boolean isBusy) {
		this.isBusy = isBusy;
	}

	/**
	 * <p>Discription:建立查詢方法,用於測試使用</p>
	 * @param sql
	 * @return
	 * @author       : lcma
	 * @update       : 2016年12月5日下午11:19:18
	 */
	public ResultSet queryBySql(String sql){
		ResultSet rs = null;
		Statement sm = null;
		try {
			sm = conn.createStatement();
			rs = sm.executeQuery(sql);
		} catch (SQLException e) {
			e.printStackTrace();
		}
		return rs;
	}
	
	
}
建立連線池介面類，IMyPool.java
package com.lcma.pools;  
  
import com.lcma.conn.PooledConnection;  
  
/** 
 * <p>Description: 連線池介面</p> 
 * <p>Copyright  : Copyright (c) 2017</p> 
 * @author       : lcma 
 * @version      : 1.0 
 */  
public interface IMyPool {  
      
    /** 
     * <p>Discription:建立連線</p> 
     * @param count 
     * @author       : lcma 
     * @update       : 2016年12月4日下午1:11:46 
     */  
    public void createConnection(int count);  
      
    /** 
     * <p>Discription:獲取連線</p> 
     * @return 
     * @author       : lcma 
     * @update       : 2016年12月4日下午1:11:34 
     */  
    public PooledConnection getConnection();  
  
}
實現連線池介面類，MyPoolImpl.java

1.讀取配置檔案，建立連線池

2.獲取連線，判斷是否有空閒的連線並且是有效的連線

package com.lcma.pools.impl;  
  
import java.io.IOException;  
import java.io.InputStream;  
import java.sql.Connection;  
import java.sql.Driver;  
import java.sql.DriverManager;  
import java.sql.SQLException;  
import java.util.Properties;  
import java.util.Vector;  
  
import com.lcma.conn.PooledConnection;  
import com.lcma.pools.IMyPool;  
  
/** 
 * <p>Title      : 連線池介面實現類</p> 
 * <p>Description: [子應用名]_[模組名]</p> 
 * <p>Copyright  : Copyright (c) 2016</p> 
 * <p>Company    : 科大訊飛</p> 
 * @author       : lcma 
 * @version      : 1.0 
 */  
public class MyPoolImpl implements IMyPool {  
    /** 
     * 驅動名稱 
     */  
    private String jdbcDriver;  
    /** 
     * 連線地址 
     */  
    private String jdbcUrl;  
    /** 
     * 使用者名稱 
     */  
    private String userName;  
    /** 
     * 密碼 
     */  
    private String password;  
    /** 
     * 初始化連線數 
     */  
    private int initCount;  
    /** 
     * 步進連線數 
     */  
    private int stepSize;  
    /** 
     * 最大連線數 
     */  
    private int poolMaxSize;  
      
    /** 
     * 連線池容器 
     */  
    private static Vector<PooledConnection> pooledConnections = new Vector<PooledConnection>();  
      
    /** 
     * 建構函式，執行初始化方法 
     */  
    public MyPoolImpl() {  
        init();  
    }  
      
    /** 
     * <p>Discription:初始化連線池</p> 
     * @author       : lcma 
     * @update       : 2016年12月5日下午8:42:37 
     */  
    private void init(){  
        InputStream is = this.getClass().getClassLoader().getResourceAsStream("jdbc.properties");  
        Properties pro = new Properties();  
        try {  
            pro.load(is);  
        } catch (IOException e) {  
            e.printStackTrace();  
        }  
        jdbcDriver = pro.getProperty("jdbcDriver");  
        jdbcUrl = pro.getProperty("jdbcUrl");  
        userName = pro.getProperty("userName");  
        password = pro.getProperty("password");  
        initCount = Integer.parseInt(pro.getProperty("initCount"));  
        stepSize = Integer.parseInt(pro.getProperty("stepSize"));  
        poolMaxSize = Integer.parseInt(pro.getProperty("poolMaxSize"));  
          
        try {  
            Driver driver = (Driver)Class.forName(jdbcDriver).newInstance();  
            //將driver註冊  
            DriverManager.registerDriver(driver);;  
        } catch (Exception e) {  
            e.printStackTrace();  
        }  
        //建立連線  
        createConnection(initCount);  
    }  
  
    /** 
     * <p>Discription:建立連線</p> 
     * @param count 
     * @author       : lcma 
     * @update       : 2016年12月4日下午1:11:46 
     */  
    @Override  
    public void createConnection(int count) {  
        if(poolMaxSize<=0 || pooledConnections.size()+count > poolMaxSize){  
            System.out.println("建立連線失敗，超過最大連線數");  
            throw new RuntimeException("建立連線失敗，超過最大連線數");  
        }  
        try {  
            //迴圈建立連線  
            for(int i = 0; i < count; i++){  
                 //建立連線  
                Connection connection = DriverManager.getConnection(jdbcUrl, userName, password);  
                //例項化連線池中的連線  
                PooledConnection pooledConnection = new PooledConnection(connection, false);  
                //存入連線池容器  
                pooledConnections.add(pooledConnection);  
            }  
         } catch (SQLException e) {  
            e.printStackTrace();  
        }  
          
    }  
  
    /** 
     * <p>Discription:獲取連線</p> 
     * @return 
     * @author       : lcma 
     * @update       : 2016年12月4日下午1:11:34 
     */  
    @Override  
    public PooledConnection getConnection() {  
        if(pooledConnections.size()<=0){  
            System.out.println("獲取連線失敗，連線池為空");  
            throw new RuntimeException("獲取連線失敗，連線池為空");  
        }  
        PooledConnection connection = getRealConnection();  
        //判斷是否為空  
        while(connection == null){  
            //建立connection，步進數  
            createConnection(stepSize);  
            //重新獲取連線，有可能獲取的還為空,採用while迴圈判斷  
            getRealConnection();  
            //防止其他執行緒過來拿連線  
            try {  
                Thread.sleep(300);  
            } catch (InterruptedException e) {  
                e.printStackTrace();  
            }  
        }  
        return connection;  
    }  
      
    //判斷我們是否拿到有效的連線物件  
    private synchronized PooledConnection getRealConnection(){  
        //先判斷連線池是不是有我們需要的空閒連線物件  
        for(PooledConnection connection : pooledConnections){  
            //未處於繁忙狀態  
            if(!connection.isBusy()){  
                Connection conn = connection.getConn();  
                try {  
                    //判斷這個連線是不是有效，isValid就是建立了一個statement，執行sql語句，看是否成功  
                    if(!conn.isValid(2000)){  
                        Connection validConn = DriverManager.getConnection(jdbcUrl, userName, password);  
                        connection.setConn(validConn);  
                    }  
                } catch (SQLException e) {  
                    e.printStackTrace();  
                }  
                //設定為繁忙  
                connection.setBusy(true);  
                return connection;  
            }  
        }  
        return null;  
    }  
  
    public String getJdbcDriver() {  
        return jdbcDriver;  
    }  
  
    public void setJdbcDriver(String jdbcDriver) {  
        this.jdbcDriver = jdbcDriver;  
    }  
  
    public String getJdbcUrl() {  
        return jdbcUrl;  
    }  
  
    public void setJdbcUrl(String jdbcUrl) {  
        this.jdbcUrl = jdbcUrl;  
    }  
  
    public String getUserName() {  
        return userName;  
    }  
  
    public void setUserName(String userName) {  
        this.userName = userName;  
    }  
  
    public String getPassword() {  
        return password;  
    }  
  
    public void setPassword(String password) {  
        this.password = password;  
    }  
  
    public int getInitCount() {  
        return initCount;  
    }  
  
    public void setInitCount(int initCount) {  
        this.initCount = initCount;  
    }  
  
    public int getStepSize() {  
        return stepSize;  
    }  
  
    public void setStepSize(int stepSize) {  
        this.stepSize = stepSize;  
    }  
  
    public int getPoolMaxSize() {  
        return poolMaxSize;  
    }  
  
    public void setPoolMaxSize(int poolMaxSize) {  
        this.poolMaxSize = poolMaxSize;  
    }  
  
  
}
建立PoolManager類，利用內部類單例模式解決多執行緒問題，多個執行緒在載入內部類的時候執行緒是互斥的，解決了執行緒安全問題。
package com.lcma.manager;  
  
import com.lcma.pools.impl.MyPoolImpl;  
  
/** 
 * <p>Title      : 利用內部類單例模式解決多執行緒問題</p> 
 * <p>Description: [子應用名]_[模組名]</p> 
 * <p>Copyright  : Copyright (c) 2016</p> 
 * <p>Company    : 科大訊飛</p> 
 * @author       : lcma 
 * @version      : 1.0 
 */  
public class PoolManager {  
      
    private static class creatPool{  
        private static MyPoolImpl poolImpl = new MyPoolImpl();  
    }  
      
    //多個執行緒在載入內部類的時候執行緒是互斥的，所以用單例模式的內部類形式避免執行緒混亂  
    public static MyPoolImpl getInstace(){  
        return creatPool.poolImpl;  
    }  
  
}
測試類MyPoolMain,測試2000個執行緒同時請求資料庫，程式應對自如，這就是資料庫連線池的強大之處。
package com.lcma.main;  
  
import java.sql.ResultSet;  
import java.sql.SQLException;  
  
import com.lcma.conn.PooledConnection;  
import com.lcma.manager.PoolManager;  
import com.lcma.pools.impl.MyPoolImpl;  
  
/**  
 * <p>Description: 測試類</p>  
 * <p>Copyright  : Copyright (c) 2017</p>  
 * @author       : lcma  
 * @version      : 1.0  
 */  
public class MyPoolMain {  
      
    /**  
     * 獲取連線池容器實現類  
     */  
    private static MyPoolImpl poolImpl = PoolManager.getInstace();  
      
    /**  
     * 單個連線查詢測試  
     */  
    public synchronized static void selectData(){  
        PooledConnection connection = poolImpl.getConnection();  
        ResultSet rs = connection.queryBySql("select * from class");  
        try {  
            while(rs.next()){  
                System.out.print(rs.getString("ID") + "\t\t");  
                System.out.print(rs.getString("NAME") + "\t\t");  
                System.out.print(rs.getString("TEACHER") + "\t\t");  
                System.out.println();  
            }  
        } catch (SQLException e) {  
            e.printStackTrace();  
        }finally {  
            try {rs.close();} catch (SQLException e) {e.printStackTrace();}  
            connection.close();  
        }  
    }  
      
    /**  
     * <p>Discription:測試2000個執行緒</p>  
     * @param args  
     * @author       : lcma  
     * @update       : 2016年12月5日下午11:44:18  
     */  
    public static void main(String[] args){  
        for (int i = 0; i < 2000; i++) {  
            new Thread(new Runnable() {  
                public void run() {  
                    selectData();  
                    System.out.println();  
                }  
            }).start();  
        }  
          
    }  
  
}

注：上面程式碼只對功能做出實現，對程式碼規範性並沒有做太高要求。


相關推薦

java建立資料庫連線池程式碼

       資料庫連線池（Connection pooling）是程式啟動時建立足夠的資料庫連線，並將這些連線組成一個連線池，由程式動態地對池中的連線進行申請，使用，釋放。        大家可以想一下，如果專案中沒有資料庫連線池會是一個什麼樣的結果？每訪問一次資料庫

簡單建立資料庫連線池幷包裝查詢程式碼

一：準備Jar包 ojdbc14.jar：oracle資料庫驅動 commons-lang-2.6.jar：工具包 二：日誌工具類 1：建立資料庫連結配置檔案db.properties(儲存在src下)： [html] v

經典的java自定義資料庫連線池程式碼

import java.sql.Connection; import java.sql.DatabaseMetaData; import java.sql.Driver; import java.sql.DriverManager; import j

java資料庫連線池程式碼實現

import java.io.InputStream; import java.sql.Connection; import java.sql.ResultSet; import java.sql.SQLException; import java.sql.Statement; import java.uti

Java配置資料庫連線池

dbcp資料庫連線池 DbcpUtils.java import java.io.IOException; import java.io.InputStream; import java.sql.Connection; import java.sql.SQLException; impor

Java的Redis連線池程式碼

其實這個是引用自網友http://blog.csdn.net/tuposky/article/details/45340183，有2個版本，差別就是ReentrantLock和synchronized。另外原作者使用了斷言，我覺得這個還是不用為好。 ReentrantLock版 import

JDBC建立資料庫連線詳細程式碼及註釋

注：完整程式碼在最後 使用jdbc建立mysql資料庫連線 1.從db.properties配置檔案中讀取資料庫連線引數。 db.properties檔案內容如下： jdbc.driver=com.mysql.jdbc.Driver jdbc.url=jdbc\:mysql\:/

Java框架資料庫連線池

Java框架資料庫連線池比較（c3p0,dbcp和proxool）  現在常用的開源資料連線池主要有c3p0,dbcp和proxool三種，其中： ¨         hiber

java建立資料庫連線

public static Connection getConnection() throws Exception {   int count = 0;   Connection con = null;   while (count < DBUTIL_PARAM_RE

Java測試資料庫連線原生程式碼

package com.tera.test; import java.sql.Connection; import java.sql.DriverManager; import java.sql.PreparedStatement; import jav

Java中資料庫連線池原理機制的詳細講解

連線池的基本工作原理 　　1、基本概念及原理 　　由上面的分析可以看出，問題的根源就在於對資料庫連線資源的低效管理。我們知道，對於共享資源，有一個很著名的設計模式：資源池 (Resource Pool)。該模式正是為了解決資源的頻繁分配?釋放所造成的問題。為解決上述問

java配置資料庫連線池的方法步驟

先來了解下什麼是資料庫連線池 資料庫連線池技術的思想非常簡單，將資料庫連線作為物件儲存在一個Vector物件中，一旦資料庫連線建立後，不同的資料庫訪問請求就可以共享這些連線，這樣，通過複用這些已經建立的資料庫連線，可以克服上述缺點，極大地節省系統資源和時間。 在實際應用開

Java jdbc資料庫連線池總結!

1. 引言 　　近年來，隨著Internet/Intranet建網技術的飛速發展和在世界範圍內的迅速普及，計算機 　　應用程式已從傳統的桌面應用轉到Web應用。基於B/S（Browser/Server）架構的3層開發模式逐漸取代C/S（Client/Server）架構的開發

Java框架資料庫連線池比較（c3p0,dbcp和proxool）

現在常用的開源資料連線池主要有c3p0,dbcp和proxool三種，其中：  ¨         hibernate開發組推薦使用c3p0;  ¨         spring開發組推薦使用dbcp (dbcp連線池有weblogic連線池同樣的問題，就是強行關閉連

建立資料庫連線池的幾種方式

方式一、在專案工程資料夾下配置DBCP建立資料庫連線池         步驟：                 1、導包。將DBCP相應的四個包匯入web資料夾下的WEB-INF資料夾下自己新建的lib資料夾裡，然後add as libriays。      

如何編寫出高效的資料庫連線池(附帶完整程式碼C#和Java實現)

{    privateboolean _enable =true; //是否失效privateboolean _isUse =false; //是否正在被使用中privateboolean _allot =true; //表示該連線是否可以被分配private Date _createTime; //建立時

實現高效的資料庫連線池(附帶完整程式碼C#和Java實現)

{    privateboolean _enable =true; //是否失效privateboolean _isUse =false; //是否正在被使用中privateboolean _allot =true; //表示該連線是否可以被分配private Date _createTime; //建立時

Java資料庫連線池細節探討

我們知道，資料庫連線池可以把資料庫的連線快取起來，下次使用的話可以直接取到快取起來的資料庫連線。那麼，在這個過程中有幾個細節需要注意： 1、資料庫的連線數有沒有限制？ 2、資料庫會不會自動斷開已經建立的連線？ 3、如果資料庫重啟了，但應用沒有重啟，那麼資料庫連線池中的所有連線都不可用了，

HikariCP 的Java資料庫連線池介紹及配置

HiKariCP是資料庫連線池的一個後起之秀，號稱效能最好，可以完美地PK掉其他連線池。 原文地址：http://blog.csdn.net/clementad/article/details/46928621 官網：https://github.com/brettwooldridge/Hi

Java Redis(三)：建立Redis連線池

Redis 連線池 public class RedisPool { private static JedisPool pool;//jedis連線池 private static Integer maxTotal = ; //最大連線數 private st