資料庫連線池

1、什麼是資料庫連線池？
      資料庫連線池負責分配、管理和釋放資料庫連線，它允許應用程式重複使用一個現有的資料庫連線，而不是再重新建立一個；釋放空閒時間超過最大空閒時間的資料庫連線來避免因為沒有釋放資料庫連線而引起的資料庫連線遺漏。這項技術能明顯提高對資料庫操作的效能。
2、為什麼要引入資料庫連線池？出現的原因
       使用者每次請求都需要向資料庫獲得連結，而資料庫建立連線通常需要消耗相對較大的資源，建立時間也較長。假設網站一天10萬訪問量，資料庫伺服器就需要建立10萬次連線，極大的浪費資料庫的資源，並且極易造成資料庫伺服器記憶體溢位、拓機。在多執行緒的環境下容易浪費資源
       資料庫連線池的出現就是為了減少伺服器的負擔，提高資源的利用效率。
3、原理：資料庫連線池的原理就是回收機制，也就是關閉的連線能及時在利用，避免浪費。

下面是簡單版的資料庫連線池
ConnsUtils.javal類

package cn.hncu.pool;

import java.io.IOException;
import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.SQLException;
import java.util.ArrayList;
import java.util.List;
import java.util.Properties;



public class ConnsUtils {
    private static
 
 List<Connection> list=new ArrayList<Connection>();
    static{
        Properties p=new Properties();
        try {
            p.load(ConnsUtils.class.getClassLoader().getResourceAsStream("jdbc.properities"));
            String url = p.getProperty("url");
            String user=p.getProperty("user"
 
);String driver=p.getProperty("driver");
            Class.forName(driver);//如果是tomcat中，載入驅動不能少
            String password=p.getProperty("password");
            for(int i=0;i<3;i++){
                Connection con=DriverManager.getConnection(url, user, password);
                list.add(con);
            }
        } catch (IOException e) {
            e.printStackTrace();
        } catch (SQLException e) {
            e.printStackTrace();
        }
    }
    public static Connection getCon(){
        synchronized (list) {
            if (list.size()<=0) {
                try {
                    list.wait();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }   
        }

        return list.remove(0);
    }
    public static void back(Connection con){
        synchronized (list) {
            System.out.println("還回來了一個連線....");
            list.notify();
            list.add(con);
        }
    }
}

測試：PoolTest .java

package cn.hncu.pool;

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

import cn.hncu.utils.ConnectFactory;

public class PoolTest {
    public static void main(String[] args) {
        Connection con=null;
        try {
            con = ConnsUtils.getCon();
        } catch (Exception e) {
            System.out.println("正在等待資源");
        }
        try {
            con.setAutoCommit(false);
            Statement st = con.createStatement();
            String sql = "insert into book(name) values('bb')";
            st.execute(sql);
            new OneThread(1).start();
            new OneThread(2).start();
            new OneThread(3).start();
            new OneThread(4).start();
            new OneThread(5).start();
            sql = "insert into book(name) values('bb2') ";
            st.execute(sql);
            System.out.println("主執行緒準備提交");
            con.commit();
            System.out.println("主執行緒提交完畢");
        } catch (Exception e) {
            try {
                con.rollback();
                System.out.println("主執行緒回滾了...");
            } catch (SQLException e1) {
                System.out.println("主執行緒回滾失敗...");
            }

        }finally{
            if(con!=null){
                try {
                    con.setAutoCommit(true);
                    ConnsUtils.back(con);//還資源
//                  con.close();
                } catch (SQLException e) {
                    throw new RuntimeException("連線關閉失敗!", e);
                }
            }

        }
    }
}

class OneThread extends Thread{
    private int i;

    public OneThread(int i) {
        this.i = i;
    }

    @Override
    public void run() {
        Connection con=ConnsUtils.getCon();
        try {
            con.setAutoCommit(false);
            Statement st = con.createStatement();
            String sql = "insert into book(name) values('aa="+i+"')";
            st.execute(sql);
            sql = "insert into book(name) values('aaa="+i+"') ";
            st.execute(sql);
            System.out.println("第"+i+"執行緒準備提交");
            con.commit();
            System.out.println("第"+i+"個執行緒提交完畢");
        } catch (Exception e) {
            try {
                con.rollback();
                System.out.println("第"+i+"個執行緒回滾了...");
            } catch (SQLException e1) {
                System.out.println("第"+i+"個執行緒回滾失敗...");
            }

        }finally{
            if(con!=null){
                try {
                    con.setAutoCommit(true);
                    ConnsUtils.back(con);//還資源
//                  con.close();
                } catch (SQLException e) {
                    throw new RuntimeException("連線關閉失敗!", e);
                }
            }

        }
    }

}

    我們發現，con物件不能關閉，否則就會出現，拿不到Connection物件的情況，導致查詢無法完成，所有必須引入動態代理來解決這個弱點。

動態代理

1、簡介：Java動態代理類位於Java.lang.reflect包下，一般主要涉及到以下兩個類：

• Interface InvocationHandler：該介面中僅定義了一個方法Object：invoke(Object obj,Method method,Object[]
  args）。在實際使用時，第一個引數obj一般是指代理類（要小心使用，不小心就是死迴圈），method是被代理的方法，args為該方法的引數陣列。這個抽象方法在代理類中動態實現。
• Proxy：該類即為動態代理類，作用類似於上例中的ProxySubject，其中主要包含以下內容： Protected
  Proxy(InvocationHandler h）：建構函式，估計用於給內部的h賦值。 Static Class getProxyClass (ClassLoader loader,Class[]
  interfaces）：獲得一個代理類，其中loader是類裝載器，interfaces是真實類所擁有的全部介面的陣列。
  2、代理機制及特點
• 通過實現 InvocationHandler 介面建立自己的呼叫處理器； 通過為 Proxy 類指定 ClassLoader 物件和一組
  interface 來建立動態代理類；
• 通過反射機制獲得動態代理類的建構函式，其唯一引數型別是呼叫處理器介面型別；
• 通過建構函式建立動態代理類例項，構造時呼叫處理器物件作為引數被傳入

3、核心程式碼：我通過圖片來進行註解

下面演示詳細程式碼，與資料庫連線池聯合使用
ConnsUtils.javal類

package cn.hncu.proxy;

import java.io.IOException;
import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
import java.lang.reflect.Proxy;
import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.SQLException;
import java.util.ArrayList;
import java.util.List;
import java.util.Properties;

public class ConnsUtils {
    private static List<Connection> pool=new ArrayList<Connection>();//建立一個pool池物件
    private static final int NUM=3;//池中最大數
    static{
        Properties p=new Properties();//從配置檔案讀取
        try {
//          p.load(ClassLoader.getSystemClassLoader().getResourceAsStream("jdbc.properities"));
            p.load(ConnsUtils.class.getClassLoader().getResourceAsStream("jdbc.properities"));
            String url = p.getProperty("url");
            String user=p.getProperty("user");
            String password=p.getProperty("password");
            for(int i=0;i<NUM;i++){
                final Connection con=DriverManager.getConnection(url, user, password);//final必須設定，因為內部類訪問
                //使用動態代理,代理conn物件，實現對close方法的攔截
                Object obj=Proxy.newProxyInstance(ConnsUtils.class.getClassLoader(), 
                                                new Class[]{Connection.class},new InvocationHandler() {
                    //proxy是代理後的物件(等價於返回的obj), method就是類反射中的方法物件, args是執行method方法所需的引數
                                                    @Override
                                                    public Object invoke(Object proxy, Method method, Object[] args)
                                                            throws Throwable {

                                                        if(method.getName().equalsIgnoreCase("close")&&(args==null||args.length==0)){
                                                            synchronized (pool) {
                                                                pool.add((Connection) proxy);//需要強轉
                                                                pool.notify();//喚醒等待的資源
                                                            }
                                                            return null;
                                                        }
                                                        return method.invoke(con, args);//其他方法就行放行
                                                    }
                                                });
                pool.add((Connection)obj);//把代理後的conn物件即obj
            }
        } catch (IOException e) {
            e.printStackTrace();
        } catch (SQLException e) {
            e.printStackTrace();
        }
    }
    public static Connection getCon(){
        synchronized (pool) {//同步鎖，一次只能一個進來拿，避免同時拿
            if(pool.size()<=0){
                try {
                    pool.wait();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
            return pool.remove(0);
        }

    }
}

我們會發現，就算我們在PoolTest下呼叫了con.close()函式，我們也沒有關閉Connection物件，因為我們在ConnsUtils中通過動態代理把con.close()進行了攔截並更改！