JDBC - 快速指南

JDBC - Quick Guidehttps://www.tutorialspoint.com/jdbc/jdbc-quick-guide.htm

JDBC - 简介

什么是 JDBC？

JDBC代表Java数据库连接性，它是一种标准的Java API ，用于在Java编程语言和各种数据库之间实现与数据库无关的连接。

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

• 建立与数据库的连接。

• 创建 SQL 或 MySQL 语句。

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

• 查看和修改结果记录。

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

• Java 应用程序

• Java 小程序

• Java 小服务程序

• Java 服务器页面 (JSP)

• 企业 JavaBeans (EJB)。

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

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

先决条件

在进一步前进之前，您需要对以下两个主题有一个很好的了解 -

• 核心 JAVA 编程

• SQL 或 MySQL 数据库

JDBC 架构

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

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

• JDBC Driver API - 这支持 JDBC Manager-to-Driver Connection。

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 语法

结构化查询语言(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 语句在之前创建的员工数据库中插入一个新行 -

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 语句从雇员表中选择年龄、第一列和最后一列，其中 id 列是 100 -

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

下面的 SQL 语句从雇员表中选择年龄、第一列和最后一列，其中第一列包含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 的员工的年龄列 -

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 设置路径

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

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

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

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

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

为 Windows 95/98/ME 设置路径

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

• 编辑“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 和密码，也可以为 JDBC 应用程序使用 root ID 和密码。

数据库创建和删除等各种数据库操作都需要管理员ID和密码。

对于 JDBC 教程的其余部分，我们将使用 MySQL 数据库，guest作为 ID，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 数据库中创建员工表，请使用以下步骤 -

第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://localhost/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 驱动程序类型

由于 Java 运行的操作系统和硬件平台种类繁多，JDBC 驱动程序的实现会有所不同。Sun 将实现类型分为四类，类型 1、2、3 和 4，解释如下 -

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

在 Type 1 驱动程序中，JDBC 桥用于访问安装在每台客户机上的 ODBC 驱动程序。使用 ODBC，需要在您的系统上配置代表目标数据库的数据源名称 (DSN)。

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

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

类型 2 - JDBC-Native API

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

如果我们更改数据库，我们必须更改本机 API，因为它是特定于数据库的，现在它们大多已过时，但您可能会意识到使用 Type 2 驱动程序可以提高速度，因为它消除了 ODBC 的开销。

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

类型 3 - JDBC-Net 纯 Java

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

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

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

您的应用程序服务器可能使用 Type 1、2 或 4 驱动程序与数据库进行通信，了解其中的细微差别会很有帮助。

类型 4 - 100% 纯 Java

在 Type 4 驱动程序中，纯基于 Java 的驱动程序通过套接字连接直接与供应商的数据库通信。这是数据库可用的最高性能驱动程序，通常由供应商自己提供。

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

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

应该使用哪个驱动程序？

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

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

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

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

JDBC - 连接

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

建立 JDBC 连接所涉及的编程相当简单。这是这些简单的四个步骤 -

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

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

• Database URL Formulation - 这是创建一个格式正确的地址，指向您希望连接的数据库。

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

导入 JDBC 包

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

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

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（字符串 url，属性道具）

• getConnection(字符串 url, 字符串用户, 字符串密码)

这里每个表单都需要一个数据库URL。数据库 URL 是指向您的数据库的地址。

制定数据库 URL 是与建立连接相关的大多数问题发生的地方。

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

关系型数据库管理系统	JDBC 驱动程序名称	网址格式
MySQL	com.mysql.jdbc.Driver	jdbc:mysql://主机名/数据库名
甲骨文	oracle.jdbc.driver.OracleDriver	jdbc:oracle:thin:@主机名:端口号:数据库名
DB2	COM.ibm.db2.jdbc.net.DB2Driver	jdbc:db2:主机名:端口号/数据库名
赛贝斯	com.sybase.jdbc.SybDriver	jdbc:sybase:Tds:主机名: 端口号/数据库名

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

创建连接对象

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

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

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

假设您使用的是 Oracle 的瘦驱动程序，您将为 URL 的数据库部分指定 host:port:databaseName 值。

如果您的 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 数据类型之间的数据类型差异的方法。

下表提供了每个接口用于决定要使用的接口的目的摘要。

接口	推荐使用
陈述	将其用于对数据库的通用访问。在运行时使用静态 SQL 语句时很有用。Statement 接口不能接受参数。
准备好的语句	当您计划多次使用 SQL 语句时使用它。PreparedStatement 接口在运行时接受输入参数。
可调用语句	当您想要访问数据库存储过程时使用它。CallableStatement 接口还可以接受运行时输入参数。

语句对象

创建语句对象

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

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

一旦您创建了一个 Statement 对象，您就可以使用它通过它的三种执行方法之一来执行一条 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 语句一样。

结束语句对象

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

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

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

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

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 数组索引，后者从 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 - Example Code。

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 对象可以使用所有这三个。

以下是每个的定义 -

范围	描述
在	创建 SQL 语句时其值未知的参数。您可以使用 setXXX() 方法将值绑定到 IN 参数。
出去	一个参数，其值由它返回的 SQL 语句提供。您可以使用 getXXX() 方法从 OUT 参数中检索值。
进出	提供输入和输出值的参数。您使用 setXXX() 方法绑定变量并使用 getXXX() 方法检索值。

下面的代码片段展示了如何使用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 - Example Code。

JDBC - 结果集

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

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

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

• 导航方法- 用于移动光标。

• Get 方法- 用于查看光标指向的当前行的列中的数据。

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

光标可根据 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 常量之一。

结果集的类型

下面给出了可能的 RSType。如果您不指定任何 ResultSet 类型，您将自动获得一个 TYPE_FORWARD_ONLY。

类型	描述
ResultSet.TYPE_FORWARD_ONLY	光标只能在结果集中向前移动。
ResultSet.TYPE_SCROLL_INSENSITIVE	游标可以前后滚动，结果集对其他人在创建结果集后对数据库所做的更改不敏感。
结果集.TYPE_SCROLL_SENSITIVE。	游标可以前后滚动，结果集对其他人在创建结果集后对数据库所做的更改很敏感。

结果集的并发性

下面给出了可能的 RSConcurrency。如果您没有指定任何并发类型，您将自动获得一个是 CONCUR_READ_ONLY。

并发	描述
结果集.CONCUR_READ_ONLY	创建只读结果集。这是默认设置
结果集.CONCUR_UPDATABLE	创建一个可更新的结果集。

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

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

导航结果集

ResultSet 接口中有几种方法涉及移动光标，包括 -

序列号	方法和描述
1	public void beforeFirst() 抛出 SQLException 将光标移动到第一行之前。
2	public void afterLast() 抛出 SQLException 将光标移动到最后一行之后。
3	public boolean first() 抛出 SQLException 将光标移动到第一行。
4	public void last() 抛出 SQLException 将光标移动到最后一行。
5	公共布尔绝对值（int 行）抛出 SQLException 将光标移动到指定行。
6	公共布尔相对（int 行）抛出 SQLException 将光标从当前指向的位置向前或向后移动给定的行数。
7	public boolean previous() 抛出 SQLException 将光标移动到上一行。如果前一行不在结果集中，则此方法返回 false。
8	public boolean next() 抛出 SQLException 将光标移动到下一行。如果结果集中没有更多行，则此方法返回 false。
9	公共 int getRow() 抛出 SQLException 返回游标指向的行号。
10	公共 void moveToInsertRow() 抛出 SQLException 将光标移动到结果集中可用于将新行插入数据库的特殊行。当前光标位置被记住。
11	公共 void moveToCurrentRow() 抛出 SQLException 如果光标当前位于插入行，则将光标移回当前行；否则，这个方法什么也不做

为了更好地理解，让我们学习Navigate - Example Code。

查看结果集

ResultSet 接口包含几十种获取当前行数据的方法。

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

• 一个接受列名的。

• 一个接受列索引的。

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

序列号	方法和描述
1	公共 int getInt(String columnName) 抛出 SQLException 在名为 columnName 的列中返回当前行中的 int。
2	公共 int getInt(int columnIndex) 抛出 SQLException 返回指定列索引中当前行的 int。列索引从 1 开始，表示行的第一列是 1，行的第二列是 2，依此类推。

类似地，ResultSet 接口中的八种 Java 基本类型中的每一种都有 get 方法，以及 java.lang.String、java.lang.Object 和 java.net.URL 等常见类型。

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

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

更新结果集

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

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

• 一个接受列名的。

• 一个接受列索引的。

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

序列号	方法和描述
1	public void updateString(int columnIndex, String s) 抛出 SQLException 将指定列中的 String 更改为 s 的值。
2	public void updateString(String columnName, String s) 抛出 SQLException 与前面的方法类似，只是列是由其名称而不是其索引指定的。

java.sql 包中的八种原始数据类型以及 String、Object、URL 和 SQL 数据类型都有更新方法。

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

序列号	方法和描述
1	公共无效更新行（） 通过更新数据库中的相应行来更新当前行。
2	公共无效删除行（） 从数据库中删除当前行
3	公共无效刷新行（） 刷新结果集中的数据以反映数据库中最近的任何更改。
4	公共无效取消行更新（） 取消对当前行所做的任何更新。
5	公共无效插入行（） 在数据库中插入一行。只有当游标指向插入行时才能调用此方法。

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

JDBC - 数据类型

JDBC 驱动程序将 Java 数据类型转换为适当的 JDBC 类型，然后再将其发送到数据库。它对大多数数据类型使用默认映射。例如，Java int 被转换为 SQL INTEGER。创建默认映射以提供驱动程序之间的一致性。

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

SQL	JDBC/Java	setXXX	updateXXX
VARCHAR	java.lang.String	setString	updateString
CHAR	java.lang.String	setString	updateString
LONGVARCHAR	java.lang.String	setString	updateString
BIT	boolean	setBoolean	updateBoolean
NUMERIC	java.math.BigDecimal	setBigDecimal	updateBigDecimal
TINYINT	byte	setByte	updateByte
SMALLINT	short	setShort	updateShort
INTEGER	int	setInt	updateInt
BIGINT	long	setLong	updateLong
REAL	float	setFloat	updateFloat
FLOAT	float	setFloat	updateFloat
DOUBLE	double	setDouble	updateDouble
VARBINARY	byte[ ]	setBytes	updateBytes
BINARY	byte[ ]	setBytes	updateBytes
DATE	java.sql.Date	setDate	updateDate
TIME	java.sql.Time	setTime	updateTime
TIMESTAMP	java.sql.Timestamp	setTimestamp	updateTimestamp
CLOB	java.sql.Clob	setClob	updateClob
BLOB	java.sql.Blob	setBlob	updateBlob
ARRAY	java.sql.Array	setARRAY	updateARRAY
REF	java.sql.Ref	SetRef	updateRef
STRUCT	java.sql.Struct	SetStruct	updateStruct

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

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

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

SQL	JDBC/Java	setXXX	getXXX
VARCHAR	java.lang.String	setString	getString
CHAR	java.lang.String	setString	getString
LONGVARCHAR	java.lang.String	setString	getString
BIT	boolean	setBoolean	getBoolean
NUMERIC	java.math.BigDecimal	setBigDecimal	getBigDecimal
TINYINT	byte	setByte	getByte
SMALLINT	short	setShort	getShort
INTEGER	int	setInt	getInt
BIGINT	long	setLong	getLong
REAL	float	setFloat	getFloat
FLOAT	float	setFloat	getFloat
DOUBLE	double	setDouble	getDouble
VARBINARY	byte[ ]	setBytes	getBytes
BINARY	byte[ ]	setBytes	getBytes
DATE	java.sql.Date	setDate	getDate
TIME	java.sql.Time	setTime	getTime
TIMESTAMP	java.sql.Timestamp	setTimestamp	getTimestamp
CLOB	java.sql.Clob	setClob	getClob
BLOB	java.sql.Blob	setBlob	getBlob
ARRAY	java.sql.Array	setARRAY	getARRAY
REF	java.sql.Ref	SetRef	getRef
STRUCT	java.sql.Struct	SetStruct	getStruct

日期和时间数据类型

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

以下示例显示日期和时间类如何格式化标准 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 的连接对数据库进行的更新，请使用以下代码 -

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 语句都不会成功，所有内容都将回滚。

为了更好地理解，让我们研究Commit - Example Code。

使用保存点

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

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

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

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

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

有一种回滚 (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 语句都不会成功，所有内容都将回滚。

为了更好地理解，让我们研究一下Savepoints - Example Code。

JDBC - 异常

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

当异常条件发生时，就会抛出异常。术语 throwed 意味着当前程序执行停止，并且控制被重定向到最近的适用 catch 子句。如果不存在适用的 catch 子句，则程序的执行结束。

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

SQLException 方法

SQLException 可能发生在驱动程序和数据库中。当这样的异常发生时，一个 SQLException 类型的对象将被传递给 catch 子句。

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

方法	描述
getErrorCode( )	获取与异常关联的错误号。
getMessage( )	获取 JDBC 驱动程序的错误消息，由驱动程序处理或获取 Oracle 错误号和数据库错误消息。
getSQLState( )	获取 XOPEN SQLstate 字符串。对于 JDBC 驱动程序错误，此方法不会返回任何有用信息。对于数据库错误，返回五位 XOPEN SQLstate 代码。此方法可以返回 null。
getNextException( )	获取异常链中的下一个 Exception 对象。
printStackTrace( )	打印当前异常或可抛出异常，它是标准错误流的回溯。
printStackTrace(PrintStream s)	将此 throwable 及其回溯打印到您指定的打印流。
printStackTrace(PrintWriter w)	打印这个 throwable 并回溯到您指定的打印编写器。

通过利用 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://localhost/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() 方法添加的所有语句。但是，您不能有选择地选择要删除的语句。

使用语句对象进行批处理

这是将批处理与语句对象一起使用的典型步骤序列 -

• 使用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 对象可以使用所有这三个。

以下是每个的定义 -

范围	描述
IN	创建 SQL 语句时其值未知的参数。您可以使用 setXXX() 方法将值绑定到 IN 参数。
OUT	一个参数，其值由它返回的 SQL 语句提供。您可以使用 getXXX() 方法从 OUT 参数中检索值。
INOUT	提供输入和输出值的参数。您使用 setXXX() 方法绑定变量并使用 getXXX() 方法检索值。

下面的代码片段展示了如何使用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-Example Code中研究了更多细节。

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' 表示时间戳的上述两种语法的组合语法。

转义关键字

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

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

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

fn 关键字

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

{fn length('Hello World')}

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

调用关键字

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

{call my_procedure(?)};

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

{? = call my_procedure(?)};

oj 关键字

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

{oj outer-join}

其中外连接 = 表 {LEFT|RIGHT|FULL} OUTERJOIN {table | 搜索条件下的外部连接}。例如 -

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://localhost/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://localhost/";
   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数据库建立连接。

• 清理环境- 尝试使用资源会自动关闭资源。

示例代码

将以下示例复制并粘贴到 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://localhost/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 语句以删除数据库。

• 清理环境- 尝试使用资源会自动关闭资源。

示例代码

将以下示例复制并粘贴到 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://localhost/";
   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 语句以在选定的数据库中创建表。

• 清理环境- 尝试使用资源会自动关闭资源。

示例代码

将以下示例复制并粘贴到 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://localhost/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 语句以在选定的数据库中删除表。

• 清理环境Reformatting JDBC Tutorial 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://localhost/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 语句以将记录插入表中。

• 清理环境尝试使用资源自动关闭资源。

示例代码

将以下示例复制并粘贴到 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://localhost/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 查询后，您可以从表中获取记录。

• 清理环境 - 尝试使用资源会自动关闭资源。

示例代码

将以下示例复制并粘贴到 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://localhost/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子句来更新条件记录。

• 清理环境- 尝试使用资源会自动关闭资源。

示例代码

将以下示例复制并粘贴到 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://localhost/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子句来删除条件记录。

• 清理环境- 尝试使用资源会自动关闭资源。

示例代码

将以下示例复制并粘贴到 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://localhost/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子句来选择记录。

• 清理环境- 尝试使用资源会自动关闭资源。

示例代码

将以下示例复制并粘贴到 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://localhost/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”开头的学生。

• 清理环境- 尝试使用资源会自动关闭资源。

示例代码

将以下示例复制并粘贴到 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://localhost/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子句按升序和降序对数据进行排序。

• 清理环境- 尝试使用资源会自动关闭资源。

示例代码

将以下示例复制并粘贴到 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://localhost/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:\>