在程序中，存在一个容器，可用的代表了数据库连接的对象。在整个程序中共享。

连接池

连接池实现数据库连接的复用
可以减少数据库连接的开、关次数

自定义连接池
定义MYPool类，实现implements接口DataSource import javax.sql.DataSource;
创建容器，用来存放数据库连接对象
初始化容器
提供getConnection(),对外提供数据库连接
提供returnConnection(),还回池里

static List<Connection> list = new LinkedList<Connection>();
    // 初始化容器
    static {
        for (int i = 1; i <= 3; i++) {
            Connection conn = JDBCUtils.getConnection();
            // 静态只能调用静态的，把连接放入池中
            list.add(conn);
        }
    }

    @Override
    public Connection getConnection() throws SQLException {
        // 拿完连接之后删掉
        Connection conn = list.remove(0);
        System.out.println("使用1个连接，还剩" + list.size() + "个");
        return conn;
    }

    // 提供returnConnection()还回池里
    public void returnConnection(Connection conn) {
        // 添加
        try {
            if (conn != null&&!conn.isClosed()) {
                list.add(conn);
                System.out.println("连接被还回，还剩" + list.size() + "个");
            }
        } catch (SQLException e) {
            e.printStackTrace();
        }
    }

package pool;

import java.io.PrintWriter;
import java.sql.Connection;
import java.sql.SQLException;
import java.sql.SQLFeatureNotSupportedException;
import java.util.LinkedList;
import java.util.List;
import java.util.logging.Logger;

import javax.sql.DataSource;

import util.JDBCUtils;

/**
 * 这个类用来完成自定义连接池
 */
public class MyPooL implements DataSource {

    static List<Connection> list = new LinkedList<Connection>();
    // 初始化容器
    static {
        for (int i = 1; i <= 3; i++) {
            Connection conn = JDBCUtils.getConnection();
            // 静态只能调用静态的，把连接放入池中
            list.add(conn);
        }
    }

    @Override
    public Connection getConnection() throws SQLException {
        // 拿完连接之后删掉
        Connection conn = list.remove(0);
        System.out.println("使用1个连接，还剩" + list.size() + "个");
        return conn;
    }

    // 提供returnConnection()还回池里
    public void returnConnection(Connection conn) {
        // 添加
        try {
            if (conn != null&&!conn.isClosed()) {
                list.add(conn);
                System.out.println("连接被还回，还剩" + list.size() + "个");
            }
        } catch (SQLException e) {
            e.printStackTrace();
        }
    }

    @Override
    public PrintWriter getLogWriter() throws SQLException {
        return null;
    }

    @Override
    public void setLogWriter(PrintWriter out) throws SQLException {

    }

    @Override
    public void setLoginTimeout(int seconds) throws SQLException {

    }

    @Override
    public int getLoginTimeout() throws SQLException {
        return 0;
    }

    @Override
    public Logger getParentLogger() throws SQLFeatureNotSupportedException {
        return null;
    }

    @Override
    public <T> T unwrap(Class<T> iface) throws SQLException {
        return null;
    }

    @Override
    public boolean isWrapperFor(Class<?> iface) throws SQLException {
        return false;
    }

    @Override
    public Connection getConnection(String username, String password) throws SQLException {
        return null;
    }

}

测试连接池

package test;

import java.sql.Connection;
import java.sql.PreparedStatement;
import java.sql.SQLException;

import org.junit.Test;

import pool.MyPooL;
import util.JDBCUtils;

/**
 * 这个类用来完成自定义连接池的测试
 */
public class TestMyPool {
    @Test
    public void delete() {
        // 删除dept表中的id为4的数据
        // 1.注册驱动2.获取数据库连接
        MyPooL pool = new MyPooL();
        Connection conn = null;
        PreparedStatement ps = null;
        try {
            conn = pool.getConnection();
            String sql = "delete from dept where id=?";
            // 3.获取传输器
            ps = conn.prepareStatement(sql);
            // 设置参数
            ps.setInt(1, 4);
            int rows = ps.executeUpdate();
            System.out.println(rows + " be affected");
        } catch (SQLException e) {
            e.printStackTrace();
        } finally {
            //释放资源
            JDBCUtils.close(null, ps, null);
            //还回池中
            pool.returnConnection(conn);
        }
    }
}

运行结果

使用1个连接，还剩2个
1 be affected
连接被还回，还剩3个