Apache Commons DBUtils指南

电玩女神 2023-09-29 08:48 10阅读 0赞

##  ##

Apache Commons DbUtils库是一组非常小的类，旨在使JDBC调用处理更容易而不会泄漏资源，并具有更干净的代码。由于 JDBC 资源清理非常繁琐且容易出错，因此 DBUtils 类有助于抽象出样板代码，以便开发人员只能专注于与数据库相关的操作。

### DBUtils的优势 ###

使用Apache Commons DBUtils的优势解释如下：

*  **无资源泄漏** − DBUtils 类确保不会发生资源泄漏。
 *  **Clean & Clear code** \- DBUtils类提供干净明了的代码来执行数据库操作，而无需编写清理或资源泄漏预防代码。
 *  **Bean Mapping** − DBUtils 类支持从结果集中自动填充 javabeans。

### DBUtils 设计原则 ###

Apache Commons DBUtils的设计原则如下：

*  **小** \- DBUtils库非常小，类更少，因此易于理解和使用。
 *  **透明** \- DBUtils库在幕后没有做太多工作。它只是接受查询并执行。
 *  **Fast** − DBUtils 库类不会创建很多后台对象，并且在数据库操作执行中非常快。

## Apache Commons DBUtils - Environment Setup ##

要开始使用 DBUtils 进行开发，您应该按照下面显示的步骤设置 DBUtils 环境。我们假设您正在使用Windows平台。

### 安装 Java ###

从 [Java 官方网站][Java]安装 J2SE 开发工具包 5.0 （JDK 5.0）。

确保按如下所述设置以下环境变量 −

*  **JAVA\_HOME** − 此环境变量应指向您安装 JDK 的目录，例如.C：\\Program Files\\Java\\jdk1.5.0。
 *  **CLASSPATH** − 此环境变量应设置适当的路径，例如.C：\\Program Files\\Java\\jdk1.5.0\_20\\jre\\lib。
 *  **PATH** − 此环境变量应指向相应的 JRE bin，例如.C：\\Program Files\\Java\\jre1.5.0\_20\\bin。

您可能已经设置了这些变量，但只是为了确保这是检查方法。

*  转到控制面板，然后双击"系统"。如果您是 Windows XP 用户，则可能必须先打开"性能和维护"，然后才能看到"系统"图标。
 *  转到"高级"选项卡，然后单击"环境变量"。
 *  现在检查是否正确设置了上述所有变量。

### 安装数据库 ###

当然，您需要的最重要的事情是一个实际运行的数据库，其中包含一个可以查询和修改的表。

安装最适合您的数据库。你可以有很多选择，最常见的是 -

*  **MySQL DB：**MySQL是一个开源数据库。您可以从[MySQL官方网站][MySQL]下载它。我们建议下载完整的 Windows 安装。
    
    此外，下载并安装[MySQL管理员][MySQL 1]以及[MySQL查询浏览器][MySQL 1]。这些是基于GUI的工具，可以使您的开发更加轻松。
    
    最后，在一个方便的目录中下载并解压缩[MySQL Connector/J][MySQL Connector_J]（MySQL JDBC驱动程序）。出于本教程的目的，我们将假设您已经在C：\\Program Files\\MySQL\\mysql-connector-java-5.1.8中安装了驱动程序。
    
    因此，将 CLASSPATH 变量设置为 C：\\Program Files\\MySQL\\mysql-connector-java-5.1.8\\mysql-connector-java-5.1.8-bin.jar。您的驱动程序版本可能因安装而异。
 *  **PostgreSQL DB：**PostgreSQL是一个开源数据库。您可以从[PostgreSQL官方网站][PostgreSQL]下载它。
    
    Postgres安装包含一个基于GUI的管理工具，称为pgAdmin III。JDBC 驱动程序也包含在安装过程中。
 *  **Oracle DB** − Oracle DB 是 Oracle 销售的商业数据库。我们假设您具有安装它所需的分发介质。
    
    Oracle 安装包括一个基于 GUI 的管理工具，称为 Enterprise Manager。JDBC 驱动程序也作为安装的一部分包含在内。

### 安装数据库驱动程序 ###

最新的 JDK 包括一个 JDBC-ODBC 桥接驱动程序，该驱动程序使大多数开放数据库连接 （ODBC） 驱动程序可供使用 JDBC API 的程序员使用。

现在，大多数数据库供应商都在提供适当的JDBC驱动程序以及数据库安装。因此，您不必担心这部分。

### 设置数据库凭据 ###

在本教程中，我们将使用MySQL数据库。安装上述任何数据库时，其管理员 ID 将设置为 **root**，并提供设置以设置您选择的密码。

使用 root 标识和口令，您可以创建另一个用户标识和口令，也可以为 JDBC 应用程序使用根标识和口令。

有各种数据库操作，如数据库创建和删除，这需要管理员 ID 和密码。

对于 JDBC 教程的其余部分，我们将使用**用户名**作为 ID 和**密码**作为密码的 MySQL 数据库。

如果您没有足够的权限来创建新用户，那么可以要求数据库管理员 （DBA） 为您创建用户标识和口令。

### 创建数据库 ###

要创建 **emp** 数据库，请使用以下步骤 −

#### 步骤1 ####

打开**命令提示符**并更改为安装目录，如下所示 −

C:\>
    C:\>cd Program Files\MySQL\bin
    C:\Program Files\MySQL\bin>

**注意：****mysqld.exe**的路径可能会有所不同，具体取决于MySQL在系统上的安装位置。您还可以查看有关如何启动和停止数据库服务器的文档。

#### 步骤2 ####

如果数据库服务器尚未运行，请通过执行以下命令来启动该数据库服务器。

C:\Program Files\MySQL\bin>mysqld
    C:\Program Files\MySQL\bin>

#### 第 3 步 ####

通过执行以下命令创建 **emp** 数据库 −

C:\Program Files\MySQL\bin> mysqladmin create emp -u root -p
    Enter password: ********
    C:\Program Files\MySQL\bin>

### 创建表 ###

要在 emp 数据库中创建 **Employees** 表，请使用以下步骤 −

#### 步骤1 ####

打开**命令提示符**并更改为安装目录，如下所示 −

C:\>
    C:\>cd Program Files\MySQL\bin
    C:\Program Files\MySQL\bin>

#### 第 2 步 ####

按如下方式登录到数据库 −

C:\Program Files\MySQL\bin>mysql -u root -p
    Enter password: ********
    mysql>

#### 第 3 步 ####

创建表**员工，**如下所示 −

mysql> use emp;
    mysql> create table Employees
        -> (
        -> id int not null,
        -> age int not null,
        -> first varchar (255),
        -> last varchar (255)
        -> );
    Query OK, 0 rows affected (0.08 sec)
    mysql>

### 创建数据记录 ###

最后，您在 Employee 表中创建少量记录，如下所示 −

mysql> INSERT INTO Employees VALUES (100, 18, 'Zara', 'Ali');
    Query OK, 1 row affected (0.05 sec)
    
    mysql> INSERT INTO Employees VALUES (101, 25, 'Mahnaz', 'Fatma');
    Query OK, 1 row affected (0.00 sec)
    
    mysql> INSERT INTO Employees VALUES (102, 30, 'Zaid', 'Khan');
    Query OK, 1 row affected (0.00 sec)
    
    mysql> INSERT INTO Employees VALUES (103, 28, 'Sumit', 'Mittal');
    Query OK, 1 row affected (0.00 sec)
    
    mysql>

要全面了解MySQL数据库，请学习[MySQL教程][MySQL 2]。

### 下载共享资源 DBUtils 档案 ###

从 [commons-dbutils-1.7-bin.zip][]， MySql connector [mysql-connector-java-5.1.28-bin.jar][] ， Apache Commons DBCP [commons-dbcp2-2.1.1-bin.zip][]， Apache Commons Pool [commons-pool2-2.4.3-bin.zip][] 和 ， Apache Commons Logging [commons-logging-1.2-bin.zip][] 下载最新版本的 Apache Common DBUtils jar 文件。在编写本教程时，我们已经下载了*commons-dbutils-1.7-bin.zip*，*mysql-connector-java-5.1.28-bin.jar*，*commons-dbcp2-2.1.1-bin.zip*，*commons-pool2-2.4.3-bin.zip*，*commons-logging-1.2-bin.zip*并将其复制到C：\\>Apache文件夹中。

<table> 
 <tbody> 
  <tr> 
   <th>操作系统</th> 
   <th>存档名称</th> 
  </tr> 
  <tr> 
   <td>窗户</td> 
   <td>commons-dbutils-1.7-bin.zip</td> 
  </tr> 
  <tr> 
   <td>Linux</td> 
   <td>commons-dbutils-1.7-bin.tar.gz</td> 
  </tr> 
  <tr> 
   <td>苹果电脑</td> 
   <td>commons-dbutils-1.7-bin.tar.gz</td> 
  </tr> 
 </tbody> 
</table>

### Set Apache Common DBUtils Environment ###

将**APACHE\_HOME**环境变量设置为指向计算机上存储 Apache jar 的基目录位置。假设我们已经在各种操作系统的Apache文件夹中提取了commons-dbutils-1.7-bin.zip，如下所示。

<table> 
 <tbody> 
  <tr> 
   <th>操作系统</th> 
   <th>输出</th> 
  </tr> 
  <tr> 
   <td>窗户</td> 
   <td>将环境变量APACHE_HOME设置为 C：\Apache</td> 
  </tr> 
  <tr> 
   <td>Linux</td> 
   <td>导出APACHE_HOME=/usr/local/Apache</td> 
  </tr> 
  <tr> 
   <td>苹果电脑</td> 
   <td>导出APACHE_HOME=/库/Apache</td> 
  </tr> 
 </tbody> 
</table>

### 设置类路径变量 ###

将 **CLASSPATH** 环境变量设置为指向 Common IO jar 位置。假设您已将 commons-dbutils-1.7-bin.zip存储在各种操作系统上的 Apache 文件夹中，如下所示。

<table> 
 <tbody> 
  <tr> 
   <th>操作系统</th> 
   <th>输出</th> 
  </tr> 
  <tr> 
   <td>窗户</td> 
   <td>将环境变量 CLASSPATH 设置为 %CLASSPATH%;%APACHE_HOME%\commons-dbutils-1.7.jar;mysql-connector-java-5.1.28.jar;commons-dbcp2-2.1.1.jar;commons-pool2-2.4.3.jar;commons-logging-1.2.jar;</td> 
  </tr> 
  <tr> 
   <td>Linux</td> 
   <td>export CLASSPATH=$CLASSPATH：$APACHE_HOME/commons-dbutils-1.7.jar：mysql-connector-java-5.1.28.jar：commons-dbcp2-2.1.1：commons-pool2-2.4.3.jar：commons-logging-1.2.jar.</td> 
  </tr> 
  <tr> 
   <td>苹果电脑</td> 
   <td>export CLASSPATH=$CLASSPATH：$APACHE_HOME/commons-dbutils-1.7.jar：mysql-connector-java-5.1.28：commons-dbcp2-2.1.1.jar：commons-pool2-2.4.3.jar;commons-logging-1.2.jar.</td> 
  </tr> 
 </tbody> 
</table>

现在，您已准备好开始试验 DBUtils。下一章将为您提供有关 DBUtils 编程的示例。

## Apache Commons DBUtils - First Application ##

本章提供了一个如何使用 DBUtils 库创建简单 JDBC 应用程序的示例。这将向您展示如何打开数据库连接、执行 SQL 查询以及显示结果。

此模板示例中提到的所有步骤将在本教程的后续章节中进行说明。

### 创建 JDBC 应用程序 ###

构建 JDBC 应用程序涉及以下六个步骤 ：

*  **导入包** − 要求您包含包含数据库编程所需的 JDBC 类的包。大多数情况下，使用**导入 java.sql.\*** 就足够了。
 *  **注册 JDBC 驱动程序** − 要求您初始化驱动程序，以便可以打开与数据库的通信通道。
 *  **打开连接** − 需要使用 **DriverManager.getConnection（）** 方法来创建一个 Connection 对象，该对象表示与数据库的物理连接。
 *  **执行查询** − 需要使用语句类型的对象来生成 SQL 语句并将其提交到数据库。
 *  **从结果集中提取数据** − 要求使用适当的 **ResultSet.getXXX（）** 方法从结果集中检索数据。
 *  **清理环境** − 需要显式关闭所有数据库资源，而不是依赖于 JVM 的垃圾回收。

### 示例代码 ###

当您将来需要创建自己的 JDBC 应用程序时，此示例示例可以用作模板。

此示例代码是根据上一章中完成的环境和数据库设置编写的。

在 MainApp 中复制并粘贴以下示例.java、编译和运行，如下所示 −

**主应用.java**

import java.sql.Connection;
    import java.sql.DriverManager;
    import java.sql.SQLException;
    
    import org.apache.commons.dbutils.DbUtils;
    import org.apache.commons.dbutils.QueryRunner;
    import org.apache.commons.dbutils.ResultSetHandler;
    import org.apache.commons.dbutils.handlers.BeanHandler;
    
    public class MainApp {
       // JDBC driver name and database URL
       static final String JDBC_DRIVER = "com.mysql.jdbc.Driver";
       static final String DB_URL = "jdbc:mysql://localhost:3306/emp";
       
       // Database credentials
       static final String USER = "root";
       static final String PASS = "admin";
       
       public static void main(String[] args) throws SQLException {
          Connection conn = null;
          QueryRunner queryRunner = new QueryRunner();
          
          //Step 1: Register JDBC driver
          DbUtils.loadDriver(JDBC_DRIVER);
    
          //Step 2: Open a connection
          System.out.println("Connecting to database...");
          conn = DriverManager.getConnection(DB_URL, USER, PASS);
          
          //Step 3: Create a ResultSet Handler to handle Employee Beans
          ResultSetHandler<Employee> resultHandler = new BeanHandler<Employee>(Employee.class);
          
          try {
             Employee emp = queryRunner.query(conn,
                "SELECT * FROM employees WHERE first=?", resultHandler, "Sumit");
             //Display values
             System.out.print("ID: " + emp.getId());
             System.out.print(", Age: " + emp.getAge());
             System.out.print(", First: " + emp.getFirst());
             System.out.println(", Last: " + emp.getLast());
          } finally {
             DbUtils.close(conn);
          }
       }
    }

**员工.java**

该程序如下所示 -

public class Employee {
       private int id;
       private int age;
       private String first;
       private String last;
       public int getId() {
          return id;
       }
       public void setId(int id) {
          this.id = id;
       }
       public int getAge() {
          return age;
       }
       public void setAge(int age) {
          this.age = age;
       }
       public String getFirst() {
          return first;
       }
       public void setFirst(String first) {
          this.first = first;
       }
       public String getLast() {
          return last;
       }
       public void setLast(String last) {
          this.last = last;
       }
    }

现在，让我们编译上面的例子，如下所示 ：

C:\>javac MainApp.java Employee.java
    C:\>

当您运行 **MainApp 时**，它会产生以下结果 −

C:\>java MainApp
    Connecting to database...
    ID: 103, Age: 28, First: Sumit, Last: Mittal
    C:\>

## Apache Commons DBUtils - Create Query ##

下面的示例将演示如何在 DBUtils 的帮助下使用 Insert 查询创建记录。我们将在"员工表"中插入一条记录。

### 语法 ###

下面给出了创建查询的语法 −

String insertQuery ="INSERT INTO employees(id,age,first,last) VALUES (?,?,?,?)";
    int insertedRecords = queryRunner.update(conn, insertQuery,104,30, "Sohan","Kumar");

哪里

*  **insertQuery** − 插入具有占位符的查询。
 *  **queryRunner** − QueryRunner 对象，用于在数据库中插入员工对象。

为了理解上述与 DBUtils 相关的概念，让我们编写一个将运行插入查询的示例。为了编写我们的示例，让我们创建一个示例应用程序。

<table> 
 <tbody> 
  <tr> 
   <th>步</th> 
   <th>描述</th> 
  </tr> 
  <tr> 
   <td>1</td> 
   <td>更新在<a href="https://www.tutorialspoint.com/dbutils/dbutils_first_application.htm" title="&quot;DBUtils - 第一个应用程序&quot;一" rel="nofollow">"DBUtils - 第一个应用程序"一</a>章下创建的文件&nbsp;<em>MainApp.java</em>。</td> 
  </tr> 
  <tr> 
   <td>2</td> 
   <td>编译并运行应用程序，如下所述。</td> 
  </tr> 
 </tbody> 
</table>

以下是**员工.java**的内容。

以下是 **MainApp.java** 文件的内容。

import java.sql.Connection;
    import java.sql.DriverManager;
    import java.sql.SQLException;
    
    import org.apache.commons.dbutils.DbUtils;
    import org.apache.commons.dbutils.QueryRunner;
    
    public class MainApp {
       // JDBC driver name and database URL
       static final String JDBC_DRIVER = "com.mysql.jdbc.Driver";
       static final String DB_URL = "jdbc:mysql://localhost:3306/emp";
       
       // Database credentials
       static final String USER = "root";
       static final String PASS = "admin";
       public static void main(String[] args) throws SQLException {
          Connection conn = null;
          QueryRunner queryRunner = new QueryRunner();
          DbUtils.loadDriver(JDBC_DRIVER);
          conn = DriverManager.getConnection(DB_URL, USER, PASS);
          try {
             int insertedRecords = queryRunner.update(conn,
                "INSERT INTO employees(id,age,first,last) VALUES (?,?,?,?)",
                104,30, "Sohan","Kumar");
             System.out.println(insertedRecords + " record(s) inserted");
          } finally {
             DbUtils.close(conn);
          }
       }
    }

创建完源文件后，让我们运行该应用程序。如果您的应用程序一切正常，它将打印以下消息 -

1 record(s) inserted.

## Apache Commons DBUtils - Read Query ##

下面的示例将演示如何在 DBUtils 的帮助下使用读取查询读取记录。我们将从员工表中读取记录。

### 语法 ###

读取查询的语法如下所述 −

ResultSetHandler<Employee> resultHandler = new BeanHandler<Employee>(Employee.class);
    Employee emp = queryRunner.query(conn, "SELECT * FROM employees WHERE first=?", resultHandler, "Sumit");

哪里

*  **resultHandler** − ResultSetHandler 对象，用于将结果集映射到 Employee 对象。
 *  **queryRunner** − QueryRunner 对象，用于从数据库中读取员工对象。

为了理解上面提到的与DBUtils相关的概念，让我们编写一个将运行读取查询的示例。为了编写我们的示例，让我们创建一个示例应用程序。

以下是**员工.java**的内容。

以下是 **MainApp.java** 文件的内容。

import java.sql.Connection;
    import java.sql.DriverManager;
    import java.sql.SQLException;
    
    import org.apache.commons.dbutils.DbUtils;
    import org.apache.commons.dbutils.QueryRunner;
    import org.apache.commons.dbutils.ResultSetHandler;
    import org.apache.commons.dbutils.handlers.BeanHandler;
    
    public class MainApp {
       // JDBC driver name and database URL
       static final String JDBC_DRIVER = "com.mysql.jdbc.Driver";
       static final String DB_URL = "jdbc:mysql://localhost:3306/emp";
    
       // Database credentials
       static final String USER = "root";
       static final String PASS = "admin";
    
       public static void main(String[] args) throws SQLException {
          Connection conn = null;
          QueryRunner queryRunner = new QueryRunner();
          //Step 1: Register JDBC driver
          DbUtils.loadDriver(JDBC_DRIVER);
    
          //Step 2: Open a connection
          System.out.println("Connecting to database...");
          conn = DriverManager.getConnection(DB_URL, USER, PASS);
          
          //Step 3: Create a ResultSet Handler to handle Employee Beans
          ResultSetHandler<Employee> resultHandler =
             new BeanHandler<Employee>(Employee.class);
          try {
             Employee emp = queryRunner.query(conn,
                "SELECT * FROM employees WHERE id=?", resultHandler, 104);
             //Display values
             System.out.print("ID: " + emp.getId());
             System.out.print(", Age: " + emp.getAge());
             System.out.print(", First: " + emp.getFirst());
             System.out.println(", Last: " + emp.getLast());
          } finally {
             DbUtils.close(conn);
          }
       }
    }

创建完源文件后，让我们运行该应用程序。如果应用程序一切正常，它将打印以下消息：

ID: 104, Age: 30, First: Sohan, Last: Kumar

## Apache Commons DBUtils - Update Query ##

下面的示例将演示如何在 DBUtils 的帮助下使用更新查询更新记录。我们将更新"员工表"中的记录。

### 语法 ###

更新查询的语法如下 ：

String updateQuery = "UPDATE employees SET age=? WHERE id=?";
    int updatedRecords = queryRunner.update(conn, updateQuery, 33,104);

哪里

*  **updateQuery** − 更新具有占位符的查询。
 *  **queryRunner** − QueryRunner 对象，用于更新数据库中的员工对象。

为了理解上面提到的与DBUtils相关的概念，让我们写一个将运行更新查询的示例。为了编写我们的示例，让我们创建一个示例应用程序。

以下是**员工.java**的内容。

以下是 **MainApp.java** 文件的内容。

import java.sql.Connection;
    import java.sql.DriverManager;
    import java.sql.SQLException;
    
    import org.apache.commons.dbutils.DbUtils;
    import org.apache.commons.dbutils.QueryRunner;
    
    public class MainApp {
       // JDBC driver name and database URL
       static final String JDBC_DRIVER = "com.mysql.jdbc.Driver";
       static final String DB_URL = "jdbc:mysql://localhost:3306/emp";
    
       // Database credentials
       static final String USER = "root";
       static final String PASS = "admin";
       public static void main(String[] args) throws SQLException {
          Connection conn = null;
          QueryRunner queryRunner = new QueryRunner();
          DbUtils.loadDriver(JDBC_DRIVER);
          conn = DriverManager.getConnection(DB_URL, USER, PASS);
          try {
             int updatedRecords = queryRunner.update(conn,
                "UPDATE employees SET age=? WHERE id=?", 33,104);
             System.out.println(updatedRecords + " record(s) updated.");
          } finally {
             DbUtils.close(conn);
          }
       }
    }

创建完源文件后，让我们运行该应用程序。如果您的应用程序一切正常，它将打印以下消息 -

1 record(s) updated.

## Apache Commons DBUtils - Delete Query ##

下面的示例将演示如何在 DBUtils 的帮助下使用"删除"查询删除记录。我们将删除"员工表"中的记录。

### 语法 ###

删除查询的语法如下所述 −

String deleteQuery = "DELETE FROM employees WHERE id=?";
    int deletedRecords = queryRunner.delete(conn, deleteQuery, 33,104);

哪里

*  **deleteQuery** − DELETE 具有占位符的查询。
 *  **queryRunner** − QueryRunner 对象，用于删除数据库中的员工对象。

为了理解上述与DBUtils相关的概念，让我们编写一个示例来运行删除查询。为了编写我们的示例，让我们创建一个示例应用程序。

以下是**员工.java**的内容。

以下是 **MainApp.java** 文件的内容。

import java.sql.Connection;
    import java.sql.DriverManager;
    import java.sql.SQLException;
    
    import org.apache.commons.dbutils.DbUtils;
    import org.apache.commons.dbutils.QueryRunner;
    
    public class MainApp {
       // JDBC driver name and database URL
       static final String JDBC_DRIVER = "com.mysql.jdbc.Driver";
       static final String DB_URL = "jdbc:mysql://localhost:3306/emp";
    
       // Database credentials
       static final String USER = "root";
       static final String PASS = "admin";
    
       public static void main(String[] args) throws SQLException {
          Connection conn = null;
          QueryRunner queryRunner = new QueryRunner();
          DbUtils.loadDriver(JDBC_DRIVER);
          conn = DriverManager.getConnection(DB_URL, USER, PASS);
          try {
             int deletedRecords = queryRunner.update(conn,
                "DELETE from employees WHERE id=?", 104);
             System.out.println(deletedRecords + " record(s) deleted.");
          } finally {
             DbUtils.close(conn);
          }
       }
    }

创建完源文件后，让我们运行该应用程序。如果您的应用程序一切正常，它将打印以下消息 -

1 record(s) deleted.

## 查询运行器接口 ##

**org.apache.commons.dbutils.QueryRunner** 类是 DBUtils 库中的中心类。它使用用于处理 ResultSet 的可插入策略执行 SQL 查询。此类是线程安全的。

### 类声明 ###

以下是 org.apache.commons.dbutils.QueryRunner class − 的声明

public class QueryRunner
       extends AbstractQueryRunner

### 用法 ###

*  **步骤 1** − 创建连接对象。
 *  **步骤 2** − 使用 QueryRunner 对象方法来进行数据库操作。

### 例 ###

下面的示例将演示如何使用 QueryRunner 类读取记录。我们将读取员工表中的一个可用记录。

### 语法 ###

ResultSetHandler<Employee> resultHandler = new BeanHandler<Employee>(Employee.class);
    Employee emp = 
       queryRunner.query(conn, "SELECT * FROM employees WHERE first=?", resultHandler, "Sumit");

哪里

*  **resultHandler** − ResultSetHandler 对象，用于将结果集映射到 Employee 对象。
 *  **queryRunner** − QueryRunner 对象，用于从数据库中读取员工对象。

为了理解上述与DBUtils相关的概念，让我们编写一个将运行读取查询的示例。为了编写我们的示例，让我们创建一个示例应用程序。

以下是**员工.java**的内容。

以下是 **MainApp.java** 文件的内容。

import java.sql.Connection;
    import java.sql.DriverManager;
    import java.sql.SQLException;
    
    import org.apache.commons.dbutils.DbUtils;
    import org.apache.commons.dbutils.QueryRunner;
    import org.apache.commons.dbutils.ResultSetHandler;
    import org.apache.commons.dbutils.handlers.BeanHandler;
    
    public class MainApp {
       // JDBC driver name and database URL
       static final String JDBC_DRIVER = "com.mysql.jdbc.Driver";  
       static final String DB_URL = "jdbc:mysql://localhost:3306/emp";
    
       //  Database credentials
       static final String USER = "root";
       static final String PASS = "admin";
    
       public static void main(String[] args) throws SQLException {
          Connection conn = null;
          QueryRunner queryRunner = new QueryRunner();
          
          //Step 1: Register JDBC driver
          DbUtils.loadDriver(JDBC_DRIVER);
    
          //Step 2: Open a connection
          System.out.println("Connecting to database...");
          conn = DriverManager.getConnection(DB_URL, USER, PASS);
    
          //Step 3: Create a ResultSet Handler to handle Employee Beans
          ResultSetHandler<Employee> resultHandler = new BeanHandler<Employee>(Employee.class);
    
          try {
             Employee emp = queryRunner.query(conn,
                "SELECT * FROM employees WHERE id=?", resultHandler, 103);
             //Display values
             System.out.print("ID: " + emp.getId());
             System.out.print(", Age: " + emp.getAge());
             System.out.print(", First: " + emp.getFirst());
             System.out.println(", Last: " + emp.getLast());
          } finally {
             DbUtils.close(conn);
          }        
       }
    }

创建完源文件后，让我们运行该应用程序。如果应用程序一切正常，它将打印以下消息。

ID: 103, Age: 28, First: Sumit, Last: Mittal

## 异步查询Runner 接口 ##

**org.apache.commons.dbutils.AsyncQueryRunner** 类有助于使用异步支持执行长时间运行的 SQL 查询。此类是线程安全的。此类支持与 QueryRunner 相同的方法，但它返回可调用对象，以后可以使用这些对象来检索结果。

### 类声明 ###

以下是 org.apache.commons.dbutils.AsyncQueryRunner class 的声明 −

public class AsyncQueryRunner
       extends AbstractQueryRunner

### 用法 ###

*  **步骤 1** − 创建连接对象。
 *  **步骤 2** − 使用 AsyncQueryRunner 对象方法来进行数据库操作。

### 例 ###

下面的示例将演示如何使用 AsyncQueryRunner 类更新记录。我们将更新员工表中的一个可用记录。

### 语法 ###

String updateQuery = "UPDATE employees SET age=? WHERE id=?";
    future = asyncQueryRunner.update(conn,
                "UPDATE employees SET age=? WHERE id=?", 33,103);

哪里

*  **updateQuery** − 更新具有占位符的查询。
 *  **asyncQueryRunner** − asyncQueryRunner 对象，用于更新数据库中的员工对象。
 *  **future** − 将来对象，用于稍后检索结果。

为了理解上述与 DBUtils 相关的概念，让我们编写一个示例，该示例将在异步模式下运行更新查询。为了编写我们的示例，让我们创建一个示例应用程序。

以下是**员工.java**的内容。

以下是 **MainApp.java** 文件的内容。

import java.sql.Connection;
    import java.sql.DriverManager;
    import java.sql.SQLException;
    
    import org.apache.commons.dbutils.AsyncQueryRunner;
    import org.apache.commons.dbutils.DbUtils;
    import org.apache.commons.dbutils.QueryRunner;
    
    import java.util.concurrent.Callable;
    import java.util.concurrent.ExecutionException; 
    import java.util.concurrent.ExecutorCompletionService; 
    import java.util.concurrent.ExecutorService;
    import java.util.concurrent.Executors; 
    import java.util.concurrent.Future;
    import java.util.concurrent.TimeUnit;
    import java.util.concurrent.TimeoutException;
    
    public class MainApp {
       // JDBC driver name and database URL
       static final String JDBC_DRIVER = "com.mysql.jdbc.Driver";  
       static final String DB_URL = "jdbc:mysql://localhost:3306/emp";
    
       //  Database credentials
       static final String USER = "root";
       static final String PASS = "admin";
    
       public static void main(String[] args) throws 
          SQLException, InterruptedException, 
          ExecutionException, TimeoutException {
          Connection conn = null;
    
          AsyncQueryRunner asyncQueryRunner = new AsyncQueryRunner( Executors.newCachedThreadPool());
    
          DbUtils.loadDriver(JDBC_DRIVER);       
          conn = DriverManager.getConnection(DB_URL, USER, PASS);
          Future<Integer> future = null;
          try {
             future = asyncQueryRunner.update(conn, 
                "UPDATE employees SET age=? WHERE id=?", 33,103);         
             Integer updatedRecords = future.get(10, TimeUnit.SECONDS);
             System.out.println(updatedRecords + " record(s) updated.");
          } finally {
             DbUtils.close(conn);
          }  
       }
    }

创建完源文件后，让我们运行该应用程序。如果应用程序一切正常，它将打印以下消息。

1 record(s) updated.

## 结果集处理程序接口 ##

**org.apache.commons.dbutils.ResultSetHandler** 接口负责将 ResultSet 转换为对象。

### 类声明 ###

以下是 org.apache.commons.dbutils.ResultSetHandler class 的声明 −

public interface ResultSetHandler<T>

### 用法 ###

*  **步骤 1** − 创建连接对象。
 *  **步骤 2** − 创建 ResultSetHandler 的实现。
 *  **步骤 3** − 将 resultSetHandler 传递给 QueryRunner 对象，并进行数据库操作。

### 例 ###

下面的示例将演示如何使用 ResultSetHandler 类映射记录。我们将阅读"员工表"中的一条可用记录。

### 语法 ###

Employee emp = queryRunner.query(conn, "SELECT * FROM employees WHERE first=?", resultHandler, "Sumit");

哪里

*  **resultHandler** − ResultSetHandler 对象，用于将结果集映射到 Employee 对象。
 *  **queryRunner** − QueryRunner 对象，用于从数据库中读取员工对象。

为了理解上述与DBUtils相关的概念，让我们编写一个将运行读取查询的示例。为了编写我们的示例，让我们创建一个示例应用程序。

以下是**员工.java**的内容。

以下是 **MainApp.java** 文件的内容。

import java.sql.Connection;
    import java.sql.DriverManager;
    import java.sql.SQLException;
    import java.sql.ResultSet;
    import java.sql.ResultSetMetaData;
    import java.util.Arrays;
    
    import org.apache.commons.dbutils.DbUtils;
    import org.apache.commons.dbutils.QueryRunner;
    import org.apache.commons.dbutils.ResultSetHandler;
    
    public class MainApp {
       // JDBC driver name and database URL
       static final String JDBC_DRIVER = "com.mysql.jdbc.Driver";  
       static final String DB_URL = "jdbc:mysql://localhost:3306/emp";
    
       //  Database credentials
       static final String USER = "root";
       static final String PASS = "admin";
    
       public static void main(String[] args) throws SQLException {
          Connection conn = null;
          QueryRunner queryRunner = new QueryRunner();
          
          //Step 1: Register JDBC driver
          DbUtils.loadDriver(JDBC_DRIVER);
    
          //Step 2: Open a connection
          System.out.println("Connecting to database...");
          conn = DriverManager.getConnection(DB_URL, USER, PASS);
    
          //Step 3: Create a ResultSet Handler to handle Employee Beans
          ResultSetHandler<Object[]> handler = new ResultSetHandler<Object[]>() {
             public Object[] handle(ResultSet rs) throws SQLException {
                if (!rs.next()) {
                   return null;
                }
                ResultSetMetaData meta = rs.getMetaData();
                int cols = meta.getColumnCount();
                Object[] result = new Object[cols];
    
                for (int i = 0; i < cols; i++) {
                   result[i] = rs.getObject(i + 1);
                }
                return result;
             }
          };
    
          try {
             Object[] result  = queryRunner.query(conn, "SELECT * FROM employees WHERE id=?",
                handler, 103);
             //Display values
             System.out.print("Result: " + Arrays.toString(result));            
          } finally {
             DbUtils.close(conn);
          }              
       }
    }

创建完源文件后，让我们运行该应用程序。如果应用程序一切正常，它将打印以下消息。

Connecting to database...
    Result: [103, 33, Sumit, Mittal]

## Apache Commons DBUtils - BeanHandler Class ##

**org.apache.commons.dbutils.BeanHandler** 是 ResultSetHandler 接口的实现，负责将第一个 ResultSet 行转换为 JavaBean。此类是线程安全的。

### 类声明 ###

以下是 org.apache.commons.dbutils.BeanHandler 类的声明 −

public class BeanHandler<T>
       extends Object implements ResultSetHandler<T>

### 用法 ###

*  **步骤 1** − 创建连接对象。
 *  **步骤 2** − 将 ResultSetHandler 实现为 BeanHandler 对象。
 *  **步骤 3** − 将 resultSetHandler 传递给 QueryRunner 对象，并进行数据库操作。

### 例 ###

下面的示例将演示如何使用 BeanHandler 类读取记录。我们将读取"员工表"中的一个可用记录，并将其映射到"员工 bean"。

### 语法 ###

Employee emp = queryRunner.query(conn, "SELECT * FROM employees WHERE first=?", resultHandler, "Sumit");

哪里

*  **resultHandler** − BeanHandler 对象，用于将结果集映射到 Employee 对象。
 *  **queryRunner** − QueryRunner 对象，用于从数据库中读取员工对象。

为了理解上述与DBUtils相关的概念，让我们编写一个将运行读取查询的示例。为了编写我们的示例，让我们创建一个示例应用程序。

以下是**员工.java**的内容。

以下是 **MainApp.java** 文件的内容。

import java.sql.Connection;
    import java.sql.DriverManager;
    import java.sql.SQLException;
    
    import org.apache.commons.dbutils.DbUtils;
    import org.apache.commons.dbutils.QueryRunner;
    import org.apache.commons.dbutils.ResultSetHandler;
    import org.apache.commons.dbutils.handlers.BeanHandler;
    
    public class MainApp {
       // JDBC driver name and database URL
       static final String JDBC_DRIVER = "com.mysql.jdbc.Driver";  
       static final String DB_URL = "jdbc:mysql://localhost:3306/emp";
    
       //  Database credentials
       static final String USER = "root";
       static final String PASS = "admin";
    
       public static void main(String[] args) throws SQLException {
          Connection conn = null;
          QueryRunner queryRunner = new QueryRunner();
          
          //Step 1: Register JDBC driver
          DbUtils.loadDriver(JDBC_DRIVER);
    
          //Step 2: Open a connection
          System.out.println("Connecting to database...");
          conn = DriverManager.getConnection(DB_URL, USER, PASS);
    
          //Step 3: Create a ResultSet Handler to handle Employee Beans
          ResultSetHandler<Employee> resultHandler 
             = new BeanHandler<Employee>(Employee.class);
    
          try {
             Employee emp = queryRunner.query(conn,
                "SELECT * FROM employees WHERE first=?", resultHandler, "Sumit");
             //Display values
             System.out.print("ID: " + emp.getId());
             System.out.print(", Age: " + emp.getAge());
             System.out.print(", First: " + emp.getFirst());
             System.out.println(", Last: " + emp.getLast());
          } finally {
             DbUtils.close(conn);
          }              
       }
    }

创建完源文件后，让我们运行该应用程序。如果应用程序一切正常，它将打印以下消息。

ID: 103, Age: 28, First: Sumit, Last: Mittal

## BeanListHandler Class ##

**org.apache.commons.dbutils.BeanListHandler** 是 ResultSetHandler 接口的实现，负责将 ResultSet 行转换为 Java Bean 的列表。此类是线程安全的。

### 类声明 ###

以下是 org.apache.commons.dbutils.BeanListHandler 类的声明 −

public class BeanListHandler<T>
       extends Object implements ResultSetHandler<List<T>>

### 用法 ###

*  **步骤 1** − 创建连接对象。
 *  **步骤 2** − 将 ResultSetHandler 实现为 BeanListHandler 对象。
 *  **步骤 3** − 将 resultSetHandler 传递给 QueryRunner 对象，并进行数据库操作。

### 例 ###

下面的示例将演示如何使用 BeanListHandler 类读取记录列表。我们将读取"员工表"中的可用记录，并将其映射到"员工 Bean"列表。

### 语法 ###

List<Employee> empList = queryRunner.query(conn, "SELECT * FROM employees", resultHandler);

哪里

*  **resultHandler** − BeanListHandler 对象，用于将结果集映射到 Employee 对象列表。
 *  **queryRunner** − QueryRunner 对象，用于从数据库中读取员工对象。

为了理解上述与DBUtils相关的概念，让我们编写一个将运行读取查询的示例。为了编写我们的示例，让我们创建一个示例应用程序。

以下是**员工.java**的内容。

以下是 **MainApp.java** 文件的内容。

import java.sql.Connection;
    import java.sql.DriverManager;
    import java.sql.SQLException;
    import java.util.List;
    
    import org.apache.commons.dbutils.DbUtils;
    import org.apache.commons.dbutils.QueryRunner;
    import org.apache.commons.dbutils.ResultSetHandler;
    import org.apache.commons.dbutils.handlers.BeanListHandler;
    
    public class MainApp {
       // JDBC driver name and database URL
       static final String JDBC_DRIVER = "com.mysql.jdbc.Driver";  
       static final String DB_URL = "jdbc:mysql://localhost:3306/emp";
    
       //  Database credentials
       static final String USER = "root";
       static final String PASS = "admin";
    
       public static void main(String[] args) throws SQLException {
          Connection conn = null;
          QueryRunner queryRunner = new QueryRunner();
          
          //Step 1: Register JDBC driver
          DbUtils.loadDriver(JDBC_DRIVER);
    
          //Step 2: Open a connection
          System.out.println("Connecting to database...");
          conn = DriverManager.getConnection(DB_URL, USER, PASS);
    
          //Step 3: Create a ResultSet Handler to handle List of Employee Beans
          ResultSetHandler<List<Employee>> resultHandler = new BeanListHandler<Employee>(Employee.class);
    
          try {
             List<Employee> empList = queryRunner.query(conn, "SELECT * FROM employees", resultHandler);
             for(Employee emp: empList ) {
                //Display values
                System.out.print("ID: " + emp.getId());
                System.out.print(", Age: " + emp.getAge());
                System.out.print(", First: " + emp.getFirst());
                System.out.println(", Last: " + emp.getLast());
             }           
          } finally {
             DbUtils.close(conn);
          }        
       }
    }

创建完源文件后，让我们运行该应用程序。如果应用程序一切正常，它将打印以下消息。

ID: 100, Age: 18, First: Zara, Last: Ali
    ID: 101, Age: 25, First: Mahnaz, Last: Fatma
    ID: 102, Age: 30, First: Zaid, Last: Khan
    ID: 103, Age: 28, First: Sumit, Last: Mittal

## ArrayListHandler Class ##

**org.apache.commons.dbutils.ArrayListHandler** 是 ResultSetHandler 接口的实现，负责将 ResultSet 行转换为对象 \[\]。此类是线程安全的。

### 类声明 ###

以下是 org.apache.commons.dbutils.ArrayListHandler class 的声明 −

public class ArrayListHandler
       extends AbstractListHandler<Object[]>

### 用法 ###

*  **步骤 1** − 创建连接对象。
 *  **步骤 2** − 将 ResultSetHandler 实现为 ArrayListHandler 对象。
 *  **步骤 3** − 将 resultSetHandler 传递给 QueryRunner 对象，并进行数据库操作。

### 例 ###

下面的示例将演示如何使用 ArrayListHandler 类读取记录列表。我们将员工表中的可用记录作为对象\[\]读取。

### 语法 ###

List<Object> result = queryRunner.query(conn, "SELECT * FROM employees", new ArrayListHandler());

哪里

*  **resultHandler** − ArrayListHandler 对象，用于将结果集映射到对象列表\[\]。
 *  **queryRunner** − QueryRunner 对象，用于从数据库中读取员工对象。

为了理解上述与DBUtils相关的概念，让我们编写一个将运行读取查询的示例。为了编写我们的示例，让我们创建一个示例应用程序。

以下是**员工.java**的内容。

以下是 **MainApp.java** 文件的内容。

import java.sql.Connection;
    import java.sql.DriverManager;
    import java.sql.SQLException;
    import java.util.Arrays;
    import java.util.List;
    
    import org.apache.commons.dbutils.DbUtils;
    import org.apache.commons.dbutils.QueryRunner;
    import org.apache.commons.dbutils.handlers.ArrayListHandler;
    
    public class MainApp {
       // JDBC driver name and database URL
       static final String JDBC_DRIVER = "com.mysql.jdbc.Driver";  
       static final String DB_URL = "jdbc:mysql://localhost:3306/emp";
    
       //  Database credentials
       static final String USER = "root";
       static final String PASS = "admin";
    
       public static void main(String[] args) throws SQLException {
          Connection conn = null;
          QueryRunner queryRunner = new QueryRunner();
          
          //Step 1: Register JDBC driver
          DbUtils.loadDriver(JDBC_DRIVER);
    
          //Step 2: Open a connection
          System.out.println("Connecting to database...");
          conn = DriverManager.getConnection(DB_URL, USER, PASS);        
    
          try {
             List<Object[]> result = queryRunner.query(conn, "SELECT * FROM employees"
                , new ArrayListHandler());  
             for(Object[] objects : result) {
                System.out.println(Arrays.toString(objects));
             }           
          } finally {
             DbUtils.close(conn);
          }        
       }
    }

Once you are done creating the source files, let us run the application. If everything is fine with your application, it will print the following message.

[100, 18, Zara, Ali]
    [101, 25, Mahnaz, Fatma]
    [102, 30, Zaid, Khan]
    [103, 28, Sumit, Mittal]

## MapListHandler Class ##

**org.apache.commons.dbutils.MapListHandler** 是 ResultSetHandler 接口的实现，负责将 ResultSet 行转换为 Maps 列表。此类是线程安全的。

### 类声明 ###

以下是 org.apache.commons.dbutils.MapListHandler class 的声明 −

public class MapListHandler
       extends AbstractListHandler<Map<String,Object>>

### 用法 ###

*  **步骤 1** − 创建连接对象。
 *  **步骤 2** − 将 ResultSetHandler 实现为 MapListHandler 对象。
 *  **步骤 3** − 将 resultSetHandler 传递给 QueryRunner 对象，并进行数据库操作。

### 例 ###

下面的示例将演示如何使用 MapListHandler 类读取记录列表。我们将以地图列表的形式读取员工表中的可用记录。

### 语法 ###

List<Map<String, Object>> result = queryRunner.query(conn, "SELECT * FROM employees", new MapListHandler());

哪里

*  **resultHandler** − MapListHandler 对象，用于将结果集映射到映射列表。
 *  **queryRunner** − QueryRunner 对象，用于从数据库中读取员工对象。

为了理解上述与DBUtils相关的概念，让我们编写一个将运行读取查询的示例。为了编写我们的示例，让我们创建一个示例应用程序。

以下是**员工.java**的内容。

以下是 **MainApp.java** 文件的内容。

import java.sql.Connection;
    import java.sql.DriverManager;
    import java.sql.SQLException;
    import java.util.List;
    import java.util.Map;
    
    import org.apache.commons.dbutils.DbUtils;
    import org.apache.commons.dbutils.QueryRunner;
    import org.apache.commons.dbutils.handlers.MapListHandler;
    
    public class MainApp {
       // JDBC driver name and database URL
       static final String JDBC_DRIVER = "com.mysql.jdbc.Driver";  
       static final String DB_URL = "jdbc:mysql://localhost:3306/emp";
    
       //  Database credentials
       static final String USER = "root";
       static final String PASS = "admin";
    
       public static void main(String[] args) throws SQLException {
          Connection conn = null;
          QueryRunner queryRunner = new QueryRunner();
          
          //Step 1: Register JDBC driver
          DbUtils.loadDriver(JDBC_DRIVER);
    
          //Step 2: Open a connection
          System.out.println("Connecting to database...");
          conn = DriverManager.getConnection(DB_URL, USER, PASS);        
    
          try {
             List<Map<String, Object>> result = queryRunner.query(
                conn, "SELECT * FROM employees", new MapListHandler());      
             System.out.println(result);
          } finally {
             DbUtils.close(conn);
          }        
       }
    }

创建完源文件后，让我们运行该应用程序。如果应用程序一切正常，它将打印以下消息。

Connecting to database...
    [{id=100, age=18, first=Zara, last=Ali}, 
    {id=101, age=25, first=Mahnaz, last=Fatma}, 
    {id=102, age=30, first=Zaid, last=Khan}, 
    {id=103, age=33, first=Sumit, last=Mittal}]

## Apache Commons DBUtils - Custom Handler ##

我们可以通过实现 ResultSetHandler 接口或扩展 ResultSetHandler 的任何现有实现来创建自己的自定义处理程序。在下面给出的示例中，我们通过扩展 BeanHandler 类创建了一个自定义处理程序 EmployeeHandler。

为了理解上述与DBUtils相关的概念，让我们编写一个将运行读取查询的示例。为了编写我们的示例，让我们创建一个示例应用程序。

以下是**员工.java**的内容。

public class Employee {
       private int id;
       private int age;
       private String first;
       private String last;
       private String name;
       public int getId() {
          return id;
       }
       public void setId(int id) {
          this.id = id;
       }
       public int getAge() {
          return age;
       }
       public void setAge(int age) {
          this.age = age;
       }
       public String getFirst() {
          return first;
       }
       public void setFirst(String first) {
          this.first = first;
       }
       public String getLast() {
          return last;
       }
       public void setLast(String last) {
          this.last = last;
       }
       public String getName() {
          return name;
       }
       public void setName(String name) {
          this.name = name;
       }
    }

Following is the content of the **EmployeeHandler.java** file.

import java.sql.ResultSet;
    import java.sql.SQLException;
    
    import org.apache.commons.dbutils.handlers.BeanHandler;
    
    public class EmployeeHandler extends BeanHandler<Employee> {
    
       public EmployeeHandler() {
          super(Employee.class);
       }
    
       @Override
       public Employee handle(ResultSet rs) throws SQLException {
          Employee employee = super.handle(rs);
          employee.setName(employee.getFirst() +", " + employee.getLast());
          return employee;
       }
    }

Following is the content of the **MainApp.java** file.

import java.sql.Connection;
    import java.sql.DriverManager;
    import java.sql.SQLException;
    
    import org.apache.commons.dbutils.DbUtils;
    import org.apache.commons.dbutils.QueryRunner;
    import org.apache.commons.dbutils.ResultSetHandler;
    import org.apache.commons.dbutils.handlers.BeanHandler;
    
    public class MainApp {
       // JDBC driver name and database URL
       static final String JDBC_DRIVER = "com.mysql.jdbc.Driver";  
       static final String DB_URL = "jdbc:mysql://localhost:3306/emp";
    
       //  Database credentials
       static final String USER = "root";
       static final String PASS = "admin";
    
       public static void main(String[] args) throws SQLException {
          Connection conn = null;
          QueryRunner queryRunner = new QueryRunner();
          DbUtils.loadDriver(JDBC_DRIVER);                 
          conn = DriverManager.getConnection(DB_URL, USER, PASS);        
          EmployeeHandler employeeHandler = new EmployeeHandler();
    
          try {
             Employee emp = queryRunner.query(conn,
             "SELECT * FROM employees WHERE first=?", employeeHandler, "Sumit");
             
             //Display values
             System.out.print("ID: " + emp.getId());
             System.out.print(", Age: " + emp.getAge());
             System.out.print(", Name: " + emp.getName());
          } finally {
             DbUtils.close(conn);
          }        
       }
    }

创建完源文件后，让我们运行该应用程序。如果应用程序一切正常，它将打印以下消息。

ID: 103, Age: 28, Name: Sumit, Mittal

## 自定义行处理器 ##

如果数据库表中的列名和等效的javabean对象名称不相似，那么我们可以使用定制的BasicRowProcessor对象来映射它们。请参阅下面的示例。

为了理解上述与DBUtils相关的概念，让我们编写一个将运行读取查询的示例。为了编写我们的示例，让我们创建一个示例应用程序。

以下是**员工.java**的内容。

以下是 **EmployeeHandler.java** 文件的内容。

import java.sql.ResultSet;
    import java.sql.SQLException;
    import java.util.HashMap;
    import java.util.Map;
    
    import org.apache.commons.dbutils.handlers.BeanHandler;
    import org.apache.commons.dbutils.BeanProcessor;
    import org.apache.commons.dbutils.BasicRowProcessor;
    
    public class EmployeeHandler extends BeanHandler<Employee> {
    
       public EmployeeHandler() {
          super(Employee.class, new BasicRowProcessor(new BeanProcessor(mapColumnsToFields())));
       }
    
       @Override
       public Employee handle(ResultSet rs) throws SQLException {
          Employee employee = super.handle(rs);
          employee.setName(employee.getFirst() +", " + employee.getLast());
          return employee;
       }
       
       public static Map<String, String> mapColumnsToFields() {
          Map<String, String> columnsToFieldsMap = new HashMap<>();
          columnsToFieldsMap.put("ID", "id");
          columnsToFieldsMap.put("AGE", "age");        
          return columnsToFieldsMap;
       }
    }

以下是 **MainApp.java** 文件的内容。

import java.sql.Connection;
    import java.sql.DriverManager;
    import java.sql.SQLException;
    
    import org.apache.commons.dbutils.DbUtils;
    import org.apache.commons.dbutils.QueryRunner;
    
    public class MainApp {
       // JDBC driver name and database URL
       static final String JDBC_DRIVER = "com.mysql.jdbc.Driver";  
       static final String DB_URL = "jdbc:mysql://localhost:3306/emp";
    
       //  Database credentials
       static final String USER = "root";
       static final String PASS = "admin";
    
       public static void main(String[] args) throws SQLException {
          Connection conn = null;
          QueryRunner queryRunner = new QueryRunner();      
          DbUtils.loadDriver(JDBC_DRIVER);                 
          conn = DriverManager.getConnection(DB_URL, USER, PASS);        
          EmployeeHandler employeeHandler = new EmployeeHandler();
    
          try {
             Employee emp = queryRunner.query(conn,
               "SELECT * FROM employees WHERE first=?", employeeHandler, "Sumit");
             
             //Display values
             System.out.print("ID: " + emp.getId());
             System.out.print(", Age: " + emp.getAge());
             System.out.print(", Name: " + emp.getName());
          } finally {
             DbUtils.close(conn);
          }              
       }
    }

创建完源文件后，让我们运行该应用程序。如果应用程序一切正常，它将打印以下消息。

ID: 103, Age: 28, Name: Sumit, Mittal

## Apache Commons DBUtils - Using DataSource ##

到目前为止，我们在使用 QueryRunner 时使用了连接对象。我们也可以毫不费力地使用数据源。下面的示例将演示如何在 QueryRunner 和数据源的帮助下使用 Read 查询读取记录。我们将从"员工表"中读取一条记录。

### 语法 ###

QueryRunner queryRunner = new QueryRunner( dataSource );
    Employee emp = queryRunner.query("SELECT * FROM employees WHERE first=?", resultHandler, "Sumit");

哪里

*  **数据源** − 已配置数据源对象。
 *  **resultHandler** − ResultSetHandler 对象，用于将结果集映射到 Employee 对象。
 *  **queryRunner** − QueryRunner 对象，用于从数据库中读取员工对象。

为了理解上述与DBUtils相关的概念，让我们编写一个将运行读取查询的示例。为了编写我们的示例，让我们创建一个示例应用程序。

以下是**员工.java**的内容。

Following is the content of the **CustomDatasource.java**.

import javax.sql.DataSource;
    import org.apache.commons.dbcp2.BasicDataSource;
    
    public class CustomDataSource {
       // JDBC driver name and database URL
       static final String JDBC_DRIVER = "com.mysql.jdbc.Driver";  
       static final String DB_URL = "jdbc:mysql://localhost:3306/emp";
       
       //  Database credentials
       static final String USER = "root";
       static final String PASS = "admin";
       private static DataSource datasource;
       private static final BasicDataSource basicDataSource;
    
       static {
          basicDataSource = new BasicDataSource();
          basicDataSource.setDriverClassName(JDBC_DRIVER);
          basicDataSource.setUsername(USER);
          basicDataSource.setPassword(PASS);
          basicDataSource.setUrl(DB_URL);
       }
    
       public static DataSource getInstance() {
          return basicDataSource;
       }
    }

以下是 **MainApp.java** 文件的内容。

import java.sql.SQLException;
    
    import org.apache.commons.dbutils.QueryRunner;
    import org.apache.commons.dbutils.ResultSetHandler;
    import org.apache.commons.dbutils.handlers.BeanHandler;
    
    public class MainApp {
       public static void main(String[] args) throws SQLException {    
          
          DbUtils.loadDriver(JDBC_DRIVER);
          QueryRunner run = new QueryRunner(CustomDataSource.getInstance());
          ResultSetHandler<Employee> resultHandler = new BeanHandler<Employee>(Employee.class);
    
          Employee emp = queryRunner.query("SELECT * FROM employees WHERE id=?",
             resultHandler, 103);
          
          //Display values
          System.out.print("ID: " + emp.getId());
          System.out.print(", Age: " + emp.getAge());
          System.out.print(", First: " + emp.getFirst());
          System.out.println(", Last: " + emp.getLast());
       }
    }

创建完源文件后，让我们运行该应用程序。如果应用程序一切正常，它将打印以下消息。

ID: 103, Age: 33, First: Sumit, Last: Mittal

[Java]: https://java.sun.com/j2se/1.5.0/download.jsp
[MySQL]: https://dev.mysql.com/downloads/mysql
[MySQL 1]: https://dev.mysql.com/downloads/gui-tools/
[MySQL Connector_J]: https://dev.mysql.com/downloads/connector/j/3.1.html
[PostgreSQL]: https://www.postgresql.org/download/
[MySQL 2]: https://www.tutorialspoint.com/mysql/index.htm
[commons-dbutils-1.7-bin.zip]: https://commons.apache.org/proper/commons-dbutils/download_dbutils.cgi
[mysql-connector-java-5.1.28-bin.jar]: https://mvnrepository.com/artifact/mysql/mysql-connector-java
[commons-dbcp2-2.1.1-bin.zip]: https://commons.apache.org/proper/commons-dbcp/download_dbcp.cgi
[commons-pool2-2.4.3-bin.zip]: https://commons.apache.org/proper/commons-pool/download_pool.cgi
[commons-logging-1.2-bin.zip]: https://commons.apache.org/proper/commons-logging/download_logging.cgi