数据库连接池原理 与实现（动脑学院Jack老师课后自己的练习有感）

第一步： 首先创建一个数据库连接池的接口：

　　　　数据库连接池接口有两个主要的方法，其中一个getConnection();  通过数据库连接池返回给用户封装的数据库连接对象

　　　　createConnections(int count);是当数据库连接池中的连接不够用的时候用来创建数据库连接个数；

　　　　参数解释： 首先，vector是我们所用的数据库连接池，其中用来存储我们所需要的数据库连接的个数，就相当于一个池子，当人们需要数据库连接时候只需要去vector中去拿就可以了，首先，因为有池子，池子中就一定要有初始化的数据库连接， 所以用一个init()函数，将池子中进行初始化，

　初始化字段：

　　public static  String jdbcDriver="";
    public static  String dbUserName="";
    public static  String dbPassword="";
    public static String dbUrl="";
    
    public static int initConCount;
    public static int maxConnects;
    public static int inCrementalcount;
    这些字段的定义是从对应的properties文件中读取数据， 分别是数据库驱动，账号，密码，数据库地址，初始化的连接数目，连接池中的最大连接数，当达到了最大个数，增加连接池中的个数。这些数据都是从properties文件中读取的。

　　　　

package jdbcpool;

import com.mysql.jdbc.Connection;

public interface IPool {
    PooledConnection getConnection();

    void createConnections(int count);
}

第二步：JdbcPool

其中JdbcPool实现了 上面的数据库连接池的接口；需要重写上面的两个方法，

package jdbcpool;

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 sun.reflect.generics.tree.Tree;

import com.sun.corba.se.spi.orbutil.fsm.InputImpl;

public class JdbcPool implements IPool{
    public static  String jdbcDriver="";
    public static  String dbUserName="";
    public static  String dbPassword="";
    public static String dbUrl="";

    public static int initConCount;
    public static int maxConnects;
    public static int inCrementalcount;

    private static Vector<PooledConnection> vector=new  Vector<PooledConnection>();//vector当成一个池子，需要就去里面拿，pooledConnction，用来分装一个JDBCconection

    public void init(){
        System.out.println("1");
        InputStream in= JdbcPool.class.getClassLoader().getResourceAsStream("jdbcpool/jdbc.properties");
        Properties pt= new Properties();
        try {
            pt.load(in);
        } catch (IOException e) {
            e.printStackTrace();
        }
        jdbcDriver=pt.getProperty("jdbcDriver");
        dbUserName=pt.getProperty("dbUserName");
        dbPassword=pt.getProperty("dbPassword");
        dbUrl=pt.getProperty("dbUrl");
        initConCount=Integer.valueOf(pt.getProperty("initConCount")) ;
        maxConnects=Integer.valueOf(pt.getProperty("maxConnects")) ;
        inCrementalcount=Integer.valueOf(pt.getProperty("inCrementalcount")) ;

        try {
            Driver driver=(Driver)(Class.forName(jdbcDriver).newInstance());
            DriverManager.registerDriver(driver);//载入JDBC驱动，连接的时候以后不用再加载驱动了
            createConnections(initConCount);//初始化连接池中数据
        } catch (InstantiationException e) {
            e.printStackTrace();
        } catch (IllegalAccessException e) {
            e.printStackTrace();
        } catch (ClassNotFoundException e) {
            e.printStackTrace();
        } catch (SQLException e) {
            e.printStackTrace();
        }
    }    

    public synchronized PooledConnection getConnection() {
        if(vector.size()<=0){//拿连接的时候，首先应该判定池子中有没有数据，没有错误就应该抛出对应的一个错误信息
            System.out.println("连接池中还没有连接");
            throw new RuntimeException("连接池中还没有连接");
        }
        PooledConnection conn = getActionConnection();//得到数据库连接
        if(conn==null){//连接池中的连接全部为忙碌状态,  这个时候要扩容//的到连接后首先应该判定连接有没有拿到，没到那就为null，拿到了就直接返回
            //这个时候需要对连接池进行增长
            createConnections(inCrementalcount);//没有了就根据对应的步长去拿
            conn=getActionConnection();//有没有再次为Null 多个线程拿连接，Vector 为单例，内存中只有一份，一直拿不到，所以为Null
            while(conn==null){//如果没有拿到，就无线循环
                try {
                    Thread.sleep(300);//每次循环休息300
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                conn=getActionConnection();//继续拿，迟早会拿到
            }
        }

        return conn;
    }
    private PooledConnection getActionConnection(){
        for (PooledConnection conn : vector) {//遍历池子中封装的jdbcPool
            if(!conn.isBusy()){//这个数据不忙碌
                Connection trueconn=conn.getConn();//拿到这个连接
                try {
                    if(!trueconn.isValid(0)){//拿到连接后要判定有没有超时
                        Connection newconn=DriverManager.getConnection(dbUrl,
                                dbUserName,
                                dbPassword);
                        conn.setConn(newconn);
                    }
                } catch (SQLException e) {
                    e.printStackTrace();
                }
                conn.setBusy(true);//拿到后就必须设置为忙碌
                return conn;
            }
        }
        return null;

    }
    /**
     * 创建连接，首先应该判定  在创建
     */
    public void createConnections(int count) {
        if(maxConnects>0&&vector.size()>=maxConnects){
            System.out.println("连接大于最大的值");
            throw new RuntimeException("连接池中的连接已经大于最大值");
        }
        for (int i = 0; i < count; i++) {
            //创建连接时候 我们要判定是否小于最大值

            try {
            Connection conn=DriverManager.getConnection(dbUrl,//创建数据库的连接
                        dbUserName,
                        dbPassword);
            vector.add(new PooledConnection(conn,false));//封装成自己的连接；
            } catch (SQLException e) {
                e.printStackTrace();
            }
        }
    }

}

第三步：新建一个PooledConnection ，用来人工封装我们的数据库连接池中的单位， this.conn=conn; this.isBusy=isBusy;isBusy为true的时候，代表该连接不可用

package jdbcpool;

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

public class PooledConnection {
    private Connection conn=null;

    private boolean isBusy=false;

    public PooledConnection(Connection conn,boolean isBusy){
        this.conn=conn;

        this.isBusy=isBusy;
    }

    public ResultSet queryBySql(String sql){
        Statement sm=null;
        ResultSet rs=null;
        try {
            sm=conn.createStatement();
            rs=sm.executeQuery(sql);
        } catch (SQLException e) {
            e.printStackTrace();
        }
        return rs;

    }
    public int updateBysql(String sql){

        Statement sm=null;
        int count=-1;
        try{
            sm=conn.createStatement();
            count=sm.executeUpdate(sql);
        } catch (SQLException e){
            e.printStackTrace();
        }
        return count;
    }
    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;
    }
    public void close(){
        isBusy=false;
    }

}

jdbc.properties  文件中配置参数，以后只用改这里就可以了
jdbcDriver=com.mysql.jdbc.Driver

dbUrl=jdbc:mysql://localhost:3306/query

dbUserName=root

dbPassword=123456

initConCount=10

maxConnects=100

inCrementalcount=2

第五步：测试JdbcPoolTest

测试用的junit ,需要导入对应的架包，

package jdbcpool;
import java.sql.ResultSet;

import org.junit.Before;
import org.junit.Test;
public class JdbcPoolTest {
    JdbcPool  pool=DbManager.getInstance();
    @Before
    public void before(){
        pool.init();
    }
    @Test
    public void select()throws  Exception{
        PooledConnection conn=pool.getConnection();
        ResultSet rs=conn.queryBySql("select * from account ");
        System.out.println("线程名称："+Thread.currentThread().getName());
        while(rs.next()){
            System.out.print(rs.getString("id")+"\t");
            System.out.print(rs.getString("account_name")+"\t");
            System.out.print(rs.getString("account_pwd")+"\t\n");
        }
        rs.close();
        conn.close();
    }
    @Test
    public void threadTest() {
        for (int i = 0; i < 100; i++) {
            new Thread(new Runnable() {
                public void run() {
                    try {
                        select();
                    } catch (Exception e) {
                        e.printStackTrace();
                    }
                }
            }).start();
        }
    }

}