Java & MySQL 快速指南

Java & MySQL - 概述

JDBC 代表 **J**ava **D**ata**b**ase **C**onnectivity，它是 Java 编程语言与各种数据库之间进行数据库无关连接的标准 Java API。

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

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

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

Java 应用程序
Java 小程序
Java Servlet
Java ServerPages (JSP)
企业 JavaBean (EJB)。

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

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

先决条件

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

JDBC 架构

JDBC API 支持用于数据库访问的两层和三层处理模型，但通常情况下，JDBC 架构包含两层：

**JDBC API** - 这提供了应用程序到 JDBC 管理器的连接。
**JDBC 驱动程序 API** - 这支持 JDBC 管理器到驱动程序的连接。

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

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

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

常见的 JDBC 组件

JDBC API 提供以下接口和类：

**DriverManager** - 此类管理数据库驱动程序列表。使用通信子协议将来自 Java 应用程序的连接请求与正确的数据库驱动程序匹配。第一个识别 JDBC 下某个子协议的驱动程序将用于建立数据库连接。
**Driver** - 此接口处理与数据库服务器的通信。您很少会直接与 Driver 对象交互。相反，您使用 DriverManager 对象，它管理此类型的对象。它还抽象了与使用 Driver 对象相关的细节。
**Connection** - 此接口包含所有用于联系数据库的方法。连接对象表示通信上下文，即所有与数据库的通信都只能通过连接对象进行。
**Statement** - 您使用从此接口创建的对象将 SQL 语句提交到数据库。一些派生接口除了执行存储过程外还接受参数。
**ResultSet** - 这些对象在使用 Statement 对象执行 SQL 查询后保存从数据库检索到的数据。它充当迭代器，允许您遍历其数据。
**SQLException** - 此类处理数据库应用程序中发生的任何错误。

JDBC 4.0 包

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

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

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

Java & MySQL - 环境设置

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

安装 Java

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

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

为 Windows 2000/XP 设置路径

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

右键单击“我的电脑”，然后选择“属性”。
在“高级”选项卡下单击“环境变量”按钮。
现在，编辑“Path”变量，并在其末尾添加 Java 可执行文件目录的路径。例如，如果当前路径设置为 C:\Windows\System32，则按如下方式进行编辑

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

为 Windows 95/98/ME 设置路径

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

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

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

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

环境变量 PATH 应设置为指向已安装 Java 二进制文件的目录。如果您遇到问题，请参考您的 shell 文档。

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

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

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

安装数据库

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

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

**MySQL 数据库** - MySQL 是一个开源数据库。您可以从MySQL 官方网站下载它。我们建议下载完整的 Windows 安装程序。
此外，还下载并安装MySQL Administrator和MySQL Query Browser。这些是基于 GUI 的工具，将使您的开发更加轻松。
最后，下载并解压MySQL Connector/J（MySQL JDBC 驱动程序）到一个方便的目录。在本教程中，我们假设您已将驱动程序安装在 C:\Program Files\MySQL\mysql-connector-java-5.1.8。
相应地，将 CLASSPATH 变量设置为 C:\Program Files\MySQL\mysql-connector-java-5.1.8\mysql-connector-java-5.1.8-bin.jar。您的驱动程序版本可能因您的安装而异。

设置数据库凭据

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

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

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

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

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

创建数据库

要创建 **TUTORIALSPOINT** 数据库，请使用以下步骤：

步骤 1

打开 **命令提示符** 并更改到以下安装目录：

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

**注意** - **mysqld.exe** 的路径可能因您系统上 MySQL 的安装位置而异。您还可以查看有关如何启动和停止数据库服务器的文档。

步骤 2

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

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

步骤 3

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

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

创建表

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

步骤 1

打开 **命令提示符** 并更改到以下安装目录：

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

步骤 2

登录到数据库，如下所示：

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

步骤 3

创建表 **Employees**，如下所示：

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

创建数据记录

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

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

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

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

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

mysql>

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

现在您可以开始试验 JDBC 了。下一章将提供一个关于 JDBC 编程的示例。

Java & MySQL - 示例代码

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

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

创建 JDBC 应用程序

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

**导入包** - 需要您包含包含数据库编程所需的 JDBC 类的包。大多数情况下，使用 *import java.sql.* 就足够了。
**打开连接** - 需要使用 *DriverManager.getConnection()* 方法来创建一个 Connection 对象，该对象表示与数据库的物理连接。
**执行查询** - 需要使用 Statement 类型的对象来构建和向数据库提交 SQL 语句。
**从结果集中提取数据** - 需要您使用适当的 *ResultSet.getXXX()* 方法从结果集中检索数据。
清理环境 − 需要显式关闭所有数据库资源，而不是依赖JVM的垃圾回收。

示例代码

这个示例可以作为模板，供您将来创建自己的JDBC应用程序时使用。

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

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

import java.sql.*;

public class TestApplication {
   static final String DB_URL = "jdbc:mysql:///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 TestApplication.java
C:\>

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

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

Java & MySQL - 连接

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

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

导入JDBC包 − 向您的Java程序添加import语句，以导入Java代码中所需的类。
数据库URL构造 − 这是为了创建一个正确格式的地址，指向您想要连接到的数据库。
创建连接对象 − 最后，编写对DriverManager对象的getConnection( )方法的调用，以建立实际的数据库连接。

导入JDBC包

Import语句告诉Java编译器在哪里可以找到代码中引用的类，它们位于源代码的开头。

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

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

注册JDBC驱动程序

您必须在类路径中拥有所需的JDBC驱动程序。在本例中，您将CLASSPATH变量设置为C:\Program Files\MySQL\mysql-connector-java-5.1.8\mysql-connector-java-5.1.8-bin.jar。您的驱动程序版本可能因安装而异。

数据库URL构造

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

getConnection(String url)
getConnection(String url, Properties prop)
getConnection(String url, String user, String password)

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

构造数据库URL是建立连接时出现的大部分问题所在。

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

数据库管理系统	JDBC驱动程序名称	URL格式
MySQL	com.mysql.jdbc.Driver	jdbc:mysql://hostname/ databaseName

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

创建连接对象

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

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

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

由于您使用的是MySQL驱动程序，因此您将为URL的数据库部分指定一个host:port:databaseName值。

如果您有一个TCP/IP地址为192.0.0.1，主机名为localhost的主机，并且您的MySQL监听器配置为监听默认端口3306，并且您的数据库名为TUTORIALSPOINT，则完整的数据库URL将是：

jdbc:mysql:///TUTORIALSPOINT

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

String URL = "jdbc:mysql:///TUTORIALSPOINT";
String USER = "guest";
String PASS = "password"
Connection conn = DriverManager.getConnection(URL, USER, PASS);

使用数据库URL和Properties对象

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

DriverManager.getConnection(String url, Properties info);

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

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

import java.util.*;

String URL = "jdbc:mysql:///TUTORIALSPOINT";
Properties info = new Properties( );
info.put( "user", "guest" );
info.put( "password", "guest123" );

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

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

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

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

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

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

Java & MySQL - 异常处理

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

当发生异常情况时，会抛出异常。“抛出”这个词意味着当前程序执行停止，控制权重定向到最近的适用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)	将此可抛出对象及其回溯打印到您指定的打印流。
printStackTrace(PrintWriter w)	将此可抛出对象及其回溯打印到您指定的打印写入器。

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

try {
   // Your risky code goes between these curly braces!!!
}
catch(Exception ex) {
   // Your exception handling code goes between these 
   // curly braces
}
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 TestApplication {
   static final String DB_URL = "jdbc:mysql:///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 TestApplication.java
C:\>

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

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

Java & MySQL - Statement

JDBC Statement接口定义了方法和属性，以启用将SQL命令发送到MySQL数据库并从数据库检索数据。Statement用于对数据库进行通用访问。当您在运行时使用静态SQL语句时，它很有用。Statement接口不能接受参数。

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

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

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

boolean execute (String SQL) − 如果可以检索ResultSet对象，则返回true布尔值；否则，返回false。使用此方法执行SQL DDL语句，或者当您需要使用真正的动态SQL时。
int executeUpdate (String SQL) − 返回受SQL语句执行影响的行数。使用此方法执行您期望获得受影响的行数的SQL语句——例如，INSERT、UPDATE或DELETE语句。
ResultSet executeQuery (String SQL) − 返回一个ResultSet对象。当您期望获得结果集时（例如使用SELECT语句时）使用此方法。

关闭Statement对象

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

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

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

我们使用try with resources，它会自动处理资源关闭。以下示例演示了所有上述概念。

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

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

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

public class TestApplication {
   static final String DB_URL = "jdbc:mysql:///TUTORIALSPOINT";
   static final String USER = "guest";
   static final String PASS = "guest123";
   static final String QUERY = "SELECT id, first, last, age FROM Employees";
   static final String UPDATE_QUERY = "UPDATE Employees set age=30 WHERE id=103";

   public static void main(String[] args) {
      // Open a connection
      try(Connection conn = DriverManager.getConnection(DB_URL, USER, PASS);
         Statement stmt = conn.createStatement();
         ) {
         // Let us check if it returns a true Result Set or not.
         Boolean ret = stmt.execute(UPDATE_QUERY);
         System.out.println("Return value is : " + ret.toString() );

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

         // Let us select all the records and display them.
         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"));
         }
         rs.close();
      } catch (SQLException e) {
         e.printStackTrace();
      } 
   }
}

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

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

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

C:\>java TestApplication
Return value is : false
Rows impacted : 1
ID: 100, Age: 18, First: Zara, Last: Ali
ID: 101, Age: 25, First: Mehnaz, Last: Fatma
ID: 102, Age: 30, First: Zaid, Last: Khan
ID: 103, Age: 30, First: Sumit, Last: Mittal
C:\>

Java & MySQL - PreparedStatement

PreparedStatement接口扩展了Statement接口，这为您提供了比通用Statement对象更多的功能和一些优势。

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

创建PreparedStatement对象

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

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

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

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

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

关闭PreparedStatement对象

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

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

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

我们使用try with resources，它会自动处理资源关闭。以下示例演示了所有上述概念。

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

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

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

public class TestApplication {
   static final String DB_URL = "jdbc:mysql:///TUTORIALSPOINT";
   static final String USER = "guest";
   static final String PASS = "guest123";
   static final String QUERY = "SELECT id, first, last, age FROM Employees";
   static final String UPDATE_QUERY = "UPDATE Employees set age=? WHERE id=?";

   public static void main(String[] args) {
      // Open a connection
      try(Connection conn = DriverManager.getConnection(DB_URL, USER, PASS);
         PreparedStatement stmt = conn.prepareStatement(UPDATE_QUERY);
      ) {		      
         // 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.
         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"));
         }
         rs.close();
      } catch (SQLException e) {
         e.printStackTrace();
      } 
   }
}

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

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

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

C:\>java TestApplication
Return value is : false
Rows impacted : 1
ID: 100, Age: 18, First: Zara, Last: Ali
ID: 101, Age: 25, First: Mehnaz, Last: Fatma
ID: 102, Age: 35, First: Zaid, Last: Khan
ID: 103, Age: 30, First: Sumit, Last: Mittal
C:\>

Java & MySQL - CallableStatement

CallableStatement接口用于执行对数据库存储过程的调用。

假设您需要在TUTORIALSPOINT数据库中执行以下存储过程：

DELIMITER $$

DROP PROCEDURE IF EXISTS `TUTORIALSPOINT`.`getEmpName` $$
CREATE PROCEDURE `TUTORIALSPOINT`.`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 {
   . . .
}

字符串变量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();
}

我们使用try with resources，它会自动处理资源关闭。以下示例演示了所有上述概念。

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

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

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

public class TestApplication {
   static final String DB_URL = "jdbc:mysql:///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, 102);  // 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: 102 is " + empName);
      } catch (SQLException e) {
         e.printStackTrace();
      } 
   }
}

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

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

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

C:\>java TestApplication
Executing stored procedure...
Emp Name with ID: 102 is Zaid
C:\>

JDBC SQL 转义语法

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

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

{keyword 'parameters'}

以下是一些在执行 JDBC 编程时非常有用的转义序列：

d、t、ts 关键字

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

{d 'yyyy-mm-dd'}

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

这是一个简单的示例，演示如何将日期插入表中：

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

stmt.executeUpdate(sql);

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

{t 'hh:mm:ss'}

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

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

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

escape 关键字

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

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

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

fn 关键字

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

{fn length('Hello World')}

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

call 关键字

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

{call my_procedure(?)};

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

{? = call my_procedure(?)};

oj 关键字

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

{oj outer-join}

其中 outer-join = 表 {LEFT|RIGHT|FULL} OUTER JOIN {表 | outer-join} on 搜索条件。例如：

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

Java & MySQL - ResultSet

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

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

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

**导航方法** - 用于在结果集内移动游标。
**获取方法** - 用于查看游标指向的当前行列中的数据。
**更新方法** - 用于更新当前行列中的数据。然后也可以更新底层数据库中的更新。

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

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

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

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

ResultSet 类型

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

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

ResultSet 的并发性

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

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

我们迄今为止编写的所有示例都可以按如下方式编写，这将初始化一个 Statement 对象以创建一个仅向前、只读的 ResultSet 对象：

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

Java & MySQL - 导航 ResultSet

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

序号	方法和描述
1	public void beforeFirst() throws SQLException 将游标移动到第一行之前。
2	public void afterLast() throws SQLException 将游标移动到最后一行之后。
3	public boolean first() throws SQLException 将游标移动到第一行。
4	public void last() throws SQLException 将游标移动到最后一行。
5	public boolean absolute(int row) throws SQLException 将游标移动到指定的行。
6	public boolean relative(int row) throws SQLException 从游标当前指向的位置向前或向后移动给定数量的行。
7	public boolean previous() throws SQLException 将游标移动到前一行。如果前一行超出结果集，则此方法返回 false。
8	public boolean next() throws SQLException 将游标移动到下一行。如果结果集中没有更多行，则此方法返回 false。
9	public int getRow() throws SQLException 返回游标指向的行号。
10	public void moveToInsertRow() throws SQLException 将游标移动到结果集中的特殊行，该行可用于将新行插入数据库。当前游标位置将被记住。
11	public void moveToCurrentRow() throws SQLException 如果游标当前位于插入行，则将游标移回当前行；否则，此方法不执行任何操作。

以下示例使用了前面描述的一些导航方法。

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

将以下示例复制并粘贴到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:///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.TYPE_SCROLL_INSENSITIVE,
         ResultSet.CONCUR_READ_ONLY);
         ResultSet rs = stmt.executeQuery(QUERY);
      ) {		
         // Move cursor to the last row.
         System.out.println("Moving cursor to the last...");
         rs.last();

         // Extract data from result set
         System.out.println("Displaying record...");
         //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);

         // Move cursor to the first row.
         System.out.println("Moving cursor to the first row...");
         rs.first();

         // Extract data from result set
         System.out.println("Displaying record...");
         // Retrieve by column name
         id  = rs.getInt("id");
         age = rs.getInt("age");
         first = rs.getString("first");
         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);
         // Move cursor to the first row.

         System.out.println("Moving cursor to the next row...");
         rs.next();

         // Extract data from result set
         System.out.println("Displaying record...");
         id  = rs.getInt("id");
         age = rs.getInt("age");
         first = rs.getString("first");
         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);		

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

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

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

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

C:\>java TestApplication
Moving cursor to the last...
Displaying record...
ID: 103, Age: 30, First: Sumit, Last: Mittal
Moving cursor to the first row...
Displaying record...
ID: 100, Age: 18, First: Zara, Last: Ali
Moving cursor to the next row...
Displaying record...
ID: 101, Age: 25, First: Mehnaz, Last: Fatma
C:\>

Java & MySQL - 查看 ResultSet

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

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

一个接受列名。
一个接受列索引。

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

序号	方法和描述
1	public int getInt(String columnName) throws SQLException 返回名为 columnName 的列中当前行中的 int。
2	public int getInt(int columnIndex) throws SQLException 返回指定列索引中当前行中的 int。列索引从 1 开始，这意味着行的第一列是 1，行的第二列是 2，依此类推。

同样，ResultSet 接口中还存在针对八种 Java 基本类型以及常见类型（如 java.lang.String、java.lang.Object 和 java.net.URL）的 get 方法。

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

以下示例使用了前面描述的一些查看方法。

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

将以下示例复制并粘贴到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:///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.TYPE_SCROLL_INSENSITIVE,
         ResultSet.CONCUR_READ_ONLY);
         ResultSet rs = stmt.executeQuery(QUERY);
      ) {		
         // Move cursor to the last row.
         System.out.println("Moving cursor to the last...");
         rs.last();

         // Extract data from result set
         System.out.println("Displaying record...");
         //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);

         // Move cursor to the first row.
         System.out.println("Moving cursor to the first row...");
         rs.first();

         // Extract data from result set
         System.out.println("Displaying record...");
         // Retrieve by column name
         id  = rs.getInt("id");
         age = rs.getInt("age");
         first = rs.getString("first");
         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);
         // Move cursor to the first row.

         System.out.println("Moving cursor to the next row...");
         rs.next();

         // Extract data from result set
         System.out.println("Displaying record...");
         id  = rs.getInt("id");
         age = rs.getInt("age");
         first = rs.getString("first");
         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);		

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

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

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

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

C:\>java TestApplication
Moving cursor to the last...
Displaying record...
ID: 103, Age: 30, First: Sumit, Last: Mittal
Moving cursor to the first row...
Displaying record...
ID: 100, Age: 18, First: Zara, Last: Ali
Moving cursor to the next row...
Displaying record...
ID: 101, Age: 25, First: Mehnaz, Last: Fatma
C:\>

Java & MySQL - 更新 ResultSet

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

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

一个接受列名。
一个接受列索引。

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

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

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

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

序号	方法和描述
1	public void updateRow() 通过更新数据库中的对应行来更新当前行。
2	public void deleteRow() 从数据库中删除当前行。
3	public void refreshRow() 刷新结果集中的数据以反映数据库中的任何最新更改。
4	public void cancelRowUpdates() 取消对当前行进行的任何更新。
5	public void insertRow() 将一行插入数据库。只有当游标指向插入行时才能调用此方法。

以下示例使用了在 ResultSet 教程中描述的 **ResultSet.CONCUR_UPDATABLE** 和 **ResultSet.TYPE_SCROLL_INSENSITIVE**。此示例将解释对表的 INSERT、UPDATE 和 DELETE 操作。

需要注意的是，您正在使用的表应正确设置主键。让我们先更新我们的参考表。

删除表并按如下方式重新创建表 **Employees**：

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

创建数据记录

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

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

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

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

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

mysql>

将以下示例复制并粘贴到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:///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 printResultSet(ResultSet rs) throws SQLException{
      // Ensure we start with first row
      rs.beforeFirst();
      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();
   }

   public static void main(String[] args) {
      // Open a connection
      try(Connection conn = DriverManager.getConnection(DB_URL, USER, PASS);
         Statement stmt = conn.createStatement(
         ResultSet.TYPE_SCROLL_INSENSITIVE,
         ResultSet.CONCUR_UPDATABLE);
         ResultSet rs = stmt.executeQuery(QUERY);
      ) {		

         System.out.println("List result set for reference....");
         printResultSet(rs);

         // Loop through result set and add 5 in age
         // Move to Before first position so while-loop works properly
         rs.beforeFirst();
         //STEP 7: Extract data from result set
         while(rs.next()){
            // Retrieve by column name
            int newAge = rs.getInt("age") + 5;
            rs.updateDouble( "age", newAge );
            rs.updateRow();
         }
         System.out.println("List result set showing new ages...");
         printResultSet(rs);

         // Insert a record into the table.
         // Move to insert row and add column data with updateXXX()
         System.out.println("Inserting a new record...");
         rs.moveToInsertRow();
         rs.updateString("first","John");
         rs.updateString("last","Paul");
         rs.updateInt("age",40);
         // Commit row
         rs.insertRow();

         System.out.println("List result set showing new set...");
         printResultSet(rs);	

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

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

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

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

C:\>java TestApplication
List result set for reference....
ID: 1, Age: 18, First: Zara, Last: Ali
ID: 2, Age: 25, First: Mahnaz, Last: Fatma
ID: 3, Age: 30, First: Zaid, Last: Khan
ID: 4, Age: 28, First: Sumit, Last: Mittal

List result set showing new ages...
ID: 1, Age: 23, First: Zara, Last: Ali
ID: 2, Age: 30, First: Mahnaz, Last: Fatma
ID: 3, Age: 35, First: Zaid, Last: Khan
ID: 4, Age: 33, First: Sumit, Last: Mittal

Inserting a new record...
List result set showing new set...
ID: 1, Age: 23, First: Zara, Last: Ali
ID: 2, Age: 30, First: Mahnaz, Last: Fatma
ID: 3, Age: 35, First: Zaid, Last: Khan
ID: 4, Age: 33, First: Sumit, Last: Mittal
ID: 5, Age: 40, First: John, Last: Paul

List the record before deleting...
ID: 1, Age: 23, First: Zara, Last: Ali
ID: 2, Age: 30, First: Mahnaz, Last: Fatma
ID: 3, Age: 35, First: Zaid, Last: Khan
ID: 4, Age: 33, First: Sumit, Last: Mittal
ID: 5, Age: 40, First: John, Last: Paul
C:\>

Java & MySQL - 事务

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

对于简单的应用程序来说，这可能足够了，但是有三个原因可以解释为什么您可能想要关闭自动提交并自行管理事务：

提高性能。
维护业务流程的完整性。
使用分布式事务。

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

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

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

conn.setAutoCommit(false);

提交和回滚

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

conn.commit( );

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

conn.rollback( );

使用保存点

新的 JDBC 3.0 保存点接口为您提供了额外的交易控制。

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

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

setSavepoint(String savepointName) − 定义一个新的保存点。它还会返回一个 Savepoint 对象。
releaseSavepoint(Savepoint savepointName) − 删除保存点。请注意，它需要一个 Savepoint 对象作为参数。此对象通常是 setSavepoint() 方法生成的保存点。

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

Java & MySQL - 提交 & 回滚

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

conn.commit( );

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

conn.rollback( );

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

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

在这种情况下，以上所有 INSERT 语句都将失败，所有内容都将回滚。

以下示例使用了描述的commit 和rollback。

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

将以下示例复制并粘贴到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:///TUTORIALSPOINT";
   static final String USER = "guest";
   static final String PASS = "guest123";
   static final String QUERY = "SELECT id, first, last, age FROM Employees";
   static final String INSERT_QUERY = "INSERT INTO Employees (first, last, age) values('Rita', 'Tez', 20)";
   static final String INSERT_QUERY_2 = "INSERT INTO Employees (first, last, age) values('Sita', 'Singh', 20)";

   public static void printResultSet(ResultSet rs) throws SQLException{
      // Ensure we start with first row
      rs.beforeFirst();
      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();
   }

   public static void main(String[] args) {

      Connection conn = null;
      Statement stmt = null;
      try{
         // Open a connection
         System.out.println("Connecting to database...");
         conn = DriverManager.getConnection(DB_URL,USER,PASS);

         // Set auto commit as false.
         conn.setAutoCommit(false);

         // Execute a query to create statment with
         // required arguments for RS example.
         System.out.println("Creating statement...");
         stmt = conn.createStatement(
            ResultSet.TYPE_SCROLL_INSENSITIVE,
            ResultSet.CONCUR_UPDATABLE);

         // INSERT a row into Employees table
         System.out.println("Inserting one row....");
         stmt.executeUpdate(INSERT_QUERY);  

         // INSERT one more row into Employees table
         stmt.executeUpdate(INSERT_QUERY_2);

         // Commit data here.
         System.out.println("Commiting data here....");
         conn.commit();

         // Now list all the available records.
         String sql = "SELECT id, first, last, age FROM Employees";
         ResultSet rs = stmt.executeQuery(sql);
         System.out.println("List result set for reference....");
         printResultSet(rs);

         // Clean-up environment
         rs.close();
         stmt.close();
         conn.close();
      }catch(SQLException se){
         se.printStackTrace();
         // If there is an error then rollback the changes.
         System.out.println("Rolling back data here....");
         try{
            if(conn!=null)
               conn.rollback();
            }catch(SQLException se2){
               se2.printStackTrace();
            }
         }catch(Exception e){
            e.printStackTrace();
         }finally{
            // finally block used to close resources
         try{
            if(stmt!=null)
               stmt.close();
         }catch(SQLException se2){
            se2.printStackTrace();
         } 
            try{
               if(conn!=null)
                  conn.close();
            }catch(SQLException se){
               se.printStackTrace();
         }
      }		   
   }
}

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

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

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

C:\>java TestApplication
Connecting to database...
Creating statement...
Inserting one row....
Commiting data here....
List result set for reference....
ID: 1, Age: 23, First: Zara, Last: Ali
ID: 2, Age: 30, First: Mahnaz, Last: Fatma
ID: 3, Age: 35, First: Zaid, Last: Khan
ID: 4, Age: 33, First: Sumit, Last: Mittal
ID: 5, Age: 40, First: John, Last: Paul
ID: 6, Age: 20, First: Rita, Last: Tez
ID: 7, Age: 20, First: Sita, Last: Singh
C:\>

Java 和 MySQL - 保存点

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

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

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

setSavepoint(String savepointName) − 定义一个新的保存点。它还会返回一个 Savepoint 对象。
releaseSavepoint(Savepoint savepointName) − 删除保存点。请注意，它需要一个 Savepoint 对象作为参数。此对象通常是 setSavepoint() 方法生成的保存点。

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

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

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

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

在这种情况下，以上所有 INSERT 语句都将失败，所有内容都将回滚。

以下示例使用了描述的setSavepoint 和rollback。

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

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

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

public class TestApplication {
   static final String DB_URL = "jdbc:mysql:///TUTORIALSPOINT";
   static final String USER = "guest";
   static final String PASS = "guest123";
   static final String QUERY = "SELECT id, first, last, age FROM Employees";
   static final String DELETE_QUERY = "DELETE FROM Employees WHERE ID = 8";
   static final String DELETE_QUERY_1 = "DELETE FROM Employees WHERE ID = 9";

   public static void printResultSet(ResultSet rs) throws SQLException{
      // Ensure we start with first row
      rs.beforeFirst();
      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();
   }

   public static void main(String[] args) {
      // Open a connection
      try(Connection conn = DriverManager.getConnection(DB_URL, USER, PASS);
         Statement stmt = conn.createStatement(
            ResultSet.TYPE_SCROLL_INSENSITIVE,
            ResultSet.CONCUR_UPDATABLE);				
      ) {		

         conn.setAutoCommit(false);
         ResultSet rs = stmt.executeQuery(QUERY);
         System.out.println("List result set for reference....");
         printResultSet(rs);

         // delete row having ID = 8
         // But save point before doing so.
         Savepoint savepoint1 = conn.setSavepoint("ROWS_DELETED_1");
         System.out.println("Deleting row....");
         stmt.executeUpdate(DELETE_QUERY);  
         // Rollback the changes after save point 1.
         conn.rollback(savepoint1);

         // delete rows having ID = 9
         // But save point before doing so.
         conn.setSavepoint("ROWS_DELETED_2");
         System.out.println("Deleting row....");

         stmt.executeUpdate(DELETE_QUERY_1);  

         rs = stmt.executeQuery(QUERY);
         System.out.println("List result set for reference....");
         printResultSet(rs);

         // Clean-up environment
         rs.close();

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

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

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

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

C:\>java TestApplication
List result set for reference....
ID: 1, Age: 23, First: Zara, Last: Ali
ID: 2, Age: 30, First: Mahnaz, Last: Fatma
ID: 3, Age: 35, First: Zaid, Last: Khan
ID: 4, Age: 33, First: Sumit, Last: Mittal
ID: 5, Age: 40, First: John, Last: Paul
ID: 7, Age: 20, First: Sita, Last: Singh
ID: 8, Age: 20, First: Rita, Last: Tez
ID: 9, Age: 20, First: Sita, Last: Singh

Deleting row....
Deleting row....
List result set for reference....
ID: 1, Age: 23, First: Zara, Last: Ali
ID: 2, Age: 30, First: Mahnaz, Last: Fatma
ID: 3, Age: 35, First: Zaid, Last: Khan
ID: 4, Age: 33, First: Sumit, Last: Mittal
ID: 5, Age: 40, First: John, Last: Paul
ID: 7, Age: 20, First: Sita, Last: Singh
ID: 8, Age: 20, First: Rita, Last: Tez
C:\>

Java & MySQL - 批量处理

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

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

JDBC 驱动程序不需要支持此功能。您应该使用DatabaseMetaData.supportsBatchUpdates() 方法来确定目标数据库是否支持批量更新处理。如果您的 JDBC 驱动程序支持此功能，则该方法返回 true。
Statement、PreparedStatement 和 CallableStatement 的addBatch() 方法用于将单个语句添加到批处理中。executeBatch() 用于启动对所有分组语句的执行。
executeBatch() 返回一个整数数组，数组的每个元素都代表相应更新语句的更新计数。
就像您可以将语句添加到批处理以进行处理一样，您也可以使用clearBatch() 方法将其删除。此方法删除您使用 addBatch() 方法添加的所有语句。但是，您不能选择性地选择要删除哪个语句。

使用 Statement 对象进行批量处理

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

使用createStatement() 方法创建一个 Statement 对象。
使用setAutoCommit() 将自动提交设置为 false。
使用在创建的 statement 对象上addBatch() 方法将任意数量的 SQL 语句添加到批处理中。
使用在创建的 statement 对象上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 对象进行批量处理的典型步骤序列：

创建带有占位符的 SQL 语句。
使用prepareStatement() 方法创建一个 PrepareStatement 对象。
使用setAutoCommit() 将自动提交设置为 false。
使用在创建的 statement 对象上addBatch() 方法将任意数量的 SQL 语句添加到批处理中。
使用在创建的 statement 对象上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();

Java 和 MySQL - 使用 Statement 对象进行批量处理

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

使用createStatement() 方法创建一个 Statement 对象。
使用setAutoCommit() 将自动提交设置为 false。
使用在创建的 statement 对象上addBatch() 方法将任意数量的 SQL 语句添加到批处理中。
使用在创建的 statement 对象上executeBatch() 方法执行所有 SQL 语句。
最后，使用commit() 方法提交所有更改。

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

将以下示例复制并粘贴到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:///TUTORIALSPOINT";
   static final String USER = "guest";
   static final String PASS = "guest123";

   public static void printResultSet(ResultSet rs) throws SQLException{
      // Ensure we start with first row
      rs.beforeFirst();
      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();
   }

   public static void main(String[] args) {
      // Open a connection
      try(Connection conn = DriverManager.getConnection(DB_URL, USER, PASS);
         Statement stmt = conn.createStatement(
            ResultSet.TYPE_SCROLL_INSENSITIVE,
            ResultSet.CONCUR_UPDATABLE)
            ) {		      
         conn.setAutoCommit(false);	    	  

         ResultSet rs = stmt.executeQuery("Select * from Employees");
         printResultSet(rs);

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

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

         // Create one more SQL statement
         SQL = "UPDATE Employees SET age = 35 " +
         "WHERE id = 7";
         // 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();

         rs = stmt.executeQuery("Select * from Employees");
         printResultSet(rs);	  

         stmt.close();
         rs.close();

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

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

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

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

C:\>java TestApplication
ID: 1, Age: 23, First: Zara, Last: Ali
ID: 2, Age: 30, First: Mahnaz, Last: Fatma
ID: 3, Age: 35, First: Zaid, Last: Khan
ID: 4, Age: 33, First: Sumit, Last: Mittal
ID: 5, Age: 40, First: John, Last: Paul
ID: 7, Age: 20, First: Sita, Last: Singh
ID: 8, Age: 20, First: Rita, Last: Tez
ID: 9, Age: 20, First: Sita, Last: Singh

ID: 1, Age: 23, First: Zara, Last: Ali
ID: 2, Age: 30, First: Mahnaz, Last: Fatma
ID: 3, Age: 35, First: Zaid, Last: Khan
ID: 4, Age: 33, First: Sumit, Last: Mittal
ID: 5, Age: 40, First: John, Last: Paul
ID: 7, Age: 35, First: Sita, Last: Singh
ID: 8, Age: 20, First: Rita, Last: Tez
ID: 9, Age: 20, First: Sita, Last: Singh
ID: 10, Age: 30, First: Zia, Last: Ali
ID: 11, Age: 35, First: Raj, Last: Kumar
C:\>

Java 和 MySQL - 使用 PrepareStatement 对象进行批量处理

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

创建带有占位符的 SQL 语句。
使用prepareStatement() 方法创建一个 PrepareStatement 对象。
使用setAutoCommit() 将自动提交设置为 false。
使用在创建的 statement 对象上addBatch() 方法将任意数量的 SQL 语句添加到批处理中。
使用在创建的 statement 对象上executeBatch() 方法执行所有 SQL 语句。
最后，使用commit() 方法提交所有更改。

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

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

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:///TUTORIALSPOINT";
   static final String USER = "guest";
   static final String PASS = "guest123";
   static final String INSERT_QUERY = "INSERT INTO Employees(first,last,age) VALUES(?, ?, ?)";

   public static void printResultSet(ResultSet rs) throws SQLException{
      // Ensure we start with first row
      rs.beforeFirst();
      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();
   }

   public static void main(String[] args) {
      // Open a connection
      try(Connection conn = DriverManager.getConnection(DB_URL, USER, PASS);
         PreparedStatement stmt = conn.prepareStatement(INSERT_QUERY,
            ResultSet.TYPE_SCROLL_INSENSITIVE,
            ResultSet.CONCUR_UPDATABLE)
      ) {		      
         conn.setAutoCommit(false);	    	  

         ResultSet rs = stmt.executeQuery("Select * from Employees");
         printResultSet(rs);

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

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

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

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

         rs = stmt.executeQuery("Select * from Employees");
         printResultSet(rs);	  

         stmt.close();
         rs.close();

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

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

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

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

C:\>java TestApplication
ID: 1, Age: 23, First: Zara, Last: Ali
ID: 2, Age: 30, First: Mahnaz, Last: Fatma
ID: 3, Age: 35, First: Zaid, Last: Khan
ID: 4, Age: 33, First: Sumit, Last: Mittal
ID: 5, Age: 40, First: John, Last: Paul
ID: 7, Age: 35, First: Sita, Last: Singh
ID: 8, Age: 20, First: Rita, Last: Tez
ID: 9, Age: 20, First: Sita, Last: Singh
ID: 10, Age: 30, First: Zia, Last: Ali
ID: 11, Age: 35, First: Raj, Last: Kumar

ID: 1, Age: 23, First: Zara, Last: Ali
ID: 2, Age: 30, First: Mahnaz, Last: Fatma
ID: 3, Age: 35, First: Zaid, Last: Khan
ID: 4, Age: 33, First: Sumit, Last: Mittal
ID: 5, Age: 40, First: John, Last: Paul
ID: 7, Age: 35, First: Sita, Last: Singh
ID: 8, Age: 20, First: Rita, Last: Tez
ID: 9, Age: 20, First: Sita, Last: Singh
ID: 10, Age: 30, First: Zia, Last: Ali
ID: 11, Age: 35, First: Raj, Last: Kumar
ID: 12, Age: 33, First: Pappu, Last: Singh
ID: 13, Age: 31, First: Pawan, Last: Singh
C:\>

Java & MySQL - 流式数据

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

可以使用以下方法来流式传输数据：

setAsciiStream() − 此方法用于提供大型 ASCII 值。
setCharacterStream() − 此方法用于提供大型 UNICODE 值。
setBinaryStream() − 此方法用于提供大型二进制值。

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

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

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

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

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

Java 和 MySQL - 创建数据库示例

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

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

必需步骤

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

**导入包** - 需要您包含包含数据库编程所需的 JDBC 类的包。大多数情况下，使用 *import java.sql.* 就足够了。
打开连接 − 需要使用DriverManager.getConnection() 方法创建一个 Connection 对象，该对象代表与数据库服务器的物理连接。
要创建新数据库，在准备数据库 URL 时无需提供任何数据库名称，如下例所示。
**执行查询** - 需要使用 Statement 类型的对象来构建和向数据库提交 SQL 语句。
清理环境 − try with resources 自动关闭资源。

示例代码

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

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

public class TestApplication {
   static final String DB_URL = "jdbc:mysql:///";
   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 TestApplication.java
C:\>

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

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

Java 和 MySQL - 选择数据库示例

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

要执行以下示例，您需要将用户名和密码替换为您实际的用户名和密码。
您正在使用的 MySQL 数据库正在运行。

必需步骤

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

导入包 − 需要包含包含数据库编程所需的 JDBC 类的包。大多数情况下，使用import java.sql.* 就足够了。
打开连接 − 需要使用DriverManager.getConnection() 方法创建一个 Connection 对象，该对象代表与选定数据库的物理连接。
准备数据库 URL 时会选择数据库。以下示例将与STUDENTS 数据库建立连接。
清理环境 − try with resources 自动关闭资源。

示例代码

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

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

public class TestApplication {
   static final String DB_URL = "jdbc:mysql:///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 TestApplication.java
C:\>

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

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

Java 和 MySQL - 删除数据库示例

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

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

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

必需步骤

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

**导入包** - 需要您包含包含数据库编程所需的 JDBC 类的包。大多数情况下，使用 *import java.sql.* 就足够了。
打开连接 − 需要使用DriverManager.getConnection() 方法创建一个 Connection 对象，该对象代表与数据库服务器的物理连接。
删除数据库不需要数据库名称在数据库 URL 中。以下示例将删除STUDENTS 数据库。
执行查询 − 需要使用 Statement 类型的对象来构建和提交用于删除数据库的 SQL 语句。
清理环境 − try with resources 自动关闭资源。

示例代码

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

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

public class TestApplication {
   static final String DB_URL = "jdbc:mysql:///";
   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 TestApplication.java
C:\>

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

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

Java 和 MySQL - 创建表示例

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

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

必需步骤

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

**导入包** - 需要您包含包含数据库编程所需的 JDBC 类的包。大多数情况下，使用 *import java.sql.* 就足够了。
打开连接 − 需要使用DriverManager.getConnection() 方法创建一个 Connection 对象，该对象代表与数据库服务器的物理连接。
执行查询 − 需要使用 Statement 类型的对象来构建和提交用于在选定数据库中创建表的 SQL 语句。
清理环境 − try with resources 自动关闭资源。

示例代码

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

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

public class TestApplication {
   static final String DB_URL = "jdbc:mysql:///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:\>

Java 和 MySQL - 删除表示例

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

要执行以下示例，您可以将用户名和密码替换为您实际的用户名和密码。
您正在使用的 MySQL 数据库正在运行。

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

必需步骤

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

**导入包** - 需要您包含包含数据库编程所需的 JDBC 类的包。大多数情况下，使用 *import java.sql.* 就足够了。
打开连接 − 需要使用DriverManager.getConnection() 方法创建一个 Connection 对象，该对象代表与数据库服务器的物理连接。
执行查询 − 需要使用 Statement 类型的对象来构建和提交用于在选定数据库中删除表的 SQL 语句。
清理环境 − try with resources 自动关闭资源。

示例代码

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

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

public class TestApplication {
   static final String DB_URL = "jdbc:mysql:///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 TestApplication.java
C:\>

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

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

Java 和 MySQL - 插入记录示例

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

要执行以下示例，您可以将用户名和密码替换为您实际的用户名和密码。
您正在使用的 MySQL 数据库正在运行。

必需步骤

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

**导入包** - 需要您包含包含数据库编程所需的 JDBC 类的包。大多数情况下，使用 *import java.sql.* 就足够了。
注册 JDBC 驱动程序 − 需要初始化驱动程序，以便您可以打开与数据库的通信通道。
打开连接 − 需要使用DriverManager.getConnection() 方法创建一个 Connection 对象，该对象代表与数据库服务器的物理连接。
执行查询 − 需要使用 Statement 类型的对象来构建和提交用于将记录插入表的 SQL 语句。
清理环境 − try with resources 自动关闭资源。

示例代码

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

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

public class TestApplication {
   static final String DB_URL = "jdbc:mysql:///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 TestApplication.java
C:\>

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

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

Java & MySQL - 选择记录示例

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

要执行以下示例，您可以将用户名和密码替换为您实际的用户名和密码。
您正在使用的 MySQL 数据库正在运行。

必需步骤

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

**导入包** - 需要您包含包含数据库编程所需的 JDBC 类的包。大多数情况下，使用 *import java.sql.* 就足够了。
打开连接 − 需要使用DriverManager.getConnection() 方法创建一个 Connection 对象，该对象代表与数据库服务器的物理连接。
执行查询 − 需要使用 Statement 类型对象来构建和提交 SQL 语句，以从表中选择（即提取）记录。
提取数据 − 一旦 SQL 查询执行完毕，您就可以从表中提取记录。
清理环境 − try with resources 自动关闭资源。

示例代码

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

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

public class TestApplication {
   static final String DB_URL = "jdbc:mysql:///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 TestApplication.java
C:\>

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

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

Java & MySQL - 更新记录示例

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

要执行以下示例，您可以将用户名和密码替换为您实际的用户名和密码。
您正在使用的 MySQL 数据库正在运行。

必需步骤

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

**导入包** - 需要您包含包含数据库编程所需的 JDBC 类的包。大多数情况下，使用 *import java.sql.* 就足够了。
打开连接 − 需要使用DriverManager.getConnection() 方法创建一个 Connection 对象，该对象代表与数据库服务器的物理连接。
执行查询 − 需要使用 Statement 类型对象来构建和提交 SQL 语句以更新表中的记录。此查询使用IN和WHERE子句来更新条件记录。
清理环境 − try with resources 自动关闭资源。

示例代码

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

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

public class TestApplication {
   static final String DB_URL = "jdbc:mysql:///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 TestApplication.java
C:\>

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

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

Java & MySQL - 删除记录示例

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

要执行以下示例，您可以将用户名和密码替换为您实际的用户名和密码。
您正在使用的 MySQL 数据库正在运行。

必需步骤

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

**导入包** - 需要您包含包含数据库编程所需的 JDBC 类的包。大多数情况下，使用 *import java.sql.* 就足够了。
注册 JDBC 驱动程序 − 需要初始化驱动程序，以便您可以打开与数据库的通信通道。
打开连接 − 需要使用DriverManager.getConnection() 方法创建一个 Connection 对象，该对象代表与数据库服务器的物理连接。
执行查询 − 需要使用 Statement 类型对象来构建和提交 SQL 语句以从表中删除记录。此查询使用WHERE子句来删除条件记录。
清理环境 − try with resources 自动关闭资源。

示例代码

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

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

public class TestApplication {
   static final String DB_URL = "jdbc:mysql:///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 TestApplication.java
C:\>

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

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

Java & MySQL - WHERE 子句示例

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

要执行以下示例，您可以将用户名和密码替换为您实际的用户名和密码。
您正在使用的 MySQL 数据库正在运行。

必需步骤

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

导入包 − 需要包含包含数据库编程所需的 JDBC 类的包。大多数情况下，使用import java.sql.* 就足够了。
注册 JDBC 驱动程序 − 需要初始化驱动程序，以便您可以打开与数据库的通信通道。
打开连接 − 需要使用DriverManager.getConnection() 方法创建一个 Connection 对象，该对象代表与数据库服务器的物理连接。
执行查询 − 需要使用 Statement 类型对象来构建和提交 SQL 语句以提取符合给定条件的表记录。此查询使用WHERE子句来选择记录。
清理环境 − try with resources 自动关闭资源。

示例代码

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

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

public class TestApplication {
   static final String DB_URL = "jdbc:mysql:///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:\>

Java & MySQL - LIKE 子句示例

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

要执行以下示例，您可以将用户名和密码替换为您实际的用户名和密码。
您正在使用的 MySQL 数据库正在运行。

必需步骤

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

**导入包** - 需要您包含包含数据库编程所需的 JDBC 类的包。大多数情况下，使用 *import java.sql.* 就足够了。
打开连接 − 需要使用DriverManager.getConnection() 方法创建一个 Connection 对象，该对象代表与数据库服务器的物理连接。
执行查询 − 需要使用 Statement 类型对象来构建和提交 SQL 语句以提取符合给定条件的表记录。此查询使用LIKE子句选择记录，例如选择所有名字以“za”开头的学生。
清理环境 − try with resources 自动关闭资源。

示例代码

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

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

public class TestApplication {
   static final String DB_URL = "jdbc:mysql:///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 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: 100, Age: 30, First: Zara, Last: Ali
ID: 102, Age: 30, First: Zaid, Last: Khan
C:\>

Java & MySQL - 数据排序示例

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

要执行以下示例，您可以将用户名和密码替换为您实际的用户名和密码。
您正在使用的 MySQL 数据库正在运行。

必需步骤

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

**导入包** - 需要您包含包含数据库编程所需的 JDBC 类的包。大多数情况下，使用 *import java.sql.* 就足够了。
打开连接 − 需要使用DriverManager.getConnection() 方法创建一个 Connection 对象，该对象代表与数据库服务器的物理连接。
执行查询 − 需要使用 Statement 类型对象来构建和提交 SQL 语句以对表中的记录进行排序。这些查询使用asc和desc子句以升序和降序对数据进行排序。
清理环境 − try with resources 自动关闭资源。

示例代码

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

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

public class TestApplication {
   static final String DB_URL = "jdbc:mysql:///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 TestApplication.java
C:\>

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

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

打印页面