三种数据库连接池的配置及使用（For JDBC）

连接池的优缺点

 

优点

 

使用连接池的最主要的优点是性能。创建一个新的数据库连接所耗费的时间主要取决于网络的速

度以及应用程序和数据库服务器的

(

网络

)

距离，而且这个过程通常是一个很耗时的过程。而采用

数据库连接池后，数据库连接请求可以直接通过连接池满足而不需要为该请求重新连接、认证到

数据库服务器，这样就节省了时间。

 

缺点

 

数据库连接池中可能存在着多个没有被使用的连接一直连接着数据库

(

这意味着资源的浪费

)

。

DBCP

一、导包

Apache官网下载DBCP包，导入两个包路径如下：

commons-dbcp-1.4-bin\commons-dbcp-1.4\commons-dbcp-1.4.jar：连接池的实现

commons-pool-1.5.6-bin\commons-pool-1.5.6\commons-pool-1.5.6.jar：连接池实现的依赖库 

CSDN上jar包的下载地址：http://download.csdn.net/detail/u012802702/9491642

二、代码示例：

方式一：使用BasicDataSource 通过方法设置连接参数。

 

[java] view plain copy
 
  1. //获取BasicDataSource并配置，开始....  
  2.         BasicDataSource source = new BasicDataSource();  
  3.     source.setDriverClassName("com.mysql.jdbc.Driver");  
  4.     source.setUrl("jdbc:mysql:///dbcptest");  
  5.     source.setUsername("root");  
  6.     source.setPassword("root");  
  7. //获取BasicDataSource并配置，结束......  
  8.     try {  
  9.             conn = source.getConnection();  
  10.             ps = conn.prepareStatement("select * from account");  
  11.             rs = ps.executeQuery();  
  12.             while (rs.next()) {  
  13.                 String name = rs.getString("name");  
  14.                 System.out.println(name);  
  15.             }   
  16.      } catch (Exception e) {  
  17.             e.printStackTrace();  
  18.         } finally {  
  19.             if (rs != null) {  
  20.                 try {  
  21.                     rs.close();  
  22.                 } catch (SQLException e) {  
  23.                     e.printStackTrace();  
  24.                 } finally {  
  25.                     rs = null;  
  26.                 }  
  27.             }  
  28.             if (ps != null) {  
  29.                 try {  
  30.                     ps.close();  
  31.                 } catch (SQLException e) {  
  32.                     e.printStackTrace();  
  33.                 } finally {  
  34.                     ps = null;  
  35.                 }  
  36.             }  
  37.             if (conn != null) {  
  38.                 try {  
  39.                     conn.close();  
  40.                 } catch (SQLException e) {  
  41.                     e.printStackTrace();  
  42.                 } finally {  
  43.                     conn = null;  
  44.                 }  
  45.             }  
  46.         }  



 


 其中的Close方法是被改写过得，及不会真正的将连接关闭，而是将其放回到连接池中，对于所有的数据源一般都会改写此方法（使用修饰）。

 

方式二：使用BasicDataSourceFactory +配置文件

 

[java] view plain copy
 
  1. try {               //获取并配置DataSource开始  
  2.         Properties prop = new Properties();  
  3.         prop.load(new FileReader("dbcp.properties"));  
  4.         BasicDataSourceFactory factory = new BasicDataSourceFactory();  
  5.         DataSource source = factory.createDataSource(prop);  
  6.     //获取并配置DataSource，结束  
  7.         conn = source.getConnection();  
  8.         ps = conn.prepareStatement("select * from account");  
  9.         rs = ps.executeQuery();  
  10.         while (rs.next()) {  
  11.             String name = rs.getString("name");  
  12.             System.out.println(name);  
  13.         }  
  14.     } catch (Exception e) {  
  15.         e.printStackTrace();  
  16.     } finally {  
  17.         if (rs != null) {  
  18.             try {  
  19.                 rs.close();  
  20.             } catch (SQLException e) {  
  21.                 e.printStackTrace();  
  22.             } finally {  
  23.                 rs = null;  
  24.             }  
  25.         }  
  26.         if (ps != null) {  
  27.             try {  
  28.                 ps.close();  
  29.             } catch (SQLException e) {  
  30.                 e.printStackTrace();  
  31.             } finally {  
  32.                 ps = null;  
  33.             }  
  34.         }  
  35.         if (conn != null) {  
  36.             try {  
  37.                 conn.close();  
  38.             } catch (SQLException e) {  
  39.                 e.printStackTrace();  
  40.             } finally {  
  41.                 conn = null;  
  42.             }  
  43.         }  
  44.     }  



 



配置文件dbcp.properties（注配置文件中的参数的名称固定）： 

 

 

[html] view plain copy
 
  1. driver=com.mysql.jdbc.Driver  
  2. url=jdbc:mysql:///dbcptest  
  3. user=root  
  4. password=root  



 

另：配置文件中除了可以配置以上4个数据库连接的必须信息外，还可以配置其他的参数，官方较完整的配置文件的参考如下：

 

[html] view plain copy
 
  1. #连接设置  
  2. driverClassName=com.mysql.jdbc.Driver  
  3. url=jdbc:mysql://localhost:3306/jdbc  
  4. username=root  
  5. password=  
  6.    
  7. #<!-- 初始化创建的连接数，当不够时再去创建 -->  
  8. initialSize=10  
  9.    
  10. #最大连接数量，连接数连不能超过该值  
  11. maxActive=50  
  12.    
  13. #<!-- 最大空闲连接，当空闲连接超过该值时就挨个关闭多余的连接，但不能小于minldle -->  
  14. maxIdle=20  
  15.    
  16. #<!-- 最小空闲连接,空闲连接的最下值 -->  
  17. minIdle=5  
  18.    
  19. #<!-- 超时等待时间以毫秒为单位 6000毫秒/1000等于60秒，当连接超过该时间便认为其实空闲连接 -->  
  20. maxWait=60000  
  21.    
  22.    
  23. #JDBC驱动建立连接时附带的连接属性属性的格式必须为这样：[属性名=property;]   
  24. #注意："user" 与 "password" 两个属性会被明确地传递，因此这里不需要包含他们。  
  25. connectionProperties=useUnicode=true;characterEncoding=gbk  
  26.    
  27. #指定由连接池所创建的连接的自动提交（auto-commit）状态。  
  28. defaultAutoCommit=true  
  29.    
  30. #driver default 指定由连接池所创建的连接的事务级别（TransactionIsolation）。  
  31. #可用值为下列之一：（详情可见javadoc。）NONE,READ_UNCOMMITTED, READ_COMMITTED, REPEATABLE_READ, SERIALIZABLE  
  32. defaultTransactionIsolation=READ_UNCOMMITTED  

 

 

C3P0

一、导包

下载C3p0数据源的jar包导入如下jar包：

Lib\c3p0-0.9.1.2.jar

CDSN的下载地址：http://download.csdn.net/detail/u012802702/9491641

二、示例

方式一：使用代码配置参数

 

[java] view plain copy
 
  1. try{  
  2.             ComboPooledDataSource source = new ComboPooledDataSource();  
  3.             source.setDriverClass("com.mysql.jdbc.Driver");  
  4.             source.setJdbcUrl("jdbc:mysql:///day11");  
  5.             source.setUser("root");  
  6.             source.setPassword("root");  
  7.               
  8.             conn = source.getConnection();  
  9.             ps = conn.prepareStatement("select * from account");  
  10.             rs = ps.executeQuery();  
  11.             while(rs.next()){  
  12.                 String name = rs.getString("name");  
  13.                 System.out.println(name);  
  14.             }  
  15.         }catch (Exception e) {  
  16.             e.printStackTrace();  
  17.         }finally{  
  18.             if(rs!=null){  
  19.                 try {  
  20.                     rs.close();  
  21.                 } catch (SQLException e) {  
  22.                     e.printStackTrace();  
  23.                 }finally{  
  24.                     rs = null;  
  25.                 }  
  26.             }  
  27.             if(ps!=null){  
  28.                 try {  
  29.                     ps.close();  
  30.                 } catch (SQLException e) {  
  31.                     e.printStackTrace();  
  32.                 }finally{  
  33.                     ps = null;  
  34.                 }  
  35.             }  
  36.             if(conn!=null){  
  37.                 try {  
  38.                     conn.close();  
  39.                 } catch (SQLException e) {  
  40.                     e.printStackTrace();  
  41.                 }finally{  
  42.                     conn = null;  
  43.                 }  
  44.             }  
  45.         }  
  46.     }  

 

 

方式二：配置文件的方式加载数据库驱动信息 

C3p0的使用较为简单，通常来说只要在src目录下添加一个c3p0的配置文件，在程序中使用一句代码

1）ComboPooledDataSource source = new ComboPooledDataSource()使用配置文件中的默认配置<default-config>，或者

2）ComboPooledDataSource source = new ComboPooledDataSource(“配置文件中name-config的名称”)使用配置文件中的其他配置

 

默认情况下C3p0会在类加载路径下搜索名称为c3p0-config.xml的配置文件，因此该配置文件应该方式在类加载目录、或者jar加载目录、或者WEB-INF/classes、或类似目录下。

c3p0-config.xml文件配置如下：

 

[html] view plain copy
 
  1. <?xml version="1.0" encoding="utf-8"?>  
  2. <c3p0-config>  
  3.   <default-config>  
  4.     <property name="driverClass">com.mysql.jdbc.Driver</property>  
  5.     <property name="jdbcUrl">jdbc:mysql:///c3p0test</property>  
  6.     <property name="user">root</property>  
  7.     <property name="password">root</property>  
  8.   </default-config>  
  9.   <named-config name="mysql2">   
  10.     <property name="driverClass">com.mysql.jdbc.Driver</property>  
  11.     <property name="jdbcUrl">jdbc:mysql:///c3p0test1</property>  
  12.     <property name="user">root</property>  
  13.     <property name="password">root</property>  
  14.   </named-config>  
  15. </c3p0-config>  
  16.       

 

当然在配置文件中可以配置数据库连接池的其他相关信息，官方建议的基本配置参数有：

acquireIncrement：声明当连接池中连接耗尽时再一次新生成多少个连接，默认为3个

initialPoolSize：当连接池启动时，初始化连接的个数，必须在minPoolSize~maxPoolSize之间，默认为3

minPoolSize：任何时间连接池中保存的最小连接数，默认3

maxPoolSize：在任何时间连接池中所能拥有的最大连接数，默认15

maxIdleTime：超过多长时间连接自动销毁，默认为0，即永远不会自动销毁

 

C03p0的官方参考模板如下：

 

[html] view plain copy
 
  1. <c3p0-config>  
  2.   <default-config>  
  3.     <property name="automaticTestTable">con_test</property>  
  4.     <property name="checkoutTimeout">30000</property>  
  5.     <property name="idleConnectionTestPeriod">30</property>  
  6. <property name="initialPoolSize">10</property>  
  7. 超过多长时间连接自动销毁，默认为0，即永远不会自动销毁  
  8.     <property name="maxIdleTime">30</property>  
  9.     <property name="maxPoolSize">100</property>  
  10.     <property name="minPoolSize">10</property>  
  11.     <property name="maxStatements">200</property>  
  12.   
  13.     <user-overrides user="test-user">  
  14.       <property name="maxPoolSize">10</property>  
  15.       <property name="minPoolSize">1</property>  
  16.       <property name="maxStatements">0</property>  
  17.     </user-overrides>  
  18.   
  19.   </default-config>  
  20.   
  21.   <!-- This app is massive! -->  
  22.   <named-config name="intergalactoApp">   
  23. 声明当连接池中连接耗尽时再一次新生成多少个连接，默认为3个  
  24. <property name="acquireIncrement">50</property>  
  25. 当连接池启动时，初始化连接的个数，必须在minPoolSize~maxPoolSize之间，默认为3  
  26. <property name="initialPoolSize">100</property>  
  27. 任何时间连接池中保存的最小连接数，默认3  
  28. <property name="minPoolSize">50</property>  
  29. 在任何时间连接池中所能拥有的最大连接数，默认15  
  30.     <property name="maxPoolSize">1000</property>  
  31.   
  32.     <!-- intergalactoApp adopts a different approach to configuring statement caching -->  
  33.     <property name="maxStatements">0</property>   
  34.     <property name="maxStatementsPerConnection">5</property>  
  35.   
  36.     <!-- he's important, but there's only one of him -->  
  37.     <user-overrides user="master-of-the-universe">   
  38.       <property name="acquireIncrement">1</property>  
  39.       <property name="initialPoolSize">1</property>  
  40.       <property name="minPoolSize">1</property>  
  41.       <property name="maxPoolSize">5</property>  
  42.       <property name="maxStatementsPerConnection">50</property>  
  43.     </user-overrides>  
  44.   </named-config>  
  45. </c3p0-config>  



 

Tomcat内置数据源（DBCP） 

 

Tomcat中内置有数据源，而DBCP与tomcat同属于Apache的项目，因此不难知道tomcat中内置的数据源其实就是DBCP数据源。使用Tomcat的内置数据源可分为两步：

 

一：为tomcat配置数据源

通常情况下，在使用eclipse或Myeclipse开发时，自己习惯于使用如下方式为tomcat配置数据源：

在web应用的META-INF文件夹下创建一个context.xml配置文件,并在其中添加<Context>标签进行配置,但，这种方式生成的数据源只能用于当前web应用.

详细context.xml文件的参考代码如下：

 

[html] view plain copy
 
  1. <?xml version="1.0" encoding="utf-8" ?>  
  2. <Context>  
  3. <Resource name="jdbc/EmployeeDB" 当前创建数据连接池的名字，自己定义，在使用jndi容器获取该数据源对象时会用到  
  4.             auth="Container" 作者  
  5.             type="javax.sql.DataSource" 对象类型这里固定为DataSource即可  
  6.             username="dbusername" 数据库连接的用户名  
  7.             password="dbpassword" 连接密码  
  8.             driverClassName="com.mysql.jdbc.Driver" 驱动  
  9.             url="jdbc:mysql:///dbcptest" 数据库的url  
  10.             maxActive="8"  DBCP的参数，DBCP的其他参数可以加入  
  11.             maxIdle="4"/>  
  12. </Context>  

 


在tomcat启动时，会逐个加载其中的web应用，当其加载到当前应用时，会加载到META-INF文件夹下该context.xml配置文件，此时tomcat会根据其中的配置信息为当前web应用创建一个数据库连接池，注该数据库连接池只能用于当前web应用，tomcat下的其他web应用无法使用该数据库连接池。至于如何配置tomcat的数据库连接池才能使当前tomcat下的所有web应用都能使用，或者可以使当前虚拟主机下的web应用都能使用？请参考其他文章：http://blog.csdn.net/u012802702/article/details/51159547。 

二、程序中获取数据源

当tomcat读取到context.xml配置文件时会为当前web应用创建数据源，但我们在当前web应用中如何获取该数据源对象？

Tomcat中有一个共有的容器：jndi，当Tomcat为web应用创建数据源之后会将数据源以键值对的形式存放到jndi容器当中，其中键名就是数据源配置时给定的名字（详见context.xml配置文件）。

而Tomcat会自动将jndi容器放到初始化容器InitalContext中。且jndi以固定的名字（java:comp/env）存储在InitalContext容器中，因此在web应用中可以通过如下步骤首先获取到数据源实例。

第一步：首先在Servlet中获取InitalContext容器实例

Context initCtx = new InitialContext();

第二步：在InitalContext容器中根据字符串java:comp/env搜寻，以及获取jndi容器实例

Context jndi = (Context) initCtx.lookup("java:comp/env");

第三部：根据数据源的名字从jndi容器获取到数据源实例。

DataSource source = jndi.lookUp("mySource");

完整参考代码如下：

 

[java] view plain copy
 
  1. Context initCtx = new InitialContext();  
  2. Context jndi = (Context) initCtx.lookup("java:comp/env");  
  3. DataSource source = jndi.lookUp("mySource");  


 

 

但到此获取到数据源对象还没有结束，因为获取jndi的代码只能在Servlet中执行，即以上代码只能在Servlet中执行，因此还应创建一个Servlet类并在其init方法中加入以上代码，之后便可以将数据源对象传给其他程序使用（可以将数据源对象设为类变量、或将其放入到ServletContext作用域中等等）。同时将该Servlet配置成为tomcat启动时执行（即在web.xml配置文件中对应的该Servlet标签下添加：<load-on-startup>1</load-on-startup>）。

参考代码如下：

[java] view plain copy
 
    1. @Override  
    2.     public void init() throws ServletException {  
    3.         try{  
    4.             Context initCtx = new InitialContext();  
    5.             Context jndi = (Context) initCtx.lookup("java:comp/env");  
    6.             DataSource source = (DataSource) jndi.lookup("mySource");  
    7.             this.getServletContext().setAttribute(“dataSource”,source);  
    8.         }catch (Exception e) {  
    9.             e.printStackTrace();  
    10.             throw new RuntimeException(e);  
    11.         }  
    12.     }  
posted @ 2019-08-22 10:12  HuSam  阅读(1044)  评论(0)  编辑  收藏  举报