天天看點
傳回

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

初始化時建立實體連接配接的個數。初始化發生在顯示調用init方法，

或者第一次getConnection時
maxActive 8 最大連接配接池數量
maxIdle 8 已經不再使用，配置了也沒效果
minIdle 最小連接配接池數量
maxWait

擷取連接配接時最大等待時間，機關毫秒。配置了maxWait之後，

預設啟用公平鎖，并發效率會有所下降，

如果需要可以通過配置useUnfairLock屬性為true使用非公平鎖。
poolPreparedStatements false

是否緩存preparedStatement，也就是PSCache。

PSCache對支援遊标的資料庫性能提升巨大，比如說oracle。

在mysql5.5以下的版本中沒有PSCache功能，建議關閉掉。

作者在5.5版本中使用PSCache，通過監控界面發現PSCache有緩存命中率記錄，

該應該是支援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 plain copy

  1. url:jdbc:mysql://localhost:3306/dragoon_v25_masterdb  
  2. driverClassName:com.mysql.jdbc.Driver  
  3. username:root  
  4. password:aaaaaaaa  
  5. filters:stat  
  6. maxActive:20  
  7. initialSize:1  
  8. maxWait:60000  
  9. minIdle:10  
  10. #maxIdle:15  
  11. timeBetweenEvictionRunsMillis:60000  
  12. minEvictableIdleTimeMillis:300000  
  13. validationQuery:SELECT 'x'  
  14. testWhileIdle:true  
  15. testOnBorrow:false  
  16. testOnReturn:false  
  17. #poolPreparedStatements:true  
  18. maxOpenPreparedStatements:20  
  19. #對于長時間不使用的連接配接強制關閉  
  20. removeAbandoned:true  
  21. #超過30分鐘開始關閉空閑連接配接  
  22. removeAbandonedTimeout:1800  
  23. #将目前關閉動作記錄到日志  
  24. 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 plain copy

  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.         <property name="maxActive" value="${maxActive}" />  
  24.         <property name="initialSize" value="${initialSize}" />  
  25.         <property name="maxWait" value="${maxWait}" />  
  26.         <property name="minIdle" value="${minIdle}" />  
  27.         <property name="timeBetweenEvictionRunsMillis" value="${timeBetweenEvictionRunsMillis}" />  
  28.         <property name="minEvictableIdleTimeMillis" value="${minEvictableIdleTimeMillis}" />  
  29.         <property name="validationQuery" value="${validationQuery}" />  
  30.         <property name="testWhileIdle" value="${testWhileIdle}" />  
  31.         <property name="testOnBorrow" value="${testOnBorrow}" />  
  32.         <property name="testOnReturn" value="${testOnReturn}" />  
  33.         <property name="maxOpenPreparedStatements"  
  34.             value="${maxOpenPreparedStatements}" />  
  35.         <property name="removeAbandoned" value="${removeAbandoned}" /> <!-- 打開removeAbandoned功能 -->  
  36.         <property name="removeAbandonedTimeout" value="${removeAbandonedTimeout}" /> <!-- 1800秒，也就是30分鐘 -->  
  37.         <property name="logAbandoned" value="${logAbandoned}" /> <!-- 關閉abanded連接配接時輸出錯誤日志 -->  
  38.     </bean>  
  39.     <bean id="dataSourceDbcp" class="org.apache.commons.dbcp.BasicDataSource"  
  40.         destroy-method="close">  
  41.         <property name="driverClassName" value="${driverClassName}" />  
  42.         <property name="url" value="${url}" />  
  43.         <property name="username" value="${username}" />  
  44.         <property name="password" value="${password}" />  
  45.         <property name="maxActive" value="${maxActive}" />  
  46.         <property name="minIdle" value="${minIdle}" />  
  47.         <property name="maxWait" value="${maxWait}" />  
  48.         <property name="defaultAutoCommit" value="true" />  
  49.         <property name="timeBetweenEvictionRunsMillis" value="${timeBetweenEvictionRunsMillis}" />  
  50.         <property name="minEvictableIdleTimeMillis" value="${minEvictableIdleTimeMillis}" />  
  51.         <property name="validationQuery" value="${validationQuery}" />  
  52.         <property name="testWhileIdle" value="${testWhileIdle}" />  
  53.         <property name="testOnBorrow" value="${testOnBorrow}" />  
  54.         <property name="testOnReturn" value="${testOnReturn}" />  
  55.         <property name="maxOpenPreparedStatements"  
  56.             value="${maxOpenPreparedStatements}" />  
  57.         <property name="removeAbandoned" value="${removeAbandoned}" />   
  58.         <property name="removeAbandonedTimeout" value="${removeAbandonedTimeout}" />  
  59.         <property name="logAbandoned" value="${logAbandoned}" />  
  60.     </bean>  
  61.     <!-- jdbcTemplate -->  
  62.     <bean id="jdbc" class="org.springframework.jdbc.core.JdbcTemplate">  
  63.         <property name="dataSource">  
  64.             <ref bean="dataSource" />  
  65.         </property>  
  66.     </bean>  
  67.     <bean id="SpringTableOperatorBean" class="com.whyun.druid.model.TableOperator"  
  68.         scope="prototype">  
  69.         <property name="dataSource">  
  70.             <ref bean="dataSource" />  
  71.         </property>  
  72.     </bean>  
  73. </beans>  

配置檔案2.1

其中第一個bean中給出的配置檔案/WEB-INF/classes/dbconfig.properties就是第1節中給出的配置檔案。我這裡還特地給出dbcp的spring配置項，目的就是将兩者進行對比，友善大家進行遷移。這裡沒有使用JdbcTemplate，是以jdbc那個bean沒有使用到。下面給出com.whyun.druid.model.TableOperator類的代碼。

[java]  view plain copy

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

代碼片段2.1

注意：在使用的時候，通過擷取完Connection對象，在使用完之後，要将其close掉，這樣其實是将用完的連接配接放入到連接配接池中，如果你不close的話，會造成連接配接洩露。

然後我們寫一個servlet來測試他.

[java]  view plain copy

  1. package com.whyun.druid.servelt;  
  2. import java.io.IOException;  
  3. import java.io.PrintWriter;  
  4. import java.sql.SQLException;  
  5. import javax.servlet.ServletContext;  
  6. import javax.servlet.ServletException;  
  7. import javax.servlet.http.HttpServlet;  
  8. import javax.servlet.http.HttpServletRequest;  
  9. import javax.servlet.http.HttpServletResponse;  
  10. import org.springframework.web.context.WebApplicationContext;  
  11. import org.springframework.web.context.support.WebApplicationContextUtils;  
  12. import com.whyun.druid.model.TableOperator;  
  13. public class TestServlet extends HttpServlet {  
  14.     private TableOperator operator;  
  15.     @Override  
  16.     public void init() throws ServletException {  
  17.         super.init();  
  18.          ServletContext servletContext = this.getServletContext();     
  19.          WebApplicationContext ctx  
  20.             = WebApplicationContextUtils.getWebApplicationContext(servletContext);  
  21.          operator = (TableOperator)ctx.getBean("SpringTableOperatorBean");  
  22.     }  
  23.     public void doGet(HttpServletRequest request, HttpServletResponse response)  
  24.             throws ServletException, IOException {  
  25.         response.setContentType("text/html");  
  26.         PrintWriter out = response.getWriter();  
  27.         boolean createResult = false;  
  28.         boolean insertResult = false;  
  29.         boolean dropResult = false;  
  30.         try {  
  31.             operator.createTable();  
  32.             createResult = true;  
  33.         } catch (SQLException e) {  
  34.             e.printStackTrace();  
  35.         }  
  36.         if (createResult) {  
  37.             try {  
  38.                 operator.insert();  
  39.                 insertResult = true;  
  40.             } catch (Exception e) {  
  41.                 e.printStackTrace();  
  42.             }  
  43.             try {  
  44.                 operator.tearDown();  
  45.                 dropResult = true;  
  46.             } catch (Exception e) {  
  47.                 e.printStackTrace();  
  48.             }  
  49.         }  
  50.         out.println("{'createResult':"+createResult+",'insertResult':"  
  51.                 +insertResult+",'dropResult':"+dropResult+"}");  
  52.         out.flush();  
  53.         out.close();  
  54.     }  
  55. }  

代碼片段2.2

這裡沒有用到struts2或者springmvc，雖然大部分開發者用的是這兩種架構。

2.2 不使用spring

類似于dbcp，druid也提供了原生态的支援。這裡僅僅列出來了如何擷取一個DataSource對象，實際使用中要将擷取DataSource的過程封裝到一個單體模式類中。先看下面這段代碼：

[java]  view plain copy

  1. package com.whyun.util.db;  
  2. import javax.sql.DataSource;  
  3. import org.apache.commons.dbcp.BasicDataSourceFactory;  
  4. import com.alibaba.druid.pool.DruidDataSourceFactory;  
  5. import com.whyun.util.config.MySqlConfigProperty;  
  6. import com.whyun.util.config.MySqlConfigProperty2;  
  7. import com.whyun.util.db.source.AbstractDataSource;  
  8. import com.whyun.util.db.source.impl.DbcpSourceMysql;  
  9. import com.whyun.util.db.source.impl.DruidSourceMysql;  
  10. import com.whyun.util.db.source.impl.DruidSourceMysql2;  
  11. // TODO: Auto-generated Javadoc  
  12. public class DataSourceUtil {  
  13.     public static final int DRUID_MYSQL_SOURCE = 0;  
  14.     private static DataSource duirdMysqlSource;  
  15.     public static final int DRUID_MYSQL_SOURCE2 = 1;  
  16.     private static DataSource druidMysqlSource2;  
  17.     public static final int DBCP_SOURCE = 4;  
  18.     private static  DataSource dbcpSource;  
  19.     public static final DataSource getDataSource(int sourceType)  
  20.         throws Exception {  
  21.         DataSource dataSource = null;  
  22.         switch(sourceType) {  
  23.         case DRUID_MYSQL_SOURCE:              
  24.             if (duirdMysqlSource == null) {  
  25.                 duirdMysqlSource = DruidDataSourceFactory.createDataSource(  
  26.                     MySqlConfigProperty.getInstance().getProperties());  
  27.             }  
  28.             dataSource = duirdMysqlSource;  
  29.             break;  
  30.         case DRUID_MYSQL_SOURCE2:  
  31.             if (druidMysqlSource2 == null) {  
  32.                 druidMysqlSource2 = DruidDataSourceFactory.createDataSource(  
  33.                     MySqlConfigProperty2.getInstance().getProperties());  
  34.             }  
  35.             dataSource = druidMysqlSource2;  
  36.             break;  
  37.         case DBCP_SOURCE:  
  38.             if (dbcpSource == null) {  
  39.                 dbcpSource = BasicDataSourceFactory.createDataSource(  
  40.                     MySqlConfigProperty.getInstance().getProperties());  
  41.             }  
  42.             dataSource = dbcpSource;  
  43.             break;  
  44.         }  
  45.         return dataSource;  
  46.     }  
  47.     public static final DataSource getDataSource2(int sourceType) throws Exception {  
  48.         AbstractDataSource abstractDataSource = null;  
  49.         switch(sourceType) {  
  50.         case DRUID_MYSQL_SOURCE:              
  51.             abstractDataSource = DruidSourceMysql.getInstance();  
  52.             break;  
  53.         case DRUID_MYSQL_SOURCE2:  
  54.             abstractDataSource = DruidSourceMysql2.getInstance();  
  55.             break;  
  56.         case DBCP_SOURCE:  
  57.             abstractDataSource = DbcpSourceMysql.getInstance();  
  58.             break;  
  59.         }  
  60.         return abstractDataSource == null ?  
  61.                 null :  
  62.                     abstractDataSource.getDataSource();  
  63.     }  
  64. }  

代碼片段2.3 手動讀取配置檔案初始化連接配接池

第37行中調用了類com.alibaba.druid.pool.DruidDataSourceFactory中createDataSource方法來初始化一個連接配接池。對比dbcp的使用方法，兩者很相似。

下面給出一個多線程的測試程式。運作後可以比較druid和dbcp的性能差别。

[java]  view plain copy

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

代碼片段2.4 連接配接池多線程測試程式

3 監控

3.1 web監控

druid提供了sql語句查詢時間等資訊的監控功能。為了讓資料庫查詢一直運作，下面特地寫了一個ajax進行輪詢。同時，還要保證在web.xml中配置如下資訊

[html]  view plain copy

  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 plain copy

  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.     setInterval(function() {  
  27.         loadDBTestMessage();  
  28.     }, 10000);  
  29. });  

代碼片段3.1 ajax輪詢

這時打開http://localhost/druid-web/druid/ 位址，會看到監控界面，點選其中的sql标簽。

druid 連接配接池

圖3.1 監控界面檢視sql查詢時間

注意：在寫配置檔案1.1時，要保證filter配置項中含有stat屬性，否則這個地方看不到sql語句的監控資料。

表格中各項含義如下

名稱 解釋 備注
ExecuteCount 目前sql已執行次數
ExecTime 目前sql已執行時間
ExecMax 目前sql最大執行時間
Txn 目前運作的事務數量
Error 目前sql執行出錯的數目
Update 目前sql更新或者删除操作中已經影響的行數
FetchRow 目前sql操作中已經讀取的行數
Running 目前sql正在運作的數目
Concurrent 目前sql最大并發執行數 
ExecHisto  目前sql做execute操作的時間分布數組 分為0-1,1-10,10-100,100-1000，>1000，5個時間分布區域，機關為ms
ExecRsHisto 

目前sql做execute操作和resultSet

打開至關閉的時間總和分布數組

 同上
FetchRowHisto 目前sql查詢時間分布數組 同上
UpdateHisto  目前sql更新、删除時間分布數組 同上

表3.1 監控字段含義

老版本的druid的jar包中不支援通過web界面進行遠端監控，從0.2.14開始可以通過配置jmx位址來擷取遠端運作druid的伺服器的監控資訊。具體配置方法如下：

[html]  view plain copy

  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包的路徑。

druid 連接配接池

圖3.2 jconsole連接配接界面

在遠端程序的輸入框裡面輸入ip:端口号，然後點選連接配接（上面的配置中沒有指定使用者名、密碼，是以這裡不用填寫）。打開的界面如下：

druid 連接配接池

圖3.3 jconsole 連接配接成功界面

可以看到和web監控界面類似的資料了。推薦直接使用web界面配置jmx位址方式來通路遠端機器的druid使用情況，因為這種方式檢視到的資料資訊更全面些。

轉自：http://blog.csdn.net/zhanyuanlin/article/details/9983171

資料庫 JAVA基礎知識
上一篇: Druid連接配接池使用
下一篇: Gcc 中的 gettimeofday 函數使用

繼續閱讀