Java 连接池原理

连接池是一个存放连接的容器，用来管理连接

1.只加载一次连接信息

2.创建初始连接数量

3.不超过最大数量情况下，扩充池内连接数量

4.
静态的加载配置文件只有一份
池对象只有一个
连接注意状态的改变
需要设置释放的操作

---

用于保存连接状态及连接

public class PoolConnection {
    private Connection con;
    private boolean busy;

    public PoolConnection(Connection con, boolean busy) {
        this.con = con;
        this.busy = busy;
    }
    public Connection getCon() {
        return con;
    }
    public void setCon(Connection con) {
        this.con = con;
    }
    public boolean isBusy() {
        return busy;
    }
    public void setBusy(boolean busy) {
        this.busy = busy;
    }
}

public class DBPool {
    //静态加载配置文件
    private static String driverClass;
    private static String url;
    private static String user;
    private static String password;
    //用于装载连接及连接状态
    private Vector<PoolConnection> pool = new Vector<PoolConnection>();
    private int minSize=10;//初始化大小
    private int maxSize=20;//最大容量
    private int step=5;//每次扩容大小
    //静态块加载数据库配置文件
    static {
        try {
            Properties prop = new Properties();
            prop.load(DBPool.class.getResourceAsStream("dbinfo.properties"));
            driverClass = prop.getProperty("driverClass");
            url = prop.getProperty("url");
            user = prop.getProperty("user");
            password = prop.getProperty("password");

        } catch (IOException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
    }
    //在构造方法中初始化连接池
    public DBPool() {
        for(int i=0;i<minSize;i++){
            pool.add(new PoolConnection(createConn(), false));
        }   
    }
    //创建连接的封装
    private Connection createConn(){
        try {
            Class.forName(driverClass);
            Connection con = DriverManager.getConnection(url, user, password);
            return con;
        } catch (ClassNotFoundException e) {

            e.printStackTrace();
        } catch (SQLException e) {
            e.printStackTrace();
        }
            return null;
    }
    //查询池中连接是否空闲，空闲返回，忙碌则尝试增加连接数
    public PoolConnection getConnection() {
        //for循环遍历找到空闲的连接
        for(PoolConnection poolConn:pool){
            if(poolConn.isBusy()){
                continue;
            }
            poolConn.setBusy(true);
            return poolConn;
        }
        //如果满了，但pool大小没有超过maxSize可以增加新连接
        if(pool.size()<maxSize){
            for(int i=0;i<step;i++){
                pool.add(new PoolConnection(createConn(), false));
            }
            // 递归调用
            return getConnection(); 
        }
        return null;
    }

}

//用于外部进行连接
public class DBConn {
    //保证一个池
    private DBPool dbPool=new DBPool();
    //获得有状态的连接池连接对象
    private PoolConnection poolCon;
    public DBConn(){

    }
    //返回池连接给的Connection
    public Connection getConnection(){
        poolCon=dbPool.getConnection();
            Connection con=poolCon.getCon();
            if(con==null){
                System.out.println("数据库池连接全部忙碌");
            }
            return con;
    }
    //释放连接（修改池连接状态，以达到重用连接）
    public void close() {
        poolCon.setBusy(false);
    }
}

---