JDBC_连接池

最新推荐文章于 2021-08-20 11:55:52 发布

劉某人゜

最新推荐文章于 2021-08-20 11:55:52 发布

阅读量136

点赞数

分类专栏： JDBC 文章标签： JDBC 连接池阿里巴巴-德鲁伊druid C3P0

本文链接：https://blog.csdn.net/weixin_44953728/article/details/100837319

版权

JDBC 专栏收录该内容

3 篇文章 0 订阅

订阅专栏

一.自定义连接池

1.为什么要使用连接池

Connection对象在JDBC使用的时候就会去创建一个对象,使用结束以后就会将这个对象给销毁了(close).每次创建和销毁对象都是耗时操作.需要使用连接池对其进行优化.

程序初始化的时候(还没有操作数据库)，初始化多个连接,将多个连接放入到池(集合)中.每次获取的时候,都可以直接从连接池中进行获取.使用结束以后,将连接归还到池中.

2.连接池原理

在这里插入图片描述

程序一开始就创建一定数量的连接，放在一个容器中，这个容器称为连接池(相当于碗柜/容器)。
使用的时候直接从连接池中取一个已经创建好的连接对象。
关闭的时候不是真正关闭连接，而是将连接对象再次放回到连接池中。

3.自定义连接池初级版本

创建一个类,定义LinkedList集合作为连接池,在静态代码块中,向集合里面添加5个连接对象
添加addBack()方法,用作归还连接

package com.a_custom;

import com.utils.JdbcUtils;

import java.sql.Connection;
import java.util.LinkedList;

/***
 *@Author:五五开
 *@Date: 2019/9/1 9:42
 *@Description:itheima
 */
/*
    自定义连接池的类
    创建一个类,定义linkedList集合作为连接池,在静态代码块中,向集合里面添加5个连接对象
    添加addBack()方法,用作归还连接
 */
public class MyDataSource {
    //定义集合,存放连接对象
    private static LinkedList<Connection> pool;

    //初始化集合,存放连接对象
    static {
        pool = new LinkedList<Connection>();
        //创建5个连接对象
        for (int i = 0; i < 5; i++) {
            try {
                //创建连接
                Connection connection = JdbcUtils.getConnection();
                pool.add(connection);
            } catch (Exception e) {
                e.printStackTrace();
            }
        }
    }

    /**
     * 从pool里面拿出连接
     *
     * @return
     */
    public Connection getABC() {
        Connection connection = pool.removeFirst();
        return connection;
    }

    /**
     * 归还连接到pool
     *
     * @param connection
     */
    public void addBack(Connection connection) {
        pool.addLast(connection);
    }

    /**
     * 获得pool中连接的数量
     *
     * @return
     */
    public static int getCount() {
        return pool.size();
    }
}

4.自定义连接池进阶版本(实现datasource)

4.1datasource接口概述

Java为数据库连接池提供了公共的接口：javax.sql.DataSource，各个厂商(用户)需要让自己的连接池实现这个接口。这样应用程序可以方便的切换不同厂商的连接池！
在这里插入图片描述

package com.a_custom;

import com.utils.JdbcUtils;

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

/*
    自定义连接池的类
    创建一个类,定义linkedList集合作为连接池,在静态代码块中,向集合里面添加5个连接对象
    添加addBack()方法,用作归还连接
 */
public class MyDataSource implements DataSource{
    //定义集合,存放连接对象
    private static LinkedList<Connection> pool;

    //初始化集合,存放连接对象
    static {
        pool = new LinkedList<Connection>();
        //创建5个连接对象
        for (int i = 0; i < 5; i++) {
            try {
                //创建连接
                Connection connection = JdbcUtils.getConnection();
                pool.add(connection);
            } catch (Exception e) {
                e.printStackTrace();
            }
        }
    }

    /**
     * 归还连接到pool
     *
     * @param connection
     */
    public void addBack(Connection connection) {
        pool.addLast(connection);
    }

    /**
     * 获得pool中连接的数量
     *
     * @return
     */
    public static int getCount() {
        return pool.size();
    }

    @Override
    /**
     * 从连接池中获得Connection对象
     */
    public Connection getConnection() throws SQLException {
        Connection connection = pool.removeFirst();
        return connection;
    }

    @Override
    public Connection getConnection(String username, String password) throws SQLException {
        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 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;
    }
}

4.2 编写连接池遇到的问题

实现dataSource接口后,addBack()不能调用了.
能不能不引入新的api,直接调用之前的API.close(),但是这个close不是关闭,是归还

4.3 解决办法

继承
条件:可以控制父类, 最起码知道父类的名字
装饰者模式
作用：改写已存在的类的某个方法或某些方法
动态代理

5.自定义连接池进阶终极版本

5.1装饰者模式概述

什么是装饰者模式
装饰者模式，是 23种常用的面向对象软件的设计模式之一. 设计模式简单来说就是编码的方式,套路,思想

动态地将责任附加到对象上。若要扩展功能，装饰者提供了比继承更加有弹性的替代方案。

装饰者的作用：改写已存在的类的某个方法或某些方法, 说白了就是增强方法的逻辑
使用装饰者模式需要满足的条件
- 增强类和被增强类实现的是同一个接口
- 增强类里面要拿到被增强类的引用

package com.a_custom;

import java.sql.*;
import java.util.LinkedList;
import java.util.Map;
import java.util.Properties;
import java.util.concurrent.Executor;

public class MyConnection implements Connection {
    private Connection connection;
    private LinkedList<Connection> pool;

    public MyConnection(Connection connection, LinkedList<Connection> pool) {
        this.connection = connection;
        this.pool = pool;
    }

    @Override
    //改写的方法 close() 改成归还, 只需要把addBack()里面的逻辑复制进来
    public void close() throws SQLException {
        pool.addLast(connection);
    }

    @Override
    public PreparedStatement prepareStatement(String sql) throws SQLException {
        return connection.prepareStatement(sql);
    }

    @Override
    public Statement createStatement() throws SQLException {
        return null;
    }

    @Override
    public CallableStatement prepareCall(String sql) throws SQLException {
        return null;
    }

    @Override
    public String nativeSQL(String sql) throws SQLException {
        return null;
    }

    @Override
    public void setAutoCommit(boolean autoCommit) throws SQLException {

    }

    @Override
    public boolean getAutoCommit() throws SQLException {
        return false;
    }

    @Override
    public void commit() throws SQLException {

    }

    @Override
    public void rollback() throws SQLException {

    }

    @Override
    public boolean isClosed() throws SQLException {
        return false;
    }

    @Override
    public DatabaseMetaData getMetaData() throws SQLException {
        return null;
    }

    @Override
    public void setReadOnly(boolean readOnly) throws SQLException {

    }

    @Override
    public boolean isReadOnly() throws SQLException {
        return false;
    }

    @Override
    public void setCatalog(String catalog) throws SQLException {

    }

    @Override
    public String getCatalog() throws SQLException {
        return null;
    }

    @Override
    public void setTransactionIsolation(int level) throws SQLException {

    }

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

    @Override
    public SQLWarning getWarnings() throws SQLException {
        return null;
    }

    @Override
    public void clearWarnings() throws SQLException {

    }

    @Override
    public Statement createStatement(int resultSetType, int resultSetConcurrency) throws SQLException {
        return null;
    }

    @Override
    public PreparedStatement prepareStatement(String sql, int resultSetType, int resultSetConcurrency) throws SQLException {
        return null;
    }

    @Override
    public CallableStatement prepareCall(String sql, int resultSetType, int resultSetConcurrency) throws SQLException {
        return null;
    }

    @Override
    public Map<String, Class<?>> getTypeMap() throws SQLException {
        return null;
    }

    @Override
    public void setTypeMap(Map<String, Class<?>> map) throws SQLException {

    }

    @Override
    public void setHoldability(int holdability) throws SQLException {

    }

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

    @Override
    public Savepoint setSavepoint() throws SQLException {
        return null;
    }

    @Override
    public Savepoint setSavepoint(String name) throws SQLException {
        return null;
    }

    @Override
    public void rollback(Savepoint savepoint) throws SQLException {

    }

    @Override
    public void releaseSavepoint(Savepoint savepoint) throws SQLException {

    }

    @Override
    public Statement createStatement(int resultSetType, int resultSetConcurrency, int resultSetHoldability) throws SQLException {
        return null;
    }

    @Override
    public PreparedStatement prepareStatement(String sql, int resultSetType, int resultSetConcurrency, int resultSetHoldability) throws SQLException {
        return null;
    }

    @Override
    public CallableStatement prepareCall(String sql, int resultSetType, int resultSetConcurrency, int resultSetHoldability) throws SQLException {
        return null;
    }

    @Override
    public PreparedStatement prepareStatement(String sql, int autoGeneratedKeys) throws SQLException {
        return null;
    }

    @Override
    public PreparedStatement prepareStatement(String sql, int[] columnIndexes) throws SQLException {
        return null;
    }

    @Override
    public PreparedStatement prepareStatement(String sql, String[] columnNames) throws SQLException {
        return null;
    }

    @Override
    public Clob createClob() throws SQLException {
        return null;
    }

    @Override
    public Blob createBlob() throws SQLException {
        return null;
    }

    @Override
    public NClob createNClob() throws SQLException {
        return null;
    }

    @Override
    public SQLXML createSQLXML() throws SQLException {
        return null;
    }

    @Override
    public boolean isValid(int timeout) throws SQLException {
        return false;
    }

    @Override
    public void setClientInfo(String name, String value) throws SQLClientInfoException {

    }

    @Override
    public void setClientInfo(Properties properties) throws SQLClientInfoException {

    }

    @Override
    public String getClientInfo(String name) throws SQLException {
        return null;
    }

    @Override
    public Properties getClientInfo() throws SQLException {
        return null;
    }

    @Override
    public Array createArrayOf(String typeName, Object[] elements) throws SQLException {
        return null;
    }

    @Override
    public Struct createStruct(String typeName, Object[] attributes) throws SQLException {
        return null;
    }

    @Override
    public void setSchema(String schema) throws SQLException {

    }

    @Override
    public String getSchema() throws SQLException {
        return null;
    }

    @Override
    public void abort(Executor executor) throws SQLException {

    }

    @Override
    public void setNetworkTimeout(Executor executor, int milliseconds) throws SQLException {

    }

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


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

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

package com.a_custom;

import com.utils.JdbcUtils;

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


/*
    自定义连接池的类
    创建一个类,定义linkedList集合作为连接池,在静态代码块中,向集合里面添加5个连接对象
    添加addBack()方法,用作归还连接
 */
public class MyDataSource03 implements DataSource{
    //定义集合,存放连接对象
    private static LinkedList<Connection> pool;

    //初始化集合,存放连接对象
    static {
        pool = new LinkedList<Connection>();
        //创建5个连接对象
        for (int i = 0; i < 5; i++) {
            try {
                //创建连接
                Connection connection = JdbcUtils.getConnection();
                pool.add(connection);
            } catch (Exception e) {
                e.printStackTrace();
            }
        }
    }

    /**
     * 获得pool中连接的数量
     *
     * @return
     */
    public static int getCount() {
        return pool.size();
    }

    @Override
    /**
     * 从连接池中获得Connection对象
     */
    public Connection getConnection() throws SQLException {
        Connection connection = pool.removeFirst();
        //增强Connection
        MyConnection myConnection = new MyConnection(connection,pool);

        return myConnection;
    }

    @Override
    public Connection getConnection(String username, String password) throws SQLException {
        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 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;
    }
}

二.第三方连接池

1.常用连接池

常见的第三方连接池如下:

C3P0是一个开源的JDBC连接池，它实现了数据源和JNDI绑定，支持JDBC3规范和JDBC2的标准扩展。C3P0是异步操作的，所以一些操作时间过长的JDBC通过其它的辅助线程完成。目前使用它的开源项目有Hibernate，Spring等。C3P0有自动回收空闲连接功能
阿里巴巴-德鲁伊druid连接池：Druid是阿里巴巴开源平台上的一个项目，整个项目由数据库连接池、插件框架和SQL解析器组成。该项目主要是为了扩展JDBC的一些限制，可以让程序员实现一些特殊的需求。
DBCP(DataBase Connection Pool)数据库连接池，是Apache上的一个Java连接池项目，也是Tomcat使用的连接池组件。dbcp没有自动回收空闲连接的功能。

2.C3P0

C3P0开源免费的连接池！目前使用它的开源项目有：Spring、Hibernate等。使用第三方工具需要导入jar包，c3p0使用时还需要添加配置文件c3p0-config.xml.
使用C3P0需要添加c3p0-0.9.1.2.jar

2.1 C3P0使用

通过硬编码来编写

        //1.创建c3p0连接池
        ComboPooledDataSource cpds = new ComboPooledDataSource();
        cpds.setDriverClass("com.mysql.jdbc.Driver"); //驱动
        cpds.setJdbcUrl("jdbc:mysql://localhost:3306/mydb4");//路径
        cpds.setUser("root");//用户名
        cpds.setPassword("root");//密码
        cpds.setInitialPoolSize(5);

        //2.从连接池里面获得Connection
        Connection connection = cpds.getConnection();

通过配置文件来编写

编写配置文件c3p0-config.xml，放在src目录下（注：文件名一定不要改)

<c3p0-config>
    <default-config>
        <property name="driverClass">com.mysql.jdbc.Driver</property>
        <property name="jdbcUrl">jdbc:mysql://localhost:3306/mydb4</property>
        <property name="user">root</property>
        <property name="password">root</property>
        <property name="initialPoolSize">5</property>
    </default-config>
</c3p0-config>

代码

        //1.创建c3p0连接池
        DataSource dataSource = new ComboPooledDataSource();

        //2.从连接池里面获得Connection
        Connection connection = dataSource.getConnection();

使用c3p0连接池改写工具类

package com.utils;

import com.mchange.v2.c3p0.ComboPooledDataSource;
import org.junit.Test;

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

/**
 * 目的:
 * 1.保证DataSource只有一个
 * 2.提供连接(DataSource获得)
 * 3.释放资源
 */
public class C3p0Utils {
    //创建C3p0数据源(连接池)
    private static DataSource dataSource = new ComboPooledDataSource();

    /**
     * 从dataSource(连接池)获得连接对象
     * @return
     * @throws Exception
     */
    public static Connection getConnection() throws Exception {
        Connection connection = dataSource.getConnection();
        return connection;
    }

    /**
     * 释放资源
     * @param resultSet
     * @param statement
     * @param connection
     */
    public static void release(ResultSet resultSet, Statement statement, Connection connection) {
        if (resultSet != null) {
            try {
                resultSet.close();
            } catch (SQLException e) {
                e.printStackTrace();
            }
        }

        if (statement != null) {
            try {
                statement.close();
            } catch (SQLException e) {
                e.printStackTrace();
            }
        }

        if (connection != null) {
            try {
                connection.close();
            } catch (SQLException e) {
                e.printStackTrace();
            }
        }
    }
}

3.DRUID

Druid是阿里巴巴开发的号称为监控而生的数据库连接池，Druid是国内目前最好的数据库连接池。在功能、性能、扩展性方面，都超过其他数据库连接池。Druid已经在阿里巴巴部署了超过600个应用，经过一年多生产环境大规模部署的严苛考验。如：一年一度的双十一活动，每年春运的抢火车票。

Druid的下载地址：https://github.com/alibaba/druid

3.1 DRUID的使用

通过硬编码方式

        //1.创建DataSource
        DruidDataSource dataSource = new DruidDataSource();
        dataSource.setDriverClassName("com.mysql.jdbc.Driver");//加载驱动
        dataSource.setUrl("jdbc:mysql://localhost:3306/mydb4");//设置数据库路径
        dataSource.setUsername("root");//设置用户名
        dataSource.setPassword("root");//设置密码

        dataSource.setInitialSize(5);//设置初始化连接的数量

        //2.从数据源中获得Connection
        DruidPooledConnection connection = dataSource.getConnection();

通过配置文件方式
创建druid.properties, 放在src目录下

# 数据库连接参数
url=jdbc:mysql:///mydb4
username=root
password=root
driverClassName=com.mysql.jdbc.Driver
# 连接池的参数
initialSize=10
maxActive=10
maxWait=2000

代码

        //0.根据druid.properties创建配置文件对象
        Properties properties = new Properties();
        //关联druid.properties文件
        InputStream is = DruidDemo.class.getClassLoader().getResourceAsStream("druid.properties");
        properties.load(is);

        //1.创建DataSource
        DataSource dataSource = DruidDataSourceFactory.createDataSource(properties);

        //2.从数据源中获得Connection
        Connection connection = dataSource.getConnection();

用配置文件的方式使用druid, 抽取成DruidUtils

package com.utils;

import com.alibaba.druid.pool.DruidDataSourceFactory;

import javax.sql.DataSource;
import java.io.IOException;
import java.io.InputStream;
import java.sql.Connection;
import java.sql.ResultSet;
import java.sql.SQLException;
import java.sql.Statement;
import java.util.Properties;

public class DruidUtils {
    //创建数据源(连接池)
    static DataSource dataSource = null;

    static {
        InputStream is = null;
        try {
            Properties properties = new Properties();
            is = DruidUtils.class.getClassLoader().getResourceAsStream("druid.properties");
            properties.load(is);
            dataSource = DruidDataSourceFactory.createDataSource(properties);
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            if (is != null) {
                try {
                    is.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }
    }

    /**
     * 获取数据源
     *
     * @return
     */
    public static DataSource getDataSource() {
        return dataSource;
    }

    /**
     * 获得连接
     *
     * @return
     * @throws SQLException
     */
    public static Connection getConnection() throws SQLException {
        Connection connection = dataSource.getConnection();
        return connection;
    }

    /**
     * 释放资源
     *
     * @param resultSet
     * @param statement
     * @param connection
     */
    public static void release(ResultSet resultSet, Statement statement, Connection connection) {
        if (resultSet != null) {
            try {
                resultSet.close();
            } catch (SQLException e) {
                e.printStackTrace();
            }
        }

        if (statement != null) {
            try {
                statement.close();
            } catch (SQLException e) {
                e.printStackTrace();
            }
        }

        if (connection != null) {
            try {
                connection.close();
            } catch (SQLException e) {
                e.printStackTrace();
            }
        }
    }
}