全面掌握apache-commons-dbcp之一：学会使用db

2017-02-22 本文已影响7004人许da广

开始使用dbcp

开发环境及版本：

Java Version：JDK 1.6
IDE：Eclipse 4.3
dbcp：dbcp 1.4

首先打开eclipse，首先新建一个Maven的pom项目，配置一些常用的插件。具体的pom.xml的如下：

<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
    xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0</modelVersion>
    <groupId>com.xg.testproject</groupId>
    <artifactId>mydbcp</artifactId>
    <version>0.0.1-SNAPSHOT</version>
    <packaging>pom</packaging>
    <!-- 整个工程构建 -->
    <build>
        <defaultGoal>clean compile </defaultGoal>
        <plugins>
            <!-- 清理 -->
            <plugin>
                <groupId>org.apache.maven.plugins</groupId>
                <artifactId>maven-clean-plugin</artifactId>
                <version>3.0.0</version>
            </plugin>
            <!-- 编译 -->
            <plugin>
                <groupId>org.apache.maven.plugins</groupId>
                <artifactId>maven-compiler-plugin</artifactId>
                <version>3.2</version>
                <configuration>
                    <source>1.6</source>
                    <target>1.6</target>
                    <encoding>UTF8</encoding>
                </configuration>
            </plugin>
        </plugins>

        <!-- 资源文件定义 -->
        <resources>
            <resource>
                <directory>src/main/java</directory>
                <filtering>true</filtering>
                <includes>
                    <include>**/*.xml</include>
                    <include>**/*.properties</include>
                </includes>
            </resource>
            <resource>
                <directory>src/main/resources</directory>
                <filtering>true</filtering>
            </resource>
        </resources>
    </build>

    <modules>
    </modules>
</project>

下载和编译dbcp源码

为了方便查看和学习，在dbcp使用阶段，我选择自己编辑源码，这样做首先我们可以清晰看到dbcp在设计实现的时候，依赖了哪些包，同时也方便我们dubug断点查看它的工作流程，为稍后详细的分析dbcp的设计和使用逻辑打下基础。

dbcp 1.4的源码可以在官网找到：

下载dbcp 1.4
下载完成后解压，得到dbcp的源码文件，解压的目录结构如下：

解压后的文件目录
在这些文件中，我们仅需要关注src目录和pom.xml文件。其他文件夹，像doc和xdocs都是项目的文档，可以不用理会，剩下的文件一部分是checkstyle，findbugs这类工具的配置，一部分是项目自身的描述文件，各位有兴趣的可以单独去研究一下，这里就不一一介绍了。

接下来，按照下述步骤，将代码迁移到我们自己的项目中：

新建项目：
选中我们项目的pom.xml，鼠标右键-》Maven-》New Maven Model Project，得到如下界面：

新建Maven项目

输入model名称（我自己新建的项目名称是dbcp），点击Finish按钮，完成项目创建。
迁移源码：将src/java下的内容，整个copy到dbcp项目下的src/java目录下；
添加依赖：打开下载下来的pom.xml，将<dependencies>标签的内的内容

    <dependencies>
        <!-- DBCP 依赖 -->
        <dependency>
            <groupId>commons-pool</groupId>
            <artifactId>commons-pool</artifactId>
            <version>1.5.4</version>
        </dependency>
        <!-- For managed connections -->
        <dependency>
            <groupId>org.apache.geronimo.specs</groupId>
            <artifactId>geronimo-jta_1.1_spec</artifactId>
            <version>1.1.1</version>
            <optional>true</optional>
        </dependency>
        <!-- tomcat naming jars for jndi reference tests -->
        <dependency>
            <groupId>tomcat</groupId>
            <artifactId>naming-common</artifactId>
            <version>5.0.28</version>
            <scope>test</scope>
        </dependency>
        <dependency>
            <groupId>tomcat</groupId>
            <artifactId>naming-java</artifactId>
            <version>5.0.28</version>
            <scope>test</scope>
        </dependency>
        <!-- dragged in by tomcat-naming jars - only for jndi tests -->
        <dependency>
            <groupId>commons-logging</groupId>
            <artifactId>commons-logging</artifactId>
            <version>1.1.1</version>
            <scope>test</scope>
        </dependency>
        <!-- for testing of managed connections -->
        <dependency>
            <groupId>org.apache.geronimo.components</groupId>
            <artifactId>geronimo-transaction</artifactId>
            <version>2.0.1</version>
            <scope>test</scope>
        </dependency>
    </dependencies>

copy到dbcp项目的pom.xml的<dependencies>内。

编译项目：选中我们新建的项目，鼠标右键-》Maven-》Update Project

按照上述步骤，如果没有看到报错，就证明dbcp的源码已经编译成功了。

总结一下dbcp的配置

在当前项目基础上，再新建一个jar包，并引入我们刚刚自己新建编译的dbcp源码包（以后统一简称为本地dbcp包），此时，我们就可以着手实现使用dbcp连接池的应用了。像所有的连接池一样，在使用之前，我们要先来看一下都有哪些配置项。在dbcp官网的api页面上，各个配置项都有详细的描述，我们就结合官网的内容，简单总结一下。

按照功能类型，dbcp的配置项可以大致分为以下几类：

核心基础配置

username
password
url
driverClassName

有点JDBC编程基础的人一看就知道上面这几个参数分别是干啥用的了，没有它们，“连接池”中的“连接”，就无从谈起了。它们是dbcp的基本配置，其他属性都有默认值，唯独这四个属性一定要由用户指定，否则就dbcp就无法使用。话说回来，一个连接池不论性能好坏，功能多少，它最重要的作用，就是得到一个java.sql.Connection对象。

connection属性的配置

connectionProperties：连接属性，以键值对的形式将下面这些具体的属性串起来
defaultAutoCommit：是否默认自动提交
defaultReadOnly：是否为只读
defaultTransactionIsolation：默认的事务隔离级别
defaultCatalog：connection的默认路径

这部分配置的作用都是标记从池中获取的connection应该具备的属性，而它们是否生效，就要看具体的JDBC驱动是不是支持了。

池属性的配置

initialSize
maxActive
maxIdle
minIdle
maxWait

又是一组关键的配置，这组配置的作用控制连接池的容量。

一个稳定的连接池，其对系统资源的占用应该是稳定在一个固定的范围内的，maxActive、maxIdle和minIdle的这三个参数的作用正在于此。首先，maxActive的意思是，池中最多可容纳的活着的连接数量，它是整个连接池的边界，当池中活着的连接达到这个数值时，dbcp将不会再新建connection，而是等待获取其他线程释放的。maxIdle的意思是连接池最多可以保持的连接数，应用场景就是dbcp会定时回收池中那些空闲连接（已激活但未使用的连接），直到池中的数量减少到maxIdle为止。minIdle是maxIdle的反义词，及连接池中最少保持的连接。maxWait定义了获取连接的等待时间，如果超过这个时间则抛出异常（默认配置），initialSize则定义了dbcp在初始化时，新建的连接数量。

高可用属性的配置

connectionInitSqls
testOnBorrow
testOnReturn
validationQuery
validationQueryTimeout

在连接池的使用过程中保持高可用，是一个优秀的连接池必不可少的素质，那如何做到这一点呢，dbcp给出的答案就在上面这些配置项上。

connectionInitSqls是在一个connection被创建之后调用的一组sql，这组sql可用来记录日志，也可以用来初始化一些数据，总之，经过connectionInitSqls之后的connection一定是正常可用的。testOnBorrow和testOnReturn的关注点则在connection从池中“取出”和“归还”，这两个关键的动作上，当他们被设置为true时，在取出和归还connection时，都需要完成校验，如果校验不通过，这个connection将被销毁。校验的sql由validationQuery定义，且定义的sql语句必须是查询语句，而且查询至少一列。validationQueryTimeout定义的是校验查询时长，如果超过这个时间，则认定为校验失败。

除了上述配置，dbcp在运行时还在内部维护了一个“清理器”（Eviction），主要用于销毁那些已被创建，但长时间未被使用的连接，Eviction在运行的时候，会用到下列属性：

testWhileIdle：清楚一个连接时是否需要校验
timeBetweenEvictionRunsMillis：Eviction运行的时间周期
numTestsPerEvictionRun：Eviction在运行时一次处理几个连接

PreparedStatements是可以缓存是，尤其在一些支持游标的数据库中（Oracle、SQL Server、DB2、Sybase），启用PreparedStatements缓存和不启用直接的性能可能相差一个数量级。dbcp配置PreparedStatements缓存主要用到以下两个配置。

poolPreparedStatements：是否缓存PreparedStatements
maxOpenPreparedStatements：缓存PreparedStatements的最大个数

普通项目使用dbcp

介绍完dbcp的配置项，我们就可以实际动手，开始使用它了。

新建一个普通的java项目：新建项目的方式和刚刚新建dbcp源码项目的方法一样。
添加依赖和配置文件：

项目建好之后，首先需要引入必须的依赖，打开项目的pom.xml，将下面的内容copy到<dependencies>标签内：

        <!-- 单元测试 -->
        <dependency>
            <groupId>junit</groupId>
            <artifactId>junit</artifactId>
            <version>4.10</version>
            <scope>test</scope>
        </dependency>   
        
        <!-- 引入本地dbcp包 -->
        <dependency>
            <groupId>com.xg.testproject</groupId>
            <artifactId>dbcp</artifactId>
            <version>0.0.1-SNAPSHOT</version>
        </dependency>   
        
        <!-- oracle数据库驱动 -->
        <dependency>    
            <groupId>com.oracle</groupId>    
            <artifactId>ojdbc6</artifactId>    
            <version>11.2.0.4</version>
        </dependency>

在项目的../src/main/resources/路径下，新建一个properties类型的文件dbcp.properties，文件内容如下：

# dbcp配置 
# 参考说明：http://commons.apache.org/proper/commons-dbcp/configuration.html
username=scott
password=tiger
url=jdbc:oracle:thin:@192.168.22.63:1521:orcl
driverClassName=oracle.jdbc.OracleDriver

创建数据源类

直接在src目录下创建class的话不是很规范，所以我们先来建一个包：com.xg.testproject.dbcp.simple，建好之后，创建一个名为MyDBCPDataSource.java的文件，源码如下：

package com.xg.testproject.dbcp.simple;

import java.io.IOException;
import java.util.Properties;

import org.apache.commons.dbcp.BasicDataSource;
import org.apache.commons.pool.impl.GenericObjectPool;

public class MyDBCPDataSource {

    // 单例数据源
    public static BasicDataSource DBCPDATASOURCE = getDBCPDataSource();

    private static BasicDataSource getDBCPDataSource() {
        // 加载配置文件
        Properties properties = new Properties();
        try {
            properties.load(MyDBCPDataSource.class.getResourceAsStream("/dbcp.properties"));
        } catch (IOException e) {
            e.printStackTrace();
        }
        BasicDataSource dataSource = new BasicDataSource();
        // 获取配置
        if(properties.isEmpty()){
            return null;
        }
        // 基础配置
        dataSource.setUsername(properties.getProperty("username"));
        dataSource.setPassword(properties.getProperty("password"));
        dataSource.setUrl(properties.getProperty("url"));
        dataSource.setDriverClassName(properties.getProperty("driverClassName"));
        // 数据库连接配置，主要由数据库驱动提供
        dataSource.setDefaultAutoCommit(Boolean.parseBoolean(oracle.jdbc.OracleConnection.CONNECTION_PROPERTY_AUTOCOMMIT_DEFAULT));
        // ...
        // 连接池的相关配置，这部分的默认配置完全由apache-commons-pool组件提供
        dataSource.setInitialSize(GenericObjectPool.DEFAULT_MIN_IDLE);
        dataSource.setMaxActive(GenericObjectPool.DEFAULT_MAX_ACTIVE);
        dataSource.setMaxIdle(GenericObjectPool.DEFAULT_MAX_ACTIVE);
        dataSource.setMinIdle(GenericObjectPool.DEFAULT_MIN_IDLE);
        dataSource.setMaxWait(GenericObjectPool.DEFAULT_MAX_WAIT);
        dataSource.setTestOnBorrow(GenericObjectPool.DEFAULT_TEST_ON_BORROW);
        dataSource.setTestOnReturn(GenericObjectPool.DEFAULT_TEST_ON_RETURN);
        dataSource.setTestWhileIdle(GenericObjectPool.DEFAULT_TEST_WHILE_IDLE);
        // 其他配置见 http://commons.apache.org/proper/commons-dbcp/configuration.html
        return dataSource;
    }
}

使用连接池：数据源创建好后，就可以测试使用了

新建一个AppMain.java，源码如下：

package com.xg.testproject.dbcp.simple;

import java.sql.Connection;
import java.sql.ResultSet;
import java.sql.SQLException;
import java.sql.Statement;

import org.apache.commons.dbcp.BasicDataSource;

public class AppMain {

    public static void main(String[] args) {
        
        BasicDataSource dataSource = MyDBCPDataSource.DBCPDATASOURCE;
        System.out.println("当前数据库连接池的容量" + dataSource.getNumActive());
        Connection conn = null;
        Statement sm = null;
        ResultSet rs = null;
        try {
            conn = dataSource.getConnection();
            sm = conn.createStatement();
            rs = sm.executeQuery("SELECT ID FROM EASYPASSPORT_USERS ");
            while (rs.next()) {
                long id = rs.getLong(1);
                System.out.println("从数据库中得到一条记录的值" + id);
            }
        } catch (SQLException e) {
            e.printStackTrace();
        } finally {
            try {
                rs.close();
            } catch (SQLException e) {
                e.printStackTrace();
            }
            try {
                sm.close();
            } catch (SQLException e) {
                e.printStackTrace();
            }
            try {
                System.out.println("当前数据库连接池的容量" + dataSource.getNumActive());
                conn.close();
                System.out.println("当前数据库连接池的容量" + dataSource.getNumActive());
            } catch (SQLException e) {
                e.printStackTrace();
            }
        }
    }
}

直接运行AppMain，可以看到程序正常运行，普通Java项目使用dbcp的例子也就到此结束

Spring集成dbcp

Spring是现行的Java应用开发标准，同样它在Java持久层方面的贡献也十分突出，但是“弱水三千只取一瓢”，我们今天仅简单介绍一下Spring如何集成dbcp并完成一些简单操作，更多Spring在Java持久层的内容，以后我会专门开专题去介绍。

新建一个java项目
添加Spring运行环境

为了配合dbcp的版本，Spring的版本我选择的是3.0.5（我本地仓库里恰好已经下载好了，其他3.x版本的Spring都可以），结合下图，我们可以清晰的看到需要将哪些依赖添加到项目中。

Spring 3.x的体系架构

具体的pom.xml的内容如下：

    <dependencies>
        <!-- Spring核心库 -->
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-beans</artifactId>
            <version>3.0.5.RELEASE</version>
        </dependency>
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-core</artifactId>
            <version>3.0.5.RELEASE</version>
        </dependency>
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-context</artifactId>
            <version>3.0.5.RELEASE</version>
        </dependency>
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-expression</artifactId>
            <version>3.0.5.RELEASE</version>
        </dependency>
        <!-- Spring数据访问相关 -->
        <dependency>
          <groupId>org.springframework</groupId>
          <artifactId>spring-tx</artifactId>
          <version>3.0.5.RELEASE</version>
        </dependency>
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-jdbc</artifactId>
            <version>3.0.5.RELEASE</version>
        </dependency>
        <!-- 单元测试 -->
        <dependency>
            <groupId>junit</groupId>
            <artifactId>junit</artifactId>
            <version>4.10</version>
            <scope>test</scope>
        </dependency>   
        <!-- 引入本地dbcp包 -->
        <dependency>
            <groupId>com.xg.testproject</groupId>
            <artifactId>dbcp</artifactId>
            <version>0.0.1-SNAPSHOT</version>
        </dependency>   
        <!-- oracle数据库驱动 -->
        <dependency>    
            <groupId>com.oracle</groupId>    
            <artifactId>ojdbc6</artifactId>    
            <version>11.2.0.4</version>
        </dependency>       
        <!-- Spring 3.x基于注解的事务配置需要依赖的cglib -->
        <dependency>
            <groupId>cglib</groupId>
            <artifactId>cglib</artifactId>
            <version>2.2.2</version>
        </dependency>

Spring配置

在项目的../src/main/resources/路径下，添加dbcp.properties（和之前一样）后，添加Spring的配置文件applicationContext.xml：

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
    xmlns:p="http://www.springframework.org/schema/p" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
    xmlns:context="http://www.springframework.org/schema/context"
    xmlns:aop="http://www.springframework.org/schema/aop" xmlns:tx="http://www.springframework.org/schema/tx"
    xmlns:task="http://www.springframework.org/schema/task"
    xsi:schemaLocation="http://www.springframework.org/schema/task http://www.springframework.org/schema/task/spring-task-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
        http://www.springframework.org/schema/aop http://www.springframework.org/schema/aop/spring-aop-3.0.xsd
        http://www.springframework.org/schema/tx http://www.springframework.org/schema/tx/spring-tx-3.0.xsd">
    
    <!-- 加载配置文件 -->
    <context:property-placeholder location="classpath:dbcp.properties" />
    
    <!-- 使用dbcp作为数据源 -->
    <bean id="dataSource" 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="initialSize" value="${initialSize}" />
        <property name="maxActive" value="${maxActive}" />
        <property name="maxIdle" value="${maxIdle}" />
        <property name="minIdle" value="${minIdle}" />
    </bean>
    
    <!-- JDBC操作使用Spring提供的jdbcTemplate -->
    <bean id="jdbcTemplate" class="org.springframework.jdbc.core.JdbcTemplate">
        <property name="dataSource">
            <ref bean="dataSource" />
        </property>
    </bean>
    
    <!-- 添加基于注解的事务管理 -->
    <bean id="transactionManager"
        class="org.springframework.jdbc.datasource.DataSourceTransactionManager">
        <property name="dataSource" ref="dataSource" />
    </bean>
    <tx:annotation-driven transaction-manager="transactionManager" />
</beans>

自定义业务操作Bean

完成了Spring的配置后，就可以定义我们自己的的业务实现Bean了，源码如下。

package com.xg.testproject.dbcp.spring;

import org.springframework.jdbc.core.JdbcTemplate;
import org.springframework.transaction.annotation.Transactional;

public class MyDBCPSpringTest {

    private JdbcTemplate template;
    
    
    public void setTemplate(JdbcTemplate template) {
        this.template = template;
    }


    @Transactional
    public long getNum(){
        return template.queryForLong("SELECT ID FROM EASYPASSPORT_USERS ");
    }
    
    @Transactional
    public double getSal(){
        return template.queryForLong("SELECT SAL FROM EMP WHERE EMPNO = 7369 ");
    }
    
    @Transactional
    public int setSal(Double sal){
        return template.update("UPDATE EMP T SET T.SAL = " + sal + " WHERE T.EMPNO = 7369");
    }
}

定义好之后，还要将我们这个bean的配置添加到applicationContext.xml中。

    <bean id="myDBCPSpringTest" class="com.xg.testproject.dbcp.spring.MyDBCPSpringTest">
        <property name="template">
            <ref bean="jdbcTemplate" />
        </property>
    </bean>

测试使用

package com.xg.testproject.dbcp.spring;

import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;

public class AppMain {

    public static void main(String[] args) {
    
        // 启动Spring容器，并加载配置文件
        ApplicationContext ctx = new ClassPathXmlApplicationContext("applicationContext.xml");  
        // 从容器中获取我们定义的业务操作bean
        MyDBCPSpringTest test = (MyDBCPSpringTest)ctx.getBean("myDBCPSpringTest");  
        // 完成业务操作
        System.out.println("从数据库中得到一条记录的值" + test.getNum());
        System.out.println("更新数据库中的一条记录");
        test.setSal(new Double("808.01"));
        System.out.println("得到刚刚更新的记录" + test.getSal());
    }
}

使用Tomcat内置的dbcp

在Tomcat 7之前，Tomcat都是默认将dbcp作为其数据库连接池的实现的，一些有相互依赖，同时规模也不是很大的应用，使用Tomcat内部集成的dbcp也不失为另一种选择。

Tomcat配置

要使用Tomcat集成的dbcp，应首先配置JNDI，具体做法如下。

给当前Eclipse项目添加Server Runtime Environments
按步骤操作，Windows-》Preferences-》Server-》Runtime Environment，得到如下界面，点击Add按钮。

添加Server Runtime Environments第一步

选择Apache Tomcat v6.0。

添加Server Runtime Environments第二步

选中本地的tomcat 6路径，点击Finish。

添加Server Runtime Environments第三步

上述步骤都完成后，就可以在本地查看Eclipse自动生成的本地Servers文件

本地Servers镜像文件

修改tomcat的contex.xml

选中上图中的servers文件夹中的context.xml，右键-》Open，在<context>标签内，添加如下内容：

    <Resource name="jdbc/mydb" auth="Container" type="javax.sql.DataSource" 
        driverClassName="oracle.jdbc.driver.OracleDriver"
        username="scott"
        password="tiger" 
        url="jdbc:oracle:thin:@192.168.22.63:1521:orcl"
        initialSize="10"
        maxActive="20" 
        maxIdle="20"
        minIdle="10" />

至此，Tomcat的配置就完成了。

新建web项目：
新建web的内容请参考拙作《快速搭建web项目》
在程序中使用dbcp

在新建的web中添加一个service类，用来获取获取Tomcat容器中的数据源，并完成jdbc操作。源码如下：

import java.sql.Connection;
import java.sql.ResultSet;
import java.sql.SQLException;
import java.sql.Statement;

import javax.naming.Context;
import javax.naming.InitialContext;
import javax.sql.DataSource;

public class MainService {

    public String userDb() throws Exception {
        // 初始化上下文环境
        Context context = new InitialContext();
        // 从上下文中获取JDBC资源，其中java:/comp/env/jdbc是通用的写法mydb是JNDI的名称
        DataSource ds = (DataSource) context.lookup("java:/comp/env/jdbc/mydb");
        // 执行sql脚本
        Connection conn = null;
        Statement sm = null;
        ResultSet rs = null;
        String rtnStr = "";
        try {
            conn = ds.getConnection();
            sm = conn.createStatement();
            rs = sm.executeQuery("SELECT EMAIL FROM EASYPASSPORT_USERS WHERE ID = 999");
            while (rs.next()) {
                rtnStr = rs.getString(1);
                System.out.println("从数据库中得到一条记录的值" + rtnStr);
            }
        } catch (SQLException e) {
            e.printStackTrace();
        } finally {
            try {
                rs.close();
            } catch (SQLException e) {
                e.printStackTrace();
            }
            try {
                sm.close();
            } catch (SQLException e) {
                e.printStackTrace();
            }
            try {
                conn.close();
            } catch (SQLException e) {
                e.printStackTrace();
            }
        }
        return rtnStr;
    }
}

然后新建一个servlet，用来验证service类是否生效。

import java.io.IOException;
import java.io.PrintWriter;

import javax.servlet.ServletException;
import javax.servlet.http.HttpServlet;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;

import com.xg.testproject.dbcp.javaee.service.MainService;

public class MainServlet extends HttpServlet {

    private static final long serialVersionUID = 1L;

    @Override
    protected void doGet(HttpServletRequest req, HttpServletResponse resp)
            throws ServletException, IOException {
        this.doPost(req, resp);
    }
    
    @Override
    protected void doPost(final HttpServletRequest req,
            final HttpServletResponse resp) throws ServletException,
            IOException {
        String rtnStr = "";
        try {
            rtnStr = new MainService().userDb();
        } catch (Exception e1) {
            e1.printStackTrace();
        }
        resp.setCharacterEncoding("UTF-8");
        PrintWriter writer;
        try {
            writer = resp.getWriter();
            writer.print(rtnStr);
            writer.flush();
            writer.close();
        } catch (IOException e) {
            System.out.println("向客户端返回数据时发生异常！");
            e.printStackTrace();
        }
    }
}

配置web.xml。

    <!-- Servlet配置 -->
    <servlet>
        <servlet-name>MainServlet</servlet-name>
        <servlet-class>com.xg.testproject.dbcp.javaee.servlet.MainServlet</servlet-class>
    </servlet>
    <servlet-mapping>
        <servlet-name>MainServlet</servlet-name>
        <url-pattern>/main.do</url-pattern>
    </servlet-mapping>

    <resource-ref>
        <description>DB Connection</description>
        <res-ref-name>jdbc/mydb</res-ref-name>
        <res-type>javax.sql.DataSource</res-type>
        <res-auth>Container</res-auth>
    </resource-ref>

启动Tomcat，并将当前web项目添加到容器中，打开浏览器，键入url：，可见浏览器中显示下图。

查看运行效果

此时查看后台日志，得到：

2017-2-22 18:01:11 org.apache.coyote.http11.Http11Protocol init
信息: Initializing Coyote HTTP/1.1 on http-8088
2017-2-22 18:01:11 org.apache.catalina.startup.Catalina load
信息: Initialization processed in 1799 ms
2017-2-22 18:01:11 org.apache.catalina.core.StandardService start
信息: Starting service Catalina
2017-2-22 18:01:11 org.apache.catalina.core.StandardEngine start
信息: Starting Servlet Engine: Apache Tomcat/6.0.35
2017-2-22 18:01:13 org.apache.coyote.http11.Http11Protocol start
信息: Starting Coyote HTTP/1.1 on http-8088
2017-2-22 18:01:14 org.apache.jk.common.ChannelSocket init
信息: JK: ajp13 listening on /0.0.0.0:8009
2017-2-22 18:01:14 org.apache.jk.server.JkMain start
信息: Jk running ID=0 time=0/164  config=null
2017-2-22 18:01:14 org.apache.catalina.startup.Catalina start
信息: Server startup in 2519 ms
从数据库中得到一条记录的值TEST@SAND.COM.CN

证明我们已经成功调用了Tomcat内部基础的dbcp。