手写数据库连接池

  1.  相信很多人看这篇文章已经知道连接池是用来干什么的?没错,数据库连接池就是为数据库连接建立一个“缓冲池”,预先在“缓冲池”中放入一定数量的连接欸,当需要建立数据库连接时,从“缓冲池”中取出一个,使用完毕后再放进去。这样的好处是,可以避免频繁的进行数据库连接占用很多的系统资源。

  

  2.  常见的数据库连接池有:dbcp,c3p0,阿里的Druid。好了,闲话不多说,本篇文章旨在加深大家对连接池的理解。这里我选用的数据库是mysql。

  

  3.  先讲讲连接池的流程:

  1. 首先要有一份配置文件吧!我们在日常的项目中使用数据源时,需要配置数据库驱动,数据库用户名,数据库密码,连接。这四个角色万万不可以少。

相信很多人看这篇文章已经知道连接池是用来干什么的?没错,数据库连接池就是为数据库连接建立一个“缓冲池”,预先在“缓冲池”中放入一定数量的连接欸,当需要建立数据库连接时,从“缓冲池”中取出一个,使用完毕后再放进去。这样的好处是,可以避免频繁的进行数据库连接占用很多的系统资源。
常见的数据库连接池有:dbcp,c3p0,阿里的Druid。好了,闲话不多说,本篇文章旨在加深大家对连接池的理解。这里我选用的数据库是mysql。
先讲讲连接池的流程:
首先要有一份配置文件吧!我们在日常的项目中使用数据源时,需要配置数据库驱动,数据库用户名,数据库密码,连接。这四个角色万万不可以少。

#文件名:db.properties
jdbc.driver=com.mysql.jdbc.Driver
jdbc.url=jdbc:mysql://localhost:3306/ssm
jdbc.username=root
jdbc.password=lfdy
jdbc.initSize=3
jdbc.maxSize=10
#是否启动检查
jdbc.health=true
#检查延迟时间
jdbc.delay=3000
#间隔时间
jdbc.period=3000
jdbc.timeout=100000

2. 我们要根据上述的配置文件db.properties编写一个类,并加载其属性

public class GPConfig {
    private String driver;
    private String url;
    private String username;
    private String password;
    private String initSize;
    private String maxSize;
    private String health;
    private String delay;
    private String period;
    private String timeout;

  //省略set和get方法//编写构造器,在构造器中对属性进行初始化
    public GPConfig() {
        Properties prop = new Properties();
        //maven项目中读取文件好像只有这中方式
        InputStream stream = this.getClass().getResourceAsStream("/resource/db.properties");
        try {
            prop.load(stream);
            //在构造器中调用setter方法,这里属性比较多,我们肯定不是一步一步的调用,建议使用反射机制
            for(Object obj : prop.keySet()){
                //获取形参,怎么获取呢?这不就是配置文件的key去掉,去掉什么呢?去掉"jdbc."
                String fieldName = obj.toString().replace("jdbc.", "");
                Field field = this.getClass().getDeclaredField(fieldName);
                Method method = this.getClass().getMethod(toUpper(fieldName), field.getType());
                method.invoke(this, prop.get(obj));
            }
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
   
    //读取配置文件中的key,并把他转成正确的set方法
    public String toUpper(String fieldName){
        char[] chars = fieldName.toCharArray();
        chars[0] -=32;    //如何把一个字符串的首字母变成大写
        return "set"+ new String(chars);
    }
}

3.好了,我们配置文件写好了,加载配置文件的类也写好了,接下来写什么呢?回忆一下,我们在没有连接池前,是不是用Class.forName(),getConnection等等来连接数据库的?所以,我们接下来编写一个类,这个类中有创建连接,获取连接的方法。

public class GPPoolDataSource {
   
    //加载配置类
    GPConfig config = new GPConfig();
   
    //写一个参数,用来标记当前有多少个活跃的连接
    private AtomicInteger currentActive = new AtomicInteger(0);
   
    //创建一个集合,干嘛的呢?用来存放连接,毕竟我们刚刚初始化的时候就需要创建initSize个连接
    //并且,当我们释放连接的时候,我们就把连接放到这里面
    Vector<Connection> freePools = new Vector<>();
   
    //正在使用的连接池
    Vector<GPPoolEntry> usePools = new Vector<>();
   
    //构造器中初始化
    public GPPoolDataSource(){
        init();
    }

//初始化方法
    public void init(){
        try {
            //我们的jdbc是不是每次都要加载呢?肯定不是的,只要加载一次就够了
            Class.forName(config.getDriver());
            for(int i = 0; i < Integer.valueOf(config.getInitSize());i++){
                Connection conn = createConn();
                freePools.add(conn);
            }
        } catch (ClassNotFoundException e) {
            e.printStackTrace();
        }
        check();
    }
   
    //创建连接
    public synchronized Connection createConn(){
        Connection conn = null;
        try {
            conn = DriverManager.getConnection(config.getUrl(), config.getUsername(), config.getPassword());
            currentActive.incrementAndGet();
            System.out.println("创建一个连接, 当前的活跃的连接数目为:"+ currentActive.get()+" 连接:"+conn);
           
        } catch (SQLException e) {
            e.printStackTrace();
        }
        return conn;
    }
    /**
     * 创建连接有了,是不是也应该获取连接呢?
     * @return
     */
    public synchronized GPPoolEntry getConn(){
        Connection conn = null;
        if(!freePools.isEmpty()){
            conn = freePools.get(0);
            freePools.remove(0);
        }else{
            if(currentActive.get() < Integer.valueOf(config.getMaxSize())){
                conn = createConn();
            }else{
                try {
                    System.out.println("连接池已经满了,需要等待...");
                    wait(1000);
                    return getConn();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        }
        GPPoolEntry poolEntry = new GPPoolEntry(conn, System.currentTimeMillis());
        //获取连接干嘛的?不就是使用的吗?所以,每获取一个,就放入正在使用池中
        usePools.add(poolEntry);
        return poolEntry;
    }
   
   
    /**
     * 创建连接,获取连接都已经有了,接下来就是该释放连接了
     */
    public synchronized void release(Connection conn){
        try {
            if(!conn.isClosed() && conn != null){
                freePools.add(conn);
            }
            System.out.println("回收了一个连接,当前空闲连接数为:"+freePools.size());
        } catch (SQLException e) {
            e.printStackTrace();
        }
    }
   
    //定时检查占用时间超长的连接,并关闭
    private void check(){
        if(Boolean.valueOf(config.getHealth())){
            Worker worker = new Worker();
            new java.util.Timer().schedule(worker, Long.valueOf(config.getDelay()), Long.valueOf(config.getPeriod()));
        }
    }
   
    class Worker extends TimerTask{
        @Override
        public void run() {
            System.out.println("例行检查...");
            for(int i = 0; i < usePools.size();i++){
                GPPoolEntry entry = usePools.get(i);
                long startTime = entry.getUseStartTime();
                long currentTime = System.currentTimeMillis();
                if((currentTime-startTime)>Long.valueOf(config.getTimeout())){
                    Connection conn = entry.getConn();
                    try {
                        if(conn != null && !conn.isClosed()){
                            conn.close();
                            usePools.remove(i);
                            currentActive.decrementAndGet();
                            System.out.println("发现有超时连接,强行关闭,当前活动的连接数:"+currentActive.get());
                        }
                    } catch (SQLException e) {
                        e.printStackTrace();
                    }
                }
            }
        }
    }
}

4.在上述的check()方法中,要检查是否超时,所以我们需要用一个包装类

public class GPPoolEntry {
   
    private Connection conn;
    private long useStartTime;
    public Connection getConn() {
        return conn;
    }
    public void setConn(Connection conn) {
        this.conn = conn;
    }
    public long getUseStartTime() {
        return useStartTime;
    }
    public void setUseStartTime(long useStartTime) {
        this.useStartTime = useStartTime;
    }
   
    public GPPoolEntry(Connection conn, long useStartTime) {
        super();
        this.conn = conn;
        this.useStartTime = useStartTime;
    }
}

5.好了,万事具备,我们写一个测试类测试一下吧

public class GPDataSourceTest {

public static void main(String[] args) {

GPPoolDataSource dataSource = new GPPoolDataSource();

Runnable runnable = () -> {
            Connection conn = dataSource.getConn().getConn();
            System.out.println(conn);
        };

ExecutorService executorService = Executors.newFixedThreadPool(5);
        for (int i = 0; i < 60; i++) {
            executorService.submit(runnable);
        }
        executorService.shutdown();
    }

}

4.好了,我给下我的结果:

 5.总结下,这个手写连接池部分,其实我也是学习的别人的,所以有很多东西不熟悉,也有许多漏洞,现在我先说下我需要完善的地方:

    • 反射机制
    • 读取properties文件
    • 线程池
    • 线程
    • 集合Vector

时间: 06-15

手写数据库连接池的相关文章

关于利用动态代理手写数据库连接池的异常 java.lang.ClassCastException: com.sun.proxy.$Proxy0 cannot be cast to java.sql.Connection

代码如下: final Connection conn=pool.remove(0); //利用动态代理改造close方法 Connection proxy= (Connection) Proxy.newProxyInstance(conn.getClass().getClassLoader(), conn.getClass().getInterfaces(), new InvocationHandler() { @Override public Object invoke(Object pro

手写连接池

4.连接池_手写连接池_动态代理 二.数据库连接池 很多很多的连接 放进一个池子里用集合来存取这些连接 手写连接池: 改造conn的close方法 1.继承 2.装饰 3.动态代理 package com.itheima.pool; import java.io.PrintWriter; import java.lang.reflect.InvocationHandler; import java.lang.reflect.Method; import java.lang.reflect.Pro

手写线程池 (一)

前言准备 1.jdk线程池的使用:https://www.cnblogs.com/jtfr/p/10187419.html 2.线程池核心:线程的复用. 运行的线程是线程池的核心,被添加的任务需要实现过Runnable接口,主要是保证有run方法.运行时候 对象.run() . 一.手写线程池注意要点 1.线程池需要添加任务,任务是放置在一个队列(FIFO)当中,具体只要保证FIFO,或优先级保证(Map集合)先执行.2.线程池运行,需要一个容器存放创建的线程,可数组或集合,可以自己设计思考.3

图解线程池工作机制,手写线程池?

ThreadPoolExecutor构造函数的各个参数说明 public ThreadPoolExecutor(int corePoolSize,//线程池中核心线程数 int maximumPoolSize,//允许的最大线程数 long keepAliveTime,//线程空闲下来后,存活的时间,这个参数只在> corePoolSize才有用 TimeUnit unit,//存活时间的单位值 BlockingQueue<Runnable> workQueue,//保存任务的阻塞队列

手写线程池

Executors.newSingleThreadExecutor(): 只有一个线程的线程池,因此所有提交的任务是顺序执行 Executors.newCachedThreadPool(): 线程池里有很多线程需要同时执行,老的可用线程将被新的任务触发重新执行, 如果线程超过60秒内没执行,那么将被终止并从池中删除 Executors.newFixedThreadPool(): 拥有固定线程数的线程池,如果没有任务执行,那么线程会一直等待 Executors.newScheduledThread

[javaEE] 数据库连接池和动态代理

实现javax.sql.DataSource接口 实现Connection getConnection()方法 定义一个静态的成员属性LinkedList类型作为连接池,在静态代码块中初始化5条数据库连接,添加到连接池中,在getConnection方法中,当获取连接的时候在连接池中remove掉一条连接就可以了 import java.lang.reflect.InvocationHandler; import java.lang.reflect.Method; import java.lan

手写Spring框架,加深对Spring工作机制的理解!

在我们的日常工作中,经常会用到Spring.Spring Boot.Spring Cloud.Struts.Mybatis.Hibernate等开源框架,有了这些框架的诞生,平时的开发工作量也是变得越来越轻松,我们用 Spring Boot 分分钟可以新建一个Web项目. 记得自己刚开始工作的时候还是在用Servlet写Web项目,自己写数据库连接池,用原生JDBC操作数据库,好了不发散了.回到这篇文章的主题,今天通过手写Spring框架,帮大家深入了解一下Spring的工作机制,文中涉及的代码

[数据库连接池] Java数据库连接池--DBCP浅析.

前言对于数据库连接池, 想必大家都已经不再陌生, 这里仅仅设计Java中的两个常用数据库连接池: DBCP和C3P0(后续会更新). 一. 为何要使用数据库连接池假设网站一天有很大的访问量,数据库服务器就需要为每次连接创建一次数据库连接,极大的浪费数据库的资源,并且极易造成数据库服务器内存溢出.拓机.数据库连接是一种关键的有限的昂贵的资源,这一点在多用户的网页应用程序中体现的尤为突出.对数据库连接的管理能显著影响到整个应用程序的伸缩性和健壮性,影响到程序的性能指标.数据库连接池正式针对这个问题提

理解数据库连接池底层原理之手写实现

第一,数据库连接池中存放的就是数据库操作管道,不仅仅是存放,而且应该是管理这些管道: 第二,应该提供外部配置文件去初始化数据库连接池: 第三,如果一个数据库操作管道已经被占用,那么其他请求是否应该得到这个管道,也就是说我们要考虑多线程并发下,管道的分配问题: 第四,如果做到管道的复用?放回池子中,标示可用,并不是真正的关闭管道: IMyPool是一个接口,对外提供数据库连接池的基本服务,比如得到一个数据库操作管道. MyDefaultPool是IMyPool的实现. MyPooledConnec