配置高并发jdbc连接池

女爷i 2022-07-11 11:10 262阅读 0赞

### ps本文转自：[http://blog.csdn.net/yp5185423/article/details/8299800/\#comments][http_blog.csdn.net_yp5185423_article_details_8299800_comments] ###

# 简单的MySQL连接池 #

第一个我们需要注意的属性是 **factory="org.apache.tomcat.jdbc.pool.DataSourceFactory"**.

当tomcat读到**type="javax.sql.DataSource"**属性时会自动重新安装DBCP，除非你指定不同的factory。factory object 本身就是创建和配置连接池的。

在Apache Tomcat中有两种方式配置 **Resource** elements

## 配置全局连接池 ##

编辑**conf/server.xml**

< GlobalNamingResources >

然后你需要创建一个 **ResourceLink** element使这个连接池对于web应用是可用的。如果你想要用同一个名字让连接池对于所有的应用有效，最简单的方法就是编辑 **conf/context.xml**文件

**\[html\]** [ view plain][view plain] [ copy][view plain] [ print][view plain] [?][view plain]

1.  <Context>  
2.    <ResourceLink type="javax.sql.DataSource"  
3.                  name="jdbc/LocalTestDB"  
4.                  global="jdbc/TestDB"  
5.  />  
6.   <Context>

![save_snippets.png][]

注意，如果你不想要全局的连接池，可以从 **server.xml**移除 **Resource** element到你的web应用的 **context.xml** 文件。

然后从刚配置好的连接池中获得连接，简单[Java][]代码：

**\[html\]** [ view plain][view plain] [ copy][view plain] [ print][view plain] [?][view plain]

1.  Context initContext = new InitialContext();  
2.  Context envContext  = (Context)initContext.lookup("java:/comp/env");  
3.  DataSource datasource = (DataSource)envContext.lookup("jdbc/LocalTestDB");  
4.  Connection con = datasource.getConnection();

Context initContext = new InitialContext();
       Context envContext  = (Context)initContext.lookup("java:/comp/env");
       DataSource datasource = (DataSource)envContext.lookup("jdbc/LocalTestDB");
       Connection con = datasource.getConnection();

## 使用java很简单 ##

还可以使用[Java][Java 1]syntax

**\[html\]** [ view plain][view plain] [ copy][view plain] [ print][view plain] [?][view plain]

1.  DataSource ds = new DataSource();  
2.  ds.setDriverClassName("com.mysql.jdbc.Driver");  
3.  ds.setUrl("jdbc:mysql://localhost:3306/mysql");  
4.  ds.setUsername("root");  
5.  ds.setPassword("password");

DataSource ds = new DataSource();
       ds.setDriverClassName("com.mysql.jdbc.Driver");
       ds.setUrl("jdbc:mysql://localhost:3306/mysql");
       ds.setUsername("root");
       ds.setPassword("password");

或者分离出连接池的属性

**\[html\]** [ view plain][view plain] [ copy][view plain] [ print][view plain] [?][view plain]

1.  PoolProperties pp = new PoolProperties();  
2.  pp.setDriverClassName("com.mysql.jdbc.Driver");  
3.  pp.setUrl("jdbc:mysql://localhost:3306/mysql");  
4.  pp.setUsername("root");  
5.  pp.setPassword("password");  
6.  DataSource ds = new DataSource(pp);

PoolProperties pp = new PoolProperties();
       pp.setDriverClassName("com.mysql.jdbc.Driver");
       pp.setUrl("jdbc:mysql://localhost:3306/mysql");
       pp.setUsername("root");
       pp.setPassword("password");
       DataSource ds = new DataSource(pp);

所有的属性我们可以在XML中通过factory object也可以直接使用 **PoolProperties**或者 **DataSource objects**设置为有效

# 设置连接池 #

我们将使用下面这些属性设置连接池

*     ** initialSize**

*  **    maxActive**

*  **    maxIdle**

*  **    minIdle**

去了解这些属性是很重要的，它们看起来很明显但又有一些神秘

**\[html\]** [ view plain][view plain] [ copy][view plain] [ print][view plain] [?][view plain]

1.  <Resource type="javax.sql.DataSource"  
2.              name="jdbc/TestDB"  
3.              factory="org.apache.tomcat.jdbc.pool.DataSourceFactory"  
4.              driverClassName="com.mysql.jdbc.Driver"  
5.              url="jdbc:mysql://localhost:3306/mysql"  
6.              username="mysql\_user"  
7.              password="mypassword123"  
8.              initialSize="10"  
9.              maxActive="100"  
10.             maxIdle="50"  
11.             minIdle="10"  
12.             />

![save_snippets.png][]

**initialSize=10** 设置连接池建立时连接的数目

*   当连接池定义在**GlobalNamingResources**中，连接池在Tomcat启动时创键

*   当连接池定义在**Context**中，连接池在第一次查找JNDI时创建

**maxActive=100** 连接[数据库][Link 1]的最大连接数。这个属性用来限制连接池中能够打开连接的数量，可以方便数据库做连接容量规划。

**minIdle=10**  连接池中存在的最小连接数目。连接池中连接数目可以变很少，如果使用了**maxAge**属性，有些空闲的连接会被关闭因为离它最近一次连接的时间过去太久了。但是，我们看到的打开的连接不会少于**minIdle**。

**maxIdle**属性有一点麻烦。它的不同的行为取决于是否使用了**pool sweeper**。**pool sweeper**是一个可以在连接池正在使用的时候[测试][Link 2]空闲连接和重置连接池大小的后台线程。还负责检测连接泄露。**pool sweeper** 通过如下方式定义的：

**\[html\]** [ view plain][view plain] [ copy][view plain] [ print][view plain] [?][view plain]

1.  public boolean isPoolSweeperEnabled() \{  
2.          boolean timer = getTimeBetweenEvictionRunsMillis()>0;  
3.          boolean result = timer && (isRemoveAbandoned() && getRemoveAbandonedTimeout()>0);  
4.          result = result || (timer && getSuspectTimeout()>0);   
5.          result = result || (timer && isTestWhileIdle() && getValidationQuery()!=null);  
6.          return result;  
7.      \}

public boolean isPoolSweeperEnabled() {
            boolean timer = getTimeBetweenEvictionRunsMillis()>0;
            boolean result = timer && (isRemoveAbandoned() && getRemoveAbandonedTimeout()>0);
            result = result || (timer && getSuspectTimeout()>0); 
            result = result || (timer && isTestWhileIdle() && getValidationQuery()!=null);
            return result;
        }

**sweeper**每 **timeBetweenEvictionRunsMillis** milliseconds运行一次。

**maxIdle**定义如下

*  **Pool sweeper**关闭，如果空闲连接池大于**maxIdle**，返回的连接将被关闭。

*  **Pool sweeper**开启，空闲的连接数可以超过**maxIdle**，但如果连接空闲的时间已经超过**minEvictableIdleTimeMillis**，能缩小到**minIdle**。听起来很奇怪连接池为什么不关闭连接当空闲连接数量大于**maxIdle**。想想下面的情况：

1.  100个线程处理100个并发请求     
    
2.  在一个请求中每个线程请求一个连接3次

在这种场景下，如果我们设置**maxIdle=50**，那么我们会关闭和打开50\*3的连接数。这样增加了数据库的负重并且减慢了应用的速度。当达到连接高峰时，我们希望能够充分利用连接池中的所有连接。因此，我们强烈希望打开**pool sweeper** 。我们将在下一个部分探讨具体的事项。我们在这里额外说明**maxAge**这个属性。**maxAge**定义连接能够打开或者存在的时间，单位为毫秒。当一个连接返回到了连接池，如果这个连接已经使用过，并且距离它第一次被使用的时间大于**maxAge**时，这个连接会被关闭。

正如我们所看到的 **isPoolSweeper**[算法][Link 3]实现，**sweeper**将会被打开，当以下任一条件满足时

*   **timeBetweenEvictionRunsMillis**>0 AND **removeAbandoned**=true AND**removeAbandonedTimeout**>0

*  ** timeBetweenEvictionRunsMillis**>0 AND **suspectTimeout**>0

*   **timeBetweenEvictionRunsMillis**>0 AND **testWhileIdle**=true AND **validationQuery**!=null

As of version 1.0.9 the following condition has been added

*  **timeBetweenEvictionRunsMillis**>0 AND **minEvictableIdleTimeMillis**>0

(timer && getMinEvictableIdleTimeMillis()>0);

因此设置最理想的连接池，我们最好修改我们的配置满足这些条件

**\[html\]** [ view plain][view plain] [ copy][view plain] [ print][view plain] [?][view plain]

![save_snippets.png][]

# 有效的连接 #

数据库连接池提出了一个挑战，因为连接池中的连接会过时。这是常有的事，要么数据库，或者可能是连接池和数据库中的一个设备，连接超时。唯一确定会话连接是活跃的真正办法是使连接在服务器和数据库做一个来回访问。在Java 6中，JDBC API处理验证连接是否是有效的方法是通过提供**isValid**变量来调用**java.sql.Connection**接口。在此之前，连接池不得不采用执行一个查询的方法，比如在[MySQL][Link 1]上执行**SELECT 1**.数据库分析这句查询很简单，不需要任何的磁盘访问。**isValid**被计划实施，但 Apache Tomcat 6的连接池，也必须保存对Java 5的兼容性。

## 校验查询 ##

校验查询会有一些挑战

1.  如果它们频繁使用，会降低系统的性能
2.  如果使用的间隔太久，会导致连接失效
3.  如果应用调用**setTransactionIsolation**并设置**autoCommit=false**，如果应用再次调用**setTransactionIsolation**，会产生一个**SQLException**异常，因为校验查询可能在数据库中已经产生了一个新的transaction。

让我们看看最典型的配置：

**\[html\]** [ view plain][view plain] [ copy][view plain] [ print][view plain] [?][view plain]

![save_snippets.png][]

在这个配置中，java代码每次调用 **Connection con = dataSource.getConnection()**时都会执行一次 **SELECT 1**查询。

这样保证了在连接提交给应用之前都已经测试过了。但是，对于在短时间内频繁使用连接的应用，会对性能有严重的影响。这有两个其他的配置选项：

*  **testWhileIdle**

*  **testOnReturn**

当在错误的时间对连接做测试，它们也不是真正的很有帮助。

对于很多应用来说，没有校验不是一个真正的困难。一些应用可以绕过校验通过设置**minIdle=0**和给**minEvictableIdleTimeMillis**一个很小的值，所以如果连接空闲了足够长的时间会让数据库会话超时，在此之前连接池将会移除这些空闲太久的连接。

最好的解决办法就是测试那些有一段时间没被测试过的连接。

**\[html\]** [ view plain][view plain] [ copy][view plain] [ print][view plain] [?][view plain]

1.  <Resource type="javax.sql.DataSource"  
2.              name="jdbc/TestDB"  
3.              factory="org.apache.tomcat.jdbc.pool.DataSourceFactory"  
4.              driverClassName="com.mysql.jdbc.Driver"  
5.              url="jdbc:mysql://localhost:3306/mysql"  
6.              username="mysql\_user"  
7.              password="mypassword123"  
8.              testOnBorrow="true"  
9.              validationQuery="SELECT 1"  
10.             validationInterval="30000"  
11.             />

![save_snippets.png][]

在这个配置中，连接校验的间隔不会超过30s。这是在性能和连接验证上的折中。正如前面提到的，如果我们想侥幸验证所有的连接，我们可以配置连接池中所有空闲连接超时。

**\[html\]** [ view plain][view plain] [ copy][view plain] [ print][view plain] [?][view plain]

1.  <Resource type="javax.sql.DataSource"  
2.              name="jdbc/TestDB"  
3.              factory="org.apache.tomcat.jdbc.pool.DataSourceFactory"  
4.              driverClassName="com.mysql.jdbc.Driver"  
5.              url="jdbc:mysql://localhost:3306/mysql"  
6.              username="mysql\_user"  
7.              password="mypassword123"  
8.              timeBetweenEvictionRunsMillis="5000"  
9.              minEvictableIdleTimeMillis="5000"  
10.             minIdle="0"  
11.             />

## 建立数据库客户会话 ##

在一些案例中，当初始化一个新的数据库会话时需要执行一些任务。可能包括执行一个简单的SQL声明或者执行一个存储过程。  
当你创建触发器时候，这是在数据库层面上的典型操作。

**\[html\]** [ view plain][view plain] [ copy][view plain] [ print][view plain] [?][view plain]

1.  create or replace trigger logon\_alter\_session after logon on database  
2.    begin  
3.      if sys\_context('USERENV', 'SESSION\_USER') = 'TEMP' then  
4.        EXECUTE IMMEDIATE 'alter session ....';  
5.      end if;  
6.    end;  
7.    /

create or replace trigger logon_alter_session after logon on database
      begin
        if sys_context('USERENV', 'SESSION_USER') = 'TEMP' then
          EXECUTE IMMEDIATE 'alter session ....';
        end if;
      end;
      /

这将影响所有的用户，在后面这种情况下这是不够的，当创建一个新的会话的时候我们希望执行一个自定义查询。

**\[html\]** [ view plain][view plain] [ copy][view plain] [ print][view plain] [?][view plain]

1.  <Resource name="jdbc/TestDB" auth="Container"  
2.              type="javax.sql.DataSource"  
3.              description="Oracle Datasource"  
4.              url="jdbc:oracle:thin:@//localhost:1521/orcl"  
5.              driverClassName="oracle.jdbc.driver.OracleDriver"  
6.              username="default\_user"  
7.              password="password"  
8.              maxActive="100"  
9.              validationQuery="select 1 from dual"  
10.             validationInterval="30000"  
11.             testOnBorrow="true"  
12.             initSQL="ALTER SESSION SET NLS\_DATE\_FORMAT = 'YYYY MM DD HH24:MI:SS'"/>

**initSQL**会被存在的每一条连接执行。

# 连接池泄露和长时间运行的查询 #

连接池包含一些诊断操作。jdbc-pool和Common DBCP都能够检测和减轻没有返回连接池中的连接。这里演示是被称为抛出内存泄露的连接。

**\[html\]** [ view plain][view plain] [ copy][view plain] [ print][view plain] [?][view plain]

1.  Connection con = dataSource.getConnection();  
2.  Statement st = con.createStatement();  
3.  st.executeUpdate("insert into id(value) values (1'); //SQLException here  
4.  con.close();

![save_snippets.png][]

Connection con = dataSource.getConnection();
      Statement st = con.createStatement();
      st.executeUpdate("insert into id(value) values (1'); //SQLException here
      con.close();

这有5个配置选项用来检测这些错误类型的连接，前三个选项配置在Common DBCP中也有

**\[html\]** [ view plain][view plain] [ copy][view plain] [ print][view plain] [?][view plain]

1.  <Resource type="javax.sql.DataSource"  
2.              name="jdbc/TestDB"  
3.              factory="org.apache.tomcat.jdbc.pool.DataSourceFactory"  
4.              driverClassName="com.mysql.jdbc.Driver"  
5.              url="jdbc:mysql://localhost:3306/mysql"  
6.              username="mysql\_user"  
7.              password="mypassword123"  
8.              maxActive="100"  
9.              timeBetweenEvictionRunsMillis="30000"  
10.             removeAbandoned="true"  
11.             removeAbandonedTimeout="60"  
12.             logAbandoned="true"  
13.             />

![save_snippets.png][]

*  **removeAbandoned**\-如果我们想检测内存泄露的连接，可以设置为true

*  **removeAbandonedTimeout**\-调用**dataSource.getConnection**开始到丢弃检测到泄露连接的时间（seconds）

*  **logAbandoned**\-如果想用log记录丢弃的连接，可以设置为true。当设置为true时，调用**dataSource.getConnection** 时会记录一个堆栈追踪，并且被打印出来当连接没有返回的时候。

但我们想要这种类型的诊断，当然有可以使用的例子。也可以运行批处理作业一次执行一个连接几分钟。我们该如何处理这些问题？  
两个额外的选项已经被加入来支持这些工作

**\[html\]** [ view plain][view plain] [ copy][view plain] [ print][view plain] [?][view plain]

1.  <Resource type="javax.sql.DataSource"  
2.             name="jdbc/TestDB"  
3.             factory="org.apache.tomcat.jdbc.pool.DataSourceFactory"  
4.             driverClassName="com.mysql.jdbc.Driver"  
5.             url="jdbc:mysql://localhost:3306/mysql"  
6.             username="mysql\_user"  
7.             password="mypassword123"  
8.             maxActive="100"  
9.             timeBetweenEvictionRunsMillis="30000"  
10.            removeAbandoned="true"  
11.            removeAbandonedTimeout="60"  
12.            logAbandoned="true"  
13.            abandonWhenPercentageFull="50"  
14.            />

*  **abandonWhenPercentageFull**\-一条连接必须满足临界值 **removeAbandonedTimeout**和打开连接的数量必须超过这个百分比。

使用这个属性可能会在一次错误判断中产生在其他地方已经被认为丢弃的连接。设置这个值为100时意味着连接数除非到了**maxActive**限制时，是不会被考虑丢弃的。这给连接池增加了一些灵活性，但是不会让批处理作业使用单独连接5分钟。在这种情况，我们想确定当我们检测到连接仍然被使用时，我们重置超时计时器，因此，连接不会被考虑丢弃。我们通过插入一个拦截器实现。

**\[html\]** [ view plain][view plain] [ copy][view plain] [ print][view plain] [?][view plain]

1.  <Resource type="javax.sql.DataSource"  
2.              name="jdbc/TestDB"  
3.              factory="org.apache.tomcat.jdbc.pool.DataSourceFactory"  
4.              driverClassName="com.mysql.jdbc.Driver"  
5.              url="jdbc:mysql://localhost:3306/mysql"  
6.              username="mysql\_user"  
7.              password="mypassword123"  
8.              maxActive="100"  
9.              timeBetweenEvictionRunsMillis="30000"  
10.             removeAbandoned="true"  
11.             removeAbandonedTimeout="60"  
12.             logAbandoned="true"  
13.             abandonWhenPercentageFull="50"  
14.             jdbcInterceptors="ResetAbandonedTimer"  
15.             />

![save_snippets.png][]

拦截器在 **org.apache.tomcat.jdbc.pool.interceptor.ResetAbandonedTimer**中被指定完全限定名称，或者在 **org.apache.tomcat.jdbc.pool.interceptor**包中使用短类名  
 每次准备语句或者执行一次查询，连接池中的计时器会被重置放弃计时器。因为如此，在5分钟的批处理作业中执行多次查询和更新，都不会超时。

这是你当然想知道的情形，但你不会想去kill或者回收连接，因为你不会知道会对你的系统产生什么影响。

**\[html\]** [ view plain][view plain] [ copy][view plain] [ print][view plain] [?][view plain]

1.  <Resource type="javax.sql.DataSource"  
2.              name="jdbc/TestDB"  
3.              factory="org.apache.tomcat.jdbc.pool.DataSourceFactory"  
4.              driverClassName="com.mysql.jdbc.Driver"  
5.              url="jdbc:mysql://localhost:3306/mysql"  
6.              username="mysql\_user"  
7.              password="mypassword123"  
8.              maxActive="100"  
9.              timeBetweenEvictionRunsMillis="30000"  
10.             logAbandoned="true"  
11.             suspectTimeout="60"  
12.             jdbcInterceptors="ResetAbandonedTimer"  
13.             />

**suspectTimeout**属性的工作方式与 **removeAbandonedTimeout** 相似，除了不关闭连接，而只是简单的记录警告和发布一个JMX通知信息。通过这种方式，你可以在不用改变你系统行为的情况下发现泄漏或者长查询。

# 从其它的数据源形成连接池 #

到目前为止我们处理连接池连接的获得是通过**java.sql.Driver**接口。因此我们使用属性

*  **driverClassName**

*  **url**

然而，一些连接配置是使用 **javax.sql.DataSource** 甚至是**javax.sql.XADataSource**接口，因此我们需要支持这些配置选项。  
 使用java相对是很容易的。

**\[html\]** [ view plain][view plain] [ copy][view plain] [ print][view plain] [?][view plain]

1.      PoolProperties pp = new PoolProperties();  
2.  pp.setDataSource(myOtherDataSource);  
3.  DataSource ds = new DataSource(pp);  
4.  Connection con = ds.getConnection();

PoolProperties pp = new PoolProperties();
       	pp.setDataSource(myOtherDataSource);
       	DataSource ds = new DataSource(pp);
       	Connection con = ds.getConnection();

或者

**\[html\]** [ view plain][view plain] [ copy][view plain] [ print][view plain] [?][view plain]

1.      DataSource ds = new DataSource();  
2.  ds.setDataSource(myOtherDataSource);  
3.  Connection con = ds.getConnection();

DataSource ds = new DataSource();
       	ds.setDataSource(myOtherDataSource);
       	Connection con = ds.getConnection();

我们能够注入另外的 **javax.sql.DataSource**或者  **javax.sql.XADataSource**对象并且用来连接检索。  
 在我们处理XA连接时很方便。

在XML配置中，jdbc-pool会使用**org.apache.tomcat.jdbc.naming.GenericNamingResourcesFactory**类，一个能够允许配置任何类型的命名资源的简单类。为了设置**Apache Derby XADataSource** 我们可以创建了下面的代码

**\[html\]** [ view plain][view plain] [ copy][view plain] [ print][view plain] [?][view plain]

这是一个简单的通过端口1527连接到网络上的相邻实例的 **XADataSource**.

如果你想要从这个数据源形成XA连接池，我们可以在它后面建立这个连接池节点。

**\[html\]** [ view plain][view plain] [ copy][view plain] [ print][view plain] [?][view plain]

1.  <Resource factory="org.apache.tomcat.jdbc.naming.GenericNamingResourcesFactory"  
2.              name="jdbc/DerbyXA1"  
3.              type="org.apache.derby.jdbc.ClientXADataSource"  
4.              databaseName="sample1"  
5.              createDatabase="create"  
6.              serverName="localhost"  
7.              portNumber="1527"  
8.              user="sample1"  
9.              password="password"/>  
10.             <Resource factory="org.apache.tomcat.jdbc.pool.DataSourceFactory"  
11.             dataSourceJNDI="DerbyXA1"  
12.             name="jdbc/TestDB1"  
13.             auth="Container"  
14.             type="javax.sql.XADataSource"  
15.             testWhileIdle="true"  
16.             testOnBorrow="true"  
17.             testOnReturn="false"  
18.             validationQuery="SELECT 1"  
19.             validationInterval="30000"  
20.             timeBetweenEvictionRunsMillis="5000"  
21.             maxActive="100"  
22.             minIdle="10"  
23.             maxIdle="20"  
24.             maxWait="10000"  
25.             initialSize="10"  
26.             removeAbandonedTimeout="60"  
27.             removeAbandoned="true"  
28.             logAbandoned="true"  
29.             minEvictableIdleTimeMillis="30000"  
30.             jmxEnabled="true"  
31.             jdbcInterceptors="ConnectionState;StatementFinalizer;SlowQueryReportJmx(threshold=10000)"  
32.             abandonWhenPercentageFull="75"/>

<Resource factory="org.apache.tomcat.jdbc.naming.GenericNamingResourcesFactory"
                name="jdbc/DerbyXA1"
                type="org.apache.derby.jdbc.ClientXADataSource"
                databaseName="sample1"
                createDatabase="create"
                serverName="localhost"
                portNumber="1527"
                user="sample1"
                password="password"/>
                <Resource factory="org.apache.tomcat.jdbc.pool.DataSourceFactory"
                dataSourceJNDI="DerbyXA1"
                name="jdbc/TestDB1"
                auth="Container"
                type="javax.sql.XADataSource"
                testWhileIdle="true"
                testOnBorrow="true"
                testOnReturn="false"
                validationQuery="SELECT 1"
                validationInterval="30000"
                timeBetweenEvictionRunsMillis="5000"
                maxActive="100"
                minIdle="10"
                maxIdle="20"
                maxWait="10000"
                initialSize="10"
                removeAbandonedTimeout="60"
                removeAbandoned="true"
                logAbandoned="true"
                minEvictableIdleTimeMillis="30000"
                jmxEnabled="true"
                jdbcInterceptors="ConnectionState;StatementFinalizer;SlowQueryReportJmx(threshold=10000)"
                abandonWhenPercentageFull="75"/>

注意 **type=javax.sql.XADataSource** 是怎样设置的，这会创建一个 **org.apache.tomcat.jdbc.pool.XADataSource**来代替 **org.apache.tomcat.jdbc.pool.DataSource**。  
这里我们通过 **dataSourceJNDI=DerbyXA1**属性链接这两个数据源。这两个数据源都不得不存在同一个命名空间，在我们的例子中，是jdbc命名空间。

目前JNDI通过**DataSource.setDataSourceJNDI(...)**查找不被支持，只能通过factory对象。

如果你加入一个

*   **javax.sql.DataSource**对象-连接池将会调用 **javax.sql.DataSource.getConnection()**方法
 *  ** javax.sql.DataSource** 对象但是在连接池中指定了**username/password**\-连接池将会调用**javax.sql.DataSource.getConnection(String username, String password)** 方法
 *  **javax.sql.XADataSource**对象-连接池将会调用 **javax.sql.XADataSource.getXAConnection()**方法
 *  **javax.sql.XADataSource** 对象但是在连接池中指定了 **username/password**\-连接池将会调用 **javax.sql.DataSource.getXAConnection(String username, String password)**方法

这是一个有趣的现象当你处理 **XADataSources**。你可以把返回的对象转换为**java.sql.Connection**对象或者**javax.sql.XAConnection**对象，并且对同一个对象的两个接口调用方法。

**\[html\]** [ view plain][view plain] [ copy][view plain] [ print][view plain] [?][view plain]

1.      DataSource ds = new DataSource();  
2.  ds.setDataSource(myOtherDataSource);  
3.  Connection con = ds.getConnection();  
4.  if (con instanceof XAConnection) \{  
5.          XAConnection xacon = (XAConnection)con;  
6.          transactionManager.enlistResource(xacon.getXAResource());  
7.  \}  
8.  Statement st = con.createStatement();  
9.  ResultSet rs = st.executeQuery(SELECT 1);

DataSource ds = new DataSource();
       	ds.setDataSource(myOtherDataSource);
       	Connection con = ds.getConnection();
       	if (con instanceof XAConnection) {
         		XAConnection xacon = (XAConnection)con;
         		transactionManager.enlistResource(xacon.getXAResource());
       	}
       	Statement st = con.createStatement();
       	ResultSet rs = st.executeQuery(SELECT 1);

# JDBC 拦截器 #

JDBC 拦截器创建是为了实现灵活性。**javax.sql.PooledConnection** 从底层驱动封装了**java.sql.Connection/javax.sql.XAConnection**或者数据源本身就是一个拦截器。拦截器以**java.lang.reflect.InvocationHandler**接口为基础。拦截器是一个继承自**org.apache.tomcat.pool.jdbc.JdbcInterceptor**的类。

在本文中，我们将介绍如果配置拦截器。在我们下一篇文章，我们将介绍如果实现自定义拦截器和它们的生命周期。

**\[html\]** [ view plain][view plain] [ copy][view plain] [ print][view plain] [?][view plain]

1.  <Resource factory="org.apache.tomcat.jdbc.pool.DataSourceFactory"  
2.     
3.              ...  
4.              jdbcInterceptors="ConnectionState;StatementFinalizer;SlowQueryReportJmx(threshold=10000)"  
5.     
6.    />

![save_snippets.png][]

与下面的相同

**\[html\]** [ view plain][view plain] [ copy][view plain] [ print][view plain] [?][view plain]

1.  <Resource factory="org.apache.tomcat.jdbc.pool.DataSourceFactory"  
2.     
3.              ...  
4.             jdbcInterceptors="org.apache.tomcat.jdbc.pool.interceptor.ConnectionState;  
5.             org.apache.tomcat.jdbc.pool.interceptor.StatementFinalizer;  
6.             org.apache.tomcat.jdbc.pool.interceptor.SlowQueryReportJmx(threshold=10000)"  
7.    />

![save_snippets.png][]

拦截器可以使用一个短小的名称，比如 **ConnectionState**，如果这个拦截器定义在 **org.apache.tomcat.jdbc.pool.interceptor** 包中。

否则，必须使用一个完全限定名称。

拦截器定义在以；分割的字符串中。拦截器可以在括号内定义0个或多个参数。参数是以逗号分割的简单键值对。

## 连接状态 ##

**java.sql.Connection**接口有如下属性

*         ** autoCommit**

*  **        readOnly**

*  **        transactionIsolation**

*  **        catalog**

这些属性的默认值可以使用如下的内容为连接池配置

*          **defaultAutoCommit**

*  **        defaultReadOnly**

*  **        defaultTransactionIsolation**

*  **        defaultCatalog**

如果设置了这些属性，当建立连接到数据库时配置这个连接。如果没有配置 **ConnectionState**拦截器，在建立连接时设置这些属性会是一次性操作。如果配置了**ConnectionState**拦截器，每次从连接池取出的连接会将被重置为期望的状态。

其中有些方法在执行查询时会导致往返数据库。比如，调用 **Connection.getTransactionIsolation()**会导致驱动查询当前会话的事务隔离级别。这种往返会导致严重的性能问题并影响应用在频繁的使用连接执行非常短和快的操作的时候。 **ConnectionState** 拦截器可以缓存这些操作的值并调用方法查询它们从而避免往返数据库。

## Statement Finalizer ##

java代码在使用**java.sql**对象后需要清除和释放使用过的资源。

一个清理代码示例

**\[html\]** [ view plain][view plain] [ copy][view plain] [ print][view plain] [?][view plain]

1.             Connection con = null;  
2.  Statement st = null;  
3.  ResultSet rs = null;  
4.  try \{  
5.              con = ds.getConnection();  
6.              ...  
7.    
8.  \} finally \{  
9.              if (rs!=null) try  \{ rs.close(); \} catch (Exception ignore)\{\}  
10.             if (st!=null) try  \{ st.close(); \} catch (Exception ignore)\{\}  
11.             if (con!=null) try \{ con.close();\} catch (Exception ignore)\{\}  
12. \}

![save_snippets.png][]

Connection con = null;
       		Statement st = null;
       		ResultSet rs = null;
       		try {
         			con = ds.getConnection();
         			...
     
       		} finally {
         			if (rs!=null) try  { rs.close(); } catch (Exception ignore){}
         			if (st!=null) try  { st.close(); } catch (Exception ignore){}
         			if (con!=null) try { con.close();} catch (Exception ignore){}
       		}

一些应用并不总是使用这种方式。我们以前展示了如何配置连接池去诊断和警告当连接没有正确关闭的情况。

当一个连接返回连接池的时候，**StatementFinalizer**拦截器确保 **java.sql.Statement**和它的子类正确关闭。

# 获得真正的JDBC连接 #

使用**javax.sql.PooledConnection**工具返回代理连接，因此取出连接十分直接，不需要转换为特殊的类。

同样适用于你配置了处理**javax.sql.XAConnection**的连接池。

另一个有趣的取出底层连接的方法是

**\[html\]** [ view plain][view plain] [ copy][view plain] [ print][view plain] [?][view plain]

1.  Connection con = ds.getConnection();  
2.  ction underlyingconnection = con.createStatement().getConnection();

![save_snippets_01.png][]

Connection con = ds.getConnection();
      	Connection underlyingconnection = con.createStatement().getConnection();

这是因为jdbc-pool默认的是没有代理声明。这当然有一个拦截器用来阻止这个用例。  
  
PS：翻译原文——http://www.tomcatexpert.com/blog/2010/04/01/configuring-jdbc-pool-high-concurrency

[http_blog.csdn.net_yp5185423_article_details_8299800_comments]: http://blog.csdn.net/yp5185423/article/details/8299800/#comments
[view plain]: http://blog.csdn.net/yp5185423/article/details/8299800/#
[save_snippets.png]: /images/20220711/af79806698bb41f3b164bda1783a4cfc.png
[Java]: http://lib.csdn.net/base/javase
[Java 1]: http://lib.csdn.net/base/java
[Link 1]: http://lib.csdn.net/base/mysql
[Link 2]: http://lib.csdn.net/base/softwaretest
[Link 3]: http://lib.csdn.net/base/datastructure
[save_snippets_01.png]: /images/20220711/11cc01d2b90b4a9fa0f7f310332d6301.png