数据库连接池原理

心已赠人 2022-05-15 02:27 254阅读 0赞

一、JDBC介绍

1.jdbc的定义
JDBC（Java DataBase Connectivity,java数据库连接）是一种用于执行SQL语句的Java API，可以为多种关系数据库提供统一访问，它由一组用Java语言编写的类和接口组成。JDBC提供了一种基准，据此可以构建更高级的工具和接口，使数据库开发人员能够编写数据库应用程序。
2.jdbc的用途
简单地说，JDBC 可做三件事：与数据库建立连接、发送 操作数据库的语句并处理结果。
这里写图片描述
下列代码段给出了以上三步的基本示例：

  1. Connection con = DriverManager.getConnection("jdbc:odbc:wombat","login",
  2. "password");
  3. Statement stmt = con.createStatement();
  4. ResultSet rs = stmt.executeQuery("SELECT a, b, c FROM Table1");
  5. while (rs.next()) {
  6. int x = rs.getInt("a");
  7. String s = rs.getString("b");
  8. float f = rs.getFloat("c");
  9. }

这里写图片描述
3.操作jdbc的问题
jdbc每一次建立连接都非常耗时，对于一个复杂的数据库应用，频繁的建立、关闭连接，会极大的减低系统的性能，因为对于连接的使用成了系统性能的瓶颈。另外，每次由线程建立连接、关闭连接，总连接数的控制等等都是非常繁琐且容易出错，对数据库连接的管理能显著影响到整个应用程序的伸缩性和健壮性，影响到程序的性能指标。针对这些问题，需要一个统一管理的框架，防止这些复杂性的扩散。而数据库连接池就是解决这些问题最有效的方式。

二、数据库连接池基本原理

1.数据库连接池基本概念
数据库连接池负责分配、管理和释放数据库连接，它允许应用程序重复使用一个现有的数据库连接，而不是再重新建立一个；释放空闲时间超过最大空闲时间的数据库连接来避免因为没有释放数据库连接而引起的数据库连接遗漏。这项技术能明显提高对数据库操作的性能。
2.连接池的优势
数据库连接池技术带来的优势：
2.1． 资源重用
由于数据库连接得到重用，避免了频繁创建、释放连接引起的大量性能开销。在减少系统消耗的基础上，另一方面也增进了系统运行环境的平稳性（减少内存碎片以及数据库临时进程/线程的数量）。
2.2． 更快的系统响应速度
数据库连接池在初始化过程中，往往已经创建了若干数据库连接置于池中备用。此时连接的初始化工作均已完成。对于业务请求处理而言，直接利用现有可用连接，避免了数据库连接初始化和释放过程的时间开销，从而缩减了系统整体响应时间。
2.3． 新的资源分配手段
对于多应用共享同一数据库的系统而言，可在应用层通过数据库连接的配置，实现数据库连接池技术。某一应用最大可用数据库连接数的限制，避免某一应用独占所有数据库资源。
2.4． 统一的连接管理，避免数据库连接泄漏
在较为完备的数据库连接池实现中，可根据预先的连接占用超时设定，强制收回被占用连接。从而避免了常规数据库连接操作中可能出现的资源泄漏。
3.数据库连接池的工作原理
这里写图片描述
关键的配置参数功能：
这里写图片描述

三、实现一个简单的连接池

基于上面的理解，我们实现一个简单的连接池。

  1. /* 1.线程安全 2.有空闲连接的数量 3.有正在使用的连接数量 */
  2. 6
  3. public class PoolConfig{ 
  5.   /* 数据库jdbc属性 */
  7.   private String driverName;//数据库的驱动类
  9.   private String url;//数据库的连接地址
  11.   private String userName;//数据库用户名
  13.   private String password;//数据库密码
  16.   /* 连接池配置 */
  18.   private int minConn = 1;//空闲集合中最少连接数
  20.   private int maxConn = 5;//空闲集合最多的连接数
  22.   private int initConn = 5;//初始连接数
  24.   private int maxActiveConn = 10;//整个连接池（数据库）允许的最大连接数
  26.   private int waitTime = 1000;//单位毫秒，连接数不够时，线程等待的时间
  28.   private boolean isCheck = false;//数据库连接池是否启用自检机制（间隔一段时间检测连接池状态）
  30.   private long checkPeriod = 1000*30;//自检周期
  34.   //以下省略getter、setter方法...
  36. }
  37. db.properties配置文件
  39. jdbc.driverName = com.mysql.jdbc.Driver
  40. jdbc.url = jdbc:mysql://localhost:3306/test?useUnicode=true&characterEncode=true&characterEncoding=utf-8
  41. jdbc.userName=root
  42. jdbc.password=root
  43. DBUtil.java数据库工具包（数据库开发者调用）
  45. public class DBUtil{ 
  47.   /* 静态数据库配置实体对象，程序运行时加载进内存 */
  49.   private static PoolConfig config = new PoolConfig(); 
  53.   static{
  54.    //初始化加载配置文件
  56.       Properties prop = new Properties();
  58.       try{
  60.           prop.load(DBUtil.class.getClassLoader().
  62.                      getResourceAsStream
  64.                     ("com/mypath/db/db.properties"));
  66.           //获取配置文件信息传入config连接池配置对象
  68.           config.setDriverName(prop.getProperty("jdbc.driverName"));
  70.           config.setUrl(prop.getProperty("jdbc.url"));
  72.           config.setUserName(prop.getProperty("jdbc.userName"));
  74.           config.setPassword(prop.getProperty("jdbc.password"));
  76.           //反射加载这个驱动（使用的是JDBC的驱动加载方式）
  78.           Class.forName(config.getDriverName());
  80.       }catch(IOException e){
  82.           e.printStackTrace();
  84.       }
  86.   }
  90.   private static ConnectionPool connPool = new ConnectionPool(config);
  94.   public static connection gerConnection(){
  96.       return connPool.getConnection();
  98.   }
  102.   public static connection gerCurrentConnection(){
  104.       return connPool.getCurrentConnection();
  106.   }
  110.   public static void closeConnection(Connection conn){
  112.       connPool.releaseConnection(conn);
  114.   }
  116. }
  117. ConnectionPool.java数据库连接池对象（根据配置创建对应连接池）
  120. public class ConnectionPool{ 
  122.  private PoolConfig config;//连接池的配置对象
  124.  private int count;//记录连接池的连接数
  126.  private boolean isActive;//连接池是否被激活
  128.  //空闲连接集合
  130.  private Vector<Connection> freeConn = new Vector<Connection>();
  132.  //正在使用的连接集合
  134.  private Vector<Connection> userConn = new Vector<Connection>();
  136.  //同一个线程无论请求多少次都使用同一个连接（使用ThreadLocal确保）
  138.  //每一个线程都私有一个连接
  140.  private static ThreadLocal<Connection> threadLocal = new ThreadLocal<Connection>();
  142.  /* 初始化连接池配置 */
  144.  public ConnectionPool(PoolConfig config){
  146.      this.config = config;
  148.  }
  152.  /* 数据库连接池初始化 */
  154.  public void init(){
  156.      for(int i=0;i<config.getInitConn();i++){
  157.    //建立初始连接
  159.          //获取连接对象
  161.          Connection conn;
  163.          try{
  165.              conn = getNewConnection();
  167.              freeConn.add(conn);
  169.              count++;
  171.          }catche(SQLException e){
  173.              e.printStackTrace();
  175.          }
  177.          isActive = true;//连接池激活
  179.      }
  181.  }
  185.  /* 获取新数据库连接 */
  187.  private synchronized Connection getNewConnection() throws SQLException{
  189.      Connection conn = null;
  191.      conn = DriverManager.getConnection(config.getUrl(),
  193.                                        config.getUserName(),
  195.                                        config.getPassword());
  197.      return conn;
  199.  }
  203.  /* 从连接池获取连接 */
  205.  public synchronized Conenction getConnection(){
  207.      Connection conn = null;
  209.      //当前连接总数小于配置的最大连接数才去获取
  211.      if(count<config.getMaxActiveConn()){
  213.          //空闲集合中有连接数
  215.          if(freeConn.size()>0){
  217.              conn = freeConn.get(0);//从空闲集合中取出
  219.              freeConn.remove(0);//移除该连接
  221.          }else{
  223.              conn = getNewConnection();//拿到新连接
  225.              count++;
  227.          }
  229.          if(isEnable(conn)){
  231.              useConn.add(conn);//添加到已经使用的连接
  233.          }else{
  235.              count--;
  237.              conn = getConnection();//递归调用到可用的连接
  239.          }
  241.      }else{
  242.    //当达到最大连接数，只能阻塞等待
  244.          wait(config.getWaitTime());//线程睡眠了一段时间
  246.          conn = getConnection();//递归调用
  248.      }catch(Exception e){
  250.          e.printStackTrace();
  252.      }
  254.      //将获取的conn设置到本地变量ThreadLocal
  256.      threadLocal.set(conn);
  258.      return conn;
  260.  }
  264.  /* 把用完的连接放回连接池集合Vector中 */
  266.  public synchronized void releaseConnection(Connection conn){
  268.      if(isEnable(conn)){
  270.          if(freeConn.size()<config.getMaxConn()){
  271.    //空闲连接数没有达到最大
  273.              freeConn.add(conn);//放回集合
  275.          }else{
  277.              conn.close();
  279.          }
  281.      }
  283.      useConn.remove(conn);
  285.      count--;
  287.      threadLocal.remove();
  289.      notifyAll();//放回连接池后说明有连接可用，唤醒阻塞的线程获取连接
  291.  }
  295.  /* 获取当前线程的本地变量连接 */
  297.  public Connection getCurrentConnection(){
  299.      return threadLocal.get();    
  301.  }
  305.  /* 判断该连接是否可用 */
  307.  private boolean isEnable(Connection conn){
  309.      if(conn == null){
  311.          return false;
  313.      }
  315.      if(conn.isClosed()){
  317.          return false;
  319.      }
  321.      return true;
  323.  }
  325. }

四、市面上常用的连接池

在Java中开源的数据库连接池有以下几种 ：
1、C3P0：是一个开放源代码的JDBC连接池，它在lib目录中与Hibernate [2] 一起发布，包括了实现jdbc3和jdbc2扩展规范说明的Connection 和Statement 池的DataSources 对象。
2、Proxool：是一个Java SQL Driver驱动程序，提供了对选择的其它类型的驱动程序的连接池封装。可以非常简单的移植到现存的代码中，完全可配置，快速、成熟、健壮。可以透明地为现存的JDBC驱动程序增加连接池功能。
3、Jakarta DBCP：DBCP是一个依赖Jakartacommons-pool对象池机制的数据库连接池。DBCP可以直接的在应用程序中使用。
4、DDConnectionBroker：是一个简单、轻量级的数据库连接池。
5、DBPool：是一个高效、易配置的数据库连接池。它除了支持连接池应有的功能之外，还包括了一个对象池，使用户能够开发一个满足自己需求的数据库连接池。
6、XAPool：是一个XA数据库连接池。它实现了javax.sql.XADataSource并提供了连接池工具。
7、Primrose：是一个Java开发的数据库连接池。当前支持的容器包括Tomcat4&5、Resin3与JBoss3。它同样也有一个独立的版本，可以在应用程序中使用而不必运行在容器中。Primrose通过一个WEB接口来控制SQL处理的追踪、配置，以及动态池管理。在重负荷的情况下可进行连接请求队列处理。
8、SmartPool：是一个连接池组件，它模仿应用服务器对象池的特性。SmartPool能够解决一些临界问题如连接泄漏（connection leaks）、连接阻塞、打开的JDBC对象（如Statements、PreparedStatements）等。SmartPool的特性包括：
支持多个pool
自动关闭相关联的JDBC对象
在所设定time-outs之后察觉连接泄漏
追踪连接使用情况
强制启用最近最少用到的连接
把SmartPool“包装”成现存的一个pool
9、MiniConnectionPoolManager：是一个轻量级JDBC数据库连接池。它只需要Java1.5（或更高）并且没有依赖第三方包。
10、BoneCP：是一个快速、开源的数据库连接池。帮用户管理数据连接，让应用程序能更快速地访问数据库。比C3P0/DBCP连接池速度快25倍。
11、Druid：Druid不仅是一个数据库连接池，还包含一个ProxyDriver、一系列内置的JDBC组件库、一个SQL Parser。
支持所有JDBC兼容的数据库，包括Oracle、MySql、Derby、Postgresql、SQL Server、H2等。
Druid针对Oracle和MySql做了特别优化，比如：
Oracle的PS Cache内存占用优化
MySql的ping检测优化
Druid提供了MySql、Oracle、Postgresql、SQL-92的SQL的完整支持，这是一个手写的高性能SQL Parser，支持Visitor模式，使得分析SQL的抽象语法树很方便。
简单SQL语句用时10微秒以内，复杂SQL用时30微秒。
通过Druid提供的SQL Parser可以在JDBC层拦截SQL做相应处理，比如说分库分表、审计等。Druid防御SQL注入攻击的WallFilter，就是通过Druid的SQL Parser分析语义实现的

发表评论

表情：
评论列表 （有 0 条评论，254人围观）

还没有评论，来说两句吧...

相关阅读

    相关 Java中数据库连接池原理机制讲解

    连接池的基本工作原理 1、基本概念及原理 由上面的分析可以看出，问题的根源就在于对数据库连接资源的低效管理。我们知道，对于共享资源，有一个很著名的设计模式：资源池（Reso

    墨蓝墨蓝/ 0 赞/ 181 阅读