自定义一个简单的JDBC连接池实现方法（附代码演示）

已于 2023-12-05 16:16:59 修改
阅读量1.3k 收藏 29
点赞数 29
分类专栏： Java 数据库 开发语言 文章标签： java 数据库 开发语言
于 2023-12-05 16:02:33 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Jin_Xiang123/article/details/134803449
版权
开发语言 同时被 3 个专栏收录
23 篇文章 0 订阅
订阅专栏
Java
18 篇文章 0 订阅
订阅专栏
数据库
3 篇文章 0 订阅
订阅专栏

Hi i,m JinXiang

⭐ 前言 ⭐

本篇文章主要介绍自定义一个简单的JDBC连接池实现方法以及部分理论知识

🍉欢迎点赞 👍 收藏 ⭐留言评论 📝私信必回哟😁

🍉博主收将持续更新学习记录获，友友们有任何问题可以在评论区留言

目录

⭐什么是连接池？

🍧连接池的实现通常会包括以下几个方面：

⭐如何自定义一个连接池

🍧一、准备工作

🍧二、代码呈现

获取连接--（MyAbsyeactDateSource）

关闭连接--（MyConnection）

两个连接池状态 工作/空闲--（MyDataSoures）

🍧三、结果呈现

取用mysql连接数据库 与 自定义连接池 进行 速度比较

结果

⭐什么是连接池？

连接池（Connection Pool）是一种数据库连接管理技术，它可以对数据库连接进行复用，从而减少了重复创建和删除连接的开销，提高了系统的性能和可扩展性。

  • 1、连接池在应用程序启动时创建一定数量的数据库连接，将这些连接保存在内存中，等待应用程序需要时提供给它，应用程序在使用完连接后将其放回连接池，而不是直接关闭它。当连接池中的连接数量不足时，连接池会自动创建新的连接，直到达到连接池的最大连接数为止。
  • 2、连接池的主要作用是提高系统的性能和可扩展性，它可以减少数据库连接的创建和销毁次数，避免了频繁的网络交互和数据库连接的资源消耗，同时也方便了系统的升级和扩展。但连接池的缺点是会占用一定的内存和资源，并且在高并发环境中可能会出现连接池满的情况，需要合理设置连接池的参数，以便在保证系统性能的情况下，最大限度地利用连接池的资源。

🍧连接池的实现通常会包括以下几个方面：

  • 1、连接池大小的管理：连接池的大小对应用程序的性能和数据库的性能都有影响。连接池大小的管理需要根据应用程序的负载情况动态调整，以提供最优的连接数量。
  • 2、连接生命周期的控制：连接池管理连接的生命周期，当连接不再使用时，将其关闭并从连接池中移除。这可以释放资源，避免连接泄漏和占用过多的资源。
  • 3、 连接的复用：连接池可以对数据库连接进行复用，避免每次连接数据库时都要重新创建连接，从而提高应用程序的性能和数据库的响应速度。
  • 4、连接的验证：连接池通常会对连接进行验证，以确保连接可用性。如果连接不可用，连接池会移除该连接并创建新的连接。这可以避免应用程序使用已经失效的连接。

总之，连接池可以有效地管理数据库连接，提高应用程序的性能和数据库的响应速度。

⭐如何自定义一个连接池

一、准备工作

在datasoures创建三个类

二、代码呈现

获取连接--（MyAbsyeactDateSource）
//是在实现mysql实现的连接

package user_defined.datasource;

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



public abstract class MyAbsyeactDateSource implements DataSource {
//=======如何得到一个连接

    private String url;
    private String username;
    private String password;
    private String driverClassName;

    //初始连接数
    private int initialSize = 10;
    //最大连接数
    private int maxActive = 30;

    public String getUrl() {
        return url;
    }

    public void setUrl(String url) {
        this.url = url;
    }

    public String getUsername() {
        return username;
    }

    public void setUsername(String username) {
        this.username = username;
    }

    public String getPassword() {
        return password;
    }

    public void setPassword(String password) {
        this.password = password;
    }

    public String getDriverClassName() {
        return driverClassName;
    }

    public void setDriverClassName(String driverClassName) {
        this.driverClassName = driverClassName;
    }

    public int getInitialSize() {
        return initialSize;
    }

    public void setInitialSize(int initialSize) {
        this.initialSize = initialSize;
    }

    public int getMaxActive() {
        return maxActive;
    }

    public void setMaxActive(int maxActive) {
        this.maxActive = maxActive;
    }

    public boolean isInitFlog() {
        return initFlog;
    }

    public void setInitFlog(boolean initFlog) {
        this.initFlog = initFlog;
    }

    //初始化值
    private boolean initFlog = false;

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

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

    private Connection daDetConnection(String username,String password) throws SQLException {
        if (!initFlog){
            try {
                Class.forName(driverClassName);
            } catch (ClassNotFoundException e) {
                throw new RuntimeException(e);
            }
            initFlog = true;
        }
        return DriverManager.getConnection(url,username,password);
    }
    @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;
    }
}
关闭连接--（MyConnection）
package user_defined.datasource;

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

public class MyConnection implements Connection {
//=======如何关闭一个连接

    private MyDataSoures myDataSoures;
    private Connection  connection;

    //构造方法
    public MyConnection(MyDataSoures myDataSoures, Connection connection) {
        this.myDataSoures = myDataSoures;
        this.connection = connection;
    }
    //只需要实现这两个方法（close，isClosed）
    @Override
    public void close() throws SQLException {
        //把连接从工作连接池放回空闲连接池
        if (myDataSoures.getIdlePool().size() < myDataSoures.getMaxActive()){
            myDataSoures.getWorkPool().remove(this);
            myDataSoures.getIdlePool().addLast(this);
        }

    }

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

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

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

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

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

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

    }

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

    @Override
    public void commit() throws SQLException {

    }

    @Override
    public void rollback() throws SQLException {

    }


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

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

    }

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

    @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;
    }
}
两个连接池状态 工作/空闲--（MyDataSoures）
package user_defined.datasource;

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

public class MyDataSoures extends MyAbsyeactDateSource {
//======两个连接池状态（工作，空闲）

    //工作连接池
    private LinkedList<MyConnection> workPool = new LinkedList<>();

    //空闲连接池
    private LinkedList<MyConnection> idlePool = new LinkedList<>();

    //get方法
    public LinkedList<MyConnection> getWorkPool() {
        return workPool;
    }

    public LinkedList<MyConnection> getIdlePool() {
        return idlePool;
    }

    public MyDataSoures(){

    }

    // TODO  从工作连接池获取到一个连接

    private boolean initFlag = false;


    //重写getconnection方法
    @Override
    public Connection getConnection() throws SQLException {
        MyConnection connection = null;
        this.init();
        //如果空闲连接不为空就直接取
        if (!idlePool.isEmpty()){
            connection = idlePool.removeFirst();
        }else {
            //如果工作连接数小于最大连接数，就创建一个
            if (workPool.size() < super.getMaxActive()){
                connection = new MyConnection(this,super.getConnection());
            }
        }

        if (connection !=null){
            workPool.addLast(connection);
        }

        return connection;
    }

    public void init() throws SQLException {
        //初始化十个连接
        if (!initFlag) {
            while (idlePool.size() < super.getInitialSize()) {
                idlePool.add(new MyConnection(this, super.getConnection()));
            }
            initFlag = true;
        }
    }
}

三、结果呈现

取用mysql连接数据库 与 自定义连接池 进行 速度比较
package user_defined;

import user_defined.datasource.MyDataSoures;

import java.sql.*;

public class Test {
    //自定义连接池
    public static String url = "jdbc:mysql://localhost:3306/1201moviedb?rewriteBatchedStatements=true&serverTimezone=UTC";
    public static String username = "root";
    public static String password = "root";
    public static String driverClassName = "com.mysql.cj.jdbc.Driver";

    @org.junit.Test
    public void TestDateSource() throws SQLException, ClassNotFoundException {
        MyDataSoures myConnection = new MyDataSoures();
        myConnection.setDriverClassName(driverClassName);
        myConnection.setUrl(url);
        myConnection.setUsername(username);
        myConnection.setPassword(password);

        long statr = System.currentTimeMillis(); //
        for (int i = 0; i < 500; i++) {
            Connection connection = myConnection.getConnection();
            connection.close();
        }
        long end = System.currentTimeMillis();
        System.out.println("MyDateSource 耗时："+(end - statr)+"ms");


        //mysql连接数据库
        Class.forName("com.mysql.cj.jdbc.Driver");
        String url = "jdbc:mysql://localhost:3306/1201moviedb?rewriteBatchedStatements=true&serverTimezone=UTC";
        String username = "root";
        String password = "root";

        long statr2 = System.currentTimeMillis(); //
        for (int i = 0; i < 500; i++) {   //执行500次
            Connection con2 = DriverManager.getConnection(url,username,password);
            con2.close();
        }
        long end2 = System.currentTimeMillis();
        System.out.println("传统数据库 耗时："+(end2 - statr2)+"ms");
    }
}
结果：

MySql连接数据库 耗时4秒 自定义连接池 1秒

总结不易，希望uu们不要吝啬亲爱的👍哟(＾Ｕ＾)ノ~ＹＯ！！如有问题，欢迎评论区批评指正😁

锦湘
关注
  • 29
    点赞
  • 踩
  • 29
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
自定义高并发jdbc连接池
06-23
自定义的JDBC连接池，支持并发访问，可维持多个数据库的连接池
自定义一个简单的JDBC连接池实现方法
08-28
下面小编就为大家分享一篇自定义一个简单的JDBC连接池实现方法，具有很好的参考价值，希望对大家有所帮助。一起跟随小编过来看看吧
java动态代理实现自定义连接池
05-06
1.主要理解动态代理的设计思想 2.理解连接池的设计思想以及优点
创建自定义连接池实例
01-20
简单的利用java装饰模式自定义实现了连接池简单实例。
1. 自定义连接池
DevOps海洋的渔夫@专栏
09-30 738
1. 自定义连接池连接池概念1. 为什么要使用连接池 Connection对象在JDBC使用的时候就会去创建一个对象,使用结束以后就会将这个对象给销毁了(close).每次创建和销毁对象都...
JDBC之自定义连接池
PP东博客
09-03 949
定义一个类实现DataSource接口定义一个容器，用于保存多个Connection连接对象定义静态代码块，通过JDBC工具类获取10个连接对象保存到容器中。重写getCOnnection方法，从容器中获取一个连接并返回。定义getSizi方法，用于获取容器的大小并返回。
自定义连接池
XXXanghongin的博客
07-05 72
例如：一个线上商城应用，QPS 达到数千，如果每次都重新创建和关闭数据库连接，性能会受到极大影响。这时预先创建好一批连接，放入连接池。一次请求到达后，从连接池获取连接，使用完毕后再还回连接池，这样既节约了连接的创建和关闭时间，也实现了连接的重用，不至于让庞大的连接数压垮数据库。对于更通用的对象池，可以考虑使用apachecommons pool，例如redis连接池可以参考jedis中关于连接池的实现。对于关系型数据库，有比较成熟的连接池实现，例如c3p0, druid等。连接的动态增长与收缩。
自定义数据库连接池
Little Big Us的博客
07-16 782
数据库连接池 数据库连接池和线程池一样，都是为了避免资源的反复创建和释放而出现的 数据库连接的背景 数据库连接是一种关键的，有限的，昂贵的资源，这一点在多用户的网页应用程序中体现的尤为突出 对数据库连接的管理能显著影响整个应用程序的性能指标，数据库连接池正是针对这一问题提出的 数据库连接池 数据库连接池负责分配，管理和释放数据库连接，它允许应用程序重复使用一个现有的数据库连接，而不是再重新建立一个。这项技术能明显的提高对数据库操作的性能 自定义数据库连接池 DataSource DataS
尝试手写一个框架（三）如何自己手写一套数据库连接池?
歪桃的博客
07-09 8243
通过数据库连接池的原理，结合并发队列，配置文件映射的知识点，尝试自己写的连接池框架
java实现jdbc连接池+相关jar包
03-02
使用java技术实现jdbc连接池 包括了全面的jar和cp30,commons-DBCP,c3p0 for linux的包,以及jdbc jars
Java 的JDBC 数据库连接池实现方法.zip_J2EE JSP_connection pool jdbc_java 连接池
09-23
J2EE 程序员一般都有现成的应用服务器所带的JDBC 数据库连接池，不过对于开发一般的 Java Application 、 Applet 或者 JSP、velocity 时，我们可用的JDBC 数据库连接池并不多...我们可以自己写一个JDBC 数据库连接池。
JDBC自定义连接池过程详解
08-25
主要介绍了JDBC自定义连接池过程详解,文中通过示例代码介绍的非常详细，对大家的学习或者工作具有一定的参考学习价值,需要的朋友可以参考下
SpringBoot使用Druid连接池 + 配置监控页面(自定义版 + starter版)
Bulut0907
08-28 7406
全方位监控、防SQL注入攻击等添加druid连接池的依赖，如下所示： 2.2 MyDataSourceConfig实现 说明如下： 2.3 application.properties配置 在代码中可以对DataSource进行各种配置参数的set，也可以在application.properties中对durid连接池进行配置，如下所示： 编写Controller进行测试 2.4 druid监控页面查看 访问http://localhost:8080/druid/index.html，页面效果如下：其中
自定义HikariCP连接池
lydms的博客
05-24 3114
官方解释：快速、简单、可靠。HikariCP 是一个“零开销”的生产就绪 JDBC 连接池。大约 130Kb，库非常轻。需要使用Jdbc自己实现查询，并且查询过程中，使用数据库连接池进行数据源管理。获取数据源从数据源获取链接/*** 获取数据库连接* @param driverClassName 驱动类(com.mysql.cj.jdbc.Driver)* @param username 用户名* @param password 密码* @return。
JDBC 连接池 详解（通俗易懂）
Cyan_RA9的博客
06-11 5589
JDBC 第五节 详解连接池 通俗易懂！
数据库连接池
qq_56101688的博客
05-03 203
自定义连接类只需要继承这个适配器类，重写需要改进的close()方法即可！但是这种方式行不通，通过查看JDBC工具类获取连接的方法我们发现：我们虽然自定义了一个子类，完成了归还连接的操作。数据库连接是一种关键的、有限的、昂贵的资源，这一点在多用户的网页应用程序中体现得尤为突出。经过我们适配器模式的改进，自定义连接类中的方法已经很简洁了。剩余所有的方法已经抽取到了适配器类中。数据库连接池负责分配、管理和释放数据库连接，它允许应用程序重复使用一个现有的数据库连接，而不是再重新建立一个。super(con);
JDBC连接池
hanhanhanfei的博客
05-17 502
1.为什么使用连接池？ 数据库连接是一种关键的有限的昂贵的资源，传统数据库连接每发出一个请求都要创建一个连接对象，使用完直接关闭不能重复利用； 关闭资源需要手动完成，一旦忘记会造成内存溢出； 请求过于频繁的时候，创建连接极其消耗内存； 而且一旦高并发访问数据库，有可能会造成系统崩溃。 为了解决这些问题，我们可以使用连接池。 2.传统JDBC的缺点 用户每次请求都需要向数据库获得链接，而数据库创建连接通常需要消耗相对较大的资源，创建时间也较长。 假设网站一天10万访问...
java jar包如何运行或调用
最新发布
NLP与推荐算法
05-08 200
java服务启动
请写出实现一个数据库连接池的关键思路与核心代码。
05-27
实现一个数据库连接池，需要考虑以下关键思路： 1. 连接池初始化：在初始化时，需要创建一定数量的数据库连接，并将其保存在连接池中，可以使用Java中的数据结构LinkedBlockingQueue来实现连接池。 2. 连接池的获取：当有请求需要连接数据库时，从连接池中获取连接，如果连接池中已经没有可用的连接，可以根据需要创建新的连接。 3. 连接池的释放：当连接使用完毕后，需要及时将其释放回连接池中，以供其他请求使用。 下面是一个简单的实现连接池的核心代码： ```java public class DBPool { private static ConnectionPool pool; private static final int POOL_SIZE = 10; // 连接池大小 static { pool = new ConnectionPool(POOL_SIZE); } public static Connection getConnection() throws SQLException { return pool.getConnection(); } public static void releaseConnection(Connection conn) { pool.releaseConnection(conn); } private static class ConnectionPool { private BlockingQueue<Connection> queue; public ConnectionPool(int poolSize) { queue = new LinkedBlockingQueue<>(poolSize); for (int i = 0; i < poolSize; i++) { try { Connection conn = createConnection(); queue.offer(conn); } catch (SQLException e) { e.printStackTrace(); } } } public Connection getConnection() throws SQLException { Connection conn = null; try { conn = queue.take(); } catch (InterruptedException e) { e.printStackTrace(); } return conn; } public void releaseConnection(Connection conn) { if (conn != null) { try { queue.put(conn); } catch (InterruptedException e) { e.printStackTrace(); } } } private Connection createConnection() throws SQLException { // 创建数据库连接 return DriverManager.getConnection("jdbc:mysql://localhost:3306/test", "root", "123456"); } } } ``` 在上面的代码中，我们使用了Java中的BlockingQueue来实现连接池，并在连接池初始化时创建了一定数量的数据库连接。getConnection方法用于获取连接，如果连接池中没有可用连接，该方法会阻塞等待。releaseConnection方法用于将连接释放回连接池中。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值