TutorialsPoint JDBC 教程

来源：易百教程

JDBC教程

JDBC API是一个Java API可以访问任何类型的表格格式数据，存储在一个关系数据库尤其是数据。 JDBC的工作原理与Java在各种平台一样，如Windows，Mac OS和各种版本的UNIX。

读者

本教程是为Java程序员设计的，需要了解JDBC框架的细节以及它的架构和实际使用情况。

必备条件

在继续本教程，应该对Java编程语言的一个很好的理解。因为要处理RDBMS，所以它需要对SQL和数据库的概念有很好的理解。

JDBC代表Java数据库连接，这对Java编程语言和广泛的数据库之间独立于数据库的连接标准的Java API。

JDBC库包含的API为每个通常与数据库的使用相关联的任务：

• 使得连接到数据库
• 创建SQL或MySQL语句
• 执行SQL或MySQL的查询数据库
• 查看和修改结果记录

从根本上说，JDBC是一种规范，它提供的接口，一套完整的，允许便携式访问底层数据库。可以用Java来写不同类型的可执行文件，如：

• Java应用程序
• Java Applets
• Java Servlets
• Java ServerPages (JSP)
• Enterprise JavaBeans (EJBs)

所有这些不同的可执行文件就可以使用JDBC驱动程序来访问数据库，并把存储的数据的优势。

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

先决条件：

以前正如期进行本教程，需要具备以下两个主题内容很好的了解：

• 核心Java编程
• SQL或MySQL数据库

JDBC架构：

JDBC API支持两层和三层处理模型进行数据库访问，但在一般的JDBC体系结构由两层组成：

• JDBC API: 提供了应用程序对JDBC的管理连接。
• JDBC Driver API: 支持JDBC管理到驱动器连接。

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

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

以下是结构图，它显示了驱动程序管理器方面的JDBC驱动程序和Java应用程序的位置：

常见的JDBC组件：

JDBC API提供了以下接口和类：

• DriverManager: 这个类管理数据库驱动程序的列表。内容是否符合从Java应用程序使用的通信子协议正确的数据库驱动程序的连接请求。识别JDBC在一定子协议的第一个驱动器将被用来建立数据库连接。
• Driver: 此接口处理与数据库服务器通信。很少直接与驱动程序对象。相反，使用DriverManager中的对象，它管理此类型的对象。它也抽象与驱动程序对象工作相关的详细信息
• Connection : 此接口与接触数据库的所有方法。连接对象表示通信上下文，即，与数据库中的所有的通信是通过唯一的连接对象。
• Statement : 可以使用这个接口创建的对象的SQL语句提交到数据库。一些派生的接口接受除执行存储过程的参数。
• ResultSet: 这些对象保存从数据库后，执行使用Statement对象的SQL查询中检索数据。它作为一个迭代器，让您可以通过移动它的数据。
• SQLException: 这个类处理发生在一个数据库应用程序的任何错误。

JDBC 4.0软件包

对JDBC4.0，java.sql和javax.sql是主要的包。这是最新版本的JDBC在写这篇教程的时候。它提供的主要类与数据源进行交互。

在这些包中的新功能包括改变在以下几个方面：

• 自动数据库驱动程序加载
• 异常处理的改进
• 增强的BLOB/ CLOB功能
• 连接和语句界面增强
• 国家字符集支持
• SQL ROWID访问
• SQL 2003 XML数据类型支持
• 注释

JDBC4简介，JDBC是什么？ - JDBC教程

JDBC是什么?

JDBC代表Java数据库连接，这对Java编程语言和广泛的数据库之间独立于数据库的连接标准的Java API。

JDBC库包含的API为每个通常与数据库的使用相关联的任务：

• 使得连接到数据库
• 创建SQL或MySQL语句
• 执行SQL或MySQL的查询数据库
• 查看和修改结果记录

从根本上说，JDBC是一种规范，它提供的接口，一套完整的，允许便携式访问底层数据库。可以用Java来写不同类型的可执行文件，如：

• Java应用程序
• Java Applets
• Java Servlets
• Java ServerPages (JSP)
• Enterprise JavaBeans (EJBs)

所有这些不同的可执行文件就可以使用JDBC驱动程序来访问数据库，并把存储的数据的优势。

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

先决条件：

以前正如期进行本教程，需要具备以下两个主题内容很好的了解：

• 核心Java编程
• SQL或MySQL数据库

JDBC架构：

JDBC API支持两层和三层处理模型进行数据库访问，但在一般的JDBC体系结构由两层组成：

• JDBC API: 提供了应用程序对JDBC的管理连接。
• JDBC Driver API: 支持JDBC管理到驱动器连接。

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

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

以下是结构图，它显示了驱动程序管理器方面的JDBC驱动程序和Java应用程序的位置：

常见的JDBC组件：

JDBC API提供了以下接口和类：

• DriverManager: 这个类管理数据库驱动程序的列表。内容是否符合从Java应用程序使用的通信子协议正确的数据库驱动程序的连接请求。识别JDBC在一定子协议的第一个驱动器将被用来建立数据库连接。
• Driver: 此接口处理与数据库服务器通信。很少直接与驱动程序对象。相反，使用DriverManager中的对象，它管理此类型的对象。它也抽象与驱动程序对象工作相关的详细信息
• Connection : 此接口与接触数据库的所有方法。连接对象表示通信上下文，即，与数据库中的所有的通信是通过唯一的连接对象。
• Statement : 可以使用这个接口创建的对象的SQL语句提交到数据库。一些派生的接口接受除执行存储过程的参数。
• ResultSet: 这些对象保存从数据库后，执行使用Statement对象的SQL查询中检索数据。它作为一个迭代器，让您可以通过移动它的数据。
• SQLException: 这个类处理发生在一个数据库应用程序的任何错误。

JDBC 4.0软件包

对JDBC4.0，java.sql和javax.sql是主要的包。这是最新版本的JDBC在写这篇教程的时候。它提供的主要类与数据源进行交互。

在这些包中的新功能包括改变在以下几个方面：

• 自动数据库驱动程序加载
• 异常处理的改进
• 增强的BLOB/ CLOB功能
• 连接和语句界面增强
• 国家字符集支持
• SQL ROWID访问
• SQL 2003 XML数据类型支持
• 注释

JDBC SQL语法 - JDBC教程

结构化查询语言（SQL）是一种标准化的语言，它允许你在数据库上执行操作，如创建项目，读取内容，内容更新和删除条目。

SQL是所有可能会使用几乎任何数据库支持，它允许独立于底层数据库的写入数据库的代码。

本教程给出的SQL，这是一个先决条件，了解JDBC概述。本教程提供了足够的SQL，以便能够创建，读取，更新和删除（通常被称为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语句用于从数据库中检索数据。该语法的SELECT是：

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

WHERE子句可以使用比较操作符例如=, !=, <, >, <=, >=,以及BETWEEN和LIKE操作符。

例子：

下面的SQL语句从Employees表选择age第一个和最后一列名where id =100：

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

下面的SQL语句从Employees表，其中第一列选择age，第一列包含 Zara:

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

UPDATE 数据:

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语句用来删除表中的数据。语法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设置,按照以下所示的步骤开发JDBC环境。以下内容假设Windows平台上。

安装Java:

安装J2SE开发工具包5.0（JDK 5.0）下载：Java官方网站。

请确保以下环境变量设置，如下所述：

• JAVA_HOME: 此环境变量应该指向安装JDK的目录，例如：C:Program FilesJavajdk1.5.0
• CLASSPATH: 此环境变量应已适当的路径设置，如： C:Program FilesJavajdk1.5.0_20jrelib
• PATH: 此环境变量应指向适当的JRE bin，如： C:Program FilesJavajre1.5.0_20in.

可能已有这些变量设置了，但只是为了确保在这里是如何检查。

• 进入控制面板，双击系统。如果是Windows XP的用户有可能要打开："性能"=》"维护"，会看到系统图标。
• 转到“高级"选项卡，然后单击"环境变量"。
• 现在，选择所有输入的变量设置正确。

将自动获得了JDBC包java.sql和javax.sql，当安装J2SE开发工具包5.0（JDK 5.0）

安装数据库：

将需要当然，最重要的是实际运行的数据库用，可以查询和修改表。

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

• MySQL DB: MySQL是一个开放源码的数据库。可以从这里下载MySQL官方网站，建议下载完整Windows安装。

此外，下载和安装MySQL管理以及MySQL查询浏览器。这些都是基于GUI的工具，这将使开发更加容易。

最后，请下载并在一个方便的目录解压缩的MySQL Connector/J（MySQL JDBC驱动程序）。对于本教程的目的，我们将假设已经安装了驱动程序位于 C:Program FilesMySQLmysql-connector-java-5.1.8.

相应地设置CLASSPATH变量到C:Program FilesMySQLmysql-connector-java-5.1.8mysql-connector-java-5.1.8-bin.jar. 根据安装的驱动程序版本可能会有所不同。

• PostgreSQL DB: PostgreSQL是一个开放源码的数据库。可以从这里下载 PostgreSQL官方网站。

Postgres安装包含一个名为pgAdmin III一个基于GUI管理工具。 JDBC驱动程序也包括作为安装的一部分。

• Oracle DB: Oracle数据库是Oracle销售的商用数据库。假设有必须的分发介质进行安装。

Oracle的安装包括一个名为Enterprise Manager中基于GUI的管理工具。 JDBC驱动程序也包括作为安装的一部分。

安装数据库驱动程序：

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

现在，大多数数据库厂商随数据库的安装提供相应的JDBC驱动程序。所以，不应该担心这部分。

设置数据库认证：

在本教程中，我们将使用MySQL数据库。当安装上述任何数据库，它的管理员ID设置为root，并给出规定设置选择的密码。

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

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

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

如果没有足够的权限来创建新的用户，那么可以让数据库管理员（DBA）来创建一个用户ID和密码给你。

创建数据库：

要创建EMP数据库，请使用下列步骤：

步骤1：

打开命令提示符并更改到安装目录，如下所示：

C:>
C:>cd Program FilesMySQLin
C:Program FilesMySQLin>

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

步骤2：

通过执行下面的命令，如果它没有运行启动数据库服务器。

C:Program FilesMySQLin>mysqld
C:Program FilesMySQLin>

步骤3：

通过执行以下命令来创建数据库EMP

C:Program FilesMySQLin> mysqladmin create EMP -u root -p
Enter password: ********
C:Program FilesMySQLin>

创建表

要创建Employees表中EMP的数据库，请执行以下步骤：

步骤1：

打开命令提示符并更改到安装目录，如下所示：

C:>
C:>cd Program FilesMySQLin
C:Program FilesMySQLin>

步骤2：

登录数据库，如下所示

C:Program FilesMySQLin>mysql -u root -p
Enter password: ********
mysql>

步骤3：

创建Employee表如下：

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

创建数据记录

最后，在Employee表中创建一些记录如下：

mysql> INSERT INTO Employees VALUES (100, 18, 'Zara', 'Ali');
Query OK, 1 row affected (0.05 sec)

mysql> INSERT INTO Employees VALUES (101, 25, 'Mahnaz', 'Fatma');
Query OK, 1 row affected (0.00 sec)

mysql> INSERT INTO Employees VALUES (102, 30, 'Zaid', 'Khan');
Query OK, 1 row affected (0.00 sec)

mysql> INSERT INTO Employees VALUES (103, 28, 'Sumit', 'Mittal');
Query OK, 1 row affected (0.00 sec)

mysql>

关于MySQL数据库的完整认识，学习MySQL教程。

现在，就可以开始使用JDBC尝试。接下来的教程将给予有关JDBC编程的一个样本示例。

JDBC示例代码 - JDBC教程

本教程提供了如何创建一个简单的JDBC应用程序的示例。演示如何打开一个数据库连接，执行SQL查询，并显示结果。

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

创建JDBC应用程序：

有下列涉及构建JDBC应用程序的六个步骤：

• 导入数据包 . 需要包括含有需要进行数据库编程的JDBC类的包。大多数情况下，使用 import java.sql.* 就可以了.
• 注册JDBC驱动程序. 需要初始化驱动程序，可以与数据库打开一个通信通道。
• 打开连接. 需要使用DriverManager.getConnection() 方法创建一个Connection对象，它代表与数据库的物理连接。
• 执行查询 . 需要使用类型声明的对象建立并提交一个SQL语句到数据库。
• 从结果集中提取数据 . 要求使用适当的关于ResultSet.getXXX()方法来检索结果集的数据。
• 清理环境. 需要明确地关闭所有的数据库资源相对依靠JVM的垃圾收集。

示例代码：

这个范例的例子可以作为一个模板，在需要建立JDBC应用程序。

基于对环境和数据库安装在前面的章节中做此示例代码已写入。

复制下面的例子FirstExample.java，编译并运行，如下所示：

//STEP 1\. Import required packages
import java.sql.*;

public class FirstExample {
// JDBC driver name and database URL
static final String JDBC_DRIVER = "com.mysql.jdbc.Driver";
static final String DB_URL = "jdbc:mysql://localhost/EMP";

// Database credentials
static final String USER = "username";
static final String PASS = "password";

public static void main(String[] args) {
Connection conn = null;
Statement stmt = null;
try{
//STEP 2: Register JDBC driver
Class.forName("com.mysql.jdbc.Driver");

//STEP 3: Open a connection
System.out.println("Connecting to database...");
conn = DriverManager.getConnection(DB_URL,USER,PASS);

//STEP 4: Execute a query
System.out.println("Creating statement...");
stmt = conn.createStatement();
String sql;
sql = "SELECT id, first, last, age FROM Employees";
ResultSet rs = stmt.executeQuery(sql);

//STEP 5: Extract data from result set
while(rs.next()){
//Retrieve by column name
int id = rs.getInt("id");
int age = rs.getInt("age");
String first = rs.getString("first");
String last = rs.getString("last");

//Display values
System.out.print("ID: " + id);
System.out.print(", Age: " + age);
System.out.print(", First: " + first);
System.out.println(", Last: " + last);
}
//STEP 6: Clean-up environment
rs.close();
stmt.close();
conn.close();
}catch(SQLException se){
//Handle errors for JDBC
se.printStackTrace();
}catch(Exception e){
//Handle errors for Class.forName
e.printStackTrace();
}finally{
//finally block used to close resources
try{
if(stmt!=null)
stmt.close();
}catch(SQLException se2){
}// nothing we can do
try{
if(conn!=null)
conn.close();
}catch(SQLException se){
se.printStackTrace();
}//end finally try
}//end try
System.out.println("Goodbye!");
}//end main
}//end FirstExample

现在来编译上面的例子如下：

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驱动程序实现JDBC API中定义的接口，用于与数据库服务器进行交互。

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

java.sql包中附带的JDK包含定义各种类与他们的行为和实际实现在第三方驱动程序。第三方供应商实现了他们的数据库驱动程序的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驱动程序，因为它消除了数据库的开销。

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

类型3：JDBC网络纯Java：

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

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

可以将应用服务器作为一个JDBC“代理”，这意味着它会调用客户端应用程序。因此，需要应用服务器的配置，以有效地使用此驱动程序类型的一些知识。

应用服务器可能使用类型1，2，或4驱动程序与数据库进行通信，了解细微之处将证明是有益的。

类型4：100％纯Java：

在一个类型4驱动程序，直接与供应商的数据库进行通信，通过socket连接一个纯粹的基于Java的驱动程序。这是可用于数据库的最高性能的驱动程序，并且通常由供应商本身提供。

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

MySQL的Connector/J的驱动程序是一个类型4驱动程序。因为他们的网络协议的专有性的，数据库厂商通常提供类型4的驱动程序。

其中驱动器应使用？

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

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

第2类驱动程序是在情况下：类型3或类型4驱动程序还没有提供数据库非常有用。

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

JDBC连接数据库 - JDBC教程

在安装相应的驱动程序后，现在是时候建立使用JDBC的数据库连接。

涉及到建立一个JDBC连接的编程是相当简单的。下面是这些简单的四个步骤：

• 导入JDBC包： 添加import语句到Java程序导入所需的类在Java代码中。
• 注册JDBC驱动程序：这一步会导致JVM加载所需的驱动程序实现到内存中，因此它可以实现JDBC请求。
• 数据库URL制定：这是创建格式正确的地址指向到要连接的数据库。
• 创建连接对象：最后，代码调用DriverManager对象的getConnection()方法来建立实际的数据库连接。

导入JDBC包：

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

使用标准的JDBC包，它允许选择，插入，更新和SQL表中删除数据，添加以下进口到您的源代码：

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

注册JDBC驱动程序：

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

需要做这个注册只能在你的程序一次。可以通过以下两种方式之一注册一个驱动程序。

方法（I）- 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()：

可以用它来注册一个驱动程序的第二种方法是使用staticDriverManager.registerDriver()方法。

应该，如果使用的是不兼容的JDK 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格式所有高亮的部分是静态的，需要改变只剩余部分按照数据库设置。

创建连接对象：

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

下面三种形式DriverManager.getConnection()方法来创建一个连接对象。getConnection()最常用形式要求传递一个数据库URL，用户名 username和密码 password：

对URL数据库部分databaseName的值：假设使用的是Oracle的瘦驱动程序，需要指定一个主机：端口。

假设有一台主机TCP/IP地址192.0.0.1 以及主机名和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和一个Properties对象：

第三种形式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 Statements,PreparedStatement和CallableStatement - 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对象，然后可以用它来与它的三个执行方法之一执行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对象增加几个高级功能。

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 例子代码.

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()方法的输出参数检索值。这种方法投射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 PreparedStatement对象实例 - JDBC教程

以下是这使得使用PreparedStatement以及打开和关闭statments的例子：

基于对环境和数据库安装在前面的章节中进行这个范例程式码已被写入。

复制下面的例子中JDBCExample.java，编译并运行，如下所示：

//STEP 1\. Import required packages
import java.sql.*;

public class JDBCExample {
// JDBC driver name and database URL
static final String JDBC_DRIVER = "com.mysql.jdbc.Driver";
static final String DB_URL = "jdbc:mysql://localhost/EMP";

// Database credentials
static final String USER = "username";
static final String PASS = "password";

public static void main(String[] args) {
Connection conn = null;
PreparedStatement stmt = null;
try{
//STEP 2: Register JDBC driver
Class.forName("com.mysql.jdbc.Driver");

//STEP 3: Open a connection
System.out.println("Connecting to database...");
conn = DriverManager.getConnection(DB_URL,USER,PASS);

//STEP 4: Execute a query
System.out.println("Creating statement...");
String sql = "UPDATE Employees set age=? WHERE id=?";
stmt = conn.prepareStatement(sql);

//Bind values into the parameters.
stmt.setInt(1, 35); // This would set age
stmt.setInt(2, 102); // This would set ID

// Let us update age of the record with ID = 102;
int rows = stmt.executeUpdate();
System.out.println("Rows impacted : " + rows );

// Let us select all the records and display them.
sql = "SELECT id, first, last, age FROM Employees";
ResultSet rs = stmt.executeQuery(sql);

//STEP 5: Extract data from result set
while(rs.next()){
//Retrieve by column name
int id = rs.getInt("id");
int age = rs.getInt("age");
String first = rs.getString("first");
String last = rs.getString("last");

//Display values
System.out.print("ID: " + id);
System.out.print(", Age: " + age);
System.out.print(", First: " + first);
System.out.println(", Last: " + last);
}
//STEP 6: Clean-up environment
rs.close();
stmt.close();
conn.close();
}catch(SQLException se){
//Handle errors for JDBC
se.printStackTrace();
}catch(Exception e){
//Handle errors for Class.forName
e.printStackTrace();
}finally{
//finally block used to close resources
try{
if(stmt!=null)
stmt.close();
}catch(SQLException se2){
}// nothing we can do
try{
if(conn!=null)
conn.close();
}catch(SQLException se){
se.printStackTrace();
}//end finally try
}//end try
System.out.println("Goodbye!");
}//end main
}//end JDBCExample

现在来编译上面的例子如下：

C:>javac JDBCExample.java
C:>

当运行JDBCExample，它会产生以下结果：

C:>java JDBCExample
Connecting to database...
Creating statement...
Rows impacted : 1
ID: 100, Age: 18, First: Zara, Last: Ali
ID: 101, Age: 25, First: Mahnaz, Last: Fatma
ID: 102, Age: 35, First: Zaid, Last: Khan
ID: 103, Age: 30, First: Sumit, Last: Mittal
Goodbye!
C:>

JDBC CallableStatement对象实例 - JDBC教程

下面是利用CallableStatement连同下列getEmpName()的MySQL存储过程的例子：

请确定已经在EMP数据库中创建该存储过程。可以使用MySQL查询浏览器来完成它。

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 ;

基于对环境和数据库安装在前面的章节中进行，这个范例程式码已被写入。

复制下面的例子中JDBCExample.java，编译并运行，如下所示：

//STEP 1\. Import required packages
import java.sql.*;

public class JDBCExample {
// JDBC driver name and database URL
static final String JDBC_DRIVER = "com.mysql.jdbc.Driver";
static final String DB_URL = "jdbc:mysql://localhost/EMP";

// Database credentials
static final String USER = "username";
static final String PASS = "password";

public static void main(String[] args) {
Connection conn = null;
CallableStatement stmt = null;
try{
//STEP 2: Register JDBC driver
Class.forName("com.mysql.jdbc.Driver");

//STEP 3: Open a connection
System.out.println("Connecting to database...");
conn = DriverManager.getConnection(DB_URL,USER,PASS);

//STEP 4: Execute a query
System.out.println("Creating statement...");
String sql = "{call getEmpName (?, ?)}";
stmt = conn.prepareCall(sql);

//Bind IN parameter first, then bind OUT parameter
int empID = 102;
stmt.setInt(1, empID); // This would set ID as 102
// 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:" +
empID + " is " + empName);
stmt.close();
conn.close();
}catch(SQLException se){
//Handle errors for JDBC
se.printStackTrace();
}catch(Exception e){
//Handle errors for Class.forName
e.printStackTrace();
}finally{
//finally block used to close resources
try{
if(stmt!=null)
stmt.close();
}catch(SQLException se2){
}// nothing we can do
try{
if(conn!=null)
conn.close();
}catch(SQLException se){
se.printStackTrace();
}//end finally try
}//end try
System.out.println("Goodbye!");
}//end main
}//end JDBCExample

现在编译上面的例子如下：

C:>javac JDBCExample.java
C:>

当运行JDBCExample，它会产生以下结果：

C:>java JDBCExample
Connecting to database...
Creating statement...
Executing stored procedure...
Emp Name with ID:102 is Zaid
Goodbye!
C:>

JDBC结果集Result/Sets - JDBC教程

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

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

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

• 导航方法：用于移动光标.
• 获取方法：用于查看当前行的光标所指向的列中的数据。
• 更新方法：用于更新当前行的列中的数据。这些更新然后可以在基础数据库中，以及更新。

将光标移动基于ResultSet的属性。所创建生成ResultSet相应的声明时，这些属性被指定。

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

• createStatement(int RSType, int RSConcurrency);
• prepareStatement(String SQL, int RSType, int RSConcurrency);
• prepareCall(String sql, int RSType, int RSConcurrency);

第一个参数表示ResultSet对象的类型，第二个参数是2的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方法有两个版本:

• 即需要在一个列名。
• 即需要在列中索引。

例如，如果有兴趣查看的列包含一个整数，需要使用ResultSet调用getInt()方法之一：

与此类似的还有get方法在ResultSet接口为每个八个Java原始类型，以及常见的类型比如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（）方法之一：

有更新方法八个原始数据类型，以及字符串，对象，URL，并在java.sql包中的SQL数据类型。

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

为了更好地理解，建议学习更新示例代码。

JDBC数据类型 - JDBC教程

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

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

JDBC3.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数据类型。

下面的例子显示了日期和时间格式类标准的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教程

如果JDBC连接是在自动提交模式下，它在默认情况下，那么每个SQL语句都是在其完成时提交到数据库。

这可能是对简单的应用程序，但有三个原因，你可能想关闭自动提交和管理自己的事务：

• 为了提高性能
• 为了保持业务流程的完整性
• 使用分布式事务

若要控制事务，以及何时更改应用到数据库。它把单个SQL语句或一组SQL语句作为一个逻辑单元，而且如果任何语句失败，整个事务失败。

若要启用，而不是JDBC驱动程序默认使用auto-commit模式手动事务支持，使用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语句会成功，一切都将被回滚。

为了更好地理解，建议学习事务提交实例代码.

使用保存点：

新的JDBC3.0保存点的接口提供了额外的事务控制。他们的环境中，如Oracle的PL/ SQL中的大多数现代的DBMS支持保存点。

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

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异常处理 - JDBC教程

异常处理，可以处理在一个受控制的方式异常情况，如程序定义的错误。

当异常情况发生时，将引发异常。抛出这个词意味着当前执行的程序停止，并控制被重定向到最近的适用的catch子句。如果没有适用 catch 子句存在，那么程序的执行结束。

JDBC的异常处理非常类似于Java Excpetion处理，但对于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 块的使用。

//STEP 1\. Import required packages
import java.sql.*;

public class JDBCExample {
// JDBC driver name and database URL
static final String JDBC_DRIVER = "com.mysql.jdbc.Driver";
static final String DB_URL = "jdbc:mysql://localhost/EMP";

// Database credentials
static final String USER = "username";
static final String PASS = "password";

public static void main(String[] args) {
Connection conn = null;
try{
//STEP 2: Register JDBC driver
Class.forName("com.mysql.jdbc.Driver");

//STEP 3: Open a connection
System.out.println("Connecting to database...");
conn = DriverManager.getConnection(DB_URL,USER,PASS);

//STEP 4: Execute a query
System.out.println("Creating statement...");
Statement stmt = conn.createStatement();
String sql;
sql = "SELECT id, first, last, age FROM Employees";
ResultSet rs = stmt.executeQuery(sql);

//STEP 5: Extract data from result set
while(rs.next()){
//Retrieve by column name
int id = rs.getInt("id");
int age = rs.getInt("age");
String first = rs.getString("first");
String last = rs.getString("last");

//Display values
System.out.print("ID: " + id);
System.out.print(", Age: " + age);
System.out.print(", First: " + first);
System.out.println(", Last: " + last);
}
//STEP 6: Clean-up environment
rs.close();
stmt.close();
conn.close();
}catch(SQLException se){
//Handle errors for JDBC
se.printStackTrace();
}catch(Exception e){
//Handle errors for Class.forName
e.printStackTrace();
}finally{
//finally block used to close resources
try{
if(conn!=null)
conn.close();
}catch(SQLException se){
se.printStackTrace();
}//end finally try
}//end try
System.out.println("Goodbye!");
}//end main
}//end JDBCExample

现在让我们来编译上面的例子如下：

C:>javac JDBCExample.java
C:>

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

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

批处理允许将相关的SQL语句组合成一个批处理和一个调用数据库提交。

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

• JDBC驱动程序不需要支持此功能。应该使用DatabaseMetaData.supportsBatchUpdates()方法来确定目标数据库支持批量更新处理。如果你的JDBC驱动程序支持此功能的方法返回true。
• 声明addBatch()方法，PreparedStatement和CallableStatement用于各个语句添加到批处理。executeBatch()将用于启动所有组合在一起的语句的执行。
• executeBatch()将返回一个整数数组，数组中的每个元素代表了各自的更新语句的更新计数。
• 可以添加语句批量处理，可以用theclearBatch()方法删除它们。此方法删除所有已添加的addBatch()方法的语句。但是，不能有选择性地选择要删除的语句。

批处理和Statement对象：

下面是步骤，使用批处理使用说明书对象的典型顺序：

• 使用createStatement()方法创建一个Statement对象。
• 设置使用自动提交为false，使用 setAutoCommit().
• 添加任意多个到批量使用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();

为了更好地理解，建议学习研究JDBC批处理用Statement对象示例代码.

批处理使用prepareStatement结果对象：

下面是步骤，使用批处理用prepareStatement结果对象的典型顺序：

• 创建SQL语句的占位符。
• 使用任一prepareStatement()方法创建prepareStatement结果对象。
• 设置使用setAutoCommit()自动提交为false。
• 添加任意多个批量使用addBatch SQL语句（上创建语句对象）的方法。
• 执行使用executeBatch()将方法上创建表对象中的所有SQL语句。
• 最后，提交使用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 Statements。本教程是类似，但它会将有关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（）方法的输出参数检索值。这种方法投射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 关键字:

他们帮助确定日期，时间和时间戳记文字。如所知，没有两个数据库管理系统是基于时间和日期的方式相同。此转义语法告诉驱动程序呈现在目标数据库的格式，日期或时间。实现例子：

{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点三十分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函数计算GE字符串的长度：

{fn length('Hello World')}

这将返回11，字符串 'Hello World'的长度。.

call 关键字:

此关键字是用来调用存储过程。例如，对于一个存储过程，需要一个IN参数，请使用以下语法：

{call my_procedure(?)};

对于一个存储过程，需要一个IN参数并返回一个OUT参数，使用下面的语法：

{? = call my_procedure(?)};

oj 关键字:

此关键字用来表示外部联接。其语法如下：

{oj outer-join}

外连接表={LEFT| RIGHT| FULL}外连接{表|外连接}的搜索条件。例如：

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

JDBC流ASCII和二进制数据 - JDBC教程

PreparedStatement对象必须使用输入和输出流提供参数数据的能力。这使能够将整个文件到数据库列，可容纳较大的值，如CLOB和BLOB数据类型。

有下列方法，可用于将数据传送：

• setAsciiStream(): 这个方法是用来提供大的ASCII值。
• setCharacterStream(): 这个方法是用来提供大的UNICODE值。
• setBinaryStream(): 这个方法是用来提供大的二进制值。

setXXXStream()方法需要一个额外的参数，文件大小，除了参数占位符。这个参数通知驱动有多少数据要使用的流被发送到数据库中。

例子

考虑到要上传一个XML文件XML_Data.xml到数据库表。下面是这个XML文件的内容：

<?xml version="1.0"?>
<Employee>
<id>100</id>
<first>Zara</first>
<last>Ali</last>
<Salary>10000</Salary>
<Dob>18-08-1978</Dob>
<Employee>

保持这个XML文件在要运行这个例子相同的目录。

这个例子将创建一个数据库表XML_Data，然后提交XML_Data.xml将被上传到该表中。

复制下面的例子JDBCExample.java，编译并运行，如下所示：

// Import required packages
import java.sql.*;
import java.io.*;
import java.util.*;

public class JDBCExample {
// JDBC driver name and database URL
static final String JDBC_DRIVER = "com.mysql.jdbc.Driver";
static final String DB_URL = "jdbc:mysql://localhost/EMP";

// Database credentials
static final String USER = "username";
static final String PASS = "password";

public static void main(String[] args) {
Connection conn = null;
PreparedStatement pstmt = null;
Statement stmt = null;
ResultSet rs = null;
try{
// Register JDBC driver
Class.forName("com.mysql.jdbc.Driver");

// Open a connection
System.out.println("Connecting to database...");
conn = DriverManager.getConnection(DB_URL,USER,PASS);

//Create a Statement object and build table
stmt = conn.createStatement();
createXMLTable(stmt);

//Open a FileInputStream
File f = new File("XML_Data.xml");
long fileLength = f.length();
FileInputStream fis = new FileInputStream(f);

//Create PreparedStatement and stream data
String SQL = "INSERT INTO XML_Data VALUES (?,?)";
pstmt = conn.prepareStatement(SQL);
pstmt.setInt(1,100);
pstmt.setAsciiStream(2,fis,(int)fileLength);
pstmt.execute();

//Close input stream
fis.close();

// Do a query to get the row
SQL = "SELECT Data FROM XML_Data WHERE id=100";
rs = stmt.executeQuery (SQL);
// 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();
stmt.close();
pstmt.close();
conn.close();
}catch(SQLException se){
//Handle errors for JDBC
se.printStackTrace();
}catch(Exception e){
//Handle errors for Class.forName
e.printStackTrace();
}finally{
//finally block used to close resources
try{
if(stmt!=null)
stmt.close();
}catch(SQLException se2){
}// nothing we can do
try{
if(pstmt!=null)
pstmt.close();
}catch(SQLException se2){
}// nothing we can do
try{
if(conn!=null)
conn.close();
}catch(SQLException se){
se.printStackTrace();
}//end finally try
}//end try
System.out.println("Goodbye!");
}//end main

public static void createXMLTable(Statement stmt)
throws SQLException{
System.out.println("Creating XML_Data table..." );
//Create SQL Statement
String streamingDataSql = "CREATE TABLE XML_Data " +
"(id INTEGER, Data LONG)";
//Drop table first if it exists.
try{
stmt.executeUpdate("DROP TABLE XML_Data");
}catch(SQLException se){
}// do nothing
//Build table.
stmt.executeUpdate(streamingDataSql);
}//end createXMLTable
}//end JDBCExample

现在让我们来编译上面的例子如下：

C:>javac JDBCExample.java
C:>

当运行JDBCExample，它会产生以下结果：

C:>java JDBCExample
Connecting to database...
Creating XML_Data table...
<?xml version="1.0"?>
<Employee>
<id>100</id>
<first>Zara</first>
<last>Ali</last>
<Salary>10000</Salary>
<Dob>18-08-1978</Dob>
<Employee>
Goodbye!
C:>

JDBC Statement对象实例 - JDBC教程

以下是利用以下三种查询以及打开和关闭说明的例子：

• boolean execute(String SQL) : 返回一个布尔值true，如果ResultSet对象可以被检索，否则返回false。使用这个方法来执行SQL DDL语句，或当需要使用真正的动态SQL。
• int executeUpdate(String SQL) : 返回受影响的SQL语句执行的行数。使用此方法来执行，而希望得到一些受影响的行的SQL语句 - 例如，INSERT，UPDATE或DELETE语句。
• ResultSet executeQuery(String SQL) : 返回ResultSet对象。当希望得到一个结果集使用此方法，就像使用一个SELECT语句。

基于对环境和数据库安装在前面的章节中做此示例代码已被写入。

复制下面的例子中JDBCExample.java，编译并运行，如下所示：

//STEP 1\. Import required packages
import java.sql.*;

public class JDBCExample {
// JDBC driver name and database URL
static final String JDBC_DRIVER = "com.mysql.jdbc.Driver";
static final String DB_URL = "jdbc:mysql://localhost/EMP";

// Database credentials
static final String USER = "username";
static final String PASS = "password";

public static void main(String[] args) {
Connection conn = null;
Statement stmt = null;
try{
//STEP 2: Register JDBC driver
Class.forName("com.mysql.jdbc.Driver");

//STEP 3: Open a connection
System.out.println("Connecting to database...");
conn = DriverManager.getConnection(DB_URL,USER,PASS);

//STEP 4: Execute a query
System.out.println("Creating statement...");
stmt = conn.createStatement();
String sql = "UPDATE Employees set age=30 WHERE id=103";

// Let us check if it returns a true Result Set or not.
Boolean ret = stmt.execute(sql);
System.out.println("Return value is : " + ret.toString() );

// Let us update age of the record with ID = 103;
int rows = stmt.executeUpdate(sql);
System.out.println("Rows impacted : " + rows );

// Let us select all the records and display them.
sql = "SELECT id, first, last, age FROM Employees";
ResultSet rs = stmt.executeQuery(sql);

//STEP 5: Extract data from result set
while(rs.next()){
//Retrieve by column name
int id = rs.getInt("id");
int age = rs.getInt("age");
String first = rs.getString("first");
String last = rs.getString("last");

//Display values
System.out.print("ID: " + id);
System.out.print(", Age: " + age);
System.out.print(", First: " + first);
System.out.println(", Last: " + last);
}
//STEP 6: Clean-up environment
rs.close();
stmt.close();
conn.close();
}catch(SQLException se){
//Handle errors for JDBC
se.printStackTrace();
}catch(Exception e){
//Handle errors for Class.forName
e.printStackTrace();
}finally{
//finally block used to close resources
try{
if(stmt!=null)
stmt.close();
}catch(SQLException se2){
}// nothing we can do
try{
if(conn!=null)
conn.close();
}catch(SQLException se){
se.printStackTrace();
}//end finally try
}//end try
System.out.println("Goodbye!");
}//end main
}//end JDBCExample

现在编译上面的例子如下：

C:>javac JDBCExample.java
C:>

当运行JDBCExample，它会产生以下结果：

C:>java JDBCExample
Connecting to database...
Creating statement...
Return value is : false
Rows impacted : 1
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: 30, First: Sumit, Last: Mittal
Goodbye!
C:>

JDBC创建数据库实例 - JDBC教程

本教程介绍了如何使用JDBC应用程序数据库的例子。执行下面的示例之前，请确保已到位如下：

• 应该有管理员特权，在给定的模式创建一个数据库。执行下面的例子中，需要与实际用户名和密码代替用户名和密码。
• MySQL或者其他数据库，正在使用的是启动和运行。

所需的步骤：

有创建使用JDBC应用程序一个新的数据库需要执行以下步骤：

• 导入数据包 . 要求包括含有需要进行数据库编程的JDBC类的包。大多数情况下，使用导入的java.sql.* 就足够了。
• 注册JDBC驱动程序 . 要求初始化驱动程序，使可以与数据库打开一个通信通道。
• 打开连接 . 要求使用DriverManager.getConnection()方法创建一个Connection对象，它代表datbase服务器的物理连接。

要创建一个新的数据库，不用给任何数据库名，同时准备数据库URL中所提到的下面的例子。

• 执行查询. 需要使用类型声明的对象建立并提交一个SQL语句到数据库。
• 清理环境. 需要明确地关闭所有的数据库资源与依靠JVM垃圾收集。

示例代码：

复制下面的例子中JDBCExample.java，编译并运行，如下所示：

//STEP 1\. Import required packages
import java.sql.*;

public class JDBCExample {
// JDBC driver name and database URL
static final String JDBC_DRIVER = "com.mysql.jdbc.Driver";
static final String DB_URL = "jdbc:mysql://localhost/";

// Database credentials
static final String USER = "username";
static final String PASS = "password";

public static void main(String[] args) {
Connection conn = null;
Statement stmt = null;
try{
//STEP 2: Register JDBC driver
Class.forName("com.mysql.jdbc.Driver");

//STEP 3: Open a connection
System.out.println("Connecting to database...");
conn = DriverManager.getConnection(DB_URL, USER, PASS);

//STEP 4: Execute a query
System.out.println("Creating database...");
stmt = conn.createStatement();

String sql = "CREATE DATABASE STUDENTS";
stmt.executeUpdate(sql);
System.out.println("Database created successfully...");
}catch(SQLException se){
//Handle errors for JDBC
se.printStackTrace();
}catch(Exception e){
//Handle errors for Class.forName
e.printStackTrace();
}finally{
//finally block used to close resources
try{
if(stmt!=null)
stmt.close();
}catch(SQLException se2){
}// nothing we can do
try{
if(conn!=null)
conn.close();
}catch(SQLException se){
se.printStackTrace();
}//end finally try
}//end try
System.out.println("Goodbye!");
}//end main
}//end JDBCExample

现在让我们来编译上面的例子如下：

C:>javac JDBCExample.java
C:>

当运行JDBCExample，它会产生以下结果：

C:>java JDBCExample
Connecting to database...
Creating database...
Database created successfully...
Goodbye!
C:>

JDBC选择数据库实例 - JDBC教程

本教程介绍了如何使用JDBC应用程序选择一个数据库的例子。执行下面的示例之前，请确保已做好如下工作：

• 执行下面的例子中，需要使用实际用户名和密码代替username和password。
• MySQL或者其他数据库，正在使用(启动和运行)。

所需的步骤：

创建使用JDBC应用程序访问数据库需要执行以下步骤：

• 导入数据包 . 要求包括含有需要进行数据库编程的JDBC类包。大多数情况下，使用 import java.sql.*就足够了。
• 注册JDBC驱动程序 . 要求初始化驱动程序，从而可以与数据库打开一个通信通道。
• 打开连接. 使用DriverManager.getConnection()方法创建一个Connection对象，它代表使用所选（selected）数据库的物理连接。

选择数据库时，准备数据库URL。下面的例子会让STUDENTS数据库连接。

• 清理环境. 需要明确地关闭所有的数据库资源相对依靠JVM的垃圾收集。

示例代码：

复制下面的例子中JDBCExample.java，编译并运行，如下所示：

//STEP 1\. Import required packages
import java.sql.*;

public class JDBCExample {
// JDBC driver name and database URL
static final String JDBC_DRIVER = "com.mysql.jdbc.Driver";
static final String DB_URL = "jdbc:mysql://localhost/STUDENTS";

// Database credentials
static final String USER = "username";
static final String PASS = "password";

public static void main(String[] args) {
Connection conn = null;
try{
//STEP 2: Register JDBC driver
Class.forName("com.mysql.jdbc.Driver");

//STEP 3: Open a connection
System.out.println("Connecting to a selected database...");
conn = DriverManager.getConnection(DB_URL, USER, PASS);
System.out.println("Connected database successfully...");
}catch(SQLException se){
//Handle errors for JDBC
se.printStackTrace();
}catch(Exception e){
//Handle errors for Class.forName
e.printStackTrace();
}finally{
//finally block used to close resources
try{
if(conn!=null)
conn.close();
}catch(SQLException se){
se.printStackTrace();
}//end finally try
}//end try
System.out.println("Goodbye!");
}//end main
}//end JDBCExample

现在来编译上面的例子如下：

C:>javac JDBCExample.java
C:>

当运行JDBCExample，它会产生以下结果：

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

JDBC删除/Delete数据库实例 - JDBC教程

本教程介绍了如何使用JDBC应用程序来删除一个现有数据库的例子。执行下面的示例之前，请确保如下：

• 执行下面的例子中，需要使用实际用户名和密码代替username和password。
• MySQL或者其他数据库，正在使用：启动和运行。

注意：这是一个严重的操作，数据库中拥有的一切将会丢失。

所需步骤：

有创建使用JDBC应用程序一个新的数据库需要执行以下步骤：

• 导入数据包：要求包括含有需要进行数据库编程的JDBC类的包。大多数情况下，使用 import java.sql.* 就可以了.
• 注册JDBC驱动程序：要求初始化驱动程序，使它可以与数据库打开一个通信通道。
• 打开一个连接：要求中使用DriverManager.getConnection()方法创建一个Connection对象，它代表与数据库服务器的物理连接。

删除一个数据库不需要数据库名称在数据库URL。下面的例子将删除STUDENTS数据库。

• 执行查询： 需要使用类型声明的对象建立并提交一个SQL语句来删除数据库。
• 清理环境. 需要明确地关闭所有的数据库资源相对依靠JVM的垃圾收集。

示例代码：

复制下面的例子中JDBCExample.java，编译并运行，如下所示：

//STEP 1\. Import required packages
import java.sql.*;

public class JDBCExample {
// JDBC driver name and database URL
static final String JDBC_DRIVER = "com.mysql.jdbc.Driver";
static final String DB_URL = "jdbc:mysql://localhost/";

// Database credentials
static final String USER = "username";
static final String PASS = "password";

public static void main(String[] args) {
Connection conn = null;
Statement stmt = null;
try{
//STEP 2: Register JDBC driver
Class.forName("com.mysql.jdbc.Driver");

//STEP 3: Open a connection
System.out.println("Connecting to a selected database...");
conn = DriverManager.getConnection(DB_URL, USER, PASS);
System.out.println("Connected database successfully...");

//STEP 4: Execute a query
System.out.println("Deleting database...");
stmt = conn.createStatement();

String sql = "DROP DATABASE STUDENTS";
stmt.executeUpdate(sql);
System.out.println("Database deleted successfully...");
}catch(SQLException se){
//Handle errors for JDBC
se.printStackTrace();
}catch(Exception e){
//Handle errors for Class.forName
e.printStackTrace();
}finally{
//finally block used to close resources
try{
if(stmt!=null)
conn.close();
}catch(SQLException se){
}// do nothing
try{
if(conn!=null)
conn.close();
}catch(SQLException se){
se.printStackTrace();
}//end finally try
}//end try
System.out.println("Goodbye!");
}//end main
}//end JDBCExample

现在让我们来编译上面的例子如下：

C:>javac JDBCExample.java
C:>

当运行JDBCExample，它会产生以下结果：

C:>java JDBCExample
Connecting to a selected database...
Connected database successfully...
Deleting database...
Database deleted successfully...
Goodbye!
C:>

JDBC创建表/Create实例 - JDBC教程

本教程介绍了如何使用JDBC应用程序来创建表的例子。执行下面的示例之前，请确保已做好如下：

• 执行下面的例子中，你可以与你的实际的用户名和密码代替user name和password。
• MySQL或者其他数据库，正在使用: 启动和运行。

所需的步骤：

使用JDBC应用程序一个新的数据库需要执行以下步骤：

• 导入数据包: 要求包括含有需要进行数据库编程的JDBC类的包。大多数情况下，使用 import java.sql.* 就可以了.
• 注册JDBC驱动程序: 要求初始化驱动程序，使它可以与数据库打开一个通信通道。
• 打开连接: 要求中使用DriverManager.getConnection()方法创建一个Connection对象，它代表与数据库服务器的物理连接。
• 执行查询: 需要使用类型声明的对象建立并提交一个SQL语句在入围数据库中创建表。
• 清理环境. 需要明确地关闭所有的数据库资源相对依靠JVM的垃圾收集。

示例代码：

复制下面的例子中JDBCExample.java，编译并运行，如下所示：

//STEP 1\. Import required packages
import java.sql.*;

public class JDBCExample {
// JDBC driver name and database URL
static final String JDBC_DRIVER = "com.mysql.jdbc.Driver";
static final String DB_URL = "jdbc:mysql://localhost/STUDENTS";

// Database credentials
static final String USER = "username";
static final String PASS = "password";

public static void main(String[] args) {
Connection conn = null;
Statement stmt = null;
try{
//STEP 2: Register JDBC driver
Class.forName("com.mysql.jdbc.Driver");

//STEP 3: Open a connection
System.out.println("Connecting to a selected database...");
conn = DriverManager.getConnection(DB_URL, USER, PASS);
System.out.println("Connected database successfully...");

//STEP 4: Execute a query
System.out.println("Creating table in given database...");
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 se){
//Handle errors for JDBC
se.printStackTrace();
}catch(Exception e){
//Handle errors for Class.forName
e.printStackTrace();
}finally{
//finally block used to close resources
try{
if(stmt!=null)
conn.close();
}catch(SQLException se){
}// do nothing
try{
if(conn!=null)
conn.close();
}catch(SQLException se){
se.printStackTrace();
}//end finally try
}//end try
System.out.println("Goodbye!");
}//end main
}//end JDBCExample

现在让我们来编译上面的例子如下：

C:>javac JDBCExample.java
C:>

当运行JDBCExample，它会产生以下结果：

C:>java JDBCExample
Connecting to a selected database...
Connected database successfully...
Creating table in given database...
Created table in given database...
Goodbye!
C:>

JDBC删除/Delete表实例 - JDBC教程

本教程介绍了如何使用JDBC应用程序来删除一个表中的一个例子。执行下面的示例之前，请确保已经做好如下：

• 执行下面的例子中，使用实际的用户名和密码代替username和password。
• MySQL或者其他数据库，正在使用：启动和运行。

注: 这是一个严重的操作，在删除一个表前，要注意表中的数据备份，一旦删除表，表中的数据将消失。

所需的步骤：

创建使用JDBC应用程序一个新的数据库需要执行以下步骤：

• 导入数据包：要求包括含有需要进行数据库编程的JDBC类的包。大多数情况下，使用 import java.sql.* 就可以了.
• 注册JDBC驱动程序：要求初始化驱动程序，使它可以与数据库打开一个通信通道。
• 打开一个连接：要求使用DriverManager.getConnection()方法创建一个Connection对象，它代表与数据库服务器的物理连接。
• 执行查询：需要使用类型声明的对象建立并提交一个SQL语句在所选择的数据库中删除表。
• 清理环境：需要明确地关闭所有的数据库资源相对依靠JVM的垃圾收集。

示例代码：

复制过去下面的例子JDBCExample.java，编译并运行，如下所示：

//STEP 1\. Import required packages
import java.sql.*;

public class JDBCExample {
// JDBC driver name and database URL
static final String JDBC_DRIVER = "com.mysql.jdbc.Driver";
static final String DB_URL = "jdbc:mysql://localhost/STUDENTS";

// Database credentials
static final String USER = "username";
static final String PASS = "password";

public static void main(String[] args) {
Connection conn = null;
Statement stmt = null;
try{
//STEP 2: Register JDBC driver
Class.forName("com.mysql.jdbc.Driver");

//STEP 3: Open a connection
System.out.println("Connecting to a selected database...");
conn = DriverManager.getConnection(DB_URL, USER, PASS);
System.out.println("Connected database successfully...");

//STEP 4: Execute a query
System.out.println("Deleting table in given database...");
stmt = conn.createStatement();

String sql = "DROP TABLE REGISTRATION ";

stmt.executeUpdate(sql);
System.out.println("Table deleted in given database...");
}catch(SQLException se){
//Handle errors for JDBC
se.printStackTrace();
}catch(Exception e){
//Handle errors for Class.forName
e.printStackTrace();
}finally{
//finally block used to close resources
try{
if(stmt!=null)
conn.close();
}catch(SQLException se){
}// do nothing
try{
if(conn!=null)
conn.close();
}catch(SQLException se){
se.printStackTrace();
}//end finally try
}//end try
System.out.println("Goodbye!");
}//end main
}//end JDBCExample

现在编译上面的例子如下：

C:>javac JDBCExample.java
C:>

当运行JDBCExample，它会产生以下结果：

C:>java JDBCExample
Connecting to a selected database...
Connected database successfully...
Deleting table in given database...
Table deleted in given database...
Goodbye!
C:>

JDBC插入/Insert记录示例 - JDBC教程

本教程介绍了如何使用JDBC应用程序中插入表中的记录的例子。执行下面的示例之前，请确保如下：

• 执行下面的例子，需要使用实际的用户名和密码代替username和password。
• MySQL或者其他数据库，正在使用：启动和运行。

所需的步骤：

创建使用JDBC应用程序一个新的数据库需要执行以下步骤：

• 导入数据包： 要求包括含有需要进行数据库编程的JDBC类的包。大多数情况下，使用 import java.sql.* 就可以了。
• 注册JDBC驱动程序：要求初始化驱动程序，使它可以与数据库打开一个通信通道。
• 打开一个连接：要求中使用DriverManager.getConnection()方法创建一个Connection对象，它代表与数据库服务器的物理连接。
• 执行查询：需要使用类型Statement对象建立并提交一个SQL语句将记录插入到表中。
• 清理环境：需要明确地关闭所有的数据库资源相对依靠JVM的垃圾收集。

示例代码：

复制过去下面的例子JDBCExample.java，编译并运行，如下所示：

//STEP 1\. Import required packages
import java.sql.*;

public class JDBCExample {
// JDBC driver name and database URL
static final String JDBC_DRIVER = "com.mysql.jdbc.Driver";
static final String DB_URL = "jdbc:mysql://localhost/STUDENTS";

// Database credentials
static final String USER = "username";
static final String PASS = "password";

public static void main(String[] args) {
Connection conn = null;
Statement stmt = null;
try{
//STEP 2: Register JDBC driver
Class.forName("com.mysql.jdbc.Driver");

//STEP 3: Open a connection
System.out.println("Connecting to a selected database...");
conn = DriverManager.getConnection(DB_URL, USER, PASS);
System.out.println("Connected database successfully...");

//STEP 4: Execute a query
System.out.println("Inserting records into the table...");
stmt = conn.createStatement();

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 se){
//Handle errors for JDBC
se.printStackTrace();
}catch(Exception e){
//Handle errors for Class.forName
e.printStackTrace();
}finally{
//finally block used to close resources
try{
if(stmt!=null)
conn.close();
}catch(SQLException se){
}// do nothing
try{
if(conn!=null)
conn.close();
}catch(SQLException se){
se.printStackTrace();
}//end finally try
}//end try
System.out.println("Goodbye!");
}//end main
}//end JDBCExample

现在让我们来编译上面的例子如下：

C:>javac JDBCExample.java
C:>

当运行JDBCExample，它会产生以下结果：

C:>java JDBCExample
Connecting to a selected database...
Connected database successfully...
Inserting records into the table...
Inserted records into the table...
Goodbye!
C:>

JDBC查询Select记录实例 - JDBC教程

本教程介绍了如何选择/select/使用JDBC应用程序从一个表中获取记录的例子。执行下面的示例之前，请确保如下：

• 执行下面的例子中，使用实际的用户名和密码代替username和password。
• MySQL或者其他数据库，正在使用：启动和运行。

所需的步骤：

创建使用JDBC应用程序一个新的数据库需要执行以下步骤：

• 导入数据包：要求您包括含有需要进行数据库编程的JDBC类的包。大多数情况下，使用 import java.sql.* 就可以了。
• 注册JDBC驱动程序：要求初始化驱动程序，使它可以数据库打开一个通信通道。
• 打开一个连接：要求中使用DriverManager.getConnection()方法创建一个Connection对象，它代表与数据库服务器的物理连接。
• 执行一个查询：需要使用Statement 类型对象，并提交一个SQL语句来选择（即取）从表中的记录。
• 提取数据：当SQL查询执行时，可以从表中提取记录。
• 清理环境：需要明确地关闭所有的数据库资源，不用依靠JVM的垃圾收集。

示例代码：

复制过去下面的例子中JDBCExample.java，编译并运行，如下所示：

//STEP 1\. Import required packages
import java.sql.*;

public class JDBCExample {
// JDBC driver name and database URL
static final String JDBC_DRIVER = "com.mysql.jdbc.Driver";
static final String DB_URL = "jdbc:mysql://localhost/STUDENTS";

// Database credentials
static final String USER = "username";
static final String PASS = "password";

public static void main(String[] args) {
Connection conn = null;
Statement stmt = null;
try{
//STEP 2: Register JDBC driver
Class.forName("com.mysql.jdbc.Driver");

//STEP 3: Open a connection
System.out.println("Connecting to a selected database...");
conn = DriverManager.getConnection(DB_URL, USER, PASS);
System.out.println("Connected database successfully...");

//STEP 4: Execute a query
System.out.println("Creating statement...");
stmt = conn.createStatement();

String sql = "SELECT id, first, last, age FROM Registration";
ResultSet rs = stmt.executeQuery(sql);
//STEP 5: Extract data from result set
while(rs.next()){
//Retrieve by column name
int id = rs.getInt("id");
int age = rs.getInt("age");
String first = rs.getString("first");
String last = rs.getString("last");

//Display values
System.out.print("ID: " + id);
System.out.print(", Age: " + age);
System.out.print(", First: " + first);
System.out.println(", Last: " + last);
}
rs.close();
}catch(SQLException se){
//Handle errors for JDBC
se.printStackTrace();
}catch(Exception e){
//Handle errors for Class.forName
e.printStackTrace();
}finally{
//finally block used to close resources
try{
if(stmt!=null)
conn.close();
}catch(SQLException se){
}// do nothing
try{
if(conn!=null)
conn.close();
}catch(SQLException se){
se.printStackTrace();
}//end finally try
}//end try
System.out.println("Goodbye!");
}//end main
}//end JDBCExample

现在让我们来编译上面的例子如下：

C:>javac JDBCExample.java
C:>

当运行JDBCExample，它会产生以下结果：

C:>java JDBCExample
Connecting to a selected database...
Connected database successfully...
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
Goodbye!
C:>

JDBC更新/Update记录实例 - JDBC教程

本教程介绍了如何使用JDBC应用程序更新表中的记录的一个例子。执行下面的示例之前，请确保如下：

• 执行下面的例子中，使用实际的用户名和密码代替username和password。
• MySQL或者其他数据库，正在使用：启动和运行。

所需的步骤：

创建使用JDBC应用程序一个新的数据库需要执行以下步骤：

• 导入包：要求包括含有需要进行数据库编程的JDBC类的包。大多数情况下，使用 import java.sql.* 就可以了。
• 注册JDBC驱动程序：要求初始化驱动程序，使它可以与数据库打开一个通信通道。
• 打开一个连接：要求使用DriverManager.getConnection()方法创建一个Connection对象，它代表与数据库服务器的物理连接。
• 执行一个查询：需要使用类型声明的对象建立并提交一个SQL语句来更新表中的记录。这个查询利用IN的和WHERE子句来更新条件的记录。
• 清理环境：需要明确地关闭所有的数据库资源相对于依靠JVM的垃圾收集。

示例代码：

复制过去下面的例子中JDBCExample.java，编译并运行，如下所示：

//STEP 1\. Import required packages
import java.sql.*;

public class JDBCExample {
// JDBC driver name and database URL
static final String JDBC_DRIVER = "com.mysql.jdbc.Driver";
static final String DB_URL = "jdbc:mysql://localhost/STUDENTS";

// Database credentials
static final String USER = "username";
static final String PASS = "password";

public static void main(String[] args) {
Connection conn = null;
Statement stmt = null;
try{
//STEP 2: Register JDBC driver
Class.forName("com.mysql.jdbc.Driver");

//STEP 3: Open a connection
System.out.println("Connecting to a selected database...");
conn = DriverManager.getConnection(DB_URL, USER, PASS);
System.out.println("Connected database successfully...");

//STEP 4: Execute a query
System.out.println("Creating statement...");
stmt = conn.createStatement();
String sql = "UPDATE Registration " +
"SET age = 30 WHERE id in (100, 101)";
stmt.executeUpdate(sql);

// Now you can extract all the records
// to see the updated records
sql = "SELECT id, first, last, age FROM Registration";
ResultSet rs = stmt.executeQuery(sql);

while(rs.next()){
//Retrieve by column name
int id = rs.getInt("id");
int age = rs.getInt("age");
String first = rs.getString("first");
String last = rs.getString("last");

//Display values
System.out.print("ID: " + id);
System.out.print(", Age: " + age);
System.out.print(", First: " + first);
System.out.println(", Last: " + last);
}
rs.close();
}catch(SQLException se){
//Handle errors for JDBC
se.printStackTrace();
}catch(Exception e){
//Handle errors for Class.forName
e.printStackTrace();
}finally{
//finally block used to close resources
try{
if(stmt!=null)
conn.close();
}catch(SQLException se){
}// do nothing
try{
if(conn!=null)
conn.close();
}catch(SQLException se){
se.printStackTrace();
}//end finally try
}//end try
System.out.println("Goodbye!");
}//end main
}//end JDBCExample

现在让我们来编译上面的例子如下：

C:>javac JDBCExample.java
C:>

当运行JDBCExample，它会产生以下结果：

C:>java JDBCExample
Connecting to a selected database...
Connected database successfully...
Creating statement...
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
Goodbye!
C:>

JDBC删除/Delete记录示例 - JDBC教程

本教程介绍了如何使用JDBC应用程序的表删除记录的例子。执行下面的示例之前，请确保以下：

• 执行下面的例子中，使用实际的用户名和密码代替username和password。
• MySQL或者其他数据库，正在使用：启动和运行。

所需的步骤：

创建使用JDBC应用程序一个新的数据库需要执行以下步骤：

• 导入包：要求包括含有需要进行数据库编程的JDBC类的包。大多数情况下，使用 import java.sql.* 就可以了。
• 注册JDBC驱动程序：要求初始化驱动程序，使它可以与数据库打开一个通信通道。
• 打开一个连接：要求使用DriverManager.getConnection()方法创建一个Connection对象，它代表与数据库服务器的物理连接。
• 执行一个查询：需要使用类型声明的对象建立并提交一个SQL语句从表中删除记录。这使得查询使用WHERE子句来删除条件的记录。
• 清理环境：需要明确地关闭所有的数据库资源相对于依靠JVM的垃圾收集。

示例代码：

复制过去下面的例子中JDBCExample.java，编译并运行，如下所示：

//STEP 1\. Import required packages
import java.sql.*;

public class JDBCExample {
// JDBC driver name and database URL
static final String JDBC_DRIVER = "com.mysql.jdbc.Driver";
static final String DB_URL = "jdbc:mysql://localhost/STUDENTS";

// Database credentials
static final String USER = "username";
static final String PASS = "password";

public static void main(String[] args) {
Connection conn = null;
Statement stmt = null;
try{
//STEP 2: Register JDBC driver
Class.forName("com.mysql.jdbc.Driver");

//STEP 3: Open a connection
System.out.println("Connecting to a selected database...");
conn = DriverManager.getConnection(DB_URL, USER, PASS);
System.out.println("Connected database successfully...");

//STEP 4: Execute a query
System.out.println("Creating statement...");
stmt = conn.createStatement();
String sql = "DELETE FROM Registration " +
"WHERE id = 101";
stmt.executeUpdate(sql);

// Now you can extract all the records
// to see the remaining records
sql = "SELECT id, first, last, age FROM Registration";
ResultSet rs = stmt.executeQuery(sql);

while(rs.next()){
//Retrieve by column name
int id = rs.getInt("id");
int age = rs.getInt("age");
String first = rs.getString("first");
String last = rs.getString("last");

//Display values
System.out.print("ID: " + id);
System.out.print(", Age: " + age);
System.out.print(", First: " + first);
System.out.println(", Last: " + last);
}
rs.close();
}catch(SQLException se){
//Handle errors for JDBC
se.printStackTrace();
}catch(Exception e){
//Handle errors for Class.forName
e.printStackTrace();
}finally{
//finally block used to close resources
try{
if(stmt!=null)
conn.close();
}catch(SQLException se){
}// do nothing
try{
if(conn!=null)
conn.close();
}catch(SQLException se){
se.printStackTrace();
}//end finally try
}//end try
System.out.println("Goodbye!");
}//end main
}//end JDBCExample

现在编译上面的例子如下：

C:>javac JDBCExample.java
C:>

当运行JDBCExample，它会产生以下结果：

C:>java JDBCExample
Connecting to a selected database...
Connected database successfully...
Creating statement...
ID: 100, Age: 30, First: Zara, Last: Ali
ID: 102, Age: 30, First: Zaid, Last: Khan
ID: 103, Age: 28, First: Sumit, Last: Mittal
Goodbye!
C:>

JDBC WHERE子句实例 - JDBC教程

本教程介绍了如何使用JDBC应用程序表中选择记录的一个例子。这将使用WHERE子句，而从表中选择记录添加附加条件。执行下面的示例之前，请确保如下：

• 执行下面的例子中，使用实际的用户名和密码代替username和password。
• MySQL或者其他数据库，正在使用：启动和运行。

所需的步骤：

创建使用JDBC应用程序一个新的数据库需要执行以下步骤：

• 导入包：要求包括含有需要进行数据库编程的JDBC类的包。大多数情况下，使用 import java.sql.* 。
• 注册JDBC驱动程序：要求初始化驱动程序，使可以与数据库打开一个通信通道。
• 打开一个连接：要求使用DriverManager.getConnection()方法创建一个Connection对象，它代表与数据库服务器的物理连接。
• 执行一个查询：需要使用类型声明的对象建立并提交一个SQL语句从符合给定条件的表获取记录。查询使用WHERE子句来查询记录。
• 清理环境：需要明确地关闭所有的数据库资源相对于依靠JVM的垃圾收集。

示例代码：

复制过去的下面的例子中JDBCExample.java，编译并运行，如下所示：

//STEP 1\. Import required packages
import java.sql.*;

public class JDBCExample {
// JDBC driver name and database URL
static final String JDBC_DRIVER = "com.mysql.jdbc.Driver";
static final String DB_URL = "jdbc:mysql://localhost/STUDENTS";

// Database credentials
static final String USER = "username";
static final String PASS = "password";

public static void main(String[] args) {
Connection conn = null;
Statement stmt = null;
try{
//STEP 2: Register JDBC driver
Class.forName("com.mysql.jdbc.Driver");

//STEP 3: Open a connection
System.out.println("Connecting to a selected database...");
conn = DriverManager.getConnection(DB_URL, USER, PASS);
System.out.println("Connected database successfully...");

//STEP 4: Execute a query
System.out.println("Creating statement...");
stmt = conn.createStatement();

// Extract records without any condition.
System.out.println("Fetching records without condition...");
String sql = "SELECT id, first, last, age FROM Registration";
ResultSet rs = stmt.executeQuery(sql);

while(rs.next()){
//Retrieve by column name
int id = rs.getInt("id");
int age = rs.getInt("age");
String first = rs.getString("first");
String last = rs.getString("last");

//Display values
System.out.print("ID: " + id);
System.out.print(", Age: " + age);
System.out.print(", First: " + first);
System.out.println(", Last: " + last);
}

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

while(rs.next()){
//Retrieve by column name
int id = rs.getInt("id");
int age = rs.getInt("age");
String first = rs.getString("first");
String last = rs.getString("last");

//Display values
System.out.print("ID: " + id);
System.out.print(", Age: " + age);
System.out.print(", First: " + first);
System.out.println(", Last: " + last);
}
rs.close();
}catch(SQLException se){
//Handle errors for JDBC
se.printStackTrace();
}catch(Exception e){
//Handle errors for Class.forName
e.printStackTrace();
}finally{
//finally block used to close resources
try{
if(stmt!=null)
conn.close();
}catch(SQLException se){
}// do nothing
try{
if(conn!=null)
conn.close();
}catch(SQLException se){
se.printStackTrace();
}//end finally try
}//end try
System.out.println("Goodbye!");
}//end main
}//end JDBCExample

现在让我们来编译上面的例子如下：

C:>javac JDBCExample.java
C:>

当运行JDBCExample，它会产生以下结果：

C:>java JDBCExample
Connecting to a selected database...
Connected database successfully...
Creating statement...
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
Goodbye!
C:>

JDBC LIKE子句实例 - JDBC教程

本教程介绍了如何使用JDBC应用程序表中选择记录的一个例子。这里使用LIKE子句，而从表中选择记录添加附加条件。执行下面的示例之前，请确保如下：

• 执行下面的例子中，请使用实际的用户名和密码代替username和password。
• MySQL或者其他数据库，正在使用：启动和运行。

所需步骤：

使用JDBC应用程序创建一个新的数据库需要执行以下步骤：

• 导入包：要求包括含有需要进行数据库编程的JDBC类的包。大多数情况下，使用 import java.sql.* 。
• 注册JDBC驱动程序：要求初始化驱动程序，使它可以与数据库打开一个通信通道。
• 打开一个连接：要求使用DriverManager.getConnection()方法创建一个Connection对象，它代表与数据库服务器的物理连接。
• 执行一个查询：需要使用类型Statement对象建立并提交一个SQL语句从符合给定条件的表获取记录。这使得查询使用LIKE子句来选择记录选择所有名字以 "za" 开始的学生。
• 清理环境：需要明确地关闭所有的数据库资源相对于依靠JVM的垃圾收集。

示例代码：

复制过去的下面的例子中JDBCExample.java，编译并运行，如下所示：

//STEP 1\. Import required packages
import java.sql.*;

public class JDBCExample {
// JDBC driver name and database URL
static final String JDBC_DRIVER = "com.mysql.jdbc.Driver";
static final String DB_URL = "jdbc:mysql://localhost/STUDENTS";

// Database credentials
static final String USER = "username";
static final String PASS = "password";

public static void main(String[] args) {
Connection conn = null;
Statement stmt = null;
try{
//STEP 2: Register JDBC driver
Class.forName("com.mysql.jdbc.Driver");

//STEP 3: Open a connection
System.out.println("Connecting to a selected database...");
conn = DriverManager.getConnection(DB_URL, USER, PASS);
System.out.println("Connected database successfully...");

//STEP 4: Execute a query
System.out.println("Creating statement...");
stmt = conn.createStatement();

// Extract records without any condition.
System.out.println("Fetching records without condition...");
String sql = "SELECT id, first, last, age FROM Registration";
ResultSet rs = stmt.executeQuery(sql);

while(rs.next()){
//Retrieve by column name
int id = rs.getInt("id");
int age = rs.getInt("age");
String first = rs.getString("first");
String last = rs.getString("last");

//Display values
System.out.print("ID: " + id);
System.out.print(", Age: " + age);
System.out.print(", First: " + first);
System.out.println(", Last: " + last);
}

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

while(rs.next()){
//Retrieve by column name
int id = rs.getInt("id");
int age = rs.getInt("age");
String first = rs.getString("first");
String last = rs.getString("last");

//Display values
System.out.print("ID: " + id);
System.out.print(", Age: " + age);
System.out.print(", First: " + first);
System.out.println(", Last: " + last);
}
rs.close();
}catch(SQLException se){
//Handle errors for JDBC
se.printStackTrace();
}catch(Exception e){
//Handle errors for Class.forName
e.printStackTrace();
}finally{
//finally block used to close resources
try{
if(stmt!=null)
conn.close();
}catch(SQLException se){
}// do nothing
try{
if(conn!=null)
conn.close();
}catch(SQLException se){
se.printStackTrace();
}//end finally try
}//end try
System.out.println("Goodbye!");
}//end main
}//end JDBCExample

现在来编译上面的例子如下：

C:>javac JDBCExample.java
C:>

当运行JDBCExample，它会产生以下结果：

C:>java JDBCExample
Connecting to a selected database...
Connected database successfully...
Creating statement...
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
Goodbye!
C:>

JDBC排序实例 - JDBC教程

本教程介绍了如何使用JDBC应用程序的对表中的数据进行排序的例子。这将使用asc和desc关键字的记录按升序或降序排序。执行下面的示例之前，请确保如下：

• 执行下面的例子中，请使用实际的用户名和密码代替username和password。
• MySQL或者其他数据库，正在使用：启动和运行。

所需步骤：

使用JDBC应用程序创建一个新的数据库需要执行以下步骤：

• 导入包：要求包括含有需要进行数据库编程的JDBC类的包。大多数情况下，使用 import java.sql.* 。
• 注册JDBC驱动程序：要求初始化驱动程序，使它可以与数据库打开一个通信通道。
• 打开一个连接：要求使用DriverManager.getConnection()方法创建一个Connection对象，它代表与数据库服务器的物理连接。
• 执行一个查询：需要使用类型语句的对象建立并提交一个SQL语句的记录从表中进行排序。查询利用ASC和DESC子句来按升序和降序顺序排序数据。
• 清理环境：需要明确地关闭所有的数据库资源相对于依靠JVM的垃圾收集。

示例代码：

复制过去的下面的例子中JDBCExample.java，编译并运行，如下所示：

//STEP 1\. Import required packages
import java.sql.*;

public class JDBCExample {
// JDBC driver name and database URL
static final String JDBC_DRIVER = "com.mysql.jdbc.Driver";
static final String DB_URL = "jdbc:mysql://localhost/STUDENTS";

// Database credentials
static final String USER = "username";
static final String PASS = "password";

public static void main(String[] args) {
Connection conn = null;
Statement stmt = null;
try{
//STEP 2: Register JDBC driver
Class.forName("com.mysql.jdbc.Driver");

//STEP 3: Open a connection
System.out.println("Connecting to a selected database...");
conn = DriverManager.getConnection(DB_URL, USER, PASS);
System.out.println("Connected database successfully...");

//STEP 4: Execute a query
System.out.println("Creating statement...");
stmt = conn.createStatement();

// Extract records in ascending order by first name.
System.out.println("Fetching records in ascending order...");
String sql = "SELECT id, first, last, age FROM Registration" +
" ORDER BY first ASC";
ResultSet rs = stmt.executeQuery(sql);

while(rs.next()){
//Retrieve by column name
int id = rs.getInt("id");
int age = rs.getInt("age");
String first = rs.getString("first");
String last = rs.getString("last");

//Display values
System.out.print("ID: " + id);
System.out.print(", Age: " + age);
System.out.print(", First: " + first);
System.out.println(", Last: " + last);
}

// Extract records in descending order by first name.
System.out.println("Fetching records in descending order...");
sql = "SELECT id, first, last, age FROM Registration" +
" ORDER BY first DESC";
rs = stmt.executeQuery(sql);

while(rs.next()){
//Retrieve by column name
int id = rs.getInt("id");
int age = rs.getInt("age");
String first = rs.getString("first");
String last = rs.getString("last");

//Display values
System.out.print("ID: " + id);
System.out.print(", Age: " + age);
System.out.print(", First: " + first);
System.out.println(", Last: " + last);
}
rs.close();
}catch(SQLException se){
//Handle errors for JDBC
se.printStackTrace();
}catch(Exception e){
//Handle errors for Class.forName
e.printStackTrace();
}finally{
//finally block used to close resources
try{
if(stmt!=null)
conn.close();
}catch(SQLException se){
}// do nothing
try{
if(conn!=null)
conn.close();
}catch(SQLException se){
se.printStackTrace();
}//end finally try
}//end try
System.out.println("Goodbye!");
}//end main
}//end JDBCExample

现在编译上面的例子如下：

C:>javac JDBCExample.java
C:>

当运行JDBCExample，它会产生以下结果：

C:>java JDBCExample
Connecting to a selected database...
Connected database successfully...
Creating statement...
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
Goodbye!
C:>

JDBC快速入门教程 - JDBC教程

JDBC是什么?

JDBC API是一个Java API，可以访问任何类型表列数据，特别是存储在关系数据库中的数据。JDBC代表Java数据库连接。

JDBC库中所包含的API任务通常与数据库使用：

• 连接到数据库
• 创建SQL或MySQL语句
• 在数据库中执行SQL或MySQL查询
• 查看和修改记录

123

先决条件:

学习JDBC，需要在以下两个主题有一定的了解：

1. JAVA核心编程
2. SQL或MySQL数据库

JDBC - 环境设置:

请确认您已完成以下设置：

1. 核心JAVA安装
2. SQL 或 MySQL数据库安装

除上述者外，需要建立一个数据库，为本程测试项目使用。假设这是EMP，在同一个数据库上创建表Employees。

创建JDBC应用程序:

参与建立一个JDBC应用程序，本教程中按六个步骤进行：

导入包:

这需要你有软件包包含了数据库编程所需的JDBC类。大多数情况下，使用import java.sql.* 就足够了，如下所示：

//STEP 1\. Import required packages
import java.sql.*;

注册JDBC驱动程序：

这需要初始化驱动程序，这样就可以打开与数据库的通信信道。以下是代码片段实现这一目标：

//STEP 2: Register JDBC driver
Class.forName("com.mysql.jdbc.Driver");

打开一个连接：

这需要使用DriverManager.getConnection()方法来创建一个Connection对象，它代表一个物理连接的数据库，如下所示：

//STEP 3: Open a connection
// Database credentials
static final String USER = "username";
static final String PASS = "password";
System.out.println("Connecting to database...");
conn = DriverManager.getConnection(DB_URL,USER,PASS);

执行一个查询：

这需要使用一个对象类型Statement或PreparedStatement构建，并提交一个SQL语句到数据库。如下：

//STEP 4: Execute a query
System.out.println("Creating statement...");
stmt = conn.createStatement();
String sql;
sql = "SELECT id, first, last, age FROM Employees";
ResultSet rs = stmt.executeQuery(sql);

如果有一个SQL UPDATE，INSERT或DELETE语句，那么需要下面的代码片段：

//STEP 4: Execute a query
System.out.println("Creating statement...");
stmt = conn.createStatement();
String sql;
sql = "DELETE FROM Employees";
ResultSet rs = stmt.executeUpdate(sql);

从结果集中提取数据：

这一步是必需的情况下，从数据库中获取数据。可以使用适当的ResultSet.getXXX()方法来检索的数据结果如下：

//STEP 5: Extract data from result set
while(rs.next()){
//Retrieve by column name
int id = rs.getInt("id");
int age = rs.getInt("age");
String first = rs.getString("first");
String last = rs.getString("last");

//Display values
System.out.print("ID: " + id);
System.out.print(", Age: " + age);
System.out.print(", First: " + first);
System.out.println(", Last: " + last);
}

清理环境：

应该明确地关闭所有的数据库资源，对依赖于JVM的垃圾收集如下：

//STEP 6: Clean-up environment
rs.close();
stmt.close();
conn.close();

第一个JDBC 程序:

基于上面的步骤，我们可以有以下综合示例代码，我们可以用它作为模板而写JDBC代码： 此示例代码已被写入基于对环境和数据库环境一章中设置完成。

//STEP 1\. Import required packages
import java.sql.*;

public class FirstExample {
// JDBC driver name and database URL
static final String JDBC_DRIVER = "com.mysql.jdbc.Driver";
static final String DB_URL = "jdbc:mysql://localhost/EMP";

// Database credentials
static final String USER = "username";
static final String PASS = "password";

public static void main(String[] args) {
Connection conn = null;
Statement stmt = null;
try{
//STEP 2: Register JDBC driver
Class.forName("com.mysql.jdbc.Driver");

//STEP 3: Open a connection
System.out.println("Connecting to database...");
conn = DriverManager.getConnection(DB_URL,USER,PASS);

//STEP 4: Execute a query
System.out.println("Creating statement...");
stmt = conn.createStatement();
String sql;
sql = "SELECT id, first, last, age FROM Employees";
ResultSet rs = stmt.executeQuery(sql);

//STEP 5: Extract data from result set
while(rs.next()){
//Retrieve by column name
int id = rs.getInt("id");
int age = rs.getInt("age");
String first = rs.getString("first");
String last = rs.getString("last");

//Display values
System.out.print("ID: " + id);
System.out.print(", Age: " + age);
System.out.print(", First: " + first);
System.out.println(", Last: " + last);
}
//STEP 6: Clean-up environment
rs.close();
stmt.close();
conn.close();
}catch(SQLException se){
//Handle errors for JDBC
se.printStackTrace();
}catch(Exception e){
//Handle errors for Class.forName
e.printStackTrace();
}finally{
//finally block used to close resources
try{
if(stmt!=null)
stmt.close();
}catch(SQLException se2){
}// nothing we can do
try{
if(conn!=null)
conn.close();
}catch(SQLException se){
se.printStackTrace();
}//end finally try
}//end try
System.out.println("Goodbye!");
}//end main
}//end FirstExample - by www.yiibai.com

现在让我们来编译上面的例子如下：

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:\>

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.
}

JDBC - 数据类型:

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

JDBC3.0的增强支持BLOB，CLOB，ARRAY，REF数据类型。的ResultSet对象UPDATEBLOB()，updateCLOB()，updateArray()和updateRef()方法，使您可以在服务器上直接操作相应的数据。

setXXX()和updateXXX()方法，可以转换成特定的Java类型到特定的JDBC数据类型。setObject()和updateObject()方法，几乎所有的Java类型映射到JDBC数据类型。

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

JDBC - 批量处理:

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

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

• JDBC驱动程序不支持此功能。您应该使用DatabaseMetaData.supportsBatchUpdates()方法来确定目标数据库支持批量更新处理。如果你的JDBC驱动程序支持此功能，则该方法返回true。
• addBatch()方法的声明，PreparedStatement和CallableStatementis用于添加单个语句的批处理。 executeBatch()将开始执行的所有语句组合到一起。
• executeBatch()将返回一个整数数组，每个数组元素的表示为相应的更新语句的更新计数。
• 可以添加语句进行批处理，可以clearBatch()方法删除它们。此方法将删除addBatch()方法添加的所有语句。但是，你不能有选择性地选择语句来删除。

JDBC - 数据流:

PreparedStatement对象有能力使用提供参数数据的输入和输出流。这使您可以将整个文件到数据库中，可容纳较大的值，如CLOB和BLOB数据类型的列。

有下列方法可用于流数据：

1. setAsciiStream(): 此方法用于提供大的ASCII值。
2. setCharacterStream(): 此方法用于提供大的UNICODE值。
3. setBinaryStream(): 使用此方法，以提供大的二进制值。

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

对于一个详细的关于所有这些概念，需要去通过学习完整的教程。