`
lishumingwm163.com
  • 浏览: 337728 次
  • 性别: Icon_minigender_1
  • 来自: 济南
社区版块
存档分类
最新评论

java druid淘宝数据库连接池数据库监听

 
阅读更多

java程序很大一部分 要操作数据库，为了提高性能操作数据库的时候，有不得不使用数据库连接池。数据库连接池有很多选择，c3p、dhcp、proxool等，druid作为 一名后起之秀，凭借其出色的性能，也逐渐印入了大家的眼帘。接下来本教程就说一下druid的简单使用。

 首先从http://repo1.maven.org/maven2/com/alibaba/druid/ 下载最新的jar包。如果想使用最新的源码编译，可以从https://github.com/alibaba/druid 下载源码，然后使用maven命令行，或者导入到eclipse中进行编译。

1 配置

和dbcp类似，druid的配置项如下

 

配置 缺省值 说明
name   配置这个属性的意义在于，如果存在多个数据源，监控的时候
可以通过名字来区分开来。如果没有配置，将会生成一个名字，
格式是："DataSource-" + System.identityHashCode(this)
jdbcUrl   连接数据库的url，不同数据库不一样。例如：
mysql : jdbc:mysql://10.20.153.104:3306/druid2 
oracle : jdbc:oracle:thin:@10.20.149.85:1521:ocnauto
username   连接数据库的用户名
password   连接数据库的密码。如果你不希望密码直接写在配置文件中，
可以使用ConfigFilter。详细看这里：
https://github.com/alibaba/druid/wiki/%E4%BD%BF%E7%94%A8ConfigFilter
driverClassName 根据url自动识别 这一项可配可不配，如果不配置druid会根据url自动识别dbType，
然后选择相应的driverClassName
initialSize 0 初始化时建立物理连接的个数。初始化发生在显示调用init方法，
或者第一次getConnection时
maxActive 8 最大连接池数量
maxIdle 8 已经不再使用，配置了也没效果
minIdle   最小连接池数量
maxWait   获取连接时最大等待时间，单位毫秒。配置了maxWait之后，
缺省启用公平锁，并发效率会有所下降，
如果需要可以通过配置useUnfairLock属性为true使用非公平锁。
poolPreparedStatements false 是否缓存preparedStatement，也就是PSCache。
PSCache对支持游标的数据库性能提升巨大，比如说oracle。
在mysql5.5以下的版本中没有PSCache功能，建议关闭掉。
5.5及以上版本有PSCache，建议开启。
maxOpenPreparedStatements -1 要启用PSCache，必须配置大于0，当大于0时，
poolPreparedStatements自动触发修改为true。
在Druid中，不会存在Oracle下PSCache占用内存过多的问题，
可以把这个数值配置大一些，比如说100
validationQuery   用来检测连接是否有效的sql，要求是一个查询语句。
如果validationQuery为null，testOnBorrow、testOnReturn、
testWhileIdle都不会其作用。
testOnBorrow true 申请连接时执行validationQuery检测连接是否有效，
做了这个配置会降低性能。
testOnReturn false 归还连接时执行validationQuery检测连接是否有效，
做了这个配置会降低性能
testWhileIdle false 建议配置为true，不影响性能，并且保证安全性。
申请连接的时候检测，如果空闲时间大于
timeBetweenEvictionRunsMillis，
执行validationQuery检测连接是否有效。
timeBetweenEvictionRunsMillis   有两个含义：
1) Destroy线程会检测连接的间隔时间
 2) testWhileIdle的判断依据，详细看testWhileIdle属性的说明
numTestsPerEvictionRun   不再使用，一个DruidDataSource只支持一个EvictionRun
minEvictableIdleTimeMillis    
connectionInitSqls   物理连接初始化的时候执行的sql
exceptionSorter 根据dbType自动识别 当数据库抛出一些不可恢复的异常时，抛弃连接
filters   属性类型是字符串，通过别名的方式配置扩展插件，
常用的插件有：
监控统计用的filter:stat
日志用的filter:log4j
 防御sql注入的filter:wall
proxyFilters   类型是List<com.alibaba.druid.filter.Filter>，
如果同时配置了filters和proxyFilters，
是组合关系，并非替换关系

表1.1 配置属性

根据常用的配置属性，首先给出一个如下的配置文件，放置于src目录下。

[plain] view plaincopy
  1. url:jdbc:mysql://localhost:3306/dragoon_v25_masterdb  
  2. driverClassName:com.mysql.jdbc.Driver  
  3. username:root  
  4. password:aaaaaaaa  
  5.        
  6. filters:stat  
  7.    
  8. maxActive:20  
  9. initialSize:1  
  10. maxWait:60000  
  11. minIdle:10  
  12. #maxIdle:15  
  13.    
  14. timeBetweenEvictionRunsMillis:60000  
  15. minEvictableIdleTimeMillis:300000  
  16.    
  17. validationQuery:SELECT 'x'  
  18. testWhileIdle:true  
  19. testOnBorrow:false  
  20. testOnReturn:false  
  21. #poolPreparedStatements:true  
  22. maxOpenPreparedStatements:20  
  23.   
  24. #对于长时间不使用的连接强制关闭  
  25. removeAbandoned:true  
  26. #超过30分钟开始关闭空闲连接  
  27. removeAbandonedTimeout:1800  
  28. #将当前关闭动作记录到日志  
  29. logAbandoned:true  

配置文件1.1 

配置项中指定了各个参数后，在连接池内部是这么使用这些参数的。数据库连接池在初始化的时候会创建initialSize个连接，当有数据库操作 时，会从池中取出一个连接。如果当前池中正在使用的连接数等于maxActive，则会等待一段时间，等待其他操作释放掉某一个连接，如果这个等待时间超 过了maxWait，则会报错；如果当前正在使用的连接数没有达到maxActive，则判断当前是否空闲连接，如果有则直接使用空闲连接，如果没有则新建立一个连接。在连接使用完毕后，不是将其物理连接关闭，而是将其放入池中等待其他操作复用。

同时连接池内部有机制判断，如果当前的总的连接数少于miniIdle，则会建立新的空闲连接，以保证连接数得到miniIdle。如果当前连接池中某个连接在空闲了timeBetweenEvictionRunsMillis时间后任然没有使用，则被物理性的关闭掉。有些数据库连接的时候有超时限制（mysql连接在8小时后断开），或者由于网络中断等原因，连接池的连接会出现失效的情况，这时候设置一个testWhileIdle 参数为true，可以保证连接池内部定时检测连接的可用性，不可用的连接会被抛弃或者重建，最大情况的保证从连接池中得到的Connection对象是可 用的。当然，为了保证绝对的可用性，你也可以使用testOnBorrow为true（即在获取Connection对象时检测其可用性），不过这样会影 响性能。

2 代码编写

2.1 使用spring

首先给出spring配置文件

 

[html] view plaincopy
  1. <?xml version="1.0" encoding="UTF-8"?>  
  2. <beans xmlns="http://www.springframework.org/schema/beans"  
  3.     xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"  
  4.     xsi:schemaLocation="http://www.springframework.org/schema/mvc http://www.springframework.org/schema/mvc/spring-mvc-3.0.xsd  
  5.         http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-3.0.xsd  
  6.         http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context-3.0.xsd">  
  7.     <!-- 给web使用的spring文件 -->  
  8.     <bean id="propertyConfigurer"  
  9.         class="org.springframework.beans.factory.config.PropertyPlaceholderConfigurer">  
  10.         <property name="locations">  
  11.             <list>  
  12.                 <value>/WEB-INF/classes/dbconfig.properties</value>  
  13.             </list>  
  14.         </property>  
  15.     </bean>  
  16.     <bean id="dataSource" class="com.alibaba.druid.pool.DruidDataSource"  
  17.         destroy-method="close">  
  18.         <property name="url" value="${url}" />  
  19.         <property name="username" value="${username}" />  
  20.         <property name="password" value="${password}" />  
  21.         <property name="driverClassName" value="${driverClassName}" />  
  22.         <property name="filters" value="${filters}" />  
  23.   
  24.         <property name="maxActive" value="${maxActive}" />  
  25.         <property name="initialSize" value="${initialSize}" />  
  26.         <property name="maxWait" value="${maxWait}" />  
  27.         <property name="minIdle" value="${minIdle}" />  
  28.   
  29.         <property name="timeBetweenEvictionRunsMillis" value="${timeBetweenEvictionRunsMillis}" />  
  30.         <property name="minEvictableIdleTimeMillis" value="${minEvictableIdleTimeMillis}" />  
  31.   
  32.         <property name="validationQuery" value="${validationQuery}" />  
  33.         <property name="testWhileIdle" value="${testWhileIdle}" />  
  34.         <property name="testOnBorrow" value="${testOnBorrow}" />  
  35.         <property name="testOnReturn" value="${testOnReturn}" />  
  36.         <property name="maxOpenPreparedStatements"  
  37.             value="${maxOpenPreparedStatements}" />  
  38.         <property name="removeAbandoned" value="${removeAbandoned}" /> <!-- 打开removeAbandoned功能 -->  
  39.         <property name="removeAbandonedTimeout" value="${removeAbandonedTimeout}" /> <!-- 1800秒，也就是30分钟 -->  
  40.         <property name="logAbandoned" value="${logAbandoned}" /> <!-- 关闭abanded连接时输出错误日志 -->  
  41.     </bean>  
  42.       
  43.     <bean id="dataSourceDbcp" class="org.apache.commons.dbcp.BasicDataSource"  
  44.         destroy-method="close">  
  45.   
  46.         <property name="driverClassName" value="${driverClassName}" />  
  47.         <property name="url" value="${url}" />  
  48.         <property name="username" value="${username}" />  
  49.         <property name="password" value="${password}" />  
  50.           
  51.         <property name="maxActive" value="${maxActive}" />  
  52.         <property name="minIdle" value="${minIdle}" />  
  53.         <property name="maxWait" value="${maxWait}" />  
  54.         <property name="defaultAutoCommit" value="true" />  
  55.           
  56.         <property name="timeBetweenEvictionRunsMillis" value="${timeBetweenEvictionRunsMillis}" />  
  57.         <property name="minEvictableIdleTimeMillis" value="${minEvictableIdleTimeMillis}" />  
  58.           
  59.         <property name="validationQuery" value="${validationQuery}" />  
  60.         <property name="testWhileIdle" value="${testWhileIdle}" />  
  61.         <property name="testOnBorrow" value="${testOnBorrow}" />  
  62.         <property name="testOnReturn" value="${testOnReturn}" />  
  63.         <property name="maxOpenPreparedStatements"  
  64.             value="${maxOpenPreparedStatements}" />  
  65.         <property name="removeAbandoned" value="${removeAbandoned}" />   
  66.         <property name="removeAbandonedTimeout" value="${removeAbandonedTimeout}" />  
  67.         <property name="logAbandoned" value="${logAbandoned}" />  
  68.     </bean>  
  69.   
  70.       
  71.     <!-- jdbcTemplate -->  
  72.     <bean id="jdbc" class="org.springframework.jdbc.core.JdbcTemplate">  
  73.         <property name="dataSource">  
  74.             <ref bean="dataSource" />  
  75.         </property>  
  76.     </bean>  
  77.   
  78.     <bean id="SpringTableOperatorBean" class="com.whyun.druid.model.TableOperator"  
  79.         scope="prototype">  
  80.         <property name="dataSource">  
  81.             <ref bean="dataSource" />  
  82.         </property>  
  83.     </bean>  
  84.       
  85. </beans>  


配置文件2.1

其中第一个bean中给出的配置文件/WEB-INF/classes/dbconfig.properties就是第1节中给出的配置文件。我这 里还特地给出dbcp的spring配置项，目的就是将两者进行对比，方便大家进行迁移。这里没有使用JdbcTemplate，所以jdbc那个 bean没有使用到。下面给出com.whyun.druid.model.TableOperator类的代码。

[java] view plaincopy
  1. package com.whyun.druid.model;  
  2.   
  3. import java.sql.Connection;  
  4. import java.sql.PreparedStatement;  
  5. import java.sql.SQLException;  
  6. import java.sql.Statement;  
  7.   
  8. import javax.sql.DataSource;  
  9.   
  10. public class TableOperator {  
  11.     private DataSource dataSource;  
  12.     public void setDataSource(DataSource dataSource) {  
  13.         this.dataSource = dataSource;  
  14.     }  
  15.   
  16.     private static final int COUNT = 800;      
  17.   
  18.     public TableOperator() {  
  19.           
  20.     }  
  21.   
  22.     public void tearDown() throws Exception {  
  23.         try {  
  24.             dropTable();  
  25.         } catch (SQLException e) {  
  26.             e.printStackTrace();  
  27.         }         
  28.     }  
  29.   
  30.     public void insert() throws Exception {  
  31.           
  32.         StringBuffer ddl = new StringBuffer();  
  33.         ddl.append("INSERT INTO t_big (");  
  34.         for (int i = 0; i < COUNT; ++i) {  
  35.             if (i != 0) {  
  36.                 ddl.append(", ");  
  37.             }  
  38.             ddl.append("F" + i);  
  39.         }  
  40.         ddl.append(") VALUES (");  
  41.         for (int i = 0; i < COUNT; ++i) {  
  42.             if (i != 0) {  
  43.                 ddl.append(", ");  
  44.             }  
  45.             ddl.append("?");  
  46.         }  
  47.         ddl.append(")");  
  48.   
  49.         Connection conn = dataSource.getConnection();  
  50.   
  51. //        System.out.println(ddl.toString());  
  52.   
  53.         PreparedStatement stmt = conn.prepareStatement(ddl.toString());  
  54.   
  55.         for (int i = 0; i < COUNT; ++i) {  
  56.             stmt.setInt(i + 1, i);  
  57.         }  
  58.         stmt.execute();  
  59.         stmt.close();  
  60.   
  61.         conn.close();  
  62.     }  
  63.   
  64.     private void dropTable() throws SQLException {  
  65.   
  66.         Connection conn = dataSource.getConnection();  
  67.   
  68.         Statement stmt = conn.createStatement();  
  69.         stmt.execute("DROP TABLE t_big");  
  70.         stmt.close();  
  71.   
  72.         conn.close();  
  73.     }  
  74.   
  75.     public void createTable() throws SQLException {  
  76.         StringBuffer ddl = new StringBuffer();  
  77.         ddl.append("CREATE TABLE t_big (FID INT AUTO_INCREMENT PRIMARY KEY ");  
  78.         for (int i = 0; i < COUNT; ++i) {  
  79.             ddl.append(", ");  
  80.             ddl.append("F" + i);  
  81.             ddl.append(" BIGINT NULL");  
  82.         }  
  83.         ddl.append(")");  
  84.   
  85.         Connection conn = dataSource.getConnection();  
  86.   
  87.         Statement stmt = conn.createStatement();  
  88.         stmt.execute(ddl.toString());  
  89.         stmt.close();  
  90.   
  91.         conn.close();  
  92.     }  
  93. }  

代码片段2.1

注意：在使用的时候，通过获取完Connection对象，在使用完之后，要将其close掉，这样其实是将用完的连接放入到连接池中，如果你不close的话，会造成连接泄露。

然后我们写一个servlet来测试他.

[java] view plaincopy
  1. package com.whyun.druid.servelt;  
  2.   
  3. import java.io.IOException;  
  4. import java.io.PrintWriter;  
  5. import java.sql.SQLException;  
  6.   
  7. import javax.servlet.ServletContext;  
  8. import javax.servlet.ServletException;  
  9. import javax.servlet.http.HttpServlet;  
  10. import javax.servlet.http.HttpServletRequest;  
  11. import javax.servlet.http.HttpServletResponse;  
  12.   
  13. import org.springframework.web.context.WebApplicationContext;  
  14. import org.springframework.web.context.support.WebApplicationContextUtils;  
  15.   
  16. import com.whyun.druid.model.TableOperator;  
  17.   
  18. public class TestServlet extends HttpServlet {  
  19.     private TableOperator operator;  
  20.       
  21.   
  22.     @Override  
  23.     public void init() throws ServletException {  
  24.           
  25.         super.init();  
  26.          ServletContext servletContext = this.getServletContext();     
  27.            
  28.          WebApplicationContext ctx  
  29.             = WebApplicationContextUtils.getWebApplicationContext(servletContext);  
  30.          operator = (TableOperator)ctx.getBean("SpringTableOperatorBean");  
  31.     }  
  32.   
  33.     /** 
  34.      * The doGet method of the servlet. <br> 
  35.      * 
  36.      * This method is called when a form has its tag value method equals to get. 
  37.      *  
  38.      * @param request the request send by the client to the server 
  39.      * @param response the response send by the server to the client 
  40.      * @throws ServletException if an error occurred 
  41.      * @throws IOException if an error occurred 
  42.      */  
  43.     public void doGet(HttpServletRequest request, HttpServletResponse response)  
  44.             throws ServletException, IOException {  
  45.   
  46.         response.setContentType("text/html");  
  47.         PrintWriter out = response.getWriter();  
  48.   
  49.         boolean createResult = false;  
  50.         boolean insertResult = false;  
  51.         boolean dropResult = false;  
  52.           
  53.         try {  
  54.             operator.createTable();  
  55.             createResult = true;  
  56.         } catch (SQLException e) {  
  57.             e.printStackTrace();  
  58.         }  
  59.         if (createResult) {  
  60.             try {  
  61.                 operator.insert();  
  62.                 insertResult = true;  
  63.             } catch (Exception e) {  
  64.                 e.printStackTrace();  
  65.             }  
  66.             try {  
  67.                 operator.tearDown();  
  68.                 dropResult = true;  
  69.             } catch (Exception e) {  
  70.                 e.printStackTrace();  
  71.             }  
  72.         }  
  73.           
  74.           
  75.         out.println("{'createResult':"+createResult+",'insertResult':"  
  76.                 +insertResult+",'dropResult':"+dropResult+"}");  
  77.           
  78.         out.flush();  
  79.         out.close();  
  80.     }  
  81.   
  82. }  

代码片段2.2

这里没有用到struts2或者springmvc，虽然大部分开发者用的是这两种框架。

 

2.2 不使用spring

类似于dbcp，druid也提供了原生态的支持。这里仅仅列出来了如何获取一个DataSource对象，实际使用中要将获取DataSource的过程封装到一个单体模式类中。先看下面这段代码：

 

[java] view plaincopy
  1. package com.whyun.util.db;  
  2.   
  3. import javax.sql.DataSource;  
  4.   
  5. import org.apache.commons.dbcp.BasicDataSourceFactory;  
  6.   
  7. import com.alibaba.druid.pool.DruidDataSourceFactory;  
  8. import com.whyun.util.config.MySqlConfigProperty;  
  9. import com.whyun.util.config.MySqlConfigProperty2;  
  10. import com.whyun.util.db.source.AbstractDataSource;  
  11. import com.whyun.util.db.source.impl.DbcpSourceMysql;  
  12. import com.whyun.util.db.source.impl.DruidSourceMysql;  
  13. import com.whyun.util.db.source.impl.DruidSourceMysql2;  
  14.   
  15. // TODO: Auto-generated Javadoc  
  16. /** 
  17.  * The Class DataSourceUtil. 
  18.  */  
  19. public class DataSourceUtil {  
  20.       
  21.     /** 使用配置文件dbconfig.properties构建Druid数据源. */  
  22.     public static final int DRUID_MYSQL_SOURCE = 0;  
  23.       
  24.     /** The duird mysql source. */  
  25.     private static DataSource duirdMysqlSource;  
  26.       
  27.     /** 使用配置文件dbconfig2.properties构建Druid数据源. */  
  28.     public static final int DRUID_MYSQL_SOURCE2 = 1;  
  29.       
  30.     /** The druid mysql source2. */  
  31.     private static DataSource druidMysqlSource2;  
  32.       
  33.     /** 使用配置文件dbconfig.properties构建Dbcp数据源. */  
  34.     public static final int DBCP_SOURCE = 4;  
  35.       
  36.     /** The dbcp source. */  
  37.     private static  DataSource dbcpSource;  
  38.       
  39.     /** 
  40.      * 根据类型获取数据源. 
  41.      * 
  42.      * @param sourceType 数据源类型 
  43.      * @return druid或者dbcp数据源 
  44.      * @throws Exception the exception 
  45.      * @NotThreadSafe 
  46.      */  
  47.     public static final DataSource getDataSource(int sourceType)  
  48.         throws Exception {  
  49.         DataSource dataSource = null;  
  50.         switch(sourceType) {  
  51.         case DRUID_MYSQL_SOURCE:              
  52.               
  53.             if (duirdMysqlSource == null) {  
  54.                 duirdMysqlSource = DruidDataSourceFactory.createDataSource(  
  55.                     MySqlConfigProperty.getInstance().getProperties());  
  56.             }  
  57.             dataSource = duirdMysqlSource;  
  58.             break;  
  59.         case DRUID_MYSQL_SOURCE2:  
  60.             if (druidMysqlSource2 == null) {  
  61.                 druidMysqlSource2 = DruidDataSourceFactory.createDataSource(  
  62.                     MySqlConfigProperty2.getInstance().getProperties());  
  63.             }  
  64.             dataSource = druidMysqlSource2;  
  65.             break;  
  66.         case DBCP_SOURCE:  
  67.             if (dbcpSource == null) {  
  68.                 dbcpSource = BasicDataSourceFactory.createDataSource(  
  69.                     MySqlConfigProperty.getInstance().getProperties());  
  70.             }  
  71.             dataSource = dbcpSource;  
  72.             break;  
  73.         }  
  74.         return dataSource;  
  75.     }  
  76.       
  77.     /** 
  78.      * 根据数据库类型标示获取DataSource对象，跟{@link com.whyun.util.db.DataSourceUtil#getDataSource(int)} 
  79.      * 不同的是，这里DataSource获取的时候使用了单体模式 
  80.      * 
  81.      * @param sourceType 数据源类型 
  82.      * @return 获取到的DataSource对象 
  83.      * @throws Exception the exception 
  84.      */  
  85.     public static final DataSource getDataSource2(int sourceType) throws Exception {  
  86.   
  87.         AbstractDataSource abstractDataSource = null;  
  88.         switch(sourceType) {  
  89.         case DRUID_MYSQL_SOURCE:              
  90.             abstractDataSource = DruidSourceMysql.getInstance();  
  91.             break;  
  92.         case DRUID_MYSQL_SOURCE2:  
  93.             abstractDataSource = DruidSourceMysql2.getInstance();  
  94.             break;  
  95.         case DBCP_SOURCE:  
  96.             abstractDataSource = DbcpSourceMysql.getInstance();  
  97.             break;  
  98.         }  
  99.         return abstractDataSource == null ?  
  100.                 null :  
  101.                     abstractDataSource.getDataSource();  
  102.     }  
  103. }  


代码片段2.3 手动读取配置文件初始化连接池

第37行中调用了类com.alibaba.druid.pool.DruidDataSourceFactory中createDataSource方法来初始化一个连接池。对比dbcp的使用方法，两者很相似。

下面给出一个多线程的测试程序。运行后可以比较druid和dbcp的性能差别。

[java] view plaincopy
  1. package com.whyun.druid.test;  
  2.   
  3. import java.sql.SQLException;  
  4. import java.util.ArrayList;  
  5. import java.util.List;  
  6. import java.util.concurrent.Callable;  
  7. import java.util.concurrent.ExecutorService;  
  8. import java.util.concurrent.Executors;  
  9. import java.util.concurrent.Future;  
  10. import java.util.concurrent.TimeUnit;  
  11.   
  12. import com.whyun.druid.model.TableOperator;  
  13. import com.whyun.util.db.DataSourceUtil;  
  14.   
  15. public class MutilThreadTest {  
  16.     public static void test(int dbType, int times)  
  17.         throws Exception {   
  18.         int numOfThreads =Runtime.getRuntime().availableProcessors()*2;  
  19.         ExecutorService executor = Executors.newFixedThreadPool(numOfThreads);    
  20.         final TableOperator test = new TableOperator();  
  21. //        int dbType = DataSourceUtil.DRUID_MYSQL_SOURCE;  
  22. //        dbType = DataSourceUtil.DBCP_SOURCE;  
  23.         test.setDataSource(DataSourceUtil.getDataSource(dbType));  
  24.           
  25.         boolean createResult = false;  
  26.         try {  
  27.             test.createTable();  
  28.             createResult = true;  
  29.         } catch (SQLException e) {  
  30.             e.printStackTrace();  
  31.         }  
  32.         if (createResult) {  
  33.             List<Future<Long>> results = new ArrayList<Future<Long>>();     
  34.             for (int i = 0; i < times; i++) {    
  35.                 results.add(executor.submit(new Callable<Long>() {    
  36.                     @Override    
  37.                     public Long call() throws Exception {    
  38.                             long begin = System.currentTimeMillis();  
  39.                                 try {  
  40.                                     test.insert();  
  41.                                     //insertResult = true;  
  42.                                 } catch (Exception e) {  
  43.                                     e.printStackTrace();  
  44.                                 }                             
  45.                             long end = System.currentTimeMillis();    
  46.                         return end - begin;    
  47.                     }    
  48.                 }));    
  49.             }    
  50.             executor.shutdown();    
  51.             while(!executor.awaitTermination(Long.MAX_VALUE, TimeUnit.DAYS));    
  52.                 
  53.             long sum = 0;    
  54.             for (Future<Long> result : results) {    
  55.                 sum += result.get();    
  56.             }    
  57.                 
  58.                 
  59.             System.out.println("---------------db type "+dbType+"------------------");    
  60.             System.out.println("number of threads :" + numOfThreads + " times:" + times);    
  61.             System.out.println("running time: " + sum + "ms");    
  62.             System.out.println("TPS: " + (double)(100000 * 1000) / (double)(sum));    
  63.             System.out.println();    
  64.             try {  
  65.                 test.tearDown();  
  66.                 //dropResult = true;  
  67.             } catch (Exception e) {  
  68.                 e.printStackTrace();  
  69.             }  
  70.         } else {  
  71.             System.out.println("初始化数据库失败");  
  72.         }  
  73.           
  74.     }    
  75.       
  76.     public static void main (String argc[])  
  77.         throws Exception {  
  78.         test(DataSourceUtil.DBCP_SOURCE,50);  
  79.         test(DataSourceUtil.DRUID_MYSQL_SOURCE,50);  
  80.           
  81.     }  
  82. }  

代码片段2.4 连接池多线程测试程序


3 监控

3.1 web监控

druid提供了sql语句查询时间等信息的监控功能。为了让数据库查询一直运行，下面特地写了一个ajax进行轮询。同时，还要保证在web.xml中配置如下信息

[html] view plaincopy
  1. <servlet>  
  2.         <servlet-name>DruidStatView</servlet-name>  
  3.         <servlet-class>com.alibaba.druid.support.http.StatViewServlet</servlet-class>  
  4.     </servlet>  
  5. <servlet-mapping>  
  6.         <servlet-name>DruidStatView</servlet-name>  
  7.         <url-pattern>/druid/*</url-pattern>  
  8.     </servlet-mapping>  

配置文件3.1 在web.xml中添加druid监控


同时将ajax代码提供如下

[javascript] view plaincopy
  1. function showTime() {  
  2.     var myDate = new Date();  
  3.     var timeStr = '';  
  4.     timeStr += myDate.getFullYear()+'-'; //获取完整的年份(4位,1970-????)  
  5.     timeStr += myDate.getMonth()+'-';      //获取当前月份(0-11,0代表1月)  
  6.     timeStr += myDate.getDate() + ' ';      //获取当前日(1-31)  
  7.     timeStr += myDate.getHours()+':';      //获取当前小时数(0-23)  
  8.     timeStr += myDate.getMinutes()+':';    //获取当前分钟数(0-59)  
  9.     timeStr += myDate.getSeconds();    //获取当前秒数(0-59)  
  10.     return timeStr  
  11. }  
  12. $(document).ready(function() {  
  13.     function loadDBTestMessage() {  
  14.         $.get('servlet/MysqlTestServlet',function(data) {  
  15.             if (typeof(data) != 'object') {  
  16.                 data = eval('(' + data + ')');  
  17.             }  
  18.             var html = '['+showTime()+']';  
  19.             html += '创建：' + data['createResult'];  
  20.             html +=  '插入：' + data['insertResult'];  
  21.             html += '销毁:' + data['dropResult'];  
  22.             html +=   
  23.             $('#message').html(html);  
  24.         });  
  25.     }  
  26.       
  27.     setInterval(function() {  
  28.         loadDBTestMessage();  
  29.     }, 10000);  
  30. });  


代码片段3.1 ajax轮询

这时打开http://localhost/druid-web/druid/ 地址，会看到监控界面，点击其中的sql标签。

图3.1 监控界面查看sql查询时间

注意：在写配置文件1.1时，要保证filter配置项中含有stat属性，否则这个地方看不到sql语句的监控数据。

从0.2.23开始监控界面支持中英文语言，所以这里就不翻译表格中的英文字段了。

 

老版本的druid的jar包中不支持通过web界面进行远程监控，从0.2.14开始可以通过配置jmx地址来获取远程运行druid的服务器的监控信息。具体配置方法如下：

[html] view plaincopy
  1. <servlet>  
  2.         <servlet-name>DruidStatView</servlet-name>  
  3.         <servlet-class>com.alibaba.druid.support.http.StatViewServlet</servlet-class>  
  4.         <init-param>  
  5.             <param-name>jmxUrl</param-name>  
  6.             <param-value>service:jmx:rmi:///jndi/rmi://localhost:9004/jmxrmi</param-value>  
  7.         </init-param>  
  8.     </servlet>  
  9.     <servlet-mapping>  
  10.         <servlet-name>DruidStatView</servlet-name>  
  11.         <url-pattern>/druid/*</url-pattern>  
  12.     </servlet-mapping>  

配置文件3.2 远程监控web

这里连接的配置参数中多了一个jmxUrl，里面配置一个jmx连接地址，如果配置了这个init-param后，那么当前web监控界面监控的就 不是本机的druid的使用情况，而是jmxUrl中指定的ip的远程机器的druid使用情况。jmx连接中也可以指定用户名、密码，在上面的 servlet中添加两个init-param，其param-name分别为jmxUsername和jmxPassword，分别对应连接jmx的用 户名和密码。对于jmx在服务器端的配置，可以参考3.2节中的介绍。

3.2 jconsole监控

同时druid提供了jconsole监控的功能，因为界面做的不是很好，所以官方中没有对其的相关介绍。如果是纯java程序的话，可以简单的使 用jconsole，也可以使用3.1中提到的通过配置init-param来访问远程druid。下面依然使用的是刚才用的web项目来模拟druid 所在的远程机器。

现在假设有两台机器，一台是运行druid的A机器，一台是要查看druid运行信息的B机器。

首先在这台远程机器A的catalina.bat（或者catalina.sh）中加入java的启动选项，放置于if "%OS%" == "Windows_NT" setlocal这句之后。

set JAVA_OPTS=%JAVA_OPTS% -Dcom.sun.management.jmxremote -Dcom.sun.management.jmxremote.port="9004" -Dcom.sun.management.jmxremote.authenticate="false" -Dcom.sun.management.jmxremote.ssl="false"

保存完之后，启动startup.bat(或者startup.sh)来运行tomcat（上面设置java启动项的配置，按理来说在eclipse中也能适用，但是笔者在其下没有试验成功）。然后在要查看监控信息的某台电脑B的命令行中运行如下命令

jconsole -pluginpath E:\kuaipan\workspace6\druid-web\WebRoot\WEB-INF\lib\druid-0.2.11.jar

这里的最后一个参数就是你的druid的jar包的路径。


图3.2 jconsole连接界面

在远程进程的输入框里面输入ip:端口号，然后点击连接（上面的配置中没有指定用户名、密码，所以这里不用填写）。打开的界面如下：


图3.3 jconsole 连接成功界面

可以看到和web监控界面类似的数据了。推荐直接使用web界面配置jmx地址方式来访问远程机器的druid使用情况，因为这种方式查看到的数据信息更全面些。

参考


可以访问http://git.oschina.net/yunnysunny/druid-demo 来获取git版本库中的最新代码。
 
oschina 问答社区： http://www.oschina.net/p/druid
分享到：
| memcached- tomcat配置详解
评论
发表评论

您还没有登录,请您登录后再发表评论

相关推荐

    mina UDP 数据库连接池

    基于MINA（Java的网络应用框架）实现的UDP接收服务器，通过结合线程池和数据库连接池技术，提供了一种解决方案。 MINA，全称为"Multi-purpose Infrastructure for Network Applications"，是一个高性能、异步事件...

    Druid简单高性能MySQL连接池

    Druid是阿里巴巴开源的一款高效、强大的数据库连接池组件，它在Java编程中广泛应用于大数据量、高并发的Web应用中。Druid不仅提供了基础的数据库连接池功能，还集成了监控、SQL解析、参数绑定等多个高级特性，为开发...

    Java源码之JDBC 连接池、监控组件 Druid

    Java中的JDBC（Java Database Connectivity）是用于与各种数据库交互的标准接口，而Druid则是一个优秀的JDBC组件，它在数据库连接池管理、性能监控、SQL解析等方面具有出色的表现。本篇文章将深入探讨Druid的核心...

    开源数据库连接池bonecp附教程

    骨CP（BoneCP）是一款高性能、轻量级的开源Java数据库连接池，它以其高效的并发性能和优秀的资源管理而受到开发者的青睐。本教程将深入探讨骨CP的基本概念、安装配置、使用方法以及优化策略。 一、骨CP简介 骨CP是...

    完整版Java web开发教程PPT课件 Java开发进阶教程 第20章 数据库连接池,缓存（共15页）.pptx

    综上所述，Java Web开发不仅涉及前端的JavaScript和DOM操作，还包括后端的Servlet、JSP、过滤器、监听器等技术，以及重要的数据持久化和性能优化手段如数据库连接池和缓存。学习并掌握这些知识点，对于成为一名全面...

    druid连接池相关资料

    Druid是阿里巴巴开源的一个高效、强大的Java数据库连接池。在Java应用程序中，数据库连接池是用于管理数据库连接的关键组件，它负责创建、分配、回收和管理数据库连接，从而提高数据库访问性能，节省系统资源。Druid...

    设置数据库连接串连接池信息

    1. 选择连接池实现：有很多成熟的连接池实现，如Apache的DBCP、C3P0，还有HikariCP、Druid等。这些连接池各有优缺点，根据项目需求和性能要求选择合适的实现。 2. 添加依赖：在项目中引入所选连接池的库文件，如果...

    druid连接池所用jar（druid-1.0.15.jar）

    Druid连接池是Java开发中广泛使用的数据库连接管理工具，它由阿里巴巴开源并维护，提供了强大的监控和扩展功能。Druid-1.0.15.jar是这个库的特定版本，包含了实现Druid连接池功能所需的类和资源。下面将详细介绍...

    druid-1.1.9_德鲁伊1.1.9_durid-1.1.9_druid-1.1.9.jar_阿里巴巴德鲁伊连接池_

    在Java开发中，数据库连接池是管理和复用数据库连接的重要工具，能够显著提高系统性能，减少数据库资源的消耗。Druid作为连接池之一，具有监控分析、扩展性强、稳定性好等优点，深受开发者喜爱。 首先，让我们详细...

    druid连接池

    Druid连接池是一款高效、强大的数据库连接池组件，广泛应用于Java Web开发中。它由阿里巴巴公司开发，旨在提供更优秀的性能、监控以及安全特性。Druid不仅是一个连接池，还包含了SQL解析器、日志监控、SQL执行统计等...

    druid-1.2.4.rar

    Druid是阿里巴巴开源的一个数据库连接池组件，它在Java开发中被广泛使用，特别是在大型互联网公司。这个"druid-1.2.4.rar"压缩包包含的是Druid 1.2.4版本的源码和相关资源，对于理解Druid的工作原理、优化数据库连接...

    druid-1.1.2.jar 及配置信息

    Druid是阿里巴巴开源的一个强大、全面且高效的Java数据库连接池组件，其版本为1.1.2。Druid在设计上不仅提供了基本的数据库连接池功能，还包含了监控、SQL解析、参数绑定优化、StatFilter统计等功能，使得它成为了一...

    阿里巴巴数据源驱动druid

    阿里巴巴的Druid是一款高效、灵活且稳定的数据源驱动，它为Java应用程序提供了强大的数据库连接池功能。Druid作为开源项目，被广泛应用于大型互联网企业和传统企业的各种系统中，其主要特性包括性能监控、连接池管理...

    Druid_1.0.9_jar包及配置文件.rar

    Druid是阿里巴巴开源的一个强大、高性能、高质量的Java数据库连接池组件。在Java Web开发中，Druid被广泛用于管理数据库连接，提供高效的连接池服务，从而提升应用性能并确保系统的稳定性和可扩展性。这个"Druid_...

    druid对配置文件中的数据库密码的加密

    Druid是阿里巴巴开源的一个数据库连接池组件，它不仅提供了...同时，Druid还提供了过滤器（Filter）和监听器（Listener）等功能，可以实现更复杂的监控和定制化需求，是现代Java Web应用中常用的数据库连接池组件之一。

    druid-master.rar_Druid_jboss druid_ojdbc5-11.2.0.3.jar

    首先，让我们深入了解Druid数据库连接池。Druid是一个综合了监控诊断、性能优化、扩展性等诸多特性的数据库连接池。它的主要功能包括： 1. **连接池管理**：Druid能够有效地管理数据库连接，避免频繁创建和关闭连接...

    druid-1.1.22.zip

    1. **Druid数据库连接池** Druid的核心功能是作为数据库连接池，它管理数据库连接，提供高效的连接获取和释放策略，避免了频繁创建和关闭数据库连接带来的性能损耗。Druid支持多种数据库，如MySQL、Oracle、...

    druid1212.zip

    首先，我们来详细了解一下Druid数据库连接池。Druid的核心功能包括连接池管理、SQL解析、执行计划分析以及性能监控。它提供了一种高效的连接池实现，可以有效地管理和重用数据库连接，避免了频繁创建和关闭连接带来...

    Druid jar包和配置文件.rar

    Druid是阿里巴巴开源的一个高效、强大的Java数据库连接池组件，它在数据库连接管理、性能优化以及监控方面具有显著优势。在Java应用中，特别是在基于Spring框架的项目中，Druid经常被用作数据库连接池的首选。这个...

    Java web、数据库开发初学者不能错过的基础

    4. 连接池：如C3P0、HikariCP、Druid等，有效管理数据库连接，提高应用性能。 5. ORM框架：如Hibernate、MyBatis，将Java对象与数据库表映射，简化数据库操作。 三、学习路线图 1. 先从Java语言基础入手，然后逐步...

Magicbox
Global site tag (gtag.js) - Google Analytics