druid简单教程

时间 2019-12-04

原文原文链接

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

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

1 配置

和dbcp相似，druid的配置项以下 java

配置	缺省值	说明
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目录下。 mysql

[plain] view plain copy

url:jdbc:mysql://localhost:3306/dragoon_v25_masterdb
driverClassName:com.mysql.jdbc.Driver
username:root
password:aaaaaaaa
filters:stat
maxActive:20
initialSize:1
maxWait:60000
minIdle:10
#maxIdle:15
timeBetweenEvictionRunsMillis:60000
minEvictableIdleTimeMillis:300000
validationQuery:SELECT 'x'
testWhileIdle:true
testOnBorrow:false
testOnReturn:false
#poolPreparedStatements:true
maxOpenPreparedStatements:20
#对于长时间不使用的链接强制关闭
removeAbandoned:true
#超过30分钟开始关闭空闲链接
removeAbandonedTimeout:1800
#将当前关闭动做记录到日志
logAbandoned:true

配置文件1.1 git

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

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

2 代码编写

2.1 使用spring

首先给出spring配置文件 ajax

[html] view plain copy

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xsi:schemaLocation="http://www.springframework.org/schema/mvc http://www.springframework.org/schema/mvc/spring-mvc-3.0.xsd
http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-3.0.xsd
http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context-3.0.xsd">
<bean id="propertyConfigurer"
class="org.springframework.beans.factory.config.PropertyPlaceholderConfigurer">
<property name="locations">
<list>
<value>/WEB-INF/classes/dbconfig.properties</value>
</list>
</property>
</bean>
<bean id="dataSource" class="com.alibaba.druid.pool.DruidDataSource"
destroy-method="close">
<property name="url" value="${url}" />
<property name="username" value="${username}" />
<property name="password" value="${password}" />
<property name="driverClassName" value="${driverClassName}" />
<property name="filters" value="${filters}" />
<property name="maxActive" value="${maxActive}" />
<property name="initialSize" value="${initialSize}" />
<property name="maxWait" value="${maxWait}" />
<property name="minIdle" value="${minIdle}" />
<property name="timeBetweenEvictionRunsMillis" value="${timeBetweenEvictionRunsMillis}" />
<property name="minEvictableIdleTimeMillis" value="${minEvictableIdleTimeMillis}" />
<property name="validationQuery" value="${validationQuery}" />
<property name="testWhileIdle" value="${testWhileIdle}" />
<property name="testOnBorrow" value="${testOnBorrow}" />
<property name="testOnReturn" value="${testOnReturn}" />
<property name="maxOpenPreparedStatements"
value="${maxOpenPreparedStatements}" />
<property name="removeAbandoned" value="${removeAbandoned}" />
<property name="removeAbandonedTimeout" value="${removeAbandonedTimeout}" />
<property name="logAbandoned" value="${logAbandoned}" />
</bean>
<bean id="dataSourceDbcp" class="org.apache.commons.dbcp.BasicDataSource"
destroy-method="close">
<property name="driverClassName" value="${driverClassName}" />
<property name="url" value="${url}" />
<property name="username" value="${username}" />
<property name="password" value="${password}" />
<property name="maxActive" value="${maxActive}" />
<property name="minIdle" value="${minIdle}" />
<property name="maxWait" value="${maxWait}" />
<property name="defaultAutoCommit" value="true" />
<property name="timeBetweenEvictionRunsMillis" value="${timeBetweenEvictionRunsMillis}" />
<property name="minEvictableIdleTimeMillis" value="${minEvictableIdleTimeMillis}" />
<property name="validationQuery" value="${validationQuery}" />
<property name="testWhileIdle" value="${testWhileIdle}" />
<property name="testOnBorrow" value="${testOnBorrow}" />
<property name="testOnReturn" value="${testOnReturn}" />
<property name="maxOpenPreparedStatements"
value="${maxOpenPreparedStatements}" />
<property name="removeAbandoned" value="${removeAbandoned}" />
<property name="removeAbandonedTimeout" value="${removeAbandonedTimeout}" />
<property name="logAbandoned" value="${logAbandoned}" />
</bean>
<bean id="jdbc" class="org.springframework.jdbc.core.JdbcTemplate">
<property name="dataSource">
<ref bean="dataSource" />
</property>
</bean>
<bean id="SpringTableOperatorBean" class="com.whyun.druid.model.TableOperator"
scope="prototype">
<property name="dataSource">
<ref bean="dataSource" />
</property>
</bean>
</beans>

配置文件2.1 spring

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

[java] view plain copy

package com.whyun.druid.model;
import java.sql.Connection;
import java.sql.PreparedStatement;
import java.sql.SQLException;
import java.sql.Statement;
import javax.sql.DataSource;
public class TableOperator {
private DataSource dataSource;
public void setDataSource(DataSource dataSource) {
this.dataSource = dataSource;
}
private static final int COUNT = 800;
public TableOperator() {
}
public void tearDown() throws Exception {
try {
dropTable();
} catch (SQLException e) {
e.printStackTrace();
}
}
public void insert() throws Exception {
StringBuffer ddl = new StringBuffer();
ddl.append("INSERT INTO t_big (");
for (int i = 0; i < COUNT; ++i) {
if (i != 0) {
ddl.append(", ");
}
ddl.append("F" + i);
}
ddl.append(") VALUES (");
for (int i = 0; i < COUNT; ++i) {
if (i != 0) {
ddl.append(", ");
}
ddl.append("?");
}
ddl.append(")");
Connection conn = dataSource.getConnection();
// System.out.println(ddl.toString());
PreparedStatement stmt = conn.prepareStatement(ddl.toString());
for (int i = 0; i < COUNT; ++i) {
stmt.setInt(i + 1, i);
}
stmt.execute();
stmt.close();
conn.close();
}
private void dropTable() throws SQLException {
Connection conn = dataSource.getConnection();
Statement stmt = conn.createStatement();
stmt.execute("DROP TABLE t_big");
stmt.close();
conn.close();
}
public void createTable() throws SQLException {
StringBuffer ddl = new StringBuffer();
ddl.append("CREATE TABLE t_big (FID INT AUTO_INCREMENT PRIMARY KEY ");
for (int i = 0; i < COUNT; ++i) {
ddl.append(", ");
ddl.append("F" + i);
ddl.append(" BIGINT NULL");
}
ddl.append(")");
Connection conn = dataSource.getConnection();
Statement stmt = conn.createStatement();
stmt.execute(ddl.toString());
stmt.close();
conn.close();
}
}

代码片断2.1

注意：在使用的时候，经过获取完Connection对象，在使用完以后，要将其close掉，这样实际上是将用完的链接放入到链接池中，若是你不close的话，会形成链接泄露。

而后咱们写一个servlet来测试他.

[java] view plain copy

package com.whyun.druid.servelt;
import java.io.IOException;
import java.io.PrintWriter;
import java.sql.SQLException;
import javax.servlet.ServletContext;
import javax.servlet.ServletException;
import javax.servlet.http.HttpServlet;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import org.springframework.web.context.WebApplicationContext;
import org.springframework.web.context.support.WebApplicationContextUtils;
import com.whyun.druid.model.TableOperator;
public class TestServlet extends HttpServlet {
private TableOperator operator;
@Override
public void init() throws ServletException {
super.init();
ServletContext servletContext = this.getServletContext();
WebApplicationContext ctx
= WebApplicationContextUtils.getWebApplicationContext(servletContext);
operator = (TableOperator)ctx.getBean("SpringTableOperatorBean");
}
/**
* The doGet method of the servlet. <br>
*
* This method is called when a form has its tag value method equals to get.
*
* @param request the request send by the client to the server
* @param response the response send by the server to the client
* @throws ServletException if an error occurred
* @throws IOException if an error occurred
*/
public void doGet(HttpServletRequest request, HttpServletResponse response)
throws ServletException, IOException {
response.setContentType("text/html");
PrintWriter out = response.getWriter();
boolean createResult = false;
boolean insertResult = false;
boolean dropResult = false;
try {
operator.createTable();
createResult = true;
} catch (SQLException e) {
e.printStackTrace();
}
if (createResult) {
try {
operator.insert();
insertResult = true;
} catch (Exception e) {
e.printStackTrace();
}
try {
operator.tearDown();
dropResult = true;
} catch (Exception e) {
e.printStackTrace();
}
}
out.println("{'createResult':"+createResult+",'insertResult':"
+insertResult+",'dropResult':"+dropResult+"}");
out.flush();
out.close();
}
}

代码片断2.2

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

2.2 不使用spring

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

[java] view plain copy

package com.whyun.util.db;
import javax.sql.DataSource;
import org.apache.commons.dbcp.BasicDataSourceFactory;
import com.alibaba.druid.pool.DruidDataSourceFactory;
import com.whyun.util.config.MySqlConfigProperty;
import com.whyun.util.config.MySqlConfigProperty2;
import com.whyun.util.db.source.AbstractDataSource;
import com.whyun.util.db.source.impl.DbcpSourceMysql;
import com.whyun.util.db.source.impl.DruidSourceMysql;
import com.whyun.util.db.source.impl.DruidSourceMysql2;
// TODO: Auto-generated Javadoc
/**
* The Class DataSourceUtil.
*/
public class DataSourceUtil {
/** 使用配置文件dbconfig.properties构建Druid数据源. */
public static final int DRUID_MYSQL_SOURCE = 0;
/** The duird mysql source. */
private static DataSource duirdMysqlSource;
/** 使用配置文件dbconfig2.properties构建Druid数据源. */
public static final int DRUID_MYSQL_SOURCE2 = 1;
/** The druid mysql source2. */
private static DataSource druidMysqlSource2;
/** 使用配置文件dbconfig.properties构建Dbcp数据源. */
public static final int DBCP_SOURCE = 4;
/** The dbcp source. */
private static DataSource dbcpSource;
/**
* 根据类型获取数据源.
*
* @param sourceType 数据源类型
* @return druid或者dbcp数据源
* @throws Exception the exception
* @NotThreadSafe
*/
public static final DataSource getDataSource(int sourceType)
throws Exception {
DataSource dataSource = null;
switch(sourceType) {
case DRUID_MYSQL_SOURCE:
if (duirdMysqlSource == null) {
duirdMysqlSource = DruidDataSourceFactory.createDataSource(
MySqlConfigProperty.getInstance().getProperties());
}
dataSource = duirdMysqlSource;
break;
case DRUID_MYSQL_SOURCE2:
if (druidMysqlSource2 == null) {
druidMysqlSource2 = DruidDataSourceFactory.createDataSource(
MySqlConfigProperty2.getInstance().getProperties());
}
dataSource = druidMysqlSource2;
break;
case DBCP_SOURCE:
if (dbcpSource == null) {
dbcpSource = BasicDataSourceFactory.createDataSource(
MySqlConfigProperty.getInstance().getProperties());
}
dataSource = dbcpSource;
break;
}
return dataSource;
}
/**
* 根据数据库类型标示获取DataSource对象，跟{@link com.whyun.util.db.DataSourceUtil#getDataSource(int)}
* 不一样的是，这里DataSource获取的时候使用了单体模式
*
* @param sourceType 数据源类型
* @return 获取到的DataSource对象
* @throws Exception the exception
*/
public static final DataSource getDataSource2(int sourceType) throws Exception {
AbstractDataSource abstractDataSource = null;
switch(sourceType) {
case DRUID_MYSQL_SOURCE:
abstractDataSource = DruidSourceMysql.getInstance();
break;
case DRUID_MYSQL_SOURCE2:
abstractDataSource = DruidSourceMysql2.getInstance();
break;
case DBCP_SOURCE:
abstractDataSource = DbcpSourceMysql.getInstance();
break;
}
return abstractDataSource == null ?
null :
abstractDataSource.getDataSource();
}
}

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

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

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

[java] view plain copy

package com.whyun.druid.test;
import java.sql.SQLException;
import java.util.ArrayList;
import java.util.List;
import java.util.concurrent.Callable;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.Future;
import java.util.concurrent.TimeUnit;
import com.whyun.druid.model.TableOperator;
import com.whyun.util.db.DataSourceUtil;
public class MutilThreadTest {
public static void test(int dbType, int times)
throws Exception {
int numOfThreads =Runtime.getRuntime().availableProcessors()*2;
ExecutorService executor = Executors.newFixedThreadPool(numOfThreads);
final TableOperator test = new TableOperator();
// int dbType = DataSourceUtil.DRUID_MYSQL_SOURCE;
// dbType = DataSourceUtil.DBCP_SOURCE;
test.setDataSource(DataSourceUtil.getDataSource(dbType));
boolean createResult = false;
try {
test.createTable();
createResult = true;
} catch (SQLException e) {
e.printStackTrace();
}
if (createResult) {
List<Future<Long>> results = new ArrayList<Future<Long>>();
for (int i = 0; i < times; i++) {
results.add(executor.submit(new Callable<Long>() {
@Override
public Long call() throws Exception {
long begin = System.currentTimeMillis();
try {
test.insert();
//insertResult = true;
} catch (Exception e) {
e.printStackTrace();
}
long end = System.currentTimeMillis();
return end - begin;
}
}));
}
executor.shutdown();
while(!executor.awaitTermination(Long.MAX_VALUE, TimeUnit.DAYS));
long sum = 0;
for (Future<Long> result : results) {
sum += result.get();
}
System.out.println("---------------db type "+dbType+"------------------");
System.out.println("number of threads :" + numOfThreads + " times:" + times);
System.out.println("running time: " + sum + "ms");
System.out.println("TPS: " + (double)(100000 * 1000) / (double)(sum));
System.out.println();
try {
test.tearDown();
//dropResult = true;
} catch (Exception e) {
e.printStackTrace();
}
} else {
System.out.println("初始化数据库失败");
}
}
public static void main (String argc[])
throws Exception {
test(DataSourceUtil.DBCP_SOURCE,50);
test(DataSourceUtil.DRUID_MYSQL_SOURCE,50);
}
}

代码片断2.4 链接池多线程测试程序

3 监控

3.1 web监控

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

[html] view plain copy

<servlet>
<servlet-name>DruidStatView</servlet-name>
<servlet-class>com.alibaba.druid.support.http.StatViewServlet</servlet-class>
</servlet>
<servlet-mapping>
<servlet-name>DruidStatView</servlet-name>
<url-pattern>/druid/*</url-pattern>
</servlet-mapping>

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

同时将ajax代码提供以下

[javascript] view plain copy

function showTime() {
var myDate = new Date();
var timeStr = '';
timeStr += myDate.getFullYear()+'-'; //获取完整的年份(4位,1970-????)
timeStr += myDate.getMonth()+'-'; //获取当前月份(0-11,0表明1月)
timeStr += myDate.getDate() + ' '; //获取当前日(1-31)
timeStr += myDate.getHours()+':'; //获取当前小时数(0-23)
timeStr += myDate.getMinutes()+':'; //获取当前分钟数(0-59)
timeStr += myDate.getSeconds(); //获取当前秒数(0-59)
return timeStr
}
$(document).ready(function() {
function loadDBTestMessage() {
$.get('servlet/MysqlTestServlet',function(data) {
if (typeof(data) != 'object') {
data = eval('(' + data + ')');
}
var html = '['+showTime()+']';
html += '建立：' + data['createResult'];
html += '插入：' + data['insertResult'];
html += '销毁:' + data['dropResult'];
html +=
$('#message').html(html);
});
}
setInterval(function() {
loadDBTestMessage();
}, 10000);
});

代码片断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 plain copy

<servlet>
<servlet-name>DruidStatView</servlet-name>
<servlet-class>com.alibaba.druid.support.http.StatViewServlet</servlet-class>
<init-param>
<param-name>jmxUrl</param-name>
<param-value>service:jmx:rmi:///jndi/rmi://localhost:9004/jmxrmi</param-value>
</init-param>
</servlet>
<servlet-mapping>
<servlet-name>DruidStatView</servlet-name>
<url-pattern>/druid/*</url-pattern>
</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