Java Mysql 简明教程

Java & MySQL - Quick Guide

Java & MySQL - Overview

JDBC 全称 *J*ava *D*ata*b*ase *C*onnectivity，它是用于 Java 编程语言和广泛数据库之间的与数据库无关的连接的标准 Java API。

JDBC 库包括用于以下任务的 API，这些任务通常与数据库使用有关。

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

从根本上说，JDBC 是一套规范，它提供了全面的接口来实现对底层数据库的可移植访问。Java 可用于编写不同类型的可执行文件，比如：

Java Applications
Java Applets
Java Servlets
Java ServerPages (JSPs)
Enterprise JavaBeans (EJBs).

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

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

Pre-Requisite

在继续下一步之前，你需要对以下两个主题有深入的了解：

JDBC Architecture

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

JDBC API — 提供应用程序与 JDBC 管理器之间的连接。
JDBC Driver API — 支持 JDBC 管理器与驱动程序之间的连接。

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

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

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

Common JDBC Components

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

DriverManager — 此类管理数据库驱动程序列表。根据通信子协议，匹配 Java 应用程序的连接请求和合适的数据库驱动程序。第一个识别特定 JDBC 子协议的驱动程序将用来建立数据库连接。
Driver — 此接口处理与数据库服务器的通信。你很少会直接与驱动程序对象交互。相反，你使用 DriverManager 对象，它会管理此类型的对象。此接口还抽象了与驱动程序对象相关的工作详情。
Connection — 此接口提供了所有用于连接数据库的方法。连接对象表示通信上下文，也就是说所有与数据库的通信都仅通过连接对象进行。
Statement — 你可以使用从此接口创建的对象向数据库提交 SQL 语句。一些派生接口接受参数并执行存储过程。
ResultSet — 使用 Statement 对象执行 SQL 查询后，这些对象会保存从数据库中检索的数据。它充当迭代器，允许你在数据中移动。
SQLException — 此类处理数据库应用程序中发生的任何错误。

The JDBC 4.0 Packages

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

这些软件包中的新功能包括以下领域的变更：

Automatic database driver loading.
Exception handling improvements.
Enhanced BLOB/CLOB functionality.
连接和语句界面增强功能。
National character set support.
SQL ROWID access.
SQL 2003 XML 数据类型支持。
Annotations.

Java & MySQL - Environment Setup

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

Install Java

Java SE 可以免费下载。若要下载 click here ，请下载与您的操作系统兼容的版本。

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

Setting Up the Path for Windows 2000/XP

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

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

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

Setting Up the Path for Windows 95/98/ME

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

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

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

Setting Up the Path for Linux, UNIX, Solaris, FreeBSD

环境变量 PATH 应设置为指向已安装 Java 二进制文件的位置。如果你在这方面遇到问题，请参阅 shell 文档。

例如，如果你使用 bash 作为你的 shell，那么你将在 .bashrc 的末尾添加以下行 −

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

当您安装 J2SE 开发工具包时，您会自动获取 JDBC 软件包 java.sql 和 javax.sql, 。

Install Database

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

安装最适合于你的数据库。你有很多选择，最常见的是 −

MySQL DB - MySQL 是一个开源数据库。您可以从 MySQL Official Site 下载它。我们建议下载完整的 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。您的驱动程序版本可能会因您的安装而异。

Set Database Credential

当我们安装 MySQL 数据库时，它的管理员 ID 设置为 root ，并提供设置密码的选项。

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

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

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

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

Create Database

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

Step 1

打开 Command Prompt 并更改到安装目录，如下所示 −

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

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

Step 2

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

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

Step 3

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

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

Create Table

要创建 Employees 表中 TUTORIALSPOINT 数据库，请执行以下步骤 −

Step 1

打开 Command Prompt 并更改到安装目录，如下所示 −

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

Step 2

登录数据库，如下所示 −

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

Step 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>

Create Data Records

最后，在 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 Tutorial 。

现在您可以开始尝试 JDBC 了。下一章将为您提供有关 JDBC 编程的示例。

Java & MySQL - Sample Code

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

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

Creating JDBC Application

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

Import the packages - 需要包括包含数据库编程所需 JDBC 类的包。通常，使用 import java.sql.* 将足够。
Open a connection − 需要使用 DriverManager.getConnection() 方法创建一个 Connection 对象，该对象表示与数据库的物理连接。
Execute a query - 需使用 Statement 类型对象来创建和向数据库提交 SQL 语句。
Extract data from result set - 要求您使用适当的 ResultSet.getXXX() 方法从结果集中检索数据。
Clean up the environment - 需要明确关闭所有数据库资源，而不是依赖 JVM 的垃圾回收。

Sample Code

此示例可以充当一种 template ，以便在未来需要创建自己 JDBC 应用时使用。

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

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

import java.sql.*;

public class TestApplication {
   static final String DB_URL = "jdbc:mysql://localhost/TUTORIALSPOINT";
   static final String USER = "guest";
   static final String PASS = "guest123";
   static final String QUERY = "SELECT id, first, last, age FROM 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 - Connections

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

建立 JDBC 连接的编程过程相当简单。下面是这三个简单步骤：

Import JDBC Packages − 在你的 Java 程序中添加 import 语句以导入 Java 代码中所需的类。
Database URL Formulation − 这是创建指向你希望连接的数据库的正确格式的地址。
Create Connection Object − 最后，编写对 DriverManager 对象的 getConnection( ) 方法的调用以建立实际的数据库连接。

Import JDBC Packages

Import 语句告诉 Java 编译器在你的代码中引用哪些类，并且放在源代码的最开始位置。

要使用标准 JDBC 软件包（它允许你选择、插入、更新和删除 SQL 表中的数据），将以下导入项添加到你的源代码：

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

Register JDBC Driver

类路径中必须有必需的 JDBC 驱动程序。在当前情况下，将 CLASSPATH 变量设置为 C:\Program Files\MySQL\mysql-connector-java-5.1.8\mysql-connector-java-5.1.8-bin.jar。你的驱动程序版本可能根据安装而有所不同。

Database URL Formulation

在加载驱动程序后，可以使用 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。

RDBMS

JDBC driver name

URL format

MySQL

com.mysql.jdbc.Driver

*jdbc:mysql://*hostname/ databaseName

URL 格式中的所有高亮部分都是静态的，你只需要根据数据库设置更改其余部分。

Create Connection Object

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

Using a Database URL with a username and password

getConnection() 最常用的形式需要你传递一个数据库 URL、一个用户名和一个密码：

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

如果你有一个 TCP/IP 地址为 192.0.0.1、主机名为 localhost 的主机，并且你的 MySQL 侦听器配置为默认情况下在端口 3306 上侦听，并且你的数据库名为 TUTORIALSPOINT，那么完整的数据库 URL 如下：

jdbc:mysql://localhost/TUTORIALSPOINT

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

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

Using a Database URL and a Properties Object

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

DriverManager.getConnection(String url, Properties info);

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

如需建立与前一个示例相同的连接，请使用以下代码：

import java.util.*;

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

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

为了更好地理解，我们建议你学习我们的 Java & MySQL - Sample Code tutorial 。

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

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 - Exceptions Handling

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

当发生异常情况时，会引发异常。术语引发表示当前程序执行停止，并且控制重定向到最近适用的 catch 子句。如果没有适用的 catch 子句，则程序执行结束。

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

SQLException Methods

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

传递的 SQLException 对象具有以下方法，可用于检索有关异常的其他信息 −

Method

Description

getErrorCode( )

获取与异常关联的错误号。

getMessage( )

获取 JDBC 驱动程序的错误消息以获取由驱动程序处理的错误，或获取数据库错误的 Oracle 错误编号和消息。

getSQLState( )

获取 XOPEN SQLstate 字符串。对于 JDBC 驱动程序错误，该方法不返回有用的信息。对于数据库错误，返回五位 XOPEN SQLstate 代码。此方法可以返回 null。

getNextException( )

获取异常链中的下一个异常对象。

printStackTrace( )

打印当前异常或可抛出内容，并将其回溯到标准错误流。

printStackTrace(PrintStream s)

将此可抛出内容及其回溯打印到您指定的打印流。

printStackTrace(PrintWriter w)

将此可抛出内容及其回溯打印到您指定的打印写入器。

通过利用异常对象中可用的信息，您可以捕获异常并适当地继续您的程序。以下是 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.
}

Example

研究以下示例代码以了解 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://localhost/TUTORIALSPOINT";
   static final String USER = "guest";
   static final String PASS = "guest123";
   static final String QUERY = "{call getEmpName (?, ?)}";

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

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

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

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

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

Java & MySQL - Statement

JDBC Statement 接口定义了方法和属性，以便能够向 MySQL 数据库发送 SQL 命令并从数据库中检索数据。Statement 用于一般性地访问您的数据库。当您在运行时使用静态 SQL 语句时，它非常有用。Statement 接口无法接受参数。

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

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

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

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

Closing Statement Object

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

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

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

我们使用 try 和 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://localhost/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 对象相比具有一些优势的附加功能。

此语句使您能够灵活地动态提供参数。

Creating PreparedStatement Object

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 object’s 方法 (a) execute()、(b) executeQuery() 和 (c) executeUpdate() 也可与 PreparedStatement 对象一起使用。但是，这些方法已修改为使用可以输入参数的 SQL 语句。

Closing PreparedStatement Object

正如你关闭一个 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 和 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://localhost/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 对象可以使用所有这三种。

以下是对每种类型的定义：

Parameter

Description

在创建 SQL 语句时不知道其值的某个参数。您可以使用 setXXX() 方法将值绑定到 IN 参数。

OUT

某个由返回的 SQL 语句提供其值的参数。您可以使用 getXXX() 方法从 OUT 参数中检索值。

INOUT

同时提供输入和输出值的某个参数。您可以使用 setXXX() 方法绑定变量，并使用 getXXX() 方法检索值。

以下代码段演示如何使用 Connection.prepareCall() 方法基于上一个存储过程实例化一个 CallableStatement 对象：

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

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

使用 CallableStatement 对象非常类似于使用 PreparedStatement 对象。您必须在执行语句之前向所有参数绑定值，否则您将收到 SQLException。

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

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

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

Closing CallableStatement Object

正如您关闭其它 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 和 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://localhost/TUTORIALSPOINT";
   static final String USER = "guest";
   static final String PASS = "guest123";
   static final String QUERY = "{call getEmpName (?, ?)}";

   public static void main(String[] args) {
      // Open a connection
      try(Connection conn = DriverManager.getConnection(DB_URL, USER, PASS);
         CallableStatement stmt = conn.prepareCall(QUERY);
      ) {
         // Bind values into the parameters.
         stmt.setInt(1, 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 Escape Syntax

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

SQL 转义语法格式如下 −

{keyword 'parameters'}

下面是执行 JDBC 编程时非常有用的转义序列 −

d, t, ts Keywords

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

{d 'yyyy-mm-dd'}

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

以下是一个简单的示例，演示如何在表中 INSERT 日期 −

//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 Keyword

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

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

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

fn Keyword

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

{fn length('Hello World')}

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

call Keyword

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

{call my_procedure(?)};

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

{? = call my_procedure(?)};

oj Keyword

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

{oj outer-join}

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

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 接口方法可以分为以下三类：

Navigational methods − 用于移动游标。
Get methods − 用于查看游标指向的当前行的列中的数据。
Update methods − 用于更新当前行的列中的数据。这些更新随后也可以在底层数据库中更新。

游标是基于 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 常量之一。

Type of ResultSet

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

Type

Description

ResultSet.TYPE_FORWARD_ONLY

游标只能在结果集中向前移动。

ResultSet.TYPE_SCROLL_INSENSITIVE

游标可以前后滚动，而结果集不会因为结果集创建后其他人对数据库所做的更改而敏感。

ResultSet.TYPE_SCROLL_SENSITIVE.

游标可以前后滚动，而结果集会由于结果集创建后其他人对数据库做出的更改而敏感。

Concurrency of ResultSet

可能的 RSConcurrency 如下所示。如果您未指定任何并发的类型，您将自动获得一个 CONCUR_READ_ONLY。

Concurrency

Description

ResultSet.CONCUR_READ_ONLY

创建一个只读结果集。这是默认设置。

ResultSet.CONCUR_UPDATABLE

创建一个可更新的结果集。

我们到目前为止编写的示例都可以如以下所示书写，它初始化一个用于创建一个前向只读 ResultSet 对象的 Statement 对象：

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

Java & MySQL - Navigating a ResultSet

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

S.N.	Methods & Description
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://localhost/TUTORIALSPOINT";
   static final String USER = "guest";
   static final String PASS = "guest123";
   static final String QUERY = "SELECT id, first, last, age FROM Employees";

   public static void main(String[] args) {
      // Open a connection
      try(Connection conn = DriverManager.getConnection(DB_URL, USER, PASS);
         Statement stmt = conn.createStatement(
         ResultSet.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 - Viewing a ResultSet

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

对于所有可能的数据类型都有一个 get 方法，并且每个 get 方法有两个版本 −

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

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

S.N.

Methods & Description

*public int getInt(String columnName) throws SQLException*返回列名为 columnName 的当前行中的 int。

*public int getInt(int columnIndex) throws SQLException*返回指定列索引中当前行中的 int。列索引从 1 开始，这意味着行的第一列为 1，行的第二列为 2，依此类推。

同样，ResultSet 接口中有 get 方法用于八种 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 数据类型的信息。

以下是利用上述部分查看方式的示例。

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

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

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

public class TestApplication {
   static final String DB_URL = "jdbc:mysql://localhost/TUTORIALSPOINT";
   static final String USER = "guest";
   static final String PASS = "guest123";
   static final String QUERY = "SELECT id, first, last, age FROM 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 - Updating a ResultSet

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

与 get 方法类似，针对每种数据类型有两种更新方法：

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

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

S.N.

Methods & Description

*public void updateString(int columnIndex, String s) throws SQLException*将指定列中的 String 更改为 s 的值。

*public void updateString(String columnName, String s) throws SQLException*与上一个方法类似，只是通过名称而不是索引指定列。

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

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

S.N.	Methods & Description
1	public void updateRow()通过更新数据库中相应的行来更新当前行。
2	public void deleteRow()从数据库中删除当前行
3	public void refreshRow()刷新结果集中的数据以反映数据库中的任何近期更改。
4	public void cancelRowUpdates()取消对当前行进行的任何更新。
5	public void insertRow()将行插入数据库。只能在游标指向插入行时调用此方法。

以下是 Result Set 教程中描述的 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>

Create Data Records

最后，在 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://localhost/TUTORIALSPOINT";
   static final String USER = "guest";
   static final String PASS = "guest123";
   static final String QUERY = "SELECT id, first, last, age FROM Employees";

   public static void 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 - Transactions

如果您的 JDBC 连接处于自动提交模式（默认如此），那么在每个 SQL 语句完成后，它都会提交到数据库。

对于简单的应用程序，这可能很好，但有三个原因会导致你想关闭自动提交并管理自己的事务：

To increase performance.
维护业务流程的完整性。
To use distributed transactions.

事务使你能够控制数据库应用更改的时间和方式。它将单独的 SQL 语句或一组 SQL 语句视为一个逻辑单元，如果其中一条语句引发故障，则整个事务就会失败。

要启用手动事务支持而非 JDBC 驱动程序默认使用的自动提交模式，请使用 Connection 对象的 setAutoCommit() 方法。若要 setAutoCommit( ) 传递布尔值 false，则可以关闭自动提交。你可以传递布尔值 true 来重新打开它。

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

conn.setAutoCommit(false);

Commit & Rollback

一旦完成更改，并且你希望提交更改，请按照如下方式调用连接对象的 commit() 方法：

conn.commit( );

否则，若要回滚对使用 conn 命名的 Connection 对数据库作出的更新，则使用以下代码：

conn.rollback( );

Using Savepoints

新的 JDBC 3.0 Savepoint 接口为你提供了额外的交易控制。

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

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

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

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

Java & MySQL - Commit & Rollback

一旦完成更改，并且你希望提交更改，请按照如下方式调用连接对象的 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://localhost/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 - SavePoint

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

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

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

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

以下示例说明了 Savepoint 对象的使用 −

try{
   //Assume a valid connection object conn
   conn.setAutoCommit(false);
   Statement stmt = conn.createStatement();

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

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

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

以下示例利用了所述 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://localhost/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 - Batch Processing

批量处理允许将相关的 SQL 语句编组为一个批处理，然后用一次数据库调用提交它们。

一次将多个 SQL 语句发送到数据库时，可以减少通信开销，进而提升性能。

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

Batching with Statement Object

以下是有关如何对语句对象使用批量处理的典型步骤序列：

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

Example

以下代码片段提供了使用语句对象的一个批量更新示例：

// 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();

Batching with PrepareStatement Object

以下是一些使用批处理和 PrepareStatement 对象的典型步骤：

使用占位符创建 SQL 语句。
使用 prepareStatement() 方法创建 PrepareStatement 对象。
使用 setAutoCommit() 将自动提交设置为 false。
使用所创建的语句对象上的 addBatch() 方法向批处理中添加任意数量的 SQL 语句。
使用 executeStatement() 方法对已创建的语句对象执行所有 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 - Batching with Statement Object

以下是有关如何对语句对象使用批量处理的典型步骤序列：

使用 createStatement() 方法创建语句对象。
使用 setAutoCommit() 将自动提交设置为 false。
使用所创建的语句对象上的 addBatch() 方法向批处理中添加任意数量的 SQL 语句。
使用 executeStatement() 方法对已创建的语句对象执行所有 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://localhost/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 - Batching with PrepareStatement Object

以下是一些使用批处理和 PrepareStatement 对象的典型步骤：

使用占位符创建 SQL 语句。
使用 prepareStatement() 方法创建 PrepareStatement 对象。
使用 setAutoCommit() 将自动提交设置为 false。
使用所创建的语句对象上的 addBatch() 方法向批处理中添加任意数量的 SQL 语句。
使用 executeStatement() 方法对已创建的语句对象执行所有 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://localhost/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 - Streaming Data

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://localhost/TUTORIALSPOINT";
   static final String USER = "guest";
   static final String PASS = "guest123";
   static final String QUERY = "SELECT Data FROM XML_Data WHERE id=100";
   static final String INSERT_QUERY="INSERT INTO XML_Data VALUES (?,?)";
   static final String CREATE_TABLE_QUERY = "CREATE TABLE XML_Data (id INTEGER, Data LONG)";
   static final String DROP_TABLE_QUERY = "DROP TABLE XML_Data";
   static final String XML_DATA = "<Employee><id>100</id><first>Zara</first><last>Ali</last><Salary>10000</Salary><Dob>18-08-1978</Dob></Employee>";

   public static void createXMLTable(Statement stmt)
      throws SQLException{
      System.out.println("Creating XML_Data table..." );
      //Drop table first if it exists.
      try{
         stmt.executeUpdate(DROP_TABLE_QUERY);
      }catch(SQLException se){
      }
      stmt.executeUpdate(CREATE_TABLE_QUERY);
   }

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

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

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

         //Close input stream
         bis.close();

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

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

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

C:\>javac 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 - Create Database Example

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

您应该具有在给定架构中创建数据库的管理员权限。要执行以下示例，您需要用实际用户名和密码替换用户名和密码。
您的 MySQL 已启动并正在运行。

Required Steps

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

Import the packages - 需要包括包含数据库编程所需 JDBC 类的包。通常，使用 import java.sql.* 将足够。
Open a connection - 需使用 DriverManager.getConnection() 方法来创建 Connection 对象，它代表与数据库服务器的物理连接。
若要创建新数据库，无需在准备数据库 URL 时提供任何数据库名称，如下例所示。
Execute a query - 需使用 Statement 类型对象来创建和向数据库提交 SQL 语句。
Clean up the environment - 使用资源会自动关闭资源。

Sample Code

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

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

public class TestApplication {
   static final String DB_URL = "jdbc:mysql://localhost/";
   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 - Select Database Example

此章节提供了一个有关如何使用 JDBC 应用选择数据库的示例。在执行以下示例之前，请确保您已经准备就绪：

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

Required Steps

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

Import the packages - 需要包含用于数据库编程所需的 JDBC 类包。通常情况下，使用 import java.sql.* 就足够了。
Open a connection - 需要使用 DriverManager.getConnection() 方法创建一个连接对象，此对象代表与 selected 数据库的物理连接。
选择数据库是在准备数据库 URL 时进行。以下示例将与 STUDENTS 数据库建立连接。
Clean up the environment - 使用资源会自动关闭资源。

Sample Code

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

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

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

   public static void main(String[] args) {
      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 - Drop Database Example

本章提供了一个使用 JDBC 应用程序删除现有数据库的示例。在执行以下示例之前，请确保您具备以下条件 -

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

NOTE - 这是一个严肃的操作，在着手上删除数据库之前，您必须做出一个坚定的决定，因为您数据库中的所有内容都将丢失。

Required Steps

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

Import the packages - 需要包括包含数据库编程所需 JDBC 类的包。通常，使用 import java.sql.* 将足够。
Open a connection - 需要使用 DriverManager.getConnection() 方法来创建 Connection 对象，该对象表示与数据库服务器的物理连接。
删除数据库不需要数据库名称在您的数据库 URL 中。以下示例将删除 STUDENTS 数据库。
Execute a query - 需要使用 Statement 类型的对象来构建和提交一个用于删除数据库的 SQL 语句。
Clean up the environment - 使用资源会自动关闭资源。

Sample Code

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

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

public class TestApplication {
   static final String DB_URL = "jdbc:mysql://localhost/";
   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 - Create Table Example

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

要执行以下示例，您可以使用实际用户名和密码替换用户名和密码。
您的 MySQL 已启动并正在运行。

Required Steps

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

Import the packages - 需要包括包含数据库编程所需 JDBC 类的包。通常，使用 import java.sql.* 将足够。
Open a connection - 需要使用 DriverManager.getConnection() 方法来创建 Connection 对象，该对象表示与数据库服务器的物理连接。
Execute a query - 需要使用 Statement 类型的对象来构建和提交 SQL 语句，以便在选定的数据库中创建表。
Clean up the environment - 使用资源会自动关闭资源。

Sample Code

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

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

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

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

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

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

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

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

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

Java & MySQL - Drop Table Example

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

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

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

Required Steps

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

Import the packages - 需要包括包含数据库编程所需 JDBC 类的包。通常，使用 import java.sql.* 将足够。
Open a connection - 需要使用 DriverManager.getConnection() 方法来创建 Connection 对象，该对象表示与数据库服务器的物理连接。
Execute a query -需要使用 Statement 类型的对象来构建和提交 SQL 语句，以删除选定数据库中的表。
Clean up the environment - 使用资源会自动关闭资源。

Sample Code

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

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

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

   public static void main(String[] args) {
      // Open a connection
      try(Connection conn = DriverManager.getConnection(DB_URL, USER, PASS);
         Statement stmt = conn.createStatement();
      ) {
         String sql = "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 - Insert Records Example

本章提供了有关如何使用 JDBC 应用程序插入表记录的示例。在执行以下示例之前，请确保以下内容就绪：

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

Required Steps

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

Import the packages - 需要包括包含数据库编程所需 JDBC 类的包。通常，使用 import java.sql.* 将足够。
Register the JDBC driver - 需要初始化驱动程序，以便打开与数据库的通信通道。
Open a connection - 需要使用 DriverManager.getConnection() 方法来创建 Connection 对象，该对象表示与数据库服务器的物理连接。
Execute a query -需要使用 Statement 类型的对象来构建和提交 SQL 语句，以将记录插入表中。
Clean up the environment - 使用资源会自动关闭资源。

Sample Code

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

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

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

   public static void main(String[] args) {
      // Open a connection
      try(Connection conn = DriverManager.getConnection(DB_URL, USER, PASS);
         Statement stmt = conn.createStatement();
      ) {
         // 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 - Select Records Example

本章提供了一个示例，说明如何使用 JDBC 应用程序从表中选择/提取记录。在执行以下示例之前，确保您已准备就绪 −

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

Required Steps

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

Import the packages - 需要包括包含数据库编程所需 JDBC 类的包。通常，使用 import java.sql.* 将足够。
Open a connection - 需要使用 DriverManager.getConnection() 方法来创建 Connection 对象，该对象表示与数据库服务器的物理连接。
Execute a query - 需要使用 Statement 类型的对象来构建和提交 SQL 语句，以便从表中选择（即检索）记录。
Extract Data - 执行 SQL 查询后，可以从表中检索记录。
Clean up the environment - 使用资源会自动关闭资源。

Sample Code

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

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

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

   public static void main(String[] args) {
      // Open a connection
      try(Connection conn = DriverManager.getConnection(DB_URL, USER, PASS);
         Statement stmt = conn.createStatement();
         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 - Update Records Example

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

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

Required Steps

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

Import the packages - 需要包括包含数据库编程所需 JDBC 类的包。通常，使用 import java.sql.* 将足够。
Open a connection - 需要使用 DriverManager.getConnection() 方法来创建 Connection 对象，该对象表示与数据库服务器的物理连接。
Execute a query - 需使用 Statement 类型对象来创建和提交 SQL 语句以更新表中的记录。此查询使用 IN 和 WHERE 子句来更新条件记录。
Clean up the environment - 使用资源会自动关闭资源。

Sample Code

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

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

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

   public static void main(String[] args) {
      // Open a connection
      try(Connection conn = DriverManager.getConnection(DB_URL, USER, PASS);
         Statement stmt = conn.createStatement();
      ) {
         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 - Delete Records Example

本章提供了一个使用 JDBC 应用程序从表中删除记录的示例。在执行以下示例之前，请确保您具备以下条件 -

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

Required Steps

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

Import the packages - 需要包括包含数据库编程所需 JDBC 类的包。通常，使用 import java.sql.* 将足够。
Register the JDBC driver - 需要初始化驱动程序，以便打开与数据库的通信通道。
Open a connection - 需要使用 DriverManager.getConnection() 方法来创建 Connection 对象，该对象表示与数据库服务器的物理连接。
Execute a query - 需要使用 Statement 类型的对象来构建和提交一个用于从表中删除记录的 SQL 语句。此查询利用了 WHERE 子句来删除条件记录。
Clean up the environment - 使用资源会自动关闭资源。

Sample Code

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

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

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

   public static void main(String[] args) {
      // Open a connection
      try(Connection conn = DriverManager.getConnection(DB_URL, USER, PASS);
         Statement stmt = conn.createStatement();
      ) {
         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 Clause Example

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

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

Required Steps

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

Import the packages - 需要包含用于数据库编程所需的 JDBC 类包。通常情况下，使用 import java.sql.* 就足够了。
Register the JDBC driver - 需要初始化驱动程序，以便打开与数据库的通信通道。
Open a connection - 需要使用 DriverManager.getConnection() 方法来创建 Connection 对象，该对象表示与数据库服务器的物理连接。
Execute a query - 需要使用 Statement 类型的对象来构建和提交 SQL 语句，以从表中检索满足给定条件的记录。该查询利用 WHERE 子句来选择记录。
Clean up the environment - 使用资源会自动关闭资源。

Sample Code

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

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

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

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

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

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

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

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

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

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

Java & MySQL - LIKE Clause Example

本章提供了使用 JDBC 应用程序从表中选择记录的示例。这将在从表中选择记录时使用 LIKE 子句添加其他条件。在执行以下示例之前，确保您已执行以下操作：

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

Required Steps

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

Import the packages - 需要包括包含数据库编程所需 JDBC 类的包。通常，使用 import java.sql.* 将足够。
Open a connection - 需要使用 DriverManager.getConnection() 方法来创建 Connection 对象，该对象表示与数据库服务器的物理连接。
Execute a query - 需要使用 Statement 类型的对象来构建和提交 SQL 语句，以从符合给定条件的表中提取记录。此查询使用 LIKE 子句来选择记录以选择所有名字以“za”开头的学生。
Clean up the environment - 使用资源会自动关闭资源。

Sample Code

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

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

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

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

         // Select all records having ID equal or greater than 101
         System.out.println("Fetching records with condition...");
         String sql = "SELECT id, first, last, age FROM Registration" +
            " WHERE 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 - Sorting Data Example

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

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

Required Steps

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

Import the packages - 需要包括包含数据库编程所需 JDBC 类的包。通常，使用 import java.sql.* 将足够。
Open a connection - 需要使用 DriverManager.getConnection() 方法来创建 Connection 对象，该对象表示与数据库服务器的物理连接。
Execute a query - 需要使用 Statement 类型的对象来构建和提交 SQL 语句，以从表中对记录进行排序。这些查询使用 asc 和 desc 子句以升序和降序对数据进行排序。
Clean up the environment - 使用资源会自动关闭资源。

Sample Code

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

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

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

   public static void main(String[] args) {
      // Open a connection
      try(Connection conn = DriverManager.getConnection(DB_URL, USER, PASS);
         Statement stmt = conn.createStatement();) {
         System.out.println("Fetching records 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:\>

S.N.	Methods & Description
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 如果光标当前位于插入行中，则将光标移回当前行；否则，此方法不执行任何操作

S.N.	Methods & Description
1	public void updateRow()通过更新数据库中相应的行来更新当前行。
2	public void deleteRow()从数据库中删除当前行
3	public void refreshRow()刷新结果集中的数据以反映数据库中的任何近期更改。
4	public void cancelRowUpdates()取消对当前行进行的任何更新。
5	public void insertRow()将行插入数据库。只能在游标指向插入行时调用此方法。