jdbc-数据库连接池

对于一个简单的数据库应用，由于对于数据库的访问不是很频繁，这时可以简单地在需要访问数据库时，就新创建一个连接，用完后就关闭它，这样做也不会带来什么明显的性能上的开销。但是对于一个复杂的数据库应用，情况就完全不同了，频繁的建立、关闭连接，会极大的减低系统的性能，因为对于连接的使用成了系统性能的瓶颈。
数据库连接池的基本原理是在内部对象池中维护一定数量的数据库连接，并对外暴露数据库连接获取和返回方法。如：外部使用者可通过getConnection方法获取连接，使用完毕后再通过releaseConnection 方法将连接返回，注意此时连接并没有关闭，而是由连接池管理器回收，并为下一次使用做好准备。这样带来的好处如下：

1、资源重用

数据库连接得到重用，避免了频繁创建、释放连接引起的大量性能开销。在减少系统消耗的基础上，另一方面也增进了系统运行环境的平稳性（减少内存碎片以及数据库临时进程/线程的数量）。

2、更快的系统响应速度

数据库连接池在初始化过程中，往往已经创建了若干数据库连接置于池中备用。此时连接的初始化工作均已完成。对于业务请求处理而言，直接利用现有可用连接，避免了数据库连接初始化和释放过程的时间开销，从而缩减了系统整体响应时间。

3、统一的连接管理，避免数据库连接泄漏

在较为完备的数据库连接池实现中，可根据预先的连接占用超时设定，强制收回被占用连接。从而避免了常规数据库连接操作中可能出现的资源泄漏。

自定义连接池

public class MyPool {

    // 初始化连接数目
    private static int init_count = 3;
    // 最大连接数
    private static int max_count = 6;
    // 记录当前使用连接数
    private static int current_count = 0;
    // 连接池
    private static LinkedList<Connection> pool = new LinkedList<>();
    
    static {
        // 初始化连接
        for (int i=0; i<init_count; i++){
            // 记录当前连接数目
            current_count++;
            // 创建原始的连接对象
            Connection con = createConnection();
            // 把连接加入连接池
            pool.addLast(con);
        }
    }

    private static Connection createConnection(){
        try {
            Class.forName("com.mysql.jdbc.Driver");
            // 原始的目标对象
            final Connection con = DriverManager.getConnection("jdbc:mysql:///ysdrzp", "root", "root");

            // 对连接对象创建代理对象
            Connection proxy = (Connection) Proxy.newProxyInstance(
                    con.getClass().getClassLoader(),
                    new Class[]{Connection.class},
                    new InvocationHandler() {
                        @Override
                        public Object invoke(Object proxy, Method method, Object[] args)
                                throws Throwable {
                            // 方法返回值
                            Object result = null;
                            // 当前执行的方法的方法名
                            String methodName = method.getName();
                            if ("close".equals(methodName)) {
                                System.out.println("begin:当前执行close方法开始！");
                                pool.addLast(con);
                                System.out.println("end: 当前连接已经放入连接池了！");
                            } else {
                                // 调用目标对象方法
                                result = method.invoke(con, args);
                            }
                            return result;
                        }
                    }
            );
            return proxy;
        } catch (Exception e) {
            throw new RuntimeException(e);
        }
    }

    public Connection getConnection(){

        if (pool.size() > 0){
            return pool.removeFirst();
        }
        
        if (current_count < max_count) {
            // 记录当前使用的连接数
            current_count++;
            // 创建连接
            return createConnection();
        }

        throw new RuntimeException("当前连接已经达到最大连接数目");
    }

    public void realeaseConnection(Connection con) {
        
        if (pool.size() < init_count){
            pool.addLast(con);
        } else {
            try {
                current_count--;
                con.close();
            } catch (SQLException e) {
                throw new RuntimeException(e);
            }
        }
    }

    public static void main(String[] args) throws SQLException {
        MyPool pool = new MyPool();
        System.out.println("当前连接: " + pool.current_count);
        pool.getConnection();
        pool.getConnection();
        Connection con4 = pool.getConnection();
        Connection con3 = pool.getConnection();
        Connection con2 = pool.getConnection();
        Connection con1 = pool.getConnection();
        // 释放连接, 连接放回连接池
        // 动态代理实现重写close()方法
        con1.close();
        pool.getConnection();
        System.out.println("连接池：" + pool.pool.size());
        System.out.println("当前连接: " + pool.current_count);
    }

}

 DBCP

 

url=jdbc:mysql:///ysdrzp
driverClassName=com.mysql.jdbc.Driver
username=root
password=root
initialSize=3
maxActive=6
maxIdle=3000

public class DBCP {

    @Test
    public void testDbcp() throws Exception {
        // DBCP连接池核心类
        BasicDataSource dataSouce = new BasicDataSource();
        dataSouce.setUrl("jdbc:mysql:///ysdrzp");
        dataSouce.setDriverClassName("com.mysql.jdbc.Driver");
        dataSouce.setUsername("root");
        dataSouce.setPassword("root");
        dataSouce.setInitialSize(3);
        dataSouce.setMaxActive(6);
        dataSouce.setMaxIdle(3000);

        Connection con = dataSouce.getConnection();
        con.prepareStatement("delete from admin where id=3").executeUpdate();
        con.close();
    }

    @Test
    public void testProp() throws Exception {
        Properties prop = new Properties();
        InputStream inStream = DBCP.class.getResourceAsStream("/db.properties");
        prop.load(inStream);
        DataSource dataSouce = BasicDataSourceFactory.createDataSource(prop);

        Connection con = dataSouce.getConnection();
        con.prepareStatement("delete from admin where id=4").executeUpdate();
        con.close();
    }
}

C3P0

<c3p0-config>

    <default-config>
        <property name="jdbcUrl">jdbc:mysql://localhost:3306/ysdrzp</property>
        <property name="driverClass">com.mysql.jdbc.Driver</property>
        <property name="user">root</property>
        <property name="password">root</property>
        <property name="initialPoolSize">3</property>
        <property name="maxPoolSize">6</property>
        <property name="maxIdleTime">1000</property>
    </default-config>

    <named-config name="dataSource">
        <property name="jdbcUrl">jdbc:mysql://localhost:3306/ysdrzp</property>
        <property name="driverClass">com.mysql.jdbc.Driver</property>
        <property name="user">root</property>
        <property name="password">root</property>
        <property name="initialPoolSize">3</property>
        <property name="maxPoolSize">6</property>
        <property name="maxIdleTime">1000</property>
    </named-config>

</c3p0-config>

public class C3P0 {

    @Test
    public void testCode() throws Exception {
        // 创建连接池核心工具类
        ComboPooledDataSource dataSource = new ComboPooledDataSource();
        // 设置连接参数：url、驱动、用户密码、初始连接数、最大连接数
        dataSource.setJdbcUrl("jdbc:mysql://localhost:3306/ysdrzp");
        dataSource.setDriverClass("com.mysql.jdbc.Driver");
        dataSource.setUser("root");
        dataSource.setPassword("root");
        dataSource.setInitialPoolSize(3);
        dataSource.setMaxPoolSize(6);
        dataSource.setMaxIdleTime(1000);

        Connection con = dataSource.getConnection();
        con.prepareStatement("delete from admin where id=7").executeUpdate();
        con.close();
    }

    @Test
    public void testXML() throws Exception {
        // 自动加载src下c3p0的配置文件【c3p0-config.xml】
        //ComboPooledDataSource dataSource = new ComboPooledDataSource();
        ComboPooledDataSource dataSource = new ComboPooledDataSource("dataSource");
        PreparedStatement pstmt = null;

        Connection con = dataSource.getConnection();
        for (int i=1; i<11;i++){
            String sql = "insert into user(name,password) values(?,?)";
            pstmt = con.prepareStatement(sql);
            pstmt.setString(1, "Rose" + i);
            pstmt.setInt(2, 1);
            pstmt.executeUpdate();
        }
        pstmt.close();
        con.close();
    }
}