JDBC - 快速指南

---

---

JDBC - 简介

什么是 JDBC？

JDBC 代表 **J**ava **D**ata**b**ase **C**onnectivity，它是一个标准的 Java API，用于在 Java 编程语言和各种数据库之间建立独立于数据库的连接。

JDBC 库包含以下每个任务的 API，这些任务通常与数据库使用相关联。

• 连接到数据库。

• 创建 SQL 或 MySQL 语句。

• 在数据库中执行 SQL 或 MySQL 查询。

• 查看和修改结果记录。

从根本上说，JDBC 是一种规范，它提供了一组完整的接口，允许以可移植的方式访问底层数据库。Java 可用于编写不同类型的可执行文件，例如 -

• Java 应用程序

• Java Applet

• Java Servlet

• Java ServerPages (JSP)

• 企业 JavaBeans (EJB)。

所有这些不同的可执行文件都能够使用 JDBC 驱动程序访问数据库并利用存储的数据。

JDBC 提供与 ODBC 相同的功能，允许 Java 程序包含独立于数据库的代码。

先决条件

在继续学习之前，您需要对以下两个主题有很好的了解 -

• 核心 Java 编程

• SQL 或 MySQL 数据库

JDBC 架构

JDBC API 支持用于数据库访问的两层和三层处理模型，但通常，JDBC 架构由两层组成 -

• **JDBC API** - 提供应用程序到 JDBC 管理器的连接。

• **JDBC 驱动程序 API** - 支持 JDBC 管理器到驱动程序的连接。

JDBC API 使用驱动程序管理器和特定于数据库的驱动程序来提供对异构数据库的透明连接。

JDBC 驱动程序管理器确保使用正确的驱动程序访问每个数据源。驱动程序管理器能够支持连接到多个异构数据库的多个并发驱动程序。

以下是架构图，它显示了驱动程序管理器相对于 JDBC 驱动程序和 Java 应用程序的位置 -

常见的 JDBC 组件

JDBC API 提供以下接口和类 -

• **DriverManager** - 此类管理数据库驱动程序列表。使用通信子协议将来自 Java 应用程序的连接请求与正确的数据库驱动程序匹配。第一个识别 JDBC 下某个特定子协议的驱动程序将用于建立数据库连接。

• **Driver** - 此接口处理与数据库服务器的通信。您很少会直接与 Driver 对象交互。相反，您使用 DriverManager 对象，它管理此类型的对象。它还抽象了与使用 Driver 对象相关的细节。

• **Connection** - 此接口包含所有用于联系数据库的方法。连接对象表示通信上下文，即所有与数据库的通信都仅通过连接对象进行。

• **Statement** - 您使用从此接口创建的对象将 SQL 语句提交到数据库。一些派生接口除了执行存储过程外还接受参数。

• **ResultSet** - 这些对象在使用 Statement 对象执行 SQL 查询后保存从数据库检索到的数据。它充当迭代器，允许您遍历其数据。

• **SQLException** - 此类处理数据库应用程序中发生的任何错误。

JDBC 4.0 包

java.sql 和 javax.sql 是 JDBC 4.0 的主要包。这是撰写本教程时的最新 JDBC 版本。它提供了与数据源交互的主要类。

这些包中的新功能包括以下方面的更改 -

• 自动加载数据库驱动程序。

• 异常处理改进。

• 增强的 BLOB/CLOB 功能。

• 连接和语句接口增强。

• 国家字符集支持。

• SQL ROWID 访问。

• SQL 2003 XML 数据类型支持。

• 注解。

JDBC - SQL 语法

**S**tructured **Q**uery **L**anguage (SQL) 是一种标准化语言，允许您对数据库执行操作，例如创建条目、读取内容、更新内容和删除条目。

SQL 几乎受您可能使用的任何数据库支持，它允许您编写独立于底层数据库的数据库代码。

本章概述了 SQL，这是理解 JDBC 概念的先决条件。在阅读完本章后，您将能够创建、读取、更新和删除（通常称为 **CRUD** 操作）数据库中的数据。

要详细了解 SQL，您可以阅读我们的 MySQL 教程。

创建数据库

CREATE DATABASE 语句用于创建新的数据库。语法如下 -

SQL> CREATE DATABASE DATABASE_NAME;

示例

以下 SQL 语句创建一个名为 EMP 的数据库 -

SQL> CREATE DATABASE EMP;

删除数据库

DROP DATABASE 语句用于删除现有数据库。语法如下 -

SQL> DROP DATABASE DATABASE_NAME;

**注意** - 要创建或删除数据库，您必须在数据库服务器上具有管理员权限。请谨慎操作，删除数据库将导致数据库中存储的所有数据丢失。

创建表

CREATE TABLE 语句用于创建新表。语法如下 -

SQL> CREATE TABLE table_name
(
   column_name column_data_type,
   column_name column_data_type,
   column_name column_data_type
   ...
);

示例

以下 SQL 语句创建一个名为 Employees 的表，其中包含四个列 -

SQL> CREATE TABLE Employees
(
   id INT NOT NULL,
   age INT NOT NULL,
   first VARCHAR(255),
   last VARCHAR(255),
   PRIMARY KEY ( id )
);

删除表

DROP TABLE 语句用于删除现有表。语法如下 -

SQL> DROP TABLE table_name;

示例

以下 SQL 语句删除名为 Employees 的表 -

SQL> DROP TABLE Employees;

插入数据

INSERT 的语法如下所示，其中 column1、column2 等代表将出现在相应列中的新数据 -

SQL> INSERT INTO table_name VALUES (column1, column2, ...);

示例

以下 SQL INSERT 语句在之前创建的 Employees 数据库中插入新行 -

SQL> INSERT INTO Employees VALUES (100, 18, 'Zara', 'Ali');

选择数据

SELECT 语句用于从数据库中检索数据。SELECT 的语法如下 -

SQL> SELECT column_name, column_name, ...
     FROM table_name
     WHERE conditions;

WHERE 子句可以使用比较运算符，例如 =、!=、<、>、<= 和 >=，以及 BETWEEN 和 LIKE 运算符。

示例

以下 SQL 语句从 Employees 表中选择 age、first 和 last 列，其中 id 列为 100 -

SQL> SELECT first, last, age 
     FROM Employees 
     WHERE id = 100;

以下 SQL 语句从 Employees 表中选择 age、first 和 last 列，其中 *first* 列包含 *Zara* -

SQL> SELECT first, last, age 
     FROM Employees 
     WHERE first LIKE '%Zara%';

更新数据

UPDATE 语句用于更新数据。UPDATE 的语法如下 -

SQL> UPDATE table_name
     SET column_name = value, column_name = value, ...
     WHERE conditions;

WHERE 子句可以使用比较运算符，例如 =、!=、<、>、<= 和 >=，以及 BETWEEN 和 LIKE 运算符。

示例

以下 SQL UPDATE 语句更改 id 为 100 的员工的 age 列 -

SQL> UPDATE Employees SET age=20 WHERE id=100;

删除数据

DELETE 语句用于从表中删除数据。DELETE 的语法如下 -

SQL> DELETE FROM table_name WHERE conditions;

WHERE 子句可以使用比较运算符，例如 =、!=、<、>、<= 和 >=，以及 BETWEEN 和 LIKE 运算符。

示例

以下 SQL DELETE 语句删除 id 为 100 的员工的记录 -

SQL> DELETE FROM Employees WHERE id=100;

JDBC - 环境配置

要开始使用 JDBC 进行开发，您应该按照以下步骤设置 JDBC 环境。我们假设您正在 Windows 平台上工作。

安装 Java

Java SE 可免费下载。要下载 请点击此处，请下载与您的操作系统兼容的版本。

按照说明下载 Java，然后运行 **.exe** 文件以在您的计算机上安装 Java。在您的计算机上安装 Java 后，您需要设置环境变量以指向正确的安装目录。

为 Windows 2000/XP 设置路径

假设您已将 Java 安装在 c:\Program Files\java\jdk 目录中 -

• 右键单击“我的电脑”，然后选择“属性”。

• 在“高级”选项卡下单击“环境变量”按钮。

• 现在，编辑“Path”变量，并在其末尾添加 Java 可执行文件目录的路径。例如，如果路径当前设置为 `C:\Windows\System32`，则按以下方式编辑它

C:\Windows\System32;c:\Program Files\java\jdk\bin

为 Windows 95/98/ME 设置路径

假设您已将 Java 安装在 c:\Program Files\java\jdk 目录中 -

• 编辑“C:\autoexec.bat”文件，并在末尾添加以下行 -

SET PATH = %PATH%;C:\Program Files\java\jdk\bin

为 Linux、UNIX、Solaris、FreeBSD 设置路径

环境变量 PATH 应设置为指向 Java 二进制文件安装的位置。如果您在执行此操作时遇到问题，请参考您的 shell 文档。

例如，如果您使用 bash 作为您的 shell，则您将在您的 **.bashrc** 文件末尾添加以下行 -

export PATH = /path/to/java:$PATH'

安装 J2SE 开发工具包后，您将自动获得两个 JDBC 包 **java.sql** 和 **javax.sql**。

安装数据库

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

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

• **MySQL DB** - MySQL 是一个开源数据库。您可以从 MySQL 官方网站 下载它。我们建议下载完整的 Windows 安装程序。

  此外，下载并安装 MySQL Administrator 以及 MySQL Query Browser。这些是基于 GUI 的工具，将使您的开发更加轻松。

  最后，下载并解压缩 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。您的驱动程序版本可能因您的安装而异。

设置数据库凭据

当我们安装 MySQL 数据库时，其管理员 ID 设置为 **root**，并且它允许您设置您选择的密码。

使用 root ID 和密码，您可以创建另一个用户 ID 和密码，或者您可以使用 root ID 和密码用于您的 JDBC 应用程序。

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

对于 JDBC 教程的其余部分，我们将使用 MySQL 数据库，其中 ID 为 **guest**，密码为 **guest123**。

如果您没有足够的权限来创建新用户，那么您可以要求您的数据库管理员 (DBA) 为您创建一个用户 ID 和密码。

创建数据库

要创建 **TUTORIALSPOINT** 数据库，请执行以下步骤 -

步骤 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

通过执行以下命令创建TUTORIALSPOINT数据库：

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

创建表

要在TUTORIALSPOINT数据库中创建Employees表，请使用以下步骤：

步骤 1

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

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

步骤 2

如下登录数据库：

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

步骤 3

如下创建Employees表：

mysql> use TUTORIALSPOINT;
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教程。

现在您已准备好开始使用JDBC进行实验。下一章将为您提供一个JDBC编程的示例。

JDBC - 示例代码

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

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

创建JDBC应用程序

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

• 导入包 - 需要包含用于数据库编程的JDBC类所在的包。大多数情况下，使用import java.sql.*就足够了。

• 打开连接 - 需要使用DriverManager.getConnection()方法创建一个Connection对象，该对象表示与数据库的物理连接。

• 执行查询 - 需要使用Statement类型的对象来构建和提交SQL语句到数据库。

• 从结果集中提取数据 - 需要使用适当的ResultSet.getXXX()方法从结果集中检索数据。

• 清理环境 - 需要显式地关闭所有数据库资源，而不是依赖JVM的垃圾回收。

示例代码

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

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

将以下示例复制并粘贴到FirstExample.java中，编译并运行如下：

import java.sql.*;

public class FirstExample {
   static final String DB_URL = "jdbc:mysql://127.0.0.1/TUTORIALSPOINT";
   static final String USER = "guest";
   static final String PASS = "guest123";
   static final String QUERY = "SELECT id, first, last, age FROM Employees";

   public static void main(String[] args) {
      // Open a connection
      try(Connection conn = DriverManager.getConnection(DB_URL, USER, PASS);
         Statement stmt = conn.createStatement();
         ResultSet rs = stmt.executeQuery(QUERY);) {
         // Extract data from result set
         while (rs.next()) {
            // Retrieve by column name
            System.out.print("ID: " + rs.getInt("id"));
            System.out.print(", Age: " + rs.getInt("age"));
            System.out.print(", First: " + rs.getString("first"));
            System.out.println(", Last: " + rs.getString("last"));
         }
      } catch (SQLException e) {
         e.printStackTrace();
      } 
   }
}

现在让我们如下编译上述示例：

C:\>javac FirstExample.java
C:\>

运行FirstExample时，会产生以下结果：

C:\>java FirstExample
Connecting to database...
Creating statement...
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
C:\>

JDBC - 驱动程序类型

什么是JDBC驱动程序？

JDBC驱动程序实现了JDBC API中定义的接口，用于与您的数据库服务器交互。

例如，使用JDBC驱动程序可以打开数据库连接，并通过发送SQL或数据库命令与之交互，然后使用Java接收结果。

JDK附带的Java.sql包包含各种类及其定义的行为，其实际实现是在第三方驱动程序中完成的。第三方供应商在其数据库驱动程序中实现了java.sql.Driver接口。

JDBC驱动程序类型

JDBC驱动程序的实现有所不同，因为Java运行在各种各样的操作系统和硬件平台上。Sun将实现类型分为四类：类型1、2、3和4，下面将对其进行解释：

类型1 - JDBC-ODBC桥接驱动程序

在类型1驱动程序中，使用JDBC桥接来访问安装在每个客户端机器上的ODBC驱动程序。使用ODBC需要在您的系统上配置一个数据源名称（DSN），该名称表示目标数据库。

当Java刚发布时，这是一个有用的驱动程序，因为大多数数据库只支持ODBC访问，但现在这种类型的驱动程序仅推荐用于实验用途或在没有其他替代方案可用时使用。

JDK 1.2附带的JDBC-ODBC桥接是这种驱动程序的一个很好的例子。

类型2 - JDBC-Native API

在类型2驱动程序中，JDBC API调用被转换为特定于数据库的本机C/C++ API调用。这些驱动程序通常由数据库供应商提供，并以与JDBC-ODBC桥接相同的方式使用。必须在每个客户端机器上安装供应商特定的驱动程序。

如果我们更改数据库，则必须更改本机API，因为它特定于某个数据库，并且现在大多数都已过时，但是使用类型2驱动程序可能会提高一些速度，因为它消除了ODBC的开销。

Oracle调用接口（OCI）驱动程序是类型2驱动程序的一个示例。

类型3 - JDBC-Net纯Java

在类型3驱动程序中，使用三层方法来访问数据库。JDBC客户端使用标准网络套接字与中间件应用程序服务器通信。然后，套接字信息由中间件应用程序服务器转换为DBMS所需的调用格式，并转发到数据库服务器。

这种类型的驱动程序非常灵活，因为它不需要在客户端安装任何代码，并且单个驱动程序实际上可以提供对多个数据库的访问。

您可以将应用程序服务器视为JDBC“代理”，这意味着它代表客户端应用程序进行调用。因此，您需要了解应用程序服务器的配置才能有效地使用此驱动程序类型。

您的应用程序服务器可能会使用类型1、2或4驱动程序与数据库通信，了解细微差别将非常有帮助。

类型4 - 100%纯Java

在类型4驱动程序中，基于纯Java的驱动程序通过套接字连接直接与供应商的数据库通信。这是数据库中最有效的驱动程序，通常由供应商本身提供。

这种类型的驱动程序非常灵活，您不需要在客户端或服务器上安装特殊的软件。此外，这些驱动程序可以动态下载。

MySQL的Connector/J驱动程序是类型4驱动程序。由于其网络协议的专有性，数据库供应商通常提供类型4驱动程序。

应该使用哪个驱动程序？

如果您正在访问一种类型的数据库，例如Oracle、Sybase或IBM，则首选的驱动程序类型是4。

如果您的Java应用程序同时访问多种类型的数据库，则类型3是首选的驱动程序。

类型2驱动程序在类型3或类型4驱动程序尚未可用于您的数据库的情况下很有用。

类型1驱动程序不被视为部署级驱动程序，通常仅用于开发和测试目的。

JDBC - 连接

安装了相应的驱动程序后，就可以使用JDBC建立数据库连接了。

建立JDBC连接所涉及的编程非常简单。以下是这四个简单的步骤：

• 导入JDBC包 - 在您的Java程序中添加import语句，以导入Java代码中所需的类。

• 注册JDBC驱动程序 - 此步骤会导致JVM将所需的驱动程序实现加载到内存中，以便它可以满足您的JDBC请求。

• 数据库URL制定 - 这是创建指向要连接的数据库的格式正确的地址。

• 创建连接对象 - 最后，编写对DriverManager对象的getConnection( )方法的调用以建立实际的数据库连接。

导入JDBC包

Import语句告诉Java编译器在哪里可以找到代码中引用的类，并且放置在源代码的开头。

要使用标准JDBC包（允许您在SQL表中选择、插入、更新和删除数据），请将以下import添加到源代码中：

import java.sql.* ;  // for standard JDBC programs
import java.math.* ; // for BigDecimal and BigInteger support

注册JDBC驱动程序

在使用驱动程序之前，必须在程序中注册它。注册驱动程序是将Oracle驱动程序的类文件加载到内存中的过程，以便可以将其用作JDBC接口的实现。

您只需要在程序中注册一次驱动程序。您可以通过两种方式之一注册驱动程序。

方法一 - Class.forName()

注册驱动程序最常见的方法是使用Java的Class.forName()方法，动态地将驱动程序的类文件加载到内存中，这会自动注册它。此方法是首选方法，因为它允许您使驱动程序注册可配置且可移植。

以下示例使用Class.forName( )来注册Oracle驱动程序：

try {
   Class.forName("oracle.jdbc.driver.OracleDriver");
}
catch(ClassNotFoundException ex) {
   System.out.println("Error: unable to load driver class!");
   System.exit(1);
}

您可以使用getInstance()方法解决不兼容的JVM，但是您必须为另外两个异常编写代码，如下所示：

try {
   Class.forName("oracle.jdbc.driver.OracleDriver").newInstance();
}
catch(ClassNotFoundException ex) {
   System.out.println("Error: unable to load driver class!");
   System.exit(1);
catch(IllegalAccessException ex) {
   System.out.println("Error: access problem while loading!");
   System.exit(2);
catch(InstantiationException ex) {
   System.out.println("Error: unable to instantiate driver!");
   System.exit(3);
}

方法二 - DriverManager.registerDriver()

您可以用来注册驱动程序的第二种方法是使用静态DriverManager.registerDriver()方法。

如果您使用的是非JDK兼容的JVM（例如Microsoft提供的JVM），则应使用registerDriver()方法。

以下示例使用registerDriver()来注册Oracle驱动程序：

try {
   Driver myDriver = new oracle.jdbc.driver.OracleDriver();
   DriverManager.registerDriver( myDriver );
}
catch(ClassNotFoundException ex) {
   System.out.println("Error: unable to load driver class!");
   System.exit(1);
}

数据库URL制定

加载驱动程序后，可以使用DriverManager.getConnection()方法建立连接。为了便于参考，我列出了三个重载的DriverManager.getConnection()方法：

• getConnection(String url)

• getConnection(String url, Properties prop)

• getConnection(String url, String user, String password)

这里每种形式都需要一个数据库URL。数据库URL是指向数据库的地址。

制定数据库URL是建立连接时出现的大多数问题所在。

下表列出了常用的JDBC驱动程序名称和数据库URL。

URL格式中所有突出显示的部分都是静态的，您只需要根据数据库设置更改其余部分。

创建连接对象

我们列出了三种形式的DriverManager.getConnection()方法来创建连接对象。

使用带有用户名和密码的数据库URL

getConnection()最常用的形式要求您传递数据库URL、用户名和密码：

假设您使用的是Oracle的thin驱动程序，您将为URL的数据库部分指定主机:端口:数据库名称值。

如果您在TCP/IP地址192.0.0.1处有一个主机，主机名为amrood，并且您的Oracle监听器配置为侦听端口1521，并且您的数据库名为EMP，则完整的数据库URL将为：

jdbc:oracle:thin:@amrood:1521:EMP

现在您必须使用适当的用户名和密码调用getConnection()方法以获取Connection对象，如下所示：

String URL = "jdbc:oracle:thin:@amrood:1521:EMP";
String USER = "username";
String PASS = "password"
Connection conn = DriverManager.getConnection(URL, USER, PASS);

仅使用数据库URL

DriverManager.getConnection() 方法的第二种形式只需要一个数据库 URL。

DriverManager.getConnection(String url);

但是，在这种情况下，数据库 URL 包含用户名和密码，并具有以下通用形式：

jdbc:oracle:driver:username/password@database

因此，上述连接可以如下创建：

String URL = "jdbc:oracle:thin:username/password@amrood:1521:EMP";
Connection conn = DriverManager.getConnection(URL);

使用数据库 URL 和属性对象

DriverManager.getConnection() 方法的第三种形式需要一个数据库 URL 和一个 Properties 对象。

DriverManager.getConnection(String url, Properties info);

Properties 对象保存一组关键字-值对。它用于在调用 getConnection() 方法期间将驱动程序属性传递给驱动程序。

要建立与前面示例相同的连接，请使用以下代码：

import java.util.*;

String URL = "jdbc:oracle:thin:@amrood:1521:EMP";
Properties info = new Properties( );
info.put( "user", "username" );
info.put( "password", "password" );

Connection conn = DriverManager.getConnection(URL, info);

关闭 JDBC 连接

在 JDBC 程序的末尾，需要显式关闭所有与数据库的连接以结束每个数据库会话。但是，如果您忘记了，Java 的垃圾收集器将在清理过时对象时关闭连接。

依赖垃圾收集，尤其是在数据库编程中，是一种非常糟糕的编程实践。您应该养成始终使用与连接对象关联的 close() 方法关闭连接的习惯。

为了确保连接已关闭，您可以在代码中提供一个“finally”块。finally 块始终执行，无论是否发生异常。

要关闭上述打开的连接，应如下调用 close() 方法：

conn.close();

显式关闭连接可以节省 DBMS 资源，这将使您的数据库管理员感到高兴。

为了更好地理解，我们建议您学习我们的 JDBC - 示例代码教程。

JDBC - 语句

获得连接后，我们可以与数据库交互。JDBC 的Statement、CallableStatement 和PreparedStatement 接口定义了允许您发送 SQL 或 PL/SQL 命令并从数据库接收数据的方法和属性。

它们还定义了有助于弥合 Java 和数据库中使用的 SQL 数据类型之间数据类型差异的方法。

下表总结了每个接口的目的，以决定使用哪个接口。

Statement 对象

创建 Statement 对象

在可以使用 Statement 对象执行 SQL 语句之前，需要使用 Connection 对象的 createStatement() 方法创建一个，如下例所示：

Statement stmt = null;
try {
   stmt = conn.createStatement( );
   . . .
}
catch (SQLException e) {
   . . .
}
finally {
   . . .
}

创建 Statement 对象后，就可以使用它通过其三个 execute 方法之一来执行 SQL 语句。

• boolean execute (String SQL)：如果可以检索 ResultSet 对象，则返回布尔值 true；否则，返回 false。使用此方法执行 SQL DDL 语句或当您需要使用真正的动态 SQL 时。

• int executeUpdate (String SQL)：返回受 SQL 语句执行影响的行数。使用此方法执行您期望获得受影响行数的 SQL 语句 - 例如，INSERT、UPDATE 或 DELETE 语句。

• ResultSet executeQuery (String SQL)：返回一个 ResultSet 对象。当您期望获得结果集时使用此方法，就像使用 SELECT 语句一样。

关闭 Statement 对象

就像关闭 Connection 对象以节省数据库资源一样，出于同样的原因，您也应该关闭 Statement 对象。

简单地调用 close() 方法即可完成工作。如果您首先关闭 Connection 对象，它也会关闭 Statement 对象。但是，您应该始终显式关闭 Statement 对象以确保正确清理。

Statement stmt = null;
try {
   stmt = conn.createStatement( );
   . . .
}
catch (SQLException e) {
   . . .
}
finally {
   stmt.close();
}

为了更好地理解，我们建议您学习 Statement - 示例教程。

PreparedStatement 对象

PreparedStatement 接口扩展了 Statement 接口，这为您提供了额外的功能，并且与通用 Statement 对象相比具有一些优势。

此语句使您可以灵活地动态提供参数。

创建 PreparedStatement 对象

PreparedStatement pstmt = null;
try {
   String SQL = "Update Employees SET age = ? WHERE id = ?";
   pstmt = conn.prepareStatement(SQL);
   . . .
}
catch (SQLException e) {
   . . .
}
finally {
   . . .
}

JDBC 中的所有参数都由？符号表示，该符号称为参数标记。在执行 SQL 语句之前，必须为每个参数提供值。

setXXX() 方法将值绑定到参数，其中XXX表示您希望绑定到输入参数的值的 Java 数据类型。如果您忘记提供值，将会收到 SQLException。

每个参数标记由其序数位置引用。第一个标记表示位置 1，下一个表示位置 2，依此类推。此方法不同于 Java 数组索引，Java 数组索引从 0 开始。

所有用于与数据库交互的Statement 对象的方法（a）execute()、（b）executeQuery() 和（c）executeUpdate() 也适用于 PreparedStatement 对象。但是，这些方法已修改为使用可以输入参数的 SQL 语句。

关闭 PreparedStatement 对象

就像关闭 Statement 对象一样，出于同样的原因，您也应该关闭 PreparedStatement 对象。

简单地调用 close() 方法即可完成工作。如果您首先关闭 Connection 对象，它也会关闭 PreparedStatement 对象。但是，您应该始终显式关闭 PreparedStatement 对象以确保正确清理。

PreparedStatement pstmt = null;
try {
   String SQL = "Update Employees SET age = ? WHERE id = ?";
   pstmt = conn.prepareStatement(SQL);
   . . .
}
catch (SQLException e) {
   . . .
}
finally {
   pstmt.close();
}

为了更好地理解，让我们学习 Prepare - 示例代码。

CallableStatement 对象

就像 Connection 对象创建 Statement 和 PreparedStatement 对象一样，它也创建 CallableStatement 对象，该对象将用于执行对数据库存储过程的调用。

创建 CallableStatement 对象

假设您需要执行以下 Oracle 存储过程：

CREATE OR REPLACE PROCEDURE getEmpName 
   (EMP_ID IN NUMBER, EMP_FIRST OUT VARCHAR) AS
BEGIN
   SELECT first INTO EMP_FIRST
   FROM Employees
   WHERE ID = EMP_ID;
END;

注意：上述存储过程是为 Oracle 编写的，但我们使用的是 MySQL 数据库，因此让我们按如下方式为 MySQL 编写相同的存储过程，以便在 EMP 数据库中创建它：

DELIMITER $$

DROP PROCEDURE IF EXISTS `EMP`.`getEmpName` $$
CREATE PROCEDURE `EMP`.`getEmpName` 
   (IN EMP_ID INT, OUT EMP_FIRST VARCHAR(255))
BEGIN
   SELECT first INTO EMP_FIRST
   FROM Employees
   WHERE ID = EMP_ID;
END $$

DELIMITER ;

存在三种类型的参数：IN、OUT 和 INOUT。PreparedStatement 对象仅使用 IN 参数。CallableStatement 对象可以使用所有三个参数。

以下是每个参数的定义：

以下代码片段显示了如何使用Connection.prepareCall() 方法根据前面的存储过程实例化CallableStatement 对象：

CallableStatement cstmt = null;
try {
   String SQL = "{call getEmpName (?, ?)}";
   cstmt = conn.prepareCall (SQL);
   . . .
}
catch (SQLException e) {
   . . .
}
finally {
   . . .
}

String 变量 SQL 表示存储过程，其中包含参数占位符。

使用 CallableStatement 对象的方式与使用 PreparedStatement 对象非常相似。在执行语句之前，必须将值绑定到所有参数，否则将收到 SQLException。

如果您有 IN 参数，只需遵循适用于 PreparedStatement 对象的相同规则和技术；使用与您正在绑定的 Java 数据类型相对应的 setXXX() 方法。

当您使用 OUT 和 INOUT 参数时，必须使用其他 CallableStatement 方法 registerOutParameter()。registerOutParameter() 方法将 JDBC 数据类型绑定到存储过程预期返回的数据类型。

调用存储过程后，您可以使用适当的 getXXX() 方法从 OUT 参数中检索值。此方法将检索到的 SQL 类型的值转换为 Java 数据类型。

关闭 CallableStatement 对象

就像关闭其他 Statement 对象一样，出于同样的原因，您也应该关闭 CallableStatement 对象。

简单地调用 close() 方法即可完成工作。如果您首先关闭 Connection 对象，它也会关闭 CallableStatement 对象。但是，您应该始终显式关闭 CallableStatement 对象以确保正确清理。

CallableStatement cstmt = null;
try {
   String SQL = "{call getEmpName (?, ?)}";
   cstmt = conn.prepareCall (SQL);
   . . .
}
catch (SQLException e) {
   . . .
}
finally {
   cstmt.close();
}

为了更好地理解，我建议您学习 Callable - 示例代码。

JDBC - 结果集

读取数据库查询数据的 SQL 语句将数据返回到结果集中。SELECT 语句是从数据库中选择行并在结果集中查看它们的标准方法。java.sql.ResultSet 接口表示数据库查询的结果集。

ResultSet 对象维护一个指向结果集中当前行的游标。“结果集”一词是指 ResultSet 对象中包含的行和列数据。

ResultSet 接口的方法可以分为三类：

• 导航方法：用于在游标周围移动。

• 获取方法：用于查看游标指向的当前行的列中的数据。

• 更新方法：用于更新当前行的列中的数据。然后也可以在底层数据库中更新这些更新。

游标是根据 ResultSet 的属性可移动的。这些属性是在创建生成 ResultSet 的相应 Statement 时指定的。

JDBC 提供以下连接方法来创建具有所需 ResultSet 的语句：

• createStatement(int RSType, int RSConcurrency);

• prepareStatement(String SQL, int RSType, int RSConcurrency);

• prepareCall(String sql, int RSType, int RSConcurrency);

第一个参数指示 ResultSet 对象的类型，第二个参数是两个 ResultSet 常量之一，用于指定结果集是只读的还是可更新的。

ResultSet 类型

可能的 RSType 如下所示。如果您未指定任何 ResultSet 类型，则将自动获得一个 TYPE_FORWARD_ONLY 类型的结果集。

ResultSet 的并发性

下面给出可能的 RSConcurrency。如果未指定任何并发类型，则会自动获得一个 CONCUR_READ_ONLY 类型。

到目前为止我们编写的所有示例都可以按如下方式编写，它初始化一个 Statement 对象以创建一个只向前、只读的 ResultSet 对象 -

try {
   Statement stmt = conn.createStatement(
                           ResultSet.TYPE_FORWARD_ONLY,
                           ResultSet.CONCUR_READ_ONLY);
}
catch(Exception ex) {
   ....
}
finally {
   ....
}

导航结果集

ResultSet 接口中包含几个涉及移动游标的方法，包括 -

为了更好地理解，让我们学习导航 - 示例代码。

查看结果集

ResultSet 接口包含数十个用于获取当前行数据的方法。

每种可能的数据类型都有一个 get 方法，并且每个 get 方法都有两个版本 -

• 一个接受列名。

• 一个接受列索引。

例如，如果您感兴趣的列包含一个 int，则需要使用 ResultSet 的 getInt() 方法之一 -

类似地，ResultSet 接口中为所有八种 Java 基本数据类型以及 java.lang.String、java.lang.Object 和 java.net.URL 等常见类型提供了 get 方法。

还有一些方法可以获取 SQL 数据类型 java.sql.Date、java.sql.Time、java.sql.TimeStamp、java.sql.Clob 和 java.sql.Blob。请查看文档以获取有关使用这些 SQL 数据类型的更多信息。

为了更好地理解，让我们学习查看 - 示例代码。

更新结果集

ResultSet 接口包含一组用于更新结果集数据的方法。

与 get 方法一样，每种数据类型都有两个 update 方法 -

• 一个接受列名。

• 一个接受列索引。

例如，要更新结果集当前行的 String 列，可以使用以下 updateString() 方法之一 -

有八种基本数据类型的 update 方法，以及 String、Object、URL 和 java.sql 包中的 SQL 数据类型。

更新结果集中的行会更改 ResultSet 对象中当前行的列，但不会更改底层数据库。要将对数据库中行的更改更新，需要调用以下方法之一。

为了更好地理解，让我们学习更新 - 示例代码。

JDBC - 数据类型

JDBC 驱动程序在将 Java 数据类型发送到数据库之前将其转换为相应的 JDBC 类型。它对大多数数据类型使用默认映射。例如，Java int 转换为 SQL INTEGER。创建默认映射是为了在驱动程序之间提供一致性。

下表总结了调用 PreparedStatement 或 CallableStatement 对象的 setXXX() 方法或 ResultSet.updateXXX() 方法时 Java 数据类型转换为的默认 JDBC 数据类型。

JDBC 3.0 增强了对 BLOB、CLOB、ARRAY 和 REF 数据类型的支持。ResultSet 对象现在具有 updateBLOB()、updateCLOB()、updateArray() 和 updateRef() 方法，使您能够直接操作服务器上的相应数据。

setXXX() 和 updateXXX() 方法使您能够将特定 Java 类型转换为特定 JDBC 数据类型。setObject() 和 updateObject() 方法使您能够将几乎任何 Java 类型映射到 JDBC 数据类型。

ResultSet 对象为每种数据类型提供相应的 getXXX() 方法以检索列值。每种方法都可以与列名或其序数位置一起使用。

日期和时间数据类型

java.sql.Date 类映射到 SQL DATE 类型，java.sql.Time 和 java.sql.Timestamp 类分别映射到 SQL TIME 和 SQL TIMESTAMP 数据类型。

以下示例显示了 Date 和 Time 类如何将标准 Java 日期和时间值格式化为与 SQL 数据类型要求匹配。

import java.sql.Date;
import java.sql.Time;
import java.sql.Timestamp;
import java.util.*;

public class SqlDateTime {
   public static void main(String[] args) {
      //Get standard date and time
      java.util.Date javaDate = new java.util.Date();
      long javaTime = javaDate.getTime();
      System.out.println("The Java Date is:" + 
             javaDate.toString());

      //Get and display SQL DATE
      java.sql.Date sqlDate = new java.sql.Date(javaTime);
      System.out.println("The SQL DATE is: " + 
             sqlDate.toString());

      //Get and display SQL TIME
      java.sql.Time sqlTime = new java.sql.Time(javaTime);
      System.out.println("The SQL TIME is: " + 
             sqlTime.toString());
      //Get and display SQL TIMESTAMP
      java.sql.Timestamp sqlTimestamp =
      new java.sql.Timestamp(javaTime);
      System.out.println("The SQL TIMESTAMP is: " + 
             sqlTimestamp.toString());
     }//end main
}//end SqlDateTime

现在让我们如下编译上述示例：

C:\>javac SqlDateTime.java
C:\>

运行JDBCExample时，它会产生以下结果 -

C:\>java SqlDateTime
The Java Date is:Tue Aug 18 13:46:02 GMT+04:00 2009
The SQL DATE is: 2009-08-18
The SQL TIME is: 13:46:02
The SQL TIMESTAMP is: 2009-08-18 13:46:02.828
C:\>

处理 NULL 值

SQL 使用 NULL 值和 Java 使用 null 是不同的概念。因此，要在 Java 中处理 SQL NULL 值，可以使用三种策略 -

• 避免使用返回基本数据类型的 getXXX( ) 方法。

• 对基本数据类型使用包装类，并使用 ResultSet 对象的 wasNull( ) 方法测试接收 getXXX( ) 方法返回值的包装类变量是否应设置为 null。

• 使用基本数据类型和 ResultSet 对象的 wasNull( ) 方法测试接收 getXXX( ) 方法返回值的基本变量是否应设置为您选择表示 NULL 的可接受值。

以下是一个处理 NULL 值的示例 -

Statement stmt = conn.createStatement( );
String sql = "SELECT id, first, last, age FROM Employees";
ResultSet rs = stmt.executeQuery(sql);

int id = rs.getInt(1);
if( rs.wasNull( ) ) {
   id = 0;
}

JDBC - 事务

如果您的 JDBC 连接处于自动提交模式（默认情况下），则每个 SQL 语句在完成时都会提交到数据库。

对于简单的应用程序，这可能很好，但是您可能希望关闭自动提交并管理自己的事务，原因有三个 -

• 提高性能。

• 维护业务流程的完整性。

• 使用分布式事务。

事务使您能够控制是否以及何时将更改应用于数据库。它将单个 SQL 语句或一组 SQL 语句视为一个逻辑单元，如果任何语句失败，则整个事务都会失败。

为了启用手动事务支持而不是 JDBC 驱动程序默认使用的自动提交模式，请使用 Connection 对象的setAutoCommit() 方法。如果将布尔值 false 传递给 setAutoCommit()，则关闭自动提交。您可以传递布尔值 true 以再次将其打开。

例如，如果您有一个名为 conn 的 Connection 对象，请编写以下代码以关闭自动提交 -

conn.setAutoCommit(false);

提交 & 回滚

完成更改并想要提交更改后，请在连接对象上调用commit() 方法，如下所示 -

conn.commit( );

否则，要回滚使用名为 conn 的 Connection 对数据库进行的更新，请使用以下代码 -

conn.rollback( );

以下示例说明了提交和回滚对象的用法 -

try{
   //Assume a valid connection object conn
   conn.setAutoCommit(false);
   Statement stmt = conn.createStatement();
   
   String SQL = "INSERT INTO Employees  " +
                "VALUES (106, 20, 'Rita', 'Tez')";
   stmt.executeUpdate(SQL);  
   //Submit a malformed SQL statement that breaks
   String SQL = "INSERTED IN Employees  " +
                "VALUES (107, 22, 'Sita', 'Singh')";
   stmt.executeUpdate(SQL);
   // If there is no error.
   conn.commit();
}catch(SQLException se){
   // If there is any error.
   conn.rollback();
}

在这种情况下，以上所有 INSERT 语句都不会成功，所有内容都将回滚。

为了更好地理解，让我们学习提交 - 示例代码。

使用保存点

新的 JDBC 3.0 保存点接口为您提供了额外的交易控制。大多数现代 DBMS 在其环境中支持保存点，例如 Oracle 的 PL/SQL。

设置保存点时，您在事务中定义了一个逻辑回滚点。如果在保存点之后发生错误，您可以使用回滚方法撤消所有更改或仅撤消保存点之后进行的更改。

Connection 对象有两个新方法可以帮助您管理保存点 -

• setSavepoint(String savepointName) - 定义一个新的保存点。它还返回一个 Savepoint 对象。

• releaseSavepoint(Savepoint savepointName) - 删除保存点。请注意，它需要一个 Savepoint 对象作为参数。此对象通常是 setSavepoint() 方法生成的保存点。

有一个rollback (String savepointName) 方法，它将工作回滚到指定的保存点。

以下示例说明了 Savepoint 对象的用法 -

try{
   //Assume a valid connection object conn
   conn.setAutoCommit(false);
   Statement stmt = conn.createStatement();
   
   //set a Savepoint
   Savepoint savepoint1 = conn.setSavepoint("Savepoint1");
   String SQL = "INSERT INTO Employees " +
                "VALUES (106, 20, 'Rita', 'Tez')";
   stmt.executeUpdate(SQL);  
   //Submit a malformed SQL statement that breaks
   String SQL = "INSERTED IN Employees " +
                "VALUES (107, 22, 'Sita', 'Tez')";
   stmt.executeUpdate(SQL);
   // If there is no error, commit the changes.
   conn.commit();

}catch(SQLException se){
   // If there is any error.
   conn.rollback(savepoint1);
}

在这种情况下，以上所有 INSERT 语句都不会成功，所有内容都将回滚。

为了更好地理解，让我们学习保存点 - 示例代码。

JDBC - 异常

异常处理允许您以受控方式处理异常情况，例如程序定义的错误。

当发生异常情况时，会抛出异常。术语“抛出”表示当前程序执行停止，并且控制权将重定向到最近适用的 catch 子句。如果不存在适用的 catch 子句，则程序的执行结束。

JDBC 异常处理与 Java 异常处理非常相似，但对于 JDBC 而言，您将处理的最常见异常是java.sql.SQLException。

SQLException 方法

SQLException 既可能发生在驱动程序中也可能发生在数据库中。当发生此类异常时，类型为 SQLException 的对象将传递给 catch 子句。

传递的 SQLException 对象具有以下方法可用于检索有关异常的更多信息 -

通过利用从 Exception 对象获得的信息，您可以捕获异常并适当地继续您的程序。以下是 try 块的一般形式 -

try {
   // Your risky code goes between these curly braces!!!
}
catch(Exception ex) {
   // Your exception handling code goes between these 
   // curly braces, similar to the exception clause 
   // in a PL/SQL block.
}
finally {
   // Your must-always-be-executed code goes between these 
   // curly braces. Like closing database connection.
}

示例

学习以下示例代码以了解try....catch...finally 块的用法。

import java.sql.CallableStatement;
import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.SQLException;

public class JDBCExample {
   static final String DB_URL = "jdbc:mysql://127.0.0.1/TUTORIALSPOINT";
   static final String USER = "guest";
   static final String PASS = "guest123";
   static final String QUERY = "{call getEmpName (?, ?)}";

   public static void main(String[] args) {
      // Open a connection
      try(Connection conn = DriverManager.getConnection(DB_URL, USER, PASS);
         CallableStatement stmt = conn.prepareCall(QUERY);
      ) {		      
         // Bind values into the parameters.
         stmt.setInt(1, 1);  // This would set ID
         // Because second parameter is OUT so register it
         stmt.registerOutParameter(2, java.sql.Types.VARCHAR);
         //Use execute method to run stored procedure.
         System.out.println("Executing stored procedure..." );
         stmt.execute();
         //Retrieve employee name with getXXX method
         String empName = stmt.getString(2);
         System.out.println("Emp Name with ID: 1 is " + empName);
      } catch (SQLException e) {
         e.printStackTrace();
      } 
   }
}

现在，让我们按如下方式编译以上示例 -

C:\>javac JDBCExample.java
C:\>

当您运行JDBCExample时，如果没有任何问题，它会产生以下结果，否则会捕获相应的错误并显示错误消息 -

C:\>java JDBCExample
Executing stored procedure...
Emp Name with ID: 1 is Zara
C:\>

尝试通过传递错误的数据库名称或错误的用户名或密码来运行以上示例，并检查结果。

JDBC - 批处理

批处理允许您将相关的 SQL 语句分组到一个批次中，并使用一次调用提交到数据库。

当您一次向数据库发送多个 SQL 语句时，您可以减少通信开销，从而提高性能。

• JDBC 驱动程序不需要支持此功能。您应该使用DatabaseMetaData.supportsBatchUpdates() 方法来确定目标数据库是否支持批更新处理。如果您的 JDBC 驱动程序支持此功能，则该方法返回 true。

• Statement、PreparedStatement 和CallableStatement 的addBatch() 方法用于将单个语句添加到批次中。executeBatch() 用于开始执行所有一起分组的语句。

• executeBatch() 返回一个整数数组，数组的每个元素代表相应更新语句的更新计数。

• 就像您可以将语句添加到批次以进行处理一样，您也可以使用clearBatch() 方法将其删除。此方法会删除您使用 addBatch() 方法添加的所有语句。但是，您无法选择性地选择要删除哪个语句。

使用 Statement 对象进行批处理

以下是使用 Statement 对象进行批处理的典型步骤序列 -

• 使用createStatement() 方法创建 Statement 对象。

• 使用setAutoCommit() 将自动提交设置为 false。

• 使用在创建的语句对象上addBatch() 方法将任意数量的 SQL 语句添加到批处理中。

• 使用在创建的语句对象上executeBatch() 方法执行所有 SQL 语句。

• 最后，使用commit() 方法提交所有更改。

示例

以下代码片段提供了一个使用 Statement 对象进行批更新的示例 -

// Create statement object
Statement stmt = conn.createStatement();

// Set auto-commit to false
conn.setAutoCommit(false);

// Create SQL statement
String SQL = "INSERT INTO Employees (id, first, last, age) " +
             "VALUES(200,'Zia', 'Ali', 30)";
// Add above SQL statement in the batch.
stmt.addBatch(SQL);

// Create one more SQL statement
String SQL = "INSERT INTO Employees (id, first, last, age) " +
             "VALUES(201,'Raj', 'Kumar', 35)";
// Add above SQL statement in the batch.
stmt.addBatch(SQL);

// Create one more SQL statement
String SQL = "UPDATE Employees SET age = 35 " +
             "WHERE id = 100";
// Add above SQL statement in the batch.
stmt.addBatch(SQL);

// Create an int[] to hold returned values
int[] count = stmt.executeBatch();

//Explicitly commit statements to apply changes
conn.commit();

为了更好地理解，让我们学习批处理 - 示例代码。

使用 PrepareStatement 对象进行批处理

以下是使用 PrepareStatement 对象进行批处理的典型步骤序列 -

1. 创建带有占位符的 SQL 语句。

2. 使用prepareStatement() 方法创建 PrepareStatement 对象。

3. 使用setAutoCommit() 将自动提交设置为 false。

4. 使用在创建的语句对象上addBatch() 方法将任意数量的 SQL 语句添加到批处理中。

5. 使用在创建的语句对象上executeBatch() 方法执行所有 SQL 语句。

6. 最后，使用commit() 方法提交所有更改。

以下代码片段提供了一个使用 PrepareStatement 对象进行批更新的示例 -

// Create SQL statement
String SQL = "INSERT INTO Employees (id, first, last, age) " +
             "VALUES(?, ?, ?, ?)";

// Create PrepareStatement object
PreparedStatemen pstmt = conn.prepareStatement(SQL);

//Set auto-commit to false
conn.setAutoCommit(false);

// Set the variables
pstmt.setInt( 1, 400 );
pstmt.setString( 2, "Pappu" );
pstmt.setString( 3, "Singh" );
pstmt.setInt( 4, 33 );
// Add it to the batch
pstmt.addBatch();

// Set the variables
pstmt.setInt( 1, 401 );
pstmt.setString( 2, "Pawan" );
pstmt.setString( 3, "Singh" );
pstmt.setInt( 4, 31 );
// Add it to the batch
pstmt.addBatch();

//add more batches
.
.
.
.
//Create an int[] to hold returned values
int[] count = stmt.executeBatch();

//Explicitly commit statements to apply changes
conn.commit();

为了更好地理解，让我们学习批处理 - 示例代码。

JDBC - 存储过程

在讨论JDBC - 语句章节时，我们已经学习了如何在 JDBC 中使用存储过程。本章与该部分类似，但会为您提供有关 JDBC SQL 转义语法的更多信息。

就像 Connection 对象创建 Statement 和 PreparedStatement 对象一样，它也创建 CallableStatement 对象，该对象将用于执行对数据库存储过程的调用。

创建 CallableStatement 对象

假设您需要执行以下 Oracle 存储过程：

CREATE OR REPLACE PROCEDURE getEmpName 
   (EMP_ID IN NUMBER, EMP_FIRST OUT VARCHAR) AS
BEGIN
   SELECT first INTO EMP_FIRST
   FROM Employees
   WHERE ID = EMP_ID;
END;

注意 - 以上存储过程是为 Oracle 编写的，但我们正在使用 MySQL 数据库，因此让我们按如下方式为 MySQL 编写相同的存储过程，以便在 EMP 数据库中创建它。

DELIMITER $$

DROP PROCEDURE IF EXISTS `EMP`.`getEmpName` $$
CREATE PROCEDURE `EMP`.`getEmpName` 
   (IN EMP_ID INT, OUT EMP_FIRST VARCHAR(255))
BEGIN
   SELECT first INTO EMP_FIRST
   FROM Employees
   WHERE ID = EMP_ID;
END $$

DELIMITER ;

存在三种类型的参数 - IN、OUT 和 INOUT。PreparedStatement 对象仅使用 IN 参数。CallableStatement 对象可以使用所有三种参数。

以下是每个参数的定义：

以下代码片段显示了如何使用Connection.prepareCall() 方法根据前面的存储过程实例化CallableStatement 对象：

CallableStatement cstmt = null;
try {
   String SQL = "{call getEmpName (?, ?)}";
   cstmt = conn.prepareCall (SQL);
   . . .
}
catch (SQLException e) {
   . . .
}
finally {
   . . .
}

String 变量 SQL 表示存储过程，带有参数占位符。

使用 CallableStatement 对象很像使用 PreparedStatement 对象。您必须在执行语句之前将值绑定到所有参数，否则您将收到 SQLException。

如果您有 IN 参数，只需遵循适用于 PreparedStatement 对象的相同规则和技术；使用与您正在绑定的 Java 数据类型相对应的 setXXX() 方法。

当您使用 OUT 和 INOUT 参数时，必须使用其他 CallableStatement 方法 registerOutParameter()。registerOutParameter() 方法将 JDBC 数据类型绑定到存储过程预期返回的数据类型。

调用存储过程后，您可以使用适当的 getXXX() 方法从 OUT 参数中检索值。此方法将检索到的 SQL 类型的值转换为 Java 数据类型。

关闭 CallableStatement 对象

就像关闭其他 Statement 对象一样，出于同样的原因，您也应该关闭 CallableStatement 对象。

简单地调用 close() 方法即可完成工作。如果您首先关闭 Connection 对象，它也会关闭 CallableStatement 对象。但是，您应该始终显式关闭 CallableStatement 对象以确保正确清理。

CallableStatement cstmt = null;
try {
   String SQL = "{call getEmpName (?, ?)}";
   cstmt = conn.prepareCall (SQL);
   . . .
}
catch (SQLException e) {
   . . .
}
finally {
   cstmt.close();
}

学习我们在Callable - 示例代码中研究了更多详细信息。

JDBC SQL 转义语法

转义语法使您可以灵活地使用通过使用标准 JDBC 方法和属性无法获得的特定于数据库的功能。

一般的 SQL 转义语法格式如下 -

{keyword 'parameters'}

以下是您在执行 JDBC 编程时会发现非常有用的转义序列 -

d、t、ts 关键字

它们有助于识别日期、时间和时间戳文字。如您所知，没有两个 DBMS 以相同的方式表示时间和日期。此转义语法告诉驱动程序以目标数据库的格式呈现日期或时间。例如 -

{d 'yyyy-mm-dd'}

其中 yyyy = 年，mm = 月；dd = 日期。使用此语法 {d '2009-09-03'} 是 2009 年 3 月 9 日。

这是一个简单的示例，展示了如何在表中插入日期 -

//Create a Statement object
stmt = conn.createStatement();
//Insert data ==> ID, First Name, Last Name, DOB
String sql="INSERT INTO STUDENTS VALUES" +
             "(100,'Zara','Ali', {d '2001-12-16'})";

stmt.executeUpdate(sql);

类似地，您可以使用以下两种语法之一，即t 或ts -

{t 'hh:mm:ss'}

其中 hh = 小时；mm = 分钟；ss = 秒。使用此语法 {t '13:30:29'} 是下午 1:30:29。

{ts 'yyyy-mm-dd hh:mm:ss'}

这是以上两种语法 'd' 和 't' 的组合语法，用于表示时间戳。

escape 关键字

此关键字标识 LIKE 子句中使用的转义字符。在使用 SQL 通配符 % 时很有用，它匹配零个或多个字符。例如 -

String sql = "SELECT symbol FROM MathSymbols
              WHERE symbol LIKE '\%' {escape '\'}";
stmt.execute(sql);

如果您使用反斜杠字符 (\) 作为转义字符，则还必须在 Java 字符串文字中使用两个反斜杠字符，因为反斜杠也是 Java 转义字符。

fn 关键字

此关键字表示 DBMS 中使用的标量函数。例如，您可以使用 SQL 函数length 获取字符串的长度 -

{fn length('Hello World')}

这将返回 11，即字符字符串“Hello World”的长度。

call 关键字

此关键字用于调用存储过程。例如，对于需要 IN 参数的存储过程，请使用以下语法 -

{call my_procedure(?)};

对于需要 IN 参数并返回 OUT 参数的存储过程，请使用以下语法 -

{? = call my_procedure(?)};

oj 关键字

此关键字用于表示外部联接。语法如下 -

{oj outer-join}

其中 outer-join = table {LEFT|RIGHT|FULL} OUTERJOIN {table | outer-join} on search-condition。例如 -

String sql = "SELECT Employees 
              FROM {oj ThisTable RIGHT
              OUTER JOIN ThatTable on id = '100'}";
stmt.execute(sql);

JDBC - 数据流

PreparedStatement 对象能够使用输入和输出流来提供参数数据。这使您可以将整个文件放入可以保存大值的数据库列中，例如 CLOB 和 BLOB 数据类型。

有以下方法可用于流式传输数据 -

• setAsciiStream() - 此方法用于提供大型 ASCII 值。

• setCharacterStream() - 此方法用于提供大型 UNICODE 值。

• setBinaryStream() - 此方法用于提供大型二进制值。

除了参数占位符之外，setXXXStream() 方法还需要一个额外的参数，即文件大小。此参数通知驱动程序应使用流向数据库发送多少数据。

此示例将创建一个名为 XML_Data 的数据库表，然后将 XML 内容写入此表。

将以下示例复制并粘贴到 FirstApplication.java 中，编译并运行如下 -

import java.io.ByteArrayInputStream;
import java.io.ByteArrayOutputStream;
import java.io.File;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.IOException;
import java.io.InputStream;
import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.PreparedStatement;
import java.sql.ResultSet;
import java.sql.SQLException;
import java.sql.Statement;

public class TestApplication {
   static final String DB_URL = "jdbc:mysql://127.0.0.1/TUTORIALSPOINT";
   static final String USER = "guest";
   static final String PASS = "guest123";
   static final String QUERY = "SELECT Data FROM XML_Data WHERE id=100";
   static final String INSERT_QUERY="INSERT INTO XML_Data VALUES (?,?)";
   static final String CREATE_TABLE_QUERY = "CREATE TABLE XML_Data (id INTEGER, Data LONG)";
   static final String DROP_TABLE_QUERY = "DROP TABLE XML_Data";
   static final String XML_DATA = "<Employee><id>100</id><first>Zara</first><last>Ali</last><Salary>10000</Salary><Dob>18-08-1978</Dob></Employee>";
   
   public static void createXMLTable(Statement stmt) 
      throws SQLException{
      System.out.println("Creating XML_Data table..." );
      //Drop table first if it exists.
      try{
         stmt.executeUpdate(DROP_TABLE_QUERY);
      }catch(SQLException se){
      }
      stmt.executeUpdate(CREATE_TABLE_QUERY);
   }

   public static void main(String[] args) {
      // Open a connection
      try(Connection conn = DriverManager.getConnection(DB_URL, USER, PASS);
         Statement stmt = conn.createStatement();
         PreparedStatement pstmt = conn.prepareStatement(INSERT_QUERY);
      ) {		      
         createXMLTable(stmt);

         ByteArrayInputStream bis = new ByteArrayInputStream(XML_DATA.getBytes());

         pstmt.setInt(1,100);
         pstmt.setAsciiStream(2,bis,XML_DATA.getBytes().length);
         pstmt.execute();

         //Close input stream
         bis.close();

         ResultSet rs = stmt.executeQuery(QUERY);
         // Get the first row
         if (rs.next ()){
            //Retrieve data from input stream
            InputStream xmlInputStream = rs.getAsciiStream (1);
            int c;
            ByteArrayOutputStream bos = new ByteArrayOutputStream();
            while (( c = xmlInputStream.read ()) != -1)
               bos.write(c);
            //Print results
            System.out.println(bos.toString());
         }
         // Clean-up environment
         rs.close();

      } catch (SQLException | IOException e) {
         e.printStackTrace();
      } 
   }
}

现在让我们如下编译上述示例：

C:\>javac FirstApplication.java
C:\>

当您运行FirstApplication时，它会产生以下结果 -

C:\>java FirstApplication
Creating XML_Data table...
<Employee><id>100</id><first>Zara</first><last>Ali</last><Salary>10000</Salary><Dob>18-08-1978</Dob></Employee>
C:\>

JDBC - 创建数据库

本教程提供了一个使用 JDBC 应用程序创建数据库的示例。在执行以下示例之前，请确保您已准备好以下内容：

• 您应该具有在给定模式中创建数据库的管理员权限。要执行以下示例，您需要将用户名和密码替换为您实际的用户名和密码。

• 您的 MySQL 或任何其他数据库正在运行。

必要步骤

使用 JDBC 应用程序创建新数据库需要以下步骤：

• 导入包 - 需要包含用于数据库编程的JDBC类所在的包。大多数情况下，使用import java.sql.*就足够了。

• 打开连接 - 需要使用DriverManager.getConnection()方法创建 Connection 对象，该对象表示与数据库服务器的物理连接。

  要创建新的数据库，您无需在准备数据库 URL 时提供任何数据库名称，如下例所示。

• 执行查询 - 需要使用Statement类型的对象来构建和提交SQL语句到数据库。

• 清理环境 - try with resources 会自动关闭资源。

示例代码

将以下示例复制并粘贴到 JDBCExample.java 中，编译并运行如下：

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

public class JDBCExample {
   static final String DB_URL = "jdbc:mysql://127.0.0.1/";
   static final String USER = "guest";
   static final String PASS = "guest123";

   public static void main(String[] args) {
      // Open a connection
      try(Connection conn = DriverManager.getConnection(DB_URL, USER, PASS);
         Statement stmt = conn.createStatement();
      ) {		      
         String sql = "CREATE DATABASE STUDENTS";
         stmt.executeUpdate(sql);
         System.out.println("Database created successfully...");   	  
      } catch (SQLException e) {
         e.printStackTrace();
      } 
   }
}

现在让我们如下编译上述示例：

C:\>javac JDBCExample.java
C:\>

运行JDBCExample时，它会产生以下结果 -

C:\>java JDBCExample
Database created successfully...
C:\>

JDBC - 选择数据库

本章提供了一个使用 JDBC 应用程序选择数据库的示例。在执行以下示例之前，请确保您已准备好以下内容：

• 要执行以下示例，您需要将用户名和密码替换为您实际的用户名和密码。

• 您正在使用的 MySQL 或任何其他数据库正在运行。

必要步骤

使用 JDBC 应用程序创建新数据库需要以下步骤：

• 导入包 - 需要包含数据库编程所需的 JDBC 类所在的包。大多数情况下，使用import java.sql.*就足够了。

• 打开连接 - 需要使用DriverManager.getConnection()方法创建 Connection 对象，该对象表示与选定数据库的物理连接。

  数据库的选择是在您准备数据库 URL 时进行的。以下示例将与STUDENTS数据库建立连接。

• 清理环境 - try with resources 会自动关闭资源。

示例代码

将以下示例复制并粘贴到 JDBCExample.java 中，编译并运行如下：

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

public class JDBCExample {
   static final String DB_URL = "jdbc:mysql://127.0.0.1/TUTORIALSPOINT";
   static final String USER = "guest";
   static final String PASS = "guest123";

   public static void main(String[] args) {
      System.out.println("Connecting to a selected database...");
      // Open a connection
      try(Connection conn = DriverManager.getConnection(DB_URL, USER, PASS);) {		      
         System.out.println("Connected database successfully...");  
      } catch (SQLException e) {
         e.printStackTrace();
      } 
   }
}

现在让我们如下编译上述示例：

C:\>javac JDBCExample.java
C:\>

运行JDBCExample时，它会产生以下结果 -

C:\>java JDBCExample
Connecting to a selected database...
Connected database successfully...
C:\>

JDBC - 删除数据库

本章提供了一个使用 JDBC 应用程序删除现有数据库的示例。在执行以下示例之前，请确保您已准备好以下内容：

• 要执行以下示例，您需要将用户名和密码替换为您实际的用户名和密码。

• 您的 MySQL 正在运行。

注意：这是一个严重的操作，在继续删除数据库之前，您必须做出坚定的决定，因为您数据库中的所有内容都将丢失。

必要步骤

使用 JDBC 应用程序创建新数据库需要以下步骤：

• 导入包 - 需要包含用于数据库编程的JDBC类所在的包。大多数情况下，使用import java.sql.*就足够了。

• 打开连接 - 需要使用DriverManager.getConnection()方法创建 Connection 对象，该对象表示与数据库服务器的物理连接。

  删除数据库不需要数据库名称在您的数据库 URL 中。以下示例将删除STUDENTS数据库。

• 执行查询 - 需要使用 Statement 类型的对象来构建和提交删除数据库的 SQL 语句。

• 清理环境 - try with resources 会自动关闭资源。

示例代码

将以下示例复制并粘贴到 JDBCExample.java 中，编译并运行如下：

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

public class JDBCExample {
   static final String DB_URL = "jdbc:mysql://127.0.0.1/";
   static final String USER = "guest";
   static final String PASS = "guest123";

   public static void main(String[] args) {
      // Open a connection
      try(Connection conn = DriverManager.getConnection(DB_URL, USER, PASS);
         Statement stmt = conn.createStatement();
      ) {		      
         String sql = "DROP DATABASE STUDENTS";
         stmt.executeUpdate(sql);
         System.out.println("Database dropped successfully...");   	  
      } catch (SQLException e) {
         e.printStackTrace();
      } 
   }
}

现在让我们如下编译上述示例：

C:\>javac JDBCExample.java
C:\>

运行JDBCExample时，它会产生以下结果 -

C:\>java JDBCExample
Database dropped successfully...
C:\>

JDBC - 创建表

本章提供了一个使用 JDBC 应用程序创建表的示例。在执行以下示例之前，请确保您已准备好以下内容：

• 要执行以下示例，您可以将用户名和密码替换为您实际的用户名和密码。

• 您的 MySQL 正在运行。

必要步骤

使用 JDBC 应用程序创建新数据库需要以下步骤：

• 导入包 - 需要包含用于数据库编程的JDBC类所在的包。大多数情况下，使用import java.sql.*就足够了。

• 打开连接 - 需要使用DriverManager.getConnection()方法创建 Connection 对象，该对象表示与数据库服务器的物理连接。

• 执行查询 - 需要使用 Statement 类型的对象来构建和提交在选定数据库中创建表的 SQL 语句。

• 清理环境 - try with resources 会自动关闭资源。

示例代码

将以下示例复制并粘贴到 TestApplication.java 中，编译并运行如下：

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

public class TestApplication {
   static final String DB_URL = "jdbc:mysql://127.0.0.1/TUTORIALSPOINT";
   static final String USER = "guest";
   static final String PASS = "guest123";

   public static void main(String[] args) {
      // Open a connection
      try(Connection conn = DriverManager.getConnection(DB_URL, USER, PASS);
         Statement stmt = conn.createStatement();
      ) {		      
          String sql = "CREATE TABLE REGISTRATION " +
                   "(id INTEGER not NULL, " +
                   " first VARCHAR(255), " + 
                   " last VARCHAR(255), " + 
                   " age INTEGER, " + 
                   " PRIMARY KEY ( id ))"; 

         stmt.executeUpdate(sql);
         System.out.println("Created table in given database...");   	  
      } catch (SQLException e) {
         e.printStackTrace();
      } 
   }
}

现在让我们如下编译上述示例：

C:\>javac TestApplication.java
C:\>

当您运行TestApplication时，它会产生以下结果：

C:\>java TestApplication
Created table in given database...
C:\>

JDBC - 删除表

本章提供了一个使用 JDBC 应用程序删除表的示例。在执行以下示例之前，请确保您已准备好以下内容：

• 要执行以下示例，您可以将用户名和密码替换为您实际的用户名和密码。

• 您正在使用的 MySQL 或任何其他数据库正在运行。

注意重新格式化 JDBC 教程这是一个严重的操作，在继续删除表之前，您必须做出坚定的决定，因为您表中的所有内容都将丢失。

必要步骤

使用 JDBC 应用程序创建新数据库需要以下步骤：

• 导入包 - 需要包含用于数据库编程的JDBC类所在的包。大多数情况下，使用import java.sql.*就足够了。

• 打开连接 - 需要使用DriverManager.getConnection()方法创建 Connection 对象，该对象表示与数据库服务器的物理连接。

• 执行查询重新格式化 JDBC 教程需要使用 Statement 类型的对象来构建和提交在选定数据库中删除表的 SQL 语句。

• 清理环境重新格式化 JDBC 教程try with resources 会自动关闭资源。

示例代码

将以下示例复制并粘贴到 JDBCExample.java 中，编译并运行如下：

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

public class JDBCExample {
   static final String DB_URL = "jdbc:mysql://127.0.0.1/TUTORIALSPOINT";
   static final String USER = "guest";
   static final String PASS = "guest123";

   public static void main(String[] args) {
      // Open a connection
      try(Connection conn = DriverManager.getConnection(DB_URL, USER, PASS);
         Statement stmt = conn.createStatement();
      ) {		      
         String sql = "DROP TABLE REGISTRATION";
         stmt.executeUpdate(sql);
         System.out.println("Table deleted in given database...");   	  
      } catch (SQLException e) {
         e.printStackTrace();
      } 
   }
}

现在让我们如下编译上述示例：

C:\>javac JDBCExample.java
C:\>

运行JDBCExample时，它会产生以下结果 -

C:\>java JDBCExample
Table deleted in given database...
C:\>

JDBC - 插入记录

本章提供了一个使用 JDBC 应用程序在表中插入记录的示例。在执行以下示例之前，请确保您已准备好以下内容：

• 要执行以下示例，您可以将用户名和密码替换为您实际的用户名和密码。

• 您正在使用的 MySQL 或任何其他数据库正在运行。

必要步骤

使用 JDBC 应用程序创建新数据库需要以下步骤：

• 导入包 - 需要包含用于数据库编程的JDBC类所在的包。大多数情况下，使用import java.sql.*就足够了。

• 注册 JDBC 驱动程序 - 需要初始化一个驱动程序，以便您可以打开与数据库的通信通道。

• 打开连接 - 需要使用DriverManager.getConnection()方法创建 Connection 对象，该对象表示与数据库服务器的物理连接。

• 执行查询 - 需要使用 Statement 类型的对象来构建和提交将记录插入表的 SQL 语句。

• 清理环境try with resources 会自动关闭资源。

示例代码

将以下示例复制并粘贴到 JDBCExample.java 中，编译并运行如下：

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

public class JDBCExample {
   static final String DB_URL = "jdbc:mysql://127.0.0.1/TUTORIALSPOINT";
   static final String USER = "guest";
   static final String PASS = "guest123";

   public static void main(String[] args) {
      // Open a connection
      try(Connection conn = DriverManager.getConnection(DB_URL, USER, PASS);
         Statement stmt = conn.createStatement();
      ) {		      
         // Execute a query
         System.out.println("Inserting records into the table...");          
         String sql = "INSERT INTO Registration VALUES (100, 'Zara', 'Ali', 18)";
         stmt.executeUpdate(sql);
         sql = "INSERT INTO Registration VALUES (101, 'Mahnaz', 'Fatma', 25)";
         stmt.executeUpdate(sql);
         sql = "INSERT INTO Registration VALUES (102, 'Zaid', 'Khan', 30)";
         stmt.executeUpdate(sql);
         sql = "INSERT INTO Registration VALUES(103, 'Sumit', 'Mittal', 28)";
         stmt.executeUpdate(sql);
         System.out.println("Inserted records into the table...");   	  
      } catch (SQLException e) {
         e.printStackTrace();
      } 
   }
}

现在让我们如下编译上述示例：

C:\>javac JDBCExample.java
C:\>

运行JDBCExample时，它会产生以下结果 -

C:\>java JDBCExample
Inserting records into the table...
Inserted records into the table...
C:\>

JDBC - 选择记录

本章提供了一个使用 JDBC 应用程序从表中选择/获取记录的示例。在执行以下示例之前，请确保您已准备好以下内容：

• 要执行以下示例，您可以将用户名和密码替换为您实际的用户名和密码。

• 您正在使用的 MySQL 或任何其他数据库正在运行。

必要步骤

使用 JDBC 应用程序创建新数据库需要以下步骤：

• 导入包 - 需要包含用于数据库编程的JDBC类所在的包。大多数情况下，使用import java.sql.*就足够了。

• 打开连接 - 需要使用DriverManager.getConnection()方法创建 Connection 对象，该对象表示与数据库服务器的物理连接。

• 执行查询 - 需要使用 Statement 类型的对象来构建和提交从表中选择（即获取）记录的 SQL 语句。

• 提取数据 - 执行 SQL 查询后，您可以从表中获取记录。

• 清理环境 - try with resources 会自动关闭资源。

示例代码

将以下示例复制并粘贴到 JDBCExample.java 中，编译并运行如下：

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

public class JDBCExample {
   static final String DB_URL = "jdbc:mysql://127.0.0.1/TUTORIALSPOINT";
   static final String USER = "guest";
   static final String PASS = "guest123";
   static final String QUERY = "SELECT id, first, last, age FROM Registration";

   public static void main(String[] args) {
      // Open a connection
      try(Connection conn = DriverManager.getConnection(DB_URL, USER, PASS);
         Statement stmt = conn.createStatement();
         ResultSet rs = stmt.executeQuery(QUERY);
      ) {		      
         while(rs.next()){
            //Display values
            System.out.print("ID: " + rs.getInt("id"));
            System.out.print(", Age: " + rs.getInt("age"));
            System.out.print(", First: " + rs.getString("first"));
            System.out.println(", Last: " + rs.getString("last"));
         }
      } catch (SQLException e) {
         e.printStackTrace();
      } 
   }
}

现在让我们如下编译上述示例：

C:\>javac JDBCExample.java
C:\>

运行JDBCExample时，它会产生以下结果 -

C:\>java JDBCExample
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
C:\>

JDBC - 更新记录

本章提供了一个使用 JDBC 应用程序更新表中记录的示例。在执行以下示例之前，请确保您已准备好以下内容：

• 要执行以下示例，您可以将用户名和密码替换为您实际的用户名和密码。

• 您正在使用的 MySQL 或任何其他数据库正在运行。

必要步骤

使用 JDBC 应用程序创建新数据库需要以下步骤：

• 导入包 - 需要包含用于数据库编程的JDBC类所在的包。大多数情况下，使用import java.sql.*就足够了。

• 打开连接 - 需要使用DriverManager.getConnection()方法创建 Connection 对象，该对象表示与数据库服务器的物理连接。

• 执行查询 - 需要使用 Statement 类型的对象来构建和提交更新表中记录的 SQL 语句。此查询使用IN和WHERE子句来更新条件记录。

• 清理环境 - try with resources 会自动关闭资源。

示例代码

将以下示例复制并粘贴到 JDBCExample.java 中，编译并运行如下：

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

public class JDBCExample {
   static final String DB_URL = "jdbc:mysql://127.0.0.1/TUTORIALSPOINT";
   static final String USER = "guest";
   static final String PASS = "guest123";
   static final String QUERY = "SELECT id, first, last, age FROM Registration";

   public static void main(String[] args) {
      // Open a connection
      try(Connection conn = DriverManager.getConnection(DB_URL, USER, PASS);
         Statement stmt = conn.createStatement();
      ) {		      
         String sql = "UPDATE Registration " +
            "SET age = 30 WHERE id in (100, 101)";
         stmt.executeUpdate(sql);
         ResultSet rs = stmt.executeQuery(QUERY);
         while(rs.next()){
            //Display values
            System.out.print("ID: " + rs.getInt("id"));
            System.out.print(", Age: " + rs.getInt("age"));
            System.out.print(", First: " + rs.getString("first"));
            System.out.println(", Last: " + rs.getString("last"));
         }
         rs.close();
      } catch (SQLException e) {
         e.printStackTrace();
      } 
   }
}

现在让我们如下编译上述示例：

C:\>javac JDBCExample.java
C:\>

运行JDBCExample时，它会产生以下结果 -

C:\>java JDBCExample
ID: 100, Age: 30, First: Zara, Last: Ali
ID: 101, Age: 30, First: Mahnaz, Last: Fatma
ID: 102, Age: 30, First: Zaid, Last: Khan
ID: 103, Age: 28, First: Sumit, Last: Mittal
C:\>

JDBC - 删除记录

本章提供了一个使用 JDBC 应用程序从表中删除记录的示例。在执行以下示例之前，请确保您已准备好以下内容：

• 要执行以下示例，您可以将用户名和密码替换为您实际的用户名和密码。

• 您正在使用的 MySQL 或任何其他数据库正在运行。

必要步骤

使用 JDBC 应用程序创建新数据库需要以下步骤：

• 导入包 - 需要包含用于数据库编程的JDBC类所在的包。大多数情况下，使用import java.sql.*就足够了。

• 注册 JDBC 驱动程序 - 需要初始化一个驱动程序，以便您可以打开与数据库的通信通道。

• 打开连接 - 需要使用DriverManager.getConnection()方法创建 Connection 对象，该对象表示与数据库服务器的物理连接。

• 执行查询 - 需要使用 Statement 类型的对象来构建和提交从表中删除记录的 SQL 语句。此查询使用WHERE子句来删除条件记录。

• 清理环境 - try with resources 会自动关闭资源。

示例代码

将以下示例复制并粘贴到 JDBCExample.java 中，编译并运行如下：

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

public class JDBCExample {
   static final String DB_URL = "jdbc:mysql://127.0.0.1/TUTORIALSPOINT";
   static final String USER = "guest";
   static final String PASS = "guest123";
   static final String QUERY = "SELECT id, first, last, age FROM Registration";

   public static void main(String[] args) {
      // Open a connection
      try(Connection conn = DriverManager.getConnection(DB_URL, USER, PASS);
         Statement stmt = conn.createStatement();
      ) {		      
         String sql = "DELETE FROM Registration " +
            "WHERE id = 101";
         stmt.executeUpdate(sql);
         ResultSet rs = stmt.executeQuery(QUERY);
         while(rs.next()){
            //Display values
            System.out.print("ID: " + rs.getInt("id"));
            System.out.print(", Age: " + rs.getInt("age"));
            System.out.print(", First: " + rs.getString("first"));
            System.out.println(", Last: " + rs.getString("last"));
         }
         rs.close();
      } catch (SQLException e) {
         e.printStackTrace();
      } 
   }
}

现在让我们如下编译上述示例：

C:\>javac JDBCExample.java
C:\>

运行JDBCExample时，它会产生以下结果 -

C:\>java JDBCExample
ID: 100, Age: 30, First: Zara, Last: Ali
ID: 102, Age: 30, First: Zaid, Last: Khan
ID: 103, Age: 28, First: Sumit, Last: Mittal
C:\>

JDBC - WHERE 子句

本章提供了一个使用 JDBC 应用程序从表中选择记录的示例。这将使用 WHERE 子句添加其他条件，以便从表中选择记录。在执行以下示例之前，请确保您已准备好以下内容：

• 要执行以下示例，您可以将用户名和密码替换为您实际的用户名和密码。

• 您正在使用的 MySQL 或任何其他数据库正在运行。

必要步骤

使用 JDBC 应用程序创建新数据库需要以下步骤：

• 导入包 - 需要包含数据库编程所需的 JDBC 类所在的包。大多数情况下，使用import java.sql.*就足够了。

• 注册 JDBC 驱动程序 - 需要初始化一个驱动程序，以便您可以打开与数据库的通信通道。

• 打开连接 - 需要使用DriverManager.getConnection()方法创建 Connection 对象，该对象表示与数据库服务器的物理连接。

• 执行查询 - 需要使用 Statement 类型的对象来构建和提交从表中获取满足给定条件的记录的 SQL 语句。此查询使用WHERE子句来选择记录。

• 清理环境 - try with resources 会自动关闭资源。

示例代码

将以下示例复制并粘贴到 TestApplication.java 中，编译并运行如下：

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

public class TestApplication {
   static final String DB_URL = "jdbc:mysql://127.0.0.1/TUTORIALSPOINT";
   static final String USER = "guest";
   static final String PASS = "guest123";
   static final String QUERY = "SELECT id, first, last, age FROM Registration";

   public static void main(String[] args) {
      // Open a connection
      try(Connection conn = DriverManager.getConnection(DB_URL, USER, PASS);
         Statement stmt = conn.createStatement();) {		      
         System.out.println("Fetching records without condition...");
         ResultSet rs = stmt.executeQuery(QUERY);
         while(rs.next()){
            //Display values
            System.out.print("ID: " + rs.getInt("id"));
            System.out.print(", Age: " + rs.getInt("age"));
            System.out.print(", First: " + rs.getString("first"));
            System.out.println(", Last: " + rs.getString("last"));
         }

         // Select all records having ID equal or greater than 101
         System.out.println("Fetching records with condition...");
         String sql = "SELECT id, first, last, age FROM Registration" +
            " WHERE id >= 101 ";
         rs = stmt.executeQuery(sql);

         while(rs.next()){
            //Display values
            System.out.print("ID: " + rs.getInt("id"));
            System.out.print(", Age: " + rs.getInt("age"));
            System.out.print(", First: " + rs.getString("first"));
            System.out.println(", Last: " + rs.getString("last"));
         }
         rs.close();
      } catch (SQLException e) {
         e.printStackTrace();
      } 
   }
}

现在让我们如下编译上述示例：

C:\>javac TestApplication.java
C:\>

当您运行TestApplication时，它会产生以下结果：

C:\>java TestApplication
Fetching records without condition...
ID: 100, Age: 30, First: Zara, Last: Ali
ID: 102, Age: 30, First: Zaid, Last: Khan
ID: 103, Age: 28, First: Sumit, Last: Mittal
Fetching records with condition...
ID: 102, Age: 30, First: Zaid, Last: Khan
ID: 103, Age: 28, First: Sumit, Last: Mittal
C:\>

JDBC - LIKE 子句

本章提供了一个使用 JDBC 应用程序从表中选择记录的示例。这将使用 LIKE 子句添加其他条件，以便从表中选择记录。在执行以下示例之前，请确保您已准备好以下内容：

• 要执行以下示例，您可以将用户名和密码替换为您实际的用户名和密码。

• 您正在使用的 MySQL 或任何其他数据库正在运行。

必要步骤

使用 JDBC 应用程序创建新数据库需要以下步骤：

• 导入包 - 需要包含用于数据库编程的JDBC类所在的包。大多数情况下，使用import java.sql.*就足够了。

• 打开连接 - 需要使用DriverManager.getConnection()方法创建 Connection 对象，该对象表示与数据库服务器的物理连接。

• 执行查询 - 需要使用 Statement 类型的对象来构建和提交从表中获取满足给定条件的记录的 SQL 语句。此查询使用LIKE子句来选择记录，以选择所有名字以“za”开头的学生。

• 清理环境 - try with resources 会自动关闭资源。

示例代码

将以下示例复制并粘贴到 JDBCExample.java 中，编译并运行如下：

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

public class JDBCExample {
   static final String DB_URL = "jdbc:mysql://127.0.0.1/TUTORIALSPOINT";
   static final String USER = "guest";
   static final String PASS = "guest123";
   static final String QUERY = "SELECT id, first, last, age FROM Registration";

   public static void main(String[] args) {
      // Open a connection
      try(Connection conn = DriverManager.getConnection(DB_URL, USER, PASS);
         Statement stmt = conn.createStatement();) {		      
         System.out.println("Fetching records without condition...");
         ResultSet rs = stmt.executeQuery(QUERY);
         while(rs.next()){
            //Display values
            System.out.print("ID: " + rs.getInt("id"));
            System.out.print(", Age: " + rs.getInt("age"));
            System.out.print(", First: " + rs.getString("first"));
            System.out.println(", Last: " + rs.getString("last"));
         }

         // Select all records having ID equal or greater than 101
         System.out.println("Fetching records with condition...");
         String sql = "SELECT id, first, last, age FROM Registration" +
            " WHERE first LIKE '%za%'";
         rs = stmt.executeQuery(sql);

         while(rs.next()){
            //Display values
            System.out.print("ID: " + rs.getInt("id"));
            System.out.print(", Age: " + rs.getInt("age"));
            System.out.print(", First: " + rs.getString("first"));
            System.out.println(", Last: " + rs.getString("last"));
         }
         rs.close();
      } catch (SQLException e) {
         e.printStackTrace();
      } 
   }
}

现在让我们如下编译上述示例：

C:\>javac JDBCExample.java
C:\>

运行JDBCExample时，它会产生以下结果 -

C:\>java JDBCExample
Fetching records without condition...
ID: 100, Age: 30, First: Zara, Last: Ali
ID: 102, Age: 30, First: Zaid, Last: Khan
ID: 103, Age: 28, First: Sumit, Last: Mittal
Fetching records with condition...
ID: 100, Age: 30, First: Zara, Last: Ali
ID: 102, Age: 30, First: Zaid, Last: Khan
C:\>

JDBC - 数据排序

本章提供了一个使用 JDBC 应用程序对表中的记录进行排序的示例。这将使用asc和desc关键字按升序或降序对记录进行排序。在执行以下示例之前，请确保您已准备好以下内容：

• 要执行以下示例，您可以将用户名和密码替换为您实际的用户名和密码。

• 您正在使用的 MySQL 或任何其他数据库正在运行。

必要步骤

使用 JDBC 应用程序创建新数据库需要以下步骤：

• 导入包 - 需要包含用于数据库编程的JDBC类所在的包。大多数情况下，使用import java.sql.*就足够了。

• 打开连接 - 需要使用DriverManager.getConnection()方法创建 Connection 对象，该对象表示与数据库服务器的物理连接。

• 执行查询 - 需要使用 Statement 类型的对象来构建和提交对表中的记录进行排序的 SQL 语句。这些查询使用asc和desc子句按升序和降序对数据进行排序。

• 清理环境 - try with resources 会自动关闭资源。

示例代码

将以下示例复制并粘贴到 JDBCExample.java 中，编译并运行如下：

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

public class JDBCExample {
   static final String DB_URL = "jdbc:mysql://127.0.0.1/TUTORIALSPOINT";
   static final String USER = "guest";
   static final String PASS = "guest123";
   static final String QUERY = "SELECT id, first, last, age FROM Registration";

   public static void main(String[] args) {
      // Open a connection
      try(Connection conn = DriverManager.getConnection(DB_URL, USER, PASS);
         Statement stmt = conn.createStatement();) {		      
         System.out.println("Fetching records in ascending order...");
         ResultSet rs = stmt.executeQuery(QUERY + " ORDER BY first ASC");
         while(rs.next()){
            //Display values
            System.out.print("ID: " + rs.getInt("id"));
            System.out.print(", Age: " + rs.getInt("age"));
            System.out.print(", First: " + rs.getString("first"));
            System.out.println(", Last: " + rs.getString("last"));
         }

         System.out.println("Fetching records in descending order...");
         rs = stmt.executeQuery(QUERY + " ORDER BY first DESC");
         while(rs.next()){
            //Display values
            System.out.print("ID: " + rs.getInt("id"));
            System.out.print(", Age: " + rs.getInt("age"));
            System.out.print(", First: " + rs.getString("first"));
            System.out.println(", Last: " + rs.getString("last"));
         }
         rs.close();
      } catch (SQLException e) {
         e.printStackTrace();
      } 
   }
}

现在让我们如下编译上述示例：

C:\>javac JDBCExample.java
C:\>

运行JDBCExample时，它会产生以下结果 -

C:\>java JDBCExample
Fetching records in ascending order...
ID: 103, Age: 28, First: Sumit, Last: Mittal
ID: 102, Age: 30, First: Zaid, Last: Khan
ID: 100, Age: 30, First: Zara, Last: Ali
Fetching records in descending order...
ID: 100, Age: 30, First: Zara, Last: Ali
ID: 102, Age: 30, First: Zaid, Last: Khan
ID: 103, Age: 28, First: Sumit, Last: Mittal
C:\>