• 手写数据库连接池

    数据库连接是个耗时操作.对数据库连接的高效管理影响应用程序的性能指标.

    数据库连接池正是针对这个问题提出来的.

    数据库连接池负责分配,管理和释放数据库连接.它允许应用程序重复使用一个现有的数据路连接,而不需要每次重新建立一个新的连接,利用数据库连接池将明显提升对数据库操作的性能.

    数据库连接池技术方案:

    1.C3P0

    2.DBCP

    3.Proxool

    4.Tomcat jdbc Oppl

    5.BoneCP

    6.Druid

    7.HikariCP

    数据库连接池属于一种池化技术:

    常见的有:http访问(httpclient),redis访问(redisPool),线程(线程池)等

    新建个空项目

    可能是版本原因idea创建空项目总要重启一下

    设置下maven和encoding

    新建模块

    DataSource是JDK里的规范,用来专门放连接的.是一个连接工厂

    自定义一个接口

    里面需要实现的两个方法是:  其他的父接口的其他方式可以暂时不管

    这样基础结构就有了

    1. package com.pool;
    2.  
    3. import java.sql.Connection;
    4. import java.sql.DriverManager;
    5. import java.sql.SQLException;
    6.  
    7. /**
    8.  * @author hrui
    9.  * @date 2023/9/10 3:06
    10.  */
    11. public class MyAbstractDataSource implements MyDataSourceInterface{
    12.  
    13.     private String url;
    14.  
    15.     private String driver;
    16.  
    17.     private String username;
    18.  
    19.     private String password;
    20.  //最大的连接数量
    21.     private int poolMaxActiveConnection=10;
    22.  
    23.     //最大空闲连接数
    24.     private int poolMaxIdIeConnection=5;
    25.  
    26.     //当连接都在使用时候,最大检出时间(等待时间),毫秒
    27.     private int poolTimeToWait=20000;
    28.  
    29.     public int getPoolMaxActiveConnection() {
    30.         return poolMaxActiveConnection;
    31.     }
    32.  
    33.     public void setPoolMaxActiveConnection(int poolMaxActiveConnection) {
    34.         this.poolMaxActiveConnection = poolMaxActiveConnection;
    35.     }
    36.  
    37.     public int getPoolMaxIdIeConnection() {
    38.         return poolMaxIdIeConnection;
    39.     }
    40.  
    41.     public void setPoolMaxIdIeConnection(int poolMaxIdIeConnection) {
    42.         this.poolMaxIdIeConnection = poolMaxIdIeConnection;
    43.     }
    44.  
    45.     public int getPoolTimeToWait() {
    46.         return poolTimeToWait;
    47.     }
    48.  
    49.     public void setPoolTimeToWait(int poolTimeToWait) {
    50.         this.poolTimeToWait = poolTimeToWait;
    51.     }
    52.  
    53.     public String getUrl() {
    54.         return url;
    55.     }
    56.  
    57.     public void setUrl(String url) {
    58.         this.url = url;
    59.     }
    60.  
    61.     public String getDriver() {
    62.         return driver;
    63.     }
    64.  
    65.     public void setDriver(String driver) {
    66.         this.driver = driver;
    67.     }
    68.  
    69.     public String getUsername() {
    70.         return username;
    71.     }
    72.  
    73.     public void setUsername(String username) {
    74.         this.username = username;
    75.     }
    76.  
    77.     public String getPassword() {
    78.         return password;
    79.     }
    80.  
    81.     public void setPassword(String password) {
    82.         this.password = password;
    83.     }
    84.  
    85.     @Override
    86.     public Connection getConnection() throws SQLException {
    87.         return getConnection(username,password);
    88.     }
    89.  
    90.     @Override
    91.     public Connection getConnection(String username, String password) throws SQLException {
    92.         return doGetConnection(username,password);
    93.     }
    94.  
    95.     private Connection doGetConnection(String username, String password) throws SQLException {
    96.         Connection connection = DriverManager.getConnection(url, username, password);
    97.         return connection;
    98.     }
    99. }

    上面三个方法,都是获得连接

    下面用动态代理方式实现对数据库连接的代理

    1. package com.pool;
    2.  
    3. import java.lang.reflect.InvocationHandler;
    4. import java.lang.reflect.Method;
    5. import java.lang.reflect.Proxy;
    6. import java.sql.Connection;
    7.  
    8. /**
    9.  * 采用动态代理实现对数据库连接的代理
    10.  * @author hrui
    11.  * @date 2023/9/10 3:45
    12.  */
    13. public  class ConnectionProxy implements InvocationHandler {
    14.  
    15.     //真正连接
    16.     private Connection realConnection;
    17.  
    18.     //代理连接
    19.     private Connection proxyConnection;
    20.  
    21.     //数据源对象
    22.     private MyDataSource myDataSource;
    23.  
    24.  
    25.     public ConnectionProxy(Connection realConnection, MyDataSource myDataSource) {
    26.         //初始化真实连接和数据源
    27.         this.realConnection = realConnection;
    28.         this.myDataSource = myDataSource;
    29.  
    30.         //初始化代理连接...需要一个代理对象  JDK动态代理
    31.         this.proxyConnection= (Connection)Proxy.newProxyInstance(Connection.class.getClassLoader(),
    32.                                                     new Class[]{Connection.class},
    33.                                                     this);
    34.  
    35.     }
    36.  
    37.     public Connection getRealConnection() {
    38.         return realConnection;
    39.     }
    40.  
    41.     public void setRealConnection(Connection realConnection) {
    42.         this.realConnection = realConnection;
    43.     }
    44.  
    45.     public Connection getProxyConnection() {
    46.         return proxyConnection;
    47.     }
    48.  
    49.     public void setProxyConnection(Connection proxyConnection) {
    50.         this.proxyConnection = proxyConnection;
    51.     }
    52.  
    53.     public MyDataSource getMyDataSource() {
    54.         return myDataSource;
    55.     }
    56.  
    57.     public void setMyDataSource(MyDataSource myDataSource) {
    58.         this.myDataSource = myDataSource;
    59.     }
    60.  
    61.     /**
    62.      * 当调用Connection对象里面的任何方法时,该方法会进行拦截
    63.      * 主要目的为了拦截Connection的close方法,当关闭时进行拦截,将Connection对象放入连接池中
    64.      * 其他方法无需拦截
    65.      * @param proxy
    66.      * @param method
    67.      * @param args
    68.      * @return
    69.      * @throws Throwable
    70.      */
    71.     @Override
    72.     public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
    73.         //获取当前调用了Connection对象的什么方法
    74.         String methodName=method.getName();
    75.         if(methodName.equals("close")){
    76.             //TODO 把连接放入连接池
    77.  
    78.             return null;
    79.         }else{
    80.             //其他方法
    81.             return method.invoke(realConnection, args);
    82.         }
    83.  
    84.     }
    85. }
    86.  
    87. }
    88.

    下面写个类继承MyAbstractDataSource  在里面放入连接池

    1. package com.pool;
    2.  
    3. import java.sql.Connection;
    4. import java.sql.SQLException;
    5. import java.util.ArrayList;
    6. import java.util.List;
    7.  
    8. /**
    9.  * 数据源连接池
    10.  * @author hrui
    11.  * @date 2023/9/10 4:15
    12.  */
    13. public class MyDataSource extends MyAbstractDataSource{
    14.  
    15.     //空闲连接
    16.     private final List<ConnectionProxy> idleConnections=new ArrayList<>();
    17.  
    18.     //激活的连接池
    19.     private final List<ConnectionProxy> activeConnections=new ArrayList<>();
    20.     
    21.     //下面三个可以抽取放到父类抽象类中,由用户配置 
    22.     //最大的连接数量
    23.     //private int poolMaxActiveConnection=10;
    24.  
    25.     //最大空闲连接数
    26.     //private int poolMaxIdIeConnection=5;
    27.  
    28.     //当连接都在使用时候,最大检出时间(等待时间),毫秒
    29.     //private int poolTimeToWait=20000;
    30.  
    31.     //用于同步监视器对象
    32.     private final Object monitor=new Object();
    33.  
    34.     //用于同步监视器对象(关闭)
    35.     //private final Object watch=new Object();
    36.  
    37.     /**
    38.      * 重写:用于获取代理连接
    39.      * @return
    40.      * @throws SQLException
    41.      */
    42.     @Override
    43.     public Connection getConnection() throws SQLException {
    44.         ConnectionProxy connectionProxy=getConnectionProxy(super.getUsername(),super.getPassword());
    45.         //返回代理连接
    46.         return super.getConnection();
    47.     }
    48.  
    49.     /**
    50.      * 获取代理连接
    51.      * @param username
    52.      * @param password
    53.      * @return
    54.      */
    55.     private ConnectionProxy getConnectionProxy(String username,String password) throws SQLException {
    56.         //TODO
    57.         //是否需要等待
    58.         boolean wait=false;
    59.         ConnectionProxy connectionProxy=null;
    60.         //刚开始没有连接
    61.         while(connectionProxy==null){
    62.             synchronized (monitor){
    63.                 //看连接池有没有空闲连接,如果不为空,直接获取连接
    64.                 if(!idleConnections.isEmpty()){
    65.                     connectionProxy=idleConnections.remove(0);
    66.                  //如果是空的
    67.                 }else{
    68.                     //没有空闲连接,那么需要获取新的连接(创建连接)
    69.                     //这里先判断最大连接数是不是小于配置数量  10
    70.                     if(activeConnections.size()<supper.getPoolMaxActiveConnection()){
    71.                         //创建新连接  需要传入真实连接
    72.                         connectionProxy=new ConnectionProxy(super.getConnection(),this);
    73.                     }
    74.                     //否则需要等待20秒   上面定义了poolTimeToWait=20000
    75.  
    76.                 }
    77.             }
    78.  
    79.             if(!wait){
    80.                 wait=true;
    81.             }
    82.  
    83.             if(connectionProxy==null){
    84.                 try {
    85.                     monitor.wait(supper.getPoolTimeToWait());
    86.                 } catch (InterruptedException e) {
    87.                     e.printStackTrace();
    88.                     //万一等待被线程打断,退出一下
    89.                     break;
    90.                 }
    91.             }
    92.  
    93.         }
    94.         if(connectionProxy!=null){
    95.             //连接对象不是空,说明已经拿到连接了,放入容器
    96.             activeConnections.add(connectionProxy);
    97.         }
    98.  
    99.         return connectionProxy;
    100.     }
    101.  
    102.     //用于关连接
    103.     //不是把连接关系,而是还给连接池
    104.     public void closeConnection(ConnectionProxy connectionProxy){
    105.         synchronized (monitor){
    106.             //最大连接(激活连接)里删除
    107.             activeConnections.remove(connectionProxy);
    108.  
    109.             //如果空闲连接<定义的数量则放入空闲连接
    110.             if(idleConnections.size()<supper.getPoolMaxIdIeConnection()){
    111.                 idleConnections.add(connectionProxy);
    112.             }
    113.             //通知一下,唤醒上面哪个等待获取连接的线程
    114.             monitor.notify();
    115.         }
    116.     }
    117. }

    那么代理对象中把连接还给连接池的方法也有了

    就是当所有连接用完了,等待20秒的逻辑没写

    下面测试自己写的连接池

    新建模块  引入依赖

    不想玩了

  • 相关阅读:
    MYSQL数据库-基本操作
    C++ 内存泄漏检测与实现
    easyui jquery 可能用到方法mark
    代码随想录 单调栈part2
    Web3与传统互联网：挑战、融合与共生
    k8s学习--kube-proxy的三种工作模式详细解释
    软件测试下的AI之路（2）
    Enzo CYTO-ID自噬检测试剂盒特点&作用机制
    Pandas:sort_index、sort_values方法的使用
    Java实现word转PDF
  • 原文地址：https://blog.csdn.net/tiantiantbtb/article/details/132786829