数据库连接池DBCP框架的研究以及源代码分析一：第一个DBCP例子

最新推荐文章于 2022-08-29 17:56:08 发布
最新推荐文章于 2022-08-29 17:56:08 发布
阅读量2.3k 收藏 3
点赞数
分类专栏： JAVA框架研究 文章标签： DBCP 连接池 DBCP源代码分析 框架研究 数据库连接池
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/springcsc1982/article/details/8842396
版权

   数据库连接池是在commons-pool的基础上扩展来的，实际上很简单，就是把连接放在池中，以达到连接共享以及避免建立新连接以及关闭连接占用资源，当然，DBCP设计得很精妙，连Statement都可以进行放入池中缓存，研究这框架的代码，确实对我们学习设计很有好处，先来看看连接池怎么用，请看下面代码：


/**
* @param args
* @throws IOException 
*/
public static void main(String[] args)   {
// TODO Auto-generated method stub
Properties prop = new Properties();

 try {
 prop.load(TEST.class.getClassLoader().getResourceAsStream("dbcpconfig.properties"));//加载配置
DataSource dataSource = org.apache.commons.dbcp.BasicDataSourceFactory.createDataSource(prop);//将配置传递给Datasource工厂

Connection conn = dataSource.getConnection();//获取连接
Statement st = conn.createStatement();
String sql = "select * from UserInfo";
ResultSet resultSet = st.executeQuery(sql);
while(resultSet.next()){
System.out.println(resultSet.getString("name"));
}

resultSet .close();

st.close();
conn.close();//注意，这里的连接，并不会真的关闭

} catch (Exception e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}

再来看看配置文件：dbcpconfig.properties


//JDBC相关配置
driverClassName=com.microsoft.jdbc.sqlserver.SQLServerDriver
url=jdbc:sqlserver://localhost:1433;DatabaseName=JDBCTEST
username=sa
password=password
initialSize=10//初始化连接数量大小
maxActive=50//最大连接数
maxIdle=20//最大空闲连接
minIdle=5//最小空闲连接
maxWait=60000//最大等待时间
connectionProperties=useUnicode=true;characterEncoding=utf-8//连接URL的属性
defaultAutoCommit=true//是否自动事务，默认不启动
defaultReadOnly=//是否只读
defaultTransactionIsolation=READ_UNCOMMITTED//数据库隔离界别


就这样，使用起来很简单，我们来看看写的代码：


DataSource dataSource = org.apache.commons.dbcp.BasicDataSourceFactory.createDataSource(prop);


DataSource  是java.sql包里面的一个接口，里面只有一个方法，就是getConnection（），但它继承自 CommonDataSource与Wrap，看类图：






因此，可以猜测到BasicDataSourceFactory创建了一个DataSource类型的对象出来，并利用它来创建Connection接口。先别急于进入代码内部，先看看BasicDataSourceFactory类的实现，先找点蛛丝马迹，对后面整体的把握很有好处，BasicDataSourceFactory的代码如下：

public class BasicDataSourceFactory implements ObjectFactory {

//这些实际是配置文件的内容
    private final static String PROP_DEFAULTAUTOCOMMIT = "defaultAutoCommit";//默认是否自动提交
    private final static String PROP_DEFAULTREADONLY = "defaultReadOnly";//是否只读
    private final static String PROP_DEFAULTTRANSACTIONISOLATION = "defaultTransactionIsolation";//数据库隔离级别
    private final static String PROP_DEFAULTCATALOG = "defaultCatalog";//数据库名称
    private final static String PROP_DRIVERCLASSNAME = "driverClassName";//驱动程序名称
    private final static String PROP_MAXACTIVE = "maxActive";//最大连接
    private final static String PROP_MAXIDLE = "maxIdle";//最大空闲数
    private final static String PROP_MINIDLE = "minIdle";//最小空闲数
    private final static String PROP_INITIALSIZE = "initialSize";//初始化大小
    private final static String PROP_MAXWAIT = "maxWait";//最大等待时间
    private final static String PROP_TESTONBORROW = "testOnBorrow";//借出对象时是否测试
    private final static String PROP_TESTONRETURN = "testOnReturn";//归还对象时是否测试
    private final static String PROP_TIMEBETWEENEVICTIONRUNSMILLIS = "timeBetweenEvictionRunsMillis";//验证对象的时间间隔
    private final static String PROP_NUMTESTSPEREVICTIONRUN = "numTestsPerEvictionRun";//每次检测对象个数
    private final static String PROP_MINEVICTABLEIDLETIMEMILLIS = "minEvictableIdleTimeMillis";//空闲时间超过多长就自动断开
    private final static String PROP_TESTWHILEIDLE = "testWhileIdle";//空闲时是否测试对象
    private final static String PROP_PASSWORD = "password";
    private final static String PROP_URL = "url";
    private final static String PROP_USERNAME = "username";
    private final static String PROP_VALIDATIONQUERY = "validationQuery";//验证连接的查询语句
    private final static String PROP_VALIDATIONQUERY_TIMEOUT = "validationQueryTimeout";//验证连接查询语句超时时间
     
    private final static String PROP_INITCONNECTIONSQLS = "initConnectionSqls";//初始化脚本，连接创建成功时执行
    private final static String PROP_ACCESSTOUNDERLYINGCONNECTIONALLOWED = "accessToUnderlyingConnectionAllowed";
    private final static String PROP_REMOVEABANDONED = "removeAbandoned";//是否关闭那些长时间占用但没有进行实际SQL操作的连接
    private final static String PROP_REMOVEABANDONEDTIMEOUT = "removeAbandonedTimeout";//长时间没有实际操作SQL的时间
    private final static String PROP_LOGABANDONED = "logAbandoned";//是否对长时间占用，但没有实际操作SQL的连接，打印Stacktrace
    private final static String PROP_POOLPREPAREDSTATEMENTS = "poolPreparedStatements";
    private final static String PROP_MAXOPENPREPAREDSTATEMENTS = "maxOpenPreparedStatements";
    private final static String PROP_CONNECTIONPROPERTIES = "connectionProperties";


    private final static String[] ALL_PROPERTIES = {
        PROP_DEFAULTAUTOCOMMIT,
        PROP_DEFAULTREADONLY,
        PROP_DEFAULTTRANSACTIONISOLATION,
        PROP_DEFAULTCATALOG,
        PROP_DRIVERCLASSNAME,
        PROP_MAXACTIVE,
        PROP_MAXIDLE,
        PROP_MINIDLE,
        PROP_INITIALSIZE,
        PROP_MAXWAIT,
        PROP_TESTONBORROW,
        PROP_TESTONRETURN,
        PROP_TIMEBETWEENEVICTIONRUNSMILLIS,
        PROP_NUMTESTSPEREVICTIONRUN,
        PROP_MINEVICTABLEIDLETIMEMILLIS,
        PROP_TESTWHILEIDLE,
        PROP_PASSWORD,
        PROP_URL,
        PROP_USERNAME,
        PROP_VALIDATIONQUERY,
        PROP_VALIDATIONQUERY_TIMEOUT,
        PROP_INITCONNECTIONSQLS,
        PROP_ACCESSTOUNDERLYINGCONNECTIONALLOWED,
        PROP_REMOVEABANDONED,
        PROP_REMOVEABANDONEDTIMEOUT,
        PROP_LOGABANDONED,
        PROP_POOLPREPAREDSTATEMENTS,
        PROP_MAXOPENPREPAREDSTATEMENTS,
        PROP_CONNECTIONPROPERTIES
    };


   
    public Object getObjectInstance(Object obj, Name name, Context nameCtx,
                                    Hashtable environment)
        throws Exception {


        // We only know how to deal with <code>javax.naming.Reference</code>s
        // that specify a class name of "javax.sql.DataSource"
        if ((obj == null) || !(obj instanceof Reference)) {
            return null;
        }
        Reference ref = (Reference) obj;
        if (!"javax.sql.DataSource".equals(ref.getClassName())) {
            return null;
        }

//读取属性
        Properties properties = new Properties();
        for (int i = 0 ; i < ALL_PROPERTIES.length ; i++) {
            String propertyName = ALL_PROPERTIES[i];
            RefAddr ra = ref.get(propertyName);
            if (ra != null) {
                String propertyValue = ra.getContent().toString();
                properties.setProperty(propertyName, propertyValue);
            }
        }

//创建数据源
        return createDataSource(properties);
    }

 //创建数据源具体方法
    public static DataSource createDataSource(Properties properties) throws Exception {
        BasicDataSource dataSource = new BasicDataSource();
        String value = null;


        value = properties.getProperty(PROP_DEFAULTAUTOCOMMIT);
        if (value != null) {
            dataSource.setDefaultAutoCommit(Boolean.valueOf(value).booleanValue());
        }


        value = properties.getProperty(PROP_DEFAULTREADONLY);
        if (value != null) {
            dataSource.setDefaultReadOnly(Boolean.valueOf(value).booleanValue());
        }


        value = properties.getProperty(PROP_DEFAULTTRANSACTIONISOLATION);
        if (value != null) {
            int level = PoolableConnectionFactory.UNKNOWN_TRANSACTIONISOLATION;
            if ("NONE".equalsIgnoreCase(value)) {
                level = Connection.TRANSACTION_NONE;
            }
            else if ("READ_COMMITTED".equalsIgnoreCase(value)) {
                level = Connection.TRANSACTION_READ_COMMITTED;
            }
            else if ("READ_UNCOMMITTED".equalsIgnoreCase(value)) {
                level = Connection.TRANSACTION_READ_UNCOMMITTED;
            }
            else if ("REPEATABLE_READ".equalsIgnoreCase(value)) {
                level = Connection.TRANSACTION_REPEATABLE_READ;
            }
            else if ("SERIALIZABLE".equalsIgnoreCase(value)) {
                level = Connection.TRANSACTION_SERIALIZABLE;
            }
            else {
                try {
                    level = Integer.parseInt(value);
                } catch (NumberFormatException e) {
                    System.err.println("Could not parse defaultTransactionIsolation: " + value);
                    System.err.println("WARNING: defaultTransactionIsolation not set");
                    System.err.println("using default value of database driver");
                    level = PoolableConnectionFactory.UNKNOWN_TRANSACTIONISOLATION;
                }
            }
            dataSource.setDefaultTransactionIsolation(level);
        }


        value = properties.getProperty(PROP_DEFAULTCATALOG);
        if (value != null) {
            dataSource.setDefaultCatalog(value);
        }


        value = properties.getProperty(PROP_DRIVERCLASSNAME);
        if (value != null) {
            dataSource.setDriverClassName(value);
        }


        value = properties.getProperty(PROP_MAXACTIVE);
        if (value != null) {
            dataSource.setMaxActive(Integer.parseInt(value));
        }


        value = properties.getProperty(PROP_MAXIDLE);
        if (value != null) {
            dataSource.setMaxIdle(Integer.parseInt(value));
        }


        value = properties.getProperty(PROP_MINIDLE);
        if (value != null) {
            dataSource.setMinIdle(Integer.parseInt(value));
        }


        value = properties.getProperty(PROP_INITIALSIZE);
        if (value != null) {
            dataSource.setInitialSize(Integer.parseInt(value));
        }


        value = properties.getProperty(PROP_MAXWAIT);
        if (value != null) {
            dataSource.setMaxWait(Long.parseLong(value));
        }


        value = properties.getProperty(PROP_TESTONBORROW);
        if (value != null) {
            dataSource.setTestOnBorrow(Boolean.valueOf(value).booleanValue());
        }


        value = properties.getProperty(PROP_TESTONRETURN);
        if (value != null) {
            dataSource.setTestOnReturn(Boolean.valueOf(value).booleanValue());
        }


        value = properties.getProperty(PROP_TIMEBETWEENEVICTIONRUNSMILLIS);
        if (value != null) {
            dataSource.setTimeBetweenEvictionRunsMillis(Long.parseLong(value));
        }


        value = properties.getProperty(PROP_NUMTESTSPEREVICTIONRUN);
        if (value != null) {
            dataSource.setNumTestsPerEvictionRun(Integer.parseInt(value));
        }


        value = properties.getProperty(PROP_MINEVICTABLEIDLETIMEMILLIS);
        if (value != null) {
            dataSource.setMinEvictableIdleTimeMillis(Long.parseLong(value));
        }


        value = properties.getProperty(PROP_TESTWHILEIDLE);
        if (value != null) {
            dataSource.setTestWhileIdle(Boolean.valueOf(value).booleanValue());
        }


        value = properties.getProperty(PROP_PASSWORD);
        if (value != null) {
            dataSource.setPassword(value);
        }


        value = properties.getProperty(PROP_URL);
        if (value != null) {
            dataSource.setUrl(value);
        }


        value = properties.getProperty(PROP_USERNAME);
        if (value != null) {
            dataSource.setUsername(value);
        }


        value = properties.getProperty(PROP_VALIDATIONQUERY);
        if (value != null) {
            dataSource.setValidationQuery(value);
        }


        value = properties.getProperty(PROP_VALIDATIONQUERY_TIMEOUT);
        if (value != null) {
            dataSource.setValidationQueryTimeout(Integer.parseInt(value));
        }
        
        value = properties.getProperty(PROP_ACCESSTOUNDERLYINGCONNECTIONALLOWED);
        if (value != null) {
            dataSource.setAccessToUnderlyingConnectionAllowed(Boolean.valueOf(value).booleanValue());
        }


        value = properties.getProperty(PROP_REMOVEABANDONED);
        if (value != null) {
            dataSource.setRemoveAbandoned(Boolean.valueOf(value).booleanValue());
        }


        value = properties.getProperty(PROP_REMOVEABANDONEDTIMEOUT);
        if (value != null) {     
            dataSource.setRemoveAbandonedTimeout(Integer.parseInt(value));
        }


        value = properties.getProperty(PROP_LOGABANDONED);
        if (value != null) {
            dataSource.setLogAbandoned(Boolean.valueOf(value).booleanValue());
        }


        value = properties.getProperty(PROP_POOLPREPAREDSTATEMENTS);
        if (value != null) {
            dataSource.setPoolPreparedStatements(Boolean.valueOf(value).booleanValue());
        }


        value = properties.getProperty(PROP_MAXOPENPREPAREDSTATEMENTS);
        if (value != null) {
            dataSource.setMaxOpenPreparedStatements(Integer.parseInt(value));
        }


        value = properties.getProperty(PROP_INITCONNECTIONSQLS);
        if (value != null) {
            StringTokenizer tokenizer = new StringTokenizer(value, ";");
            dataSource.setConnectionInitSqls(Collections.list(tokenizer));
        }


        value = properties.getProperty(PROP_CONNECTIONPROPERTIES);
        if (value != null) {
          Properties p = getProperties(value);
          Enumeration e = p.propertyNames();
          while (e.hasMoreElements()) {
            String propertyName = (String) e.nextElement();
            dataSource.addConnectionProperty(propertyName, p.getProperty(propertyName));
          }
        }


        // DBCP-215
        // Trick to make sure that initialSize connections are created
        if (dataSource.getInitialSize() > 0) {
            dataSource.getLogWriter();
        }


        // 返回数据源
        return dataSource;
    }


//获取属性
    static private Properties getProperties(String propText) throws Exception {
      Properties p = new Properties();
      if (propText != null) {
        p.load(new ByteArrayInputStream(propText.replace(';', '\n').getBytes()));
      }
      return p;
    }

先分析到这里，明天继续。











springcsc1982
关注
  • 0
    点赞
  • 踩
  • 3
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
tomcat-dbcp源码
12-22
好不容易才找到的，在apache上可以下载tomcat的源码，但是没有tomcat-dbcp的源码，现在终于找到了，免费分享给大家，
DBCP( Database Connection Pool ）数据库连接池
最新发布
03-22
DBCP是一个依赖Jakarta commons-pool对象池机制的数据库连接池.DBCP可以直接的在应用程序中使用，Tomcat的数据源使用的就是DBCP； 使用连接池的第一项工作就是导包，这里需要的两个jar包分别是： commons-dbcp-1.4....
JDBC线程池创建与DBCP源码阅读
weixin_30378623的博客
11-16 141
创建数据库连接是一个比较消耗性能的操作，同时在并发量较大的情况下创建过多的连接对服务器形成巨大的压力。对于资源的频繁分配﹑释放所造成的问题，使用连接池技术是一种比较好的解决方式。在Java中，连接池已经有很多开源实现了，在这里使用commons-dbcp2这个包来创建JDBC连接池：public final class JDBCUtil{ private static DataSour...
Java数据库之C3P0和DBCP框架
MiChong的博客
10-18 391
一、C3P0框架： 1、数据库xml文件的配置： com.mysql.jdbc.Driver jdbc:mysql:///classwork root 9919 5 20 com.mysql.jdbc.Driver jdbc:mysql:///classwork root 9919 是new ComboPool
dbcp源码分析
weixin_40224981的博客
04-09 662
转载自：https://www.ktanx.com/blog/p/1274 如果自己实现一个DataSource，最基本的数据准备 1.dbs=new DataSource() 2.connPool=new ConnectionPool()关联到dbs 3.driverConnectionFactorty创建最基本conn,add到connPool 4.dbs中的connPool并不是可池子化管理...
dbcp2配置参数不生效导致的请求阻塞
比尔·马云的博客
01-10 1100
数据库配置不生效，数据库请求阻塞，dbcp2连接池资源耗尽
DBCP连接池原理分析
08-25
DBCP连接池介绍 ----------------------------- 目前 DBCP 有两个版本分别是 1.3 和 1.4。 DBCP 1.3 版本需要运行于 JDK 1.4-1.5 ，支持 JDBC 3。 DBCP 1.4 版本需要运行于 JDK 1.6 ，支持 JDBC 4。 1.3和1.4基于...
常用开源数据库连接池 文档和源码及jar包
04-30
C3P0是一个开放源代码的JDBC连接池，它在lib目录中与Hibernate一起发布,包括了实现jdbc3和jdbc2扩展规范说明的Connection 和Statement 池的DataSources 对象。 DBCP(DataBase connection pool),数据库连接池。是 ...
commons-dbcp:Apache Commons DBCP的镜像
03-18
Apache Commons DBCP软件实现数据库连接池 文献资料 可以在上找到更多信息。可以浏览 。与Apache Commons DBCP的使用有关的问题应张贴到。 在哪里可以获得最新版本？ 您可以从我们的下载源代码和二进制文件。 或者...
Java设计模式之：静态代理和JDK动态代理（案例实战）
06-12
代理模式：是一种设计模式，提供了对...代理模式在不修改源代码的情况下使得原本不具有某种行为能力的类对象具有某种行为能力。 本课程以自定义连接池为案例详细讲解动态代理，让学生在学完代理后，能灵活运用代理。
dbcp的jar包和源码
05-29
dbcp的jar包和源码dbcp的jar包和源码dbcp的jar包和源码dbcp的jar包和源码dbcp的jar包和源码
数据库连接池DBCP框架的研究以及源代码分析二：寻找真正的DataSource
软件开发技术改变世界
04-24 1936
从DataSourceFactory中，我们看到DataSourceFactory创建了一个DataBaseSource，如下代码       public static DataSource createDataSource(Properties properties) throws Exception {         BasicDataSource dataSource = new
框架--Spring框架和C3P0,DBCP,DRUID整合
weixin_45089791的博客
08-04 234
Spring框架和dbcp,c3p0,druid的整合 Spring 和c3p0的整合 maven依赖： <dependency> <groupId>mysql</groupId> <artifactId>mysql-connector-java</artifactId> ...
数据库连接池DBCP框架的研究以及源代码分析三：打开AbandonedObjectPool连接池
软件开发技术改变世界
04-28 1420
前面，我们已经找到了真正的DataSource，这个类就是PoolingDataSource ， 同时，也找到了对象状态维护工厂PoolableConnectionFactory目前不用急于往下看代码，如果再继续看，就容易晕，先从整体上思考一下，既然DBCP可以处理我们没有关闭的连接，那么，它的一定有自己的对象池，而且必须继承自GenericObjectPool，我们根据GenericObjec
Spring框架 dbcp数据库连接池
weixin_62282158的博客
08-29 315
Spring框架 dbcp数据库连接池
数据源
CSDN_HCX的博客
01-02 591
数据源 现在很多WEB服务器(Weblogic,WebSphere, Tomcat)都提供了DataSoruce的实现，即连接池的实现。通常我们把DataSource的实现，按其英文含义称之为数据 源，数据源中都包含了数据库连接池的实现。 也有一些开源组织提供了数据源的独立实现： •DBCP数据库连接池 •C3P0数据库连接池 实际应用时不需要编写连接数据库代码，直接从数据源获得数据库的连接。程...
Java配置数据库连接池
KingRobin
10-18 257
dbcp数据库连接池 DbcpUtils.java import java.io.IOException; import java.io.InputStream; import java.sql.Connection; import java.sql.SQLException; import java.util.Properties; import javax.sql.DataSource...
Java数据库连接池
pan_junbiao的博客
01-27 1723
一、应用程序直接获取数据库连接的缺点 用户每次请求都需要向数据库获得链接，而数据库创建连接通常需要消耗相对较大的资源，创建时间也较长。假设网站一天10万访问量，数据库服务器就需要创建10万次连接，极大的浪费数据库的资源，并且极易造成数据库服务器内存溢出、拓机。如下图所示： 二、使用数据库连接池优化程序性能 2.1、数据库连接池的基本概念 数据库连接是一种关键的有限的昂贵的资源，这一点在...
DBCP连接池配置示例
wentao365的专栏
06-17 142
[code="java"] ${jdbc.oralce.driverClassName} ${jdbc.oralce.url} ${jdbc.oralce.authusername} ${jdbc.oralce.authpassword} ...
你作为一个Java领域的专家，请完成以下任务：Spring如何连接/使用数据库？
05-19
1. 配置数据源：在Spring配置文件中配置数据源，例如使用Apache Commons DBCP连接池，可以在配置文件中添加以下代码： ``` <bean id="dataSource" class="org.apache.commons.dbcp.BasicDataSource"> ...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值