利用几种设计模式来实现自定义数据库连接池

最新推荐文章于 2021-07-15 10:40:25 发布
最新推荐文章于 2021-07-15 10:40:25 发布
阅读量843 收藏 2
点赞数
分类专栏： 数据库 文章标签： java mysql
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/walker_0312/article/details/106794336
版权

利用几种设计模式来实现自定义数据库连接池

自定义数据库连接池

核心API

DataSource 接口概述
javax.sql.DataSource 接口：数据源(数据库连接池)。Java 官方提供的数据库连接池规范(接口)
	* 如果想完成数据库连接池技术，就必须实现 DataSource 接口
	* 核心功能：获取数据库连接对象：Connection getConnection();

实现步骤

① 定义一个类，实现 DataSource 接口。
② 定义一个容器，用于保存多个 Connection 连接对象。
③ 定义静态代码块，通过 JDBC 工具类获取 10 个连接保存到容器中。
④ 重写 getConnection 方法，从容器中获取一个连接并返回。
⑤ 定义 getSize 方法，用于获取容器的大小并返回。

归还数据库连接的方式

① 继承方式
	父类中的一个方法的功能不够完美-->解决方法,创建一个子类来继承,并重写父类中的该方法,以达到目的.
② 装饰者设计模式
	作用:在不改变原有类的情况下增强原有类的功能.
	特点:装饰者以及被装饰者应该是同一个类型.
		如果被装饰者有功能实现那么自己不再重复实现直接使用被装饰者功能.
		装饰者需要做的只是其他额外功能的实现.
③ 适配器设计模式
	对象:
		* 目标接口(我们想要什么类型)
		* 已存在实现
		* 适配(实现目标接口,继承已有实现)
④ 动态代理方式
	动态代理：在不改变目标对象方法的情况下对方法进行增强
	* 组成
		被代理对象：真实的对象
		代理对象：内存中的一个对象
	* 要求
		代理对象必须和被代理对象实现相同的接口
	* 实现
		Proxy.newProxyInstance()
	特点:
		代理出来的对象和原本被代理对象没有任何关系,只不过他们都有相同接口
		如果遇到不想增强的方法那么我们可以利用反射调用被代理对象的方法(这才是产生关联的原因)

1.继承方式

1. 继承方式归还数据库连接的思想。
	* 通过打印连接对象，发现 DriverManager 获取的连接实现类是 JDBC4Connection
	* 那我们就可以自定义一个类，继承 JDBC4Connection 这个类，重写 close() 方法，完成连接对象的归还
2. 继承方式归还数据库连接的实现步骤。
	* 定义一个类，继承 JDBC4Connection 。 
	* 定义 Connection 连接对象和连接池容器对象的成员变量。
	* 通过有参构造方法完成对成员变量的赋值。
	* 重写 close 方法，将连接对象添加到池中。
3. 继承方式归还数据库连接存在的问题。
	* 通过查看 JDBC 工具类获取连接的方法发现：我们虽然自定义了一个子类，完成了归还连接的操作。但是
	DriverManager 获取的还是 JDBC4Connection 这个对象，并不是我们的子类对象，而我们又不能整体
	去修改驱动包中类的功能，所继承这种方式行不通！
继承方式自定义连接池代码
/*
    自定义的连接对象
    1.定义一个类，继承JDBC4Connection
    2.定义Connection连接对象和容器对象的成员变量
    3.通过有参构造方法为成员变量赋值
    4.重写close方法，完成归还连接
 */
public class MyConnection1 extends JDBC4Connection{//1.定义一个类，继承JDBC4Connection
    //2.定义Connection连接对象和容器对象的成员变量
    private Connection con;
    private List<Connection> pool;

    //3.通过有参构造方法为成员变量赋值
    public MyConnection1(String hostToConnectTo, int portToConnectTo, Properties info, String databaseToConnectTo, String url,Connection con,List<Connection> pool) throws SQLException {
        super(hostToConnectTo, portToConnectTo, info, databaseToConnectTo, url);
        this.con = con;
        this.pool = pool;
    }

    //4.重写close方法，完成归还连接
    @Override
    public void close() throws SQLException {
        pool.add(con);
    }
}

2.装饰者设计模式

1. 装饰设计模式归还数据库连接的思想。
	* 我们可以自定义一个类，实现 Connection 接口。这样就具备了和 JDBC4Connection 相同的行为了
	* 重写 close() 方法，完成连接的归还。其余的功能还调用 mysql 驱动包实现类原有的方法即可
2. 装饰设计模式归还数据库连接的实现步骤。
	* 定义一个类，实现 Connection 接口
	* 定义 Connection 连接对象和连接池容器对象的成员变量
	* 通过有参构造方法完成对成员变量的赋值
	* 重写 close() 方法，将连接对象添加到池中
	* 剩余方法，只需要调用 mysql 驱动包的连接对象完成即可
	* 在自定义连接池中，将获取的连接对象通过自定义连接对象进行包装
3. 装饰设计模式归还数据库连接存在的问题。
	* 实现 Connection 接口后，有大量的方法需要在自定义类中进行重写
小案例
public interface KTV {
    void sing();
}

public class BaseKTV implements KTV {
    @Override
    public void sing() {
        //实现基础的唱歌
        System.out.println("唱歌~~");
    }
}

/**
 * 对BaseKTV进行装饰-->灯光
 */
public class LightKTV implements KTV{
    private KTV ktv;

    public LightKTV(KTV ktv){
        this.ktv = ktv;
    }
    public void sing() {
        ktv.sing();
        System.out.println("灯光~~");
    }
}

public class SpecialKTV implements KTV {
    private KTV ktv;
    public SpecialKTV(KTV ktv){
        this.ktv = ktv;
    }
    @Override
    public void sing() {
        ktv.sing();
        System.out.println("嗨皮~~");
    }
}

public class Demo {
    public static void main(String[] args) {
        KTV ktv = new BaseKTV();
        LightKTV lightKTV = new LightKTV(ktv);
        SpecialKTV specialKTV = new SpecialKTV(lightKTV);
        specialKTV.sing();
    }
}
装饰者设计模式自定义连接池代码
/*
    1.定义一个类，实现Connection接口
    2.定义连接对象和连接池容器对象的成员变量
    3.通过有参构造方法为成员变量赋值
    4.重写close方法，完成归还连接
    5.剩余方法，还是调用原有的连接对象中的功能即可
 */
//1.定义一个类，实现Connection接口
public class MyConnection2 implements Connection{

    //2.定义连接对象和连接池容器对象的成员变量
    private Connection con;
    private List<Connection> pool;

    //3.通过有参构造方法为成员变量赋值
    public MyConnection2(Connection con,List<Connection> pool) {
        this.con = con;
        this.pool = pool;
    }

    //4.重写close方法，完成归还连接
    @Override
    public void close() throws SQLException {
        pool.add(con);
    }

    //5.剩余方法，还是调用原有的连接对象中的功能即可

3.适配器模式

1. 适配器设计模式归还数据库连接的思想。
	* 我们可以提供一个适配器类，实现 Connection 接口，将所有方法进行实现(除了close方法)
    * 自定义连接类只需要继承这个适配器类，重写需要改进的 close() 方法即可
2. 适配器设计模式归还数据库连接的实现步骤。
	* 定义一个适配器类，实现 Connection 接口。
	* 定义 Connection 连接对象的成员变量。
	* 通过有参构造方法完成对成员变量的赋值。
	* 重写所有方法(除了 close )，调用mysql驱动包的连接对象完成即可。
	* 定义一个连接类，继承适配器类。
	* 定义 Connection 连接对象和连接池容器对象的成员变量，并通过有参构造进行赋值。
	* 重写 close() 方法，完成归还连接。
	* 在自定义连接池中，将获取的连接对象通过自定义连接对象进行包装。
3. 适配器设计模式归还数据库连接存在的问题。
	* 自定义连接类虽然很简洁了，但适配器类还是我们自己编写的，也比较的麻烦
小案例
public interface Sports {
    void sport();
}

public class Exercises {
    public void doExercises(){
        System.out.println("跑步");
    }
}

public class Shipeiqi extends Exercises implements Sports {
    @Override
    public void sport() {
        doExercises();  //调用父类Exercises的方法
    }
}

public class Master {
    private Sports sport;
    public Master(Sports sport){
        this.sport = sport;
    }
    public void sport(){
        sport.sport();
    }
}

public class Demo {
    public static void main(String[] args) {
        Master master = new Master(new Shipeiqi());
        master.sport();
    }
}
适配器模式自定义连接池代码
/*
    1.定义一个类，继承适配器类
    2.定义连接对象和连接池容器对象的成员变量
    3.通过有参构造为变量赋值
    4.重写close方法，完成归还连接
 */
//1.定义一个类，继承适配器类
public class MyConnection3 extends MyAdapter {

    //2.定义连接对象和连接池容器对象的成员变量
    private Connection con;
    private List<Connection> pool;

    //3.通过有参构造为变量赋值
    public MyConnection3(Connection con,List<Connection> pool) {
        super(con);
        this.con = con;
        this.pool = pool;
    }

    //4.重写close方法，完成归还连接
    @Override
    public void close() {
        pool.add(con);
    }
}

/*
    1.定义一个适配器类。实现Connection接口
    2.定义连接对象的成员变量
    3.通过有参构造为变量赋值
    4.重写所有的抽象方法(除了close)
 */
public abstract class MyAdapter implements Connection {

    //2.定义连接对象的成员变量
    private Connection con;

    //3.通过有参构造为变量赋值
    public MyAdapter(Connection con) {
        this.con = con;
    }
    //4.重写所有的抽象方法(除了close)

4.动态代理

1. 动态代理方式归还数据库连接的思想。
	* 我们可以通过 Proxy 来完成对 Connection 实现类对象的代理
	* 代理过程中判断如果执行的是 close 方法，就将连接归还池中。如果是其他方法则调用连接对象原来的功能即可
2. 动态代理方式归还数据库连接的实现步骤。
	* 定义一个类，实现 DataSource 接口
	* 定义一个容器，用于保存多个Connection连接对象
	* 定义静态代码块，通过 JDBC 工具类获取 10 个连接保存到容器中
	* 重写 getConnection 方法，从容器中获取一个连接
	* 通过 Proxy 代理，如果是 close 方法，就将连接归还池中。如果是其他方法则调用原有功能
	* 定义 getSize 方法，用于获取容器的大小并返回
3. 动态代理方式归还数据库连接存在的问题。
	* 我们自己写的连接池技术不够完善，功能也不够强大
小案例
public interface StudentInterface {
    void study();
    void eat(String name);
}

public class Student implements StudentInterface {
    @Override
    public void study() {
        System.out.println("学java");
    }

    @Override
    public void eat(String name) {
        System.out.println("吃" + name);
    }
}

/*
            要求：在不改动Student类中任何的代码的前提下，通过study方法输出一句话：学成啦!
            类加载器：和被代理对象使用相同的类加载器
            接口类型Class数组：和被代理对象使用相同接口
            代理规则：完成代理增强的功能
         */
public class Demo {
    public static void main(String[] args) {
        Student student = new Student();
        StudentInterface stu = (StudentInterface) Proxy.newProxyInstance(student.getClass().getClassLoader(), student.getClass().getInterfaces(), new InvocationHandler() {
            @Override
            public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
                if (method.getName().equals("study")){
                    System.out.println("学成啦");
                    return null;
                }else {
                    method.invoke(student,args);
                    return null;
                }
            }
        });
        stu.eat("小面");
        stu.study();
    }
}

自定义连接池代码

public class MyDataSource implements DataSource {
    //1.准备一个容器。用于保存多个数据库连接对象
    private static List<Connection> pool = Collections.synchronizedList(new ArrayList<>());

    //2.定义静态代码块,获取多个连接对象保存到容器中
    static{
        for(int i = 1; i <= 10; i++) {
            Connection con = JDBCUtils.getConnection();
            pool.add(con);
        }
    }

    //4.提供一个获取连接池大小的方法
    public int getSize() {
        return pool.size();
    }

    /*
        动态代理方式
     */
    @Override
    public Connection getConnection() throws SQLException {
        if(pool.size() > 0) {
            Connection con = pool.remove(0);

            Connection proxyCon = (Connection) Proxy.newProxyInstance(con.getClass().getClassLoader(), new Class[]{Connection.class}, new InvocationHandler() {
                /*
                    执行Connection实现类连接对象所有的方法都会经过invoke
                    如果是close方法，归还连接
                    如果不是，直接执行连接对象原有的功能即可
                 */
                @Override
                public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
                    if(method.getName().equals("close")) {
                        //归还连接
                        pool.add(con);
                        return null;
                    }else {
                        return method.invoke(con,args);
                    }
                }
            });

            return proxyCon;
        }else {
            throw new RuntimeException("连接数量已用尽");
        }
    }

    //3.重写getConnection方法，用于返回一个连接对象
    /*@Override
    public Connection getConnection() throws SQLException {
        if(pool.size() > 0) {
            Connection con = pool.remove(0);
            //通过自定义的连接对象 对原有的连接对象进行包装
            //MyConnection2 myCon = new MyConnection2(con,pool);
            MyConnection3 myCon = new MyConnection3(con,pool);
            return myCon;
        }else {
            throw new RuntimeException("连接数量已用尽");
        }
    }*/

    @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;
    }
}
维轻松
关注
专栏目录
MyBatis集成Druid数据库连接池——提升数据库连接效率
AI天才研究院
07-28 2061
随着互联网信息技术的飞速发展，网站日益复杂，用户访问量激增，网站的负载压力也越来越高。为了保证网站的稳定运行和可靠服务，网站开发者需要根据网站运行状况进行优化和升级。如何更好地管理和使用数据库资源是网站开发者面临的重要课题之一。MyBatis 是一种优秀的持久层框架，它支持自定义 SQL、存储过程以及高级映射。MyBatis 和 Hibernate 等ORM 框架一样，都可以使用基于 Java 的 XML 配置或者注解的方式，将对象关系映射到数据库中。
基于java的数据库连接池（使用了程序设计模式）
04-15
基于java的数据库连接池设计与实现 。 使用了程序设计模式的思想编写。 包含工程文件（eclipse） 包含论文（pdf） 包含演示文档
数据库 -- 由数据库连接池引出的三种设计模式
weixin_30536513的博客
03-31 261
笔记摘要： 这里首先对数据库连接池的优化进行了说明，同时自己编写了一个数据库连接池，在实际开发中，为了获取标准的数据源，我们需要去实现javax.sal.DataSource接口， 在实现过程中对于链接对象的close方法进行了不同的实现，以便在关闭close的时候，将连接对象放回连接池，而不是关闭掉，针对这一问题，提供了3种不同的解决 方案，涉及了3种设计模式...
数据库连接池（设计模式）——数据库
06-26 918
文章转载自：https://blog.csdn.net/hu_belif/article/details/80812047 一、什么是数据库连接池？ 官方：数据库连接池（Connection pooling）是程序启动时建立足够的数据库连接，并将这些连接组成一个连接池，由程序动态地对池中的连接进行申请，使用，释放。个人理解：创建数据库连接是一个很耗时的操作，也容易对数据库造成安全...
数据库连接池、DAO设计模式和MVC设计模式
璃尔 ° 的博客
07-15 761
JDBC一、数据库连接池1.1 基础1.2 数据库连接池_C3P01.3 数据库连接池_Druid二、更新与查询工具类的实现 一、数据库连接池 1.1 基础 概念 数据库连接池是一个容器(集合)，存放数据库连接的容器。 当系统初始化好后，容器被创建，容器中会申请一些连接对象，当用户来访问数据库时，从容器中获取连接对象，用户访问完之后，会将连接对象归还给容器。 好处 节约资源 用户访问高效 实现 标准接口：DataSource(javax.sql包下) javax.sql.D
C3P0和Druid数据库连接池的简单使用；几种设计模式简介；简略介绍自定义数据库连接池注意点
weixin_46837969的博客
06-24 619
数据库连接池 负责分配、管理和释放数据库连接； 它允许应用程序重复使用一个连接，而不是新建连接，提高了程序的效率； 由于新建数据库连接也是要耗费性能和时间的，当访问量十分巨大的时候，对程序性能的影响就极为显著，为了解决这个问题出现了数据库连接池的技术； C3P0连接池 使用步骤 1、导入jar包； 2、导入配置文件到src目录下；(配置文件会自动导入，但是名字必须是c3p0-config.xml或者c3p0-config-properties) 3、创建C3P0连接池对象； 4、获取连接； 5、使用连接；
DAO_TEST.rar_delphi dao_数据库连接池
09-24
标题中的"DAO_TEST.rar_delphi dao_数据库连接池"表明这是一个关于使用Delphi编程...通过深入研究和理解这个项目，开发者可以提升在Delphi环境下利用DAO进行数据库操作的能力，以及掌握数据库连接池的设计和实现技巧。
数据库连接池扩展：实现自定义连接池的策略和最佳实践指南
[数据库连接池扩展：实现自定义连接池的策略和最佳实践指南](https://innolitics.com/img/database-pool.png) # 1. 数据库连接池概念及重要性 在现代应用系统中，数据库连接池已经成为了提升数据库操作效率的重要...
JAVA_java数据库连接池[借鉴].pdf
10-11
Java数据库连接池（Java Database Connectivity Pool，简称JDBC连接池）是软件开发中用来管理和优化数据库连接的一种技术。它的核心思想是复用已存在的数据库连接，以减少创建和销毁连接时的开销，提高应用程序的...
连接池和装饰设计模式
qq_22078383的博客
08-06 740
连接池 数据库连接池负责分配、管理和释放数据库连接，它允许应用程序重复使用一个现有的数据库连接。释放空闲时间超过最大空闲时间的数据库连接来避免因为没有释放数据库连接而引起的数据库连接遗漏。这项技术能明显提高对数据库操作的性能。 传统的连接的缺点：多个用户并发访问servlet，从dao层获取链接，数据库创建连接要耗费大量资源。 使用连接池的优点:用户可以往连接池获取连接，用完之后把连接放回
由数据库连接所联想到的5种设计模式
03-18
NULL 博文链接：https://sectioncc.iteye.com/blog/678894
设计模式:单例模式的数据库连接
qq_37880655的博客
12-29 1265
1:protected//定义私有函数,只可以被同一包中的类所访问 2:public//定义公共函数3:self::$ins//调用当前类的静态方法,自 PHP 5.3.0 后可用$this例:<?php //单例模式的数据库连接 class dbClassManage { protected static $ins=null; public static function get
自定义连接池的实现；自定义连接池的问题，自定义连接池的优化，
boss_way的博客
10-31 464
4 自定义连接池的实现： 编写一个类实现DataSource接口 重写getConnection方法， 初始化提供多个连接，存在内存中（定义一个集合，用于存储连接对象） 获取连接 connection conn  =  集合对象.remove() ;获得移出的连接对象 归还连接 connlist.add(conn) ；将移出的连接对象 重新添加到连接集合中   编写归还的连接方法
简易连接池原理以及装饰者设计模式
T_Antry
09-02 8850
简易连接池原理以及装饰者设计模式首先当然得简要说说为什么要有连接池在不用连接池之前下面先看一下我在使用连接池之前写的数据库连接工具类至于怎么用我还是简单带过一下那么接下来是不是就可以说说如何把它变成连接池了？是的，可以！（跟傻逼一样自言自语） 首先当然得简要说说为什么要有连接池 有文章说第一位设计者是去游泳的时候，进去穿共用的拖鞋，出来的时候还回去。因此称之为池，顾名思义，连接池就是存放多个连接（拖鞋）的池了。当服务需要的时候到这里取一个连接，用完还回来。 哦对，还等讲一下为什么要还，每一次都买一双，用完就
由JDBC数据库连接所联想到的五种设计模式
Make progress step by step everyday.....
10-21 1118
最近在看设计模式方面的资料.突发灵感，从数据库的连接中联想到了5种设计模式.然后编写了下,都能实现,可能有些实现方式在实际生产环境中并没有意义.就当是对设计模式的学习吧. 首先上演的就是策略模式.我们在连接数据库时,并非一种数据库,比如,有时是MySql,有时是Oracle,有时又换到SQL Server,都要涉及数据库的切换.此时.我们就可以将数据库连接的算法封装起来,使它们可以相互替换.
自定义实现数据库连接池
HYN205的博客
10-29 274
数据库连接池： &gt;数据库的连接对象创建工作，比较消耗性能 &gt;一开始先在内存中开辟一块空间（集合） ， 先往池子里面放置 多个连接对象。  后面需要连接的话，直接从池子里面去。不要去自己创建连接了。  使用完毕， 要记得归还连接。确保连接对象能循环利用。即创建一个池子（容器） ， 专门用来管理连接对象 连接池作用： &gt;更快响应速度 连接池里的连接在一开始就已经创建好了，后...
数据库连接池的代理设计模式
小琼
09-20 299
    /*动态代理, 技术入口: java.lang.reflect包中，        Object proxiedObj = Proxy.newProxyInstance(...)      */ import java.io.IOException; import java.lang.reflect.InvocationHandler; import java.lang.reflect....
Java自制数据库连接池实现详解
在本教程中，我们将实现一个简单的数据库连接池，包括以下几个关键类和接口： 1. `.ConnectionParam`: 这个类用于存储数据库连接参数和连接池配置，通过Builder模式构建，方便设置和管理这些参数。 ```java public...
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值