Java 和 MySQL – 快速指南
Java 和 MySQL – 快速指南
Java 和 MySQL – 概述
JDBC代表Ĵ AVA d ATA b ASE Ç 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 Driver API – 这支持 JDBC Manager-to-Driver 连接。
JDBC API 使用驱动程序管理器和特定于数据库的驱动程序来提供与异构数据库的透明连接。
JDBC 驱动程序管理器确保使用正确的驱动程序访问每个数据源。驱动程序管理器能够支持连接到多个异构数据库的多个并发驱动程序。
以下是架构图，显示了驱动程序管理器相对于 JDBC 驱动程序和 Java 应用程序的位置 –
常见的 JDBC 组件
JDBC API 提供以下接口和类 –
-
DriverManager – 此类管理数据库驱动程序列表。使用通信子协议将来自 java 应用程序的连接请求与正确的数据库驱动程序匹配。JDBC 下识别某个子协议的第一个驱动程序将用于建立数据库连接。
-
驱动程序– 此接口处理与数据库服务器的通信。您很少会直接与 Driver 对象交互。相反，您使用 DriverManager 对象，它管理这种类型的对象。它还抽象了与使用 Driver 对象相关的细节。
-
连接– 此接口与用于联系数据库的所有方法。连接对象代表通信上下文，即所有与数据库的通信都只通过连接对象。
-
语句– 您使用从此接口创建的对象将 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 设置路径
假设您已经在 c:\Program Files\java\jdk 目录中安装了 Java –
-
右键单击“我的电脑”并选择“属性”。
-
单击“高级”选项卡下的“环境变量”按钮。
-
现在，编辑“路径”变量并在其末尾添加 Java 可执行目录的路径。例如，如果路径当前设置为
C:\Windows\System32，则按以下方式对其进行编辑
C:\Windows\System32;c:\Program Files\java\jdk\bin
为 Windows 95/98/ME 设置路径
假设您已经在 c:\Program Files\java\jdk 目录中安装了 Java –
-
编辑 ‘C:\autoexec.bat’ 文件并在末尾添加以下行 –
SET PATH = %PATH%;C:\Program Files\java\jdk\bin
为 Linux、UNIX、Solaris、FreeBSD 设置路径
环境变量 PATH 应设置为指向 Java 二进制文件的安装位置。如果您在执行此操作时遇到问题，请参阅您的 shell 文档。
例如，如果您使用 bash 作为 shell，那么您将在.bashrc的末尾添加以下行–
export PATH = /path/to/java:$PATH'
当您安装 J2SE Development Kit 时，您会自动获得 JDBC 包java.sql和javax.sql。
安装数据库
您需要的最重要的当然是一个实际运行的数据库，其中包含一个您可以查询和修改的表。
安装最适合您的数据库。您可以有很多选择，最常见的是 –
-
MySQL DB – MySQL 是一个开源数据库。你可以从MySQL 官方网站下载它。我们建议下载完整的 Windows 安装。
-
此外，下载并安装MySQL Administrator以及MySQL Query Browser。这些是基于 GUI 的工具，它们将使您的开发变得更加容易。
-
最后，将MySQL Connector/J（MySQL JDBC 驱动程序）下载并解压到一个方便的目录中。出于本教程的目的，我们假设您已将驱动程序安装在 C:\Program Files\MySQL\mysql-connector-java-5.1.8。
-
因此，将 CLASSPATH 变量设置为 C:\Program Files\MySQL\mysql-connector-java-5.1.8\mysql-connector-java-5.1.8-bin.jar。您的驱动程序版本可能因您的安装而异。
设置数据库凭据
当我们安装 MySQL 数据库时，它的管理员 ID 被设置为root并且它允许设置您选择的密码。
使用 root ID 和密码，您可以创建另一个用户 ID 和密码，或者您可以为 JDBC 应用程序使用 root ID 和密码。
有各种数据库操作，如数据库创建和删除，需要管理员 ID 和密码。
对于 JDBC 教程的其余部分，我们将使用 MySQL 数据库，以guest作为ID，以guest123作为密码。
如果您没有足够的权限来创建新用户，那么您可以要求您的数据库管理员 (DBA) 为您创建一个用户 ID 和密码。
创建数据库
要创建TUTORIALSPOINT数据库，请使用以下步骤 –
第1步
打开命令提示符并更改到安装目录，如下所示 –
C:\> C:\>cd Program Files\MySQL\bin C:\Program Files\MySQL\bin>
注意– mysqld.exe的路径可能因系统上 MySQL 的安装位置而异。您还可以查看有关如何启动和停止数据库服务器的文档。
第2步
通过执行以下命令启动数据库服务器（如果它尚未运行）。
C:\Program Files\MySQL\bin>mysqld C:\Program Files\MySQL\bin>
第 3 步
通过执行以下命令创建TUTORIALSPOINT数据库 –
C:\Program Files\MySQL\bin> mysqladmin create TUTORIALSPOINT -u guest -p Enter password: ******** C:\Program Files\MySQL\bin>
创建表
要在 TUTORIALSPOINT 数据库中创建员工表，请使用以下步骤 –
第1步
打开命令提示符并更改到安装目录，如下所示 –
C:\> C:\>cd Program Files\MySQL\bin C:\Program Files\MySQL\bin>
第2步
登录数据库如下 –
C:\Program Files\MySQL\bin>mysql -u guest -p Enter password: ******** mysql>
第 3 步
创建表员工如下 –
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://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 – 连接
安装了适当的驱动程序后，就可以使用 JDBC 建立数据库连接了。
建立 JDBC 连接所涉及的编程相当简单。这是这些简单的三个步骤 –
-
导入 JDBC 包–向 Java 程序添加导入语句以在 Java 代码中导入所需的类。
-
数据库 URL 公式– 这是创建一个格式正确的地址，指向您希望连接的数据库。
-
创建连接对象– 最后，调用DriverManager对象的getConnection()方法来建立实际的数据库连接。
导入 JDBC 包
在导入语句告诉Java编译器在哪里可以找到你在你的代码中引用和被放置在最开始的源代码的类。
要使用允许您在 SQL 表中选择、插入、更新和删除数据的标准 JDBC 包，请将以下导入添加到您的源代码中 –
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（字符串网址）
-
getConnection（字符串网址，属性道具）
-
getConnection(String url, String user, String password)
这里每个表单都需要一个数据库URL。数据库 URL 是指向您的数据库的地址。
制定数据库 URL 是大多数与建立连接相关的问题发生的地方。
下表列出了 MySQL JDBC 驱动程序名称和数据库 URL。
| RDBMS | JDBC 驱动程序名称 | 网址格式 |
|---|---|---|
| MySQL | com.mysql.jdbc.Driver | jdbc:mysql://主机名/数据库名 |
URL 格式中所有突出显示的部分都是静态的，您只需根据数据库设置更改其余部分。
创建连接对象
我们列出了三种形式的DriverManager.getConnection()方法来创建连接对象。
使用带有用户名和密码的数据库 URL
最常用的 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);
使用数据库 URL 和属性对象
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 – 示例代码教程。
现在让我们编译上面的例子如下 –
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 可能发生在驱动程序和数据库中。发生此类异常时，将向 catch 子句传递 SQLException 类型的对象。
传递的 SQLException 对象具有以下可用于检索有关异常的附加信息的方法 –
| Method | 描述 |
|---|---|
| getErrorCode( ) | 获取与异常关联的错误号。 |
| getMessage( ) | 获取 JDBC 驱动程序的错误消息，由驱动程序处理或获取 Oracle 错误号和数据库错误消息。 |
| getSQLState( ) | 获取 XOPEN SQLstate 字符串。对于 JDBC 驱动程序错误，此方法不会返回任何有用的信息。对于数据库错误，返回五位 XOPEN SQLstate 代码。此方法可以返回 null。 |
| getNextException( ) | 获取异常链中的下一个异常对象。 |
| printStackTrace( ) | 打印当前异常或可抛出异常，并回溯到标准错误流。 |
| printStackTrace(PrintStream s) | 将此 throwable 及其回溯打印到您指定的打印流。 |
| printStackTrace(PrintWriter w) | 打印这个 throwable 并且它是您指定的打印作者的回溯。 |
通过利用 Exception 对象提供的信息，您可以捕获异常并适当地继续您的程序。这是 try 块的一般形式 –
try {
// Your risky code goes between these curly braces!!!
}
catch(Exception ex) {
// Your exception handling code goes between these
// curly braces
}
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://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 – 声明
JDBC Statement 接口定义了用于向 MySQL 数据库发送 SQL 命令并从数据库中检索数据的方法和属性。语句用于对数据库进行通用访问。当您在运行时使用静态 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 语句一样。
结束语对象
正如您关闭 Connection 对象以节省数据库资源一样，出于同样的原因，您也应该关闭 Statement 对象。
对 close() 方法的简单调用即可完成这项工作。如果先关闭 Connection 对象，它也会关闭 Statement 对象。但是，您应该始终明确关闭 Statement 对象以确保正确清理。
Statement stmt = null;
try {
stmt = conn.createStatement( );
. . .
}
catch (SQLException e) {
. . .
}
finally {
stmt.close();
}
我们正在对资源使用 try ，它会自动处理资源关闭。以下示例演示了上述所有概念。
这段代码是根据上一章中完成的环境和数据库设置编写的。
将以下示例复制并粘贴到 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对象有两个优点附加功能。
此语句使您可以灵活地动态提供参数。
创建 PreparedStatement 对象
PreparedStatement pstmt = null;
try {
String SQL = "Update Employees SET age = ? WHERE id = ?";
pstmt = conn.prepareStatement(SQL);
. . .
}
catch (SQLException e) {
. . .
}
finally {
. . .
}
JDBC 中的所有参数都用? 符号，称为参数标记。在执行 SQL 语句之前，您必须为每个参数提供值。
所述的setXXX（）方法绑定值的参数，其中XXX代表要绑定到输入参数的值的Java数据类型。如果您忘记提供值，您将收到 SQLException。
每个参数标记由其序号位置引用。第一个标记表示位置 1，下一个位置 2，依此类推。此方法与 Java 数组索引的方法不同，后者从 0 开始。
用于与数据库交互的Statement 对象的所有方法 (a) execute()、(b) executeQuery() 和 (c) executeUpdate() 也适用于 PreparedStatement 对象。但是，这些方法被修改为使用可以输入参数的 SQL 语句。
关闭 PreparedStatement 对象
就像关闭 Statement 对象一样，出于同样的原因，您也应该关闭 PreparedStatement 对象。
对 close() 方法的简单调用即可完成这项工作。如果先关闭 Connection 对象，它也会关闭 PreparedStatement 对象。但是，您应该始终明确关闭 PreparedStatement 对象以确保正确清理。
PreparedStatement pstmt = null;
try {
String SQL = "Update Employees SET age = ? WHERE id = ?";
pstmt = conn.prepareStatement(SQL);
. . .
}
catch (SQLException e) {
. . .
}
finally {
pstmt.close();
}
我们正在对资源使用 try ，它会自动处理资源关闭。以下示例演示了上述所有概念。
这段代码是根据上一章中完成的环境和数据库设置编写的。
将以下示例复制并粘贴到 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 | 描述 |
|---|---|
| IN | 创建 SQL 语句时其值未知的参数。您可以使用 setXXX() 方法将值绑定到 IN 参数。 |
| OUT | 一个参数，其值由它返回的 SQL 语句提供。您可以使用 getXXX() 方法从 OUT 参数中检索值。 |
| INOUT | 提供输入和输出值的参数。您可以使用 setXXX() 方法绑定变量并使用 getXXX() 方法检索值。 |
以下代码片段展示了如何使用Connection.prepareCall()方法基于前面的存储过程实例化CallableStatement对象 –
CallableStatement cstmt = null;
try {
String SQL = "{call getEmpName (?, ?)}";
cstmt = conn.prepareCall (SQL);
. . .
}
catch (SQLException e) {
. . .
}
finally {
. . .
}
String 变量 SQL，代表存储过程，带有参数占位符。
使用 CallableStatement 对象与使用 PreparedStatement 对象非常相似。您必须在执行语句之前将值绑定到所有参数，否则您将收到 SQLException。
如果您有 IN 参数，只需遵循适用于 PreparedStatement 对象的相同规则和技术；使用与您要绑定的 Java 数据类型相对应的 setXXX() 方法。
当您使用 OUT 和 INOUT 参数时，您必须使用额外的 CallableStatement 方法 registerOutParameter()。registerOutParameter() 方法将 JDBC 数据类型绑定到存储过程预期返回的数据类型。
一旦调用了存储过程，就可以使用适当的 getXXX() 方法从 OUT 参数中检索值。此方法将检索到的 SQL 类型值转换为 Java 数据类型。
关闭 CallableStatement 对象
正如您关闭其他 Statement 对象一样，出于同样的原因，您也应该关闭 CallableStatement 对象。
对 close() 方法的简单调用即可完成这项工作。如果先关闭 Connection 对象，它也会关闭 CallableStatement 对象。但是，您应该始终显式关闭 CallableStatement 对象以确保正确清理。
CallableStatement cstmt = null;
try {
String SQL = "{call getEmpName (?, ?)}";
cstmt = conn.prepareCall (SQL);
. . .
}
catch (SQLException e) {
. . .
}
finally {
cstmt.close();
}
我们正在对资源使用 try ，它会自动处理资源关闭。以下示例演示了上述所有概念。
这段代码是根据上一章中完成的环境和数据库设置编写的。
将以下示例复制并粘贴到 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 转义语法
通过使用标准的 JDBC 方法和属性，转义语法使您可以灵活地使用您无法使用的数据库特定功能。
一般的 SQL 转义语法格式如下 –
{keyword 'parameters'}
以下是以下转义序列，在执行 JDBC 编程时您会发现它们非常有用 –
d, t, ts 关键词
它们有助于识别日期、时间和时间戳文字。如您所知，没有两个 DBMS 以相同的方式表示时间和日期。此转义语法告诉驱动程序以目标数据库的格式呈现日期或时间。例如 –
{d 'yyyy-mm-dd'}
其中 yyyy = 年，mm = 月；dd = 日期。使用此语法 {d ‘2009-09-03’} 是 2009 年 3 月 9 日。
这是一个简单的例子，展示了如何在表格中插入日期 –
//Create a Statement object
stmt = conn.createStatement();
//Insert data ==> ID, First Name, Last Name, DOB
String sql="INSERT INTO STUDENTS VALUES" +
"(100,'Zara','Ali', {d '2001-12-16'})";
stmt.executeUpdate(sql);
同样，您可以使用以下两种语法之一，t或ts –
{t 'hh:mm:ss'}
其中 hh = 小时；mm = 分钟；ss = 秒。使用此语法 {t ’13:30:29′} 是下午 1:30:29。
{ts 'yyyy-mm-dd hh:mm:ss'}
这是上面两种语法的组合语法，用于 ‘d’ 和 ‘t’ 来表示时间戳。
转义关键字
此关键字标识 LIKE 子句中使用的转义字符。使用 SQL 通配符 % 时很有用，它匹配零个或多个字符。例如 –
String sql = "SELECT symbol FROM MathSymbols WHERE symbol LIKE '\%' {escape '\'}";
stmt.execute(sql);
如果使用反斜杠字符 (\) 作为转义字符，则还必须在 Java 字符串文字中使用两个反斜杠字符，因为反斜杠也是 Java 转义字符。
fn 关键字
此关键字表示 DBMS 中使用的标量函数。例如，您可以使用 SQL 函数length来获取字符串的长度 –
{fn length('Hello World')}
这将返回 11，即字符串“Hello World”的长度。
呼叫关键字
该关键字用于调用存储过程。例如，对于需要 IN 参数的存储过程，请使用以下语法 –
{call my_procedure(?)};
对于需要 IN 参数并返回 OUT 参数的存储过程，请使用以下语法 –
{? = call my_procedure(?)};
oj 关键字
此关键字用于表示外连接。语法如下 –
{oj outer-join}
其中外连接 = table {LEFT|RIGHT|FULL} OUTERJOIN {table | 外连接} 搜索条件。例如 –
String sql = "SELECT Employees FROM {oj ThisTable RIGHT OUTER JOIN ThatTable on id = '100'}";
stmt.execute(sql);
Java & MySQL – 结果集
从数据库查询中读取数据的 SQL 语句返回结果集中的数据。SELECT 语句是从数据库中选择行并在结果集中查看它们的标准方法。该java.sql.ResultSet中的接口表示结果集数据库查询。
ResultSet 对象维护一个指向结果集中当前行的游标。术语“结果集”是指包含在 ResultSet 对象中的行和列数据。
ResultSet 接口的方法可以分为三类 –
-
导航方法– 用于移动光标。
-
获取方法– 用于查看光标指向的当前行的列中的数据。
-
更新方法– 用于更新当前行列中的数据。然后也可以在底层数据库中更新更新。
光标可根据 ResultSet 的属性移动。这些属性是在创建生成 ResultSet 的相应 Statement 时指定的。
JDBC 提供以下连接方法来创建具有所需结果集的语句 –
-
createStatement(int RSType, int RSConcurrency);
-
prepareStatement(String SQL, int RSType, int RSConcurrency);
-
prepareCall(String sql, int RSType, int RSConcurrency);
第一个参数指示 ResultSet 对象的类型，第二个参数是两个 ResultSet 常量之一，用于指定结果集是只读还是可更新。
结果集的类型
下面给出了可能的 RSType。如果您不指定任何 ResultSet 类型，您将自动获得一个 TYPE_FORWARD_ONLY。
| Type | 描述 |
|---|---|
| ResultSet.TYPE_FORWARD_ONLY | 游标只能在结果集中向前移动。 |
| ResultSet.TYPE_SCROLL_INSENSITIVE | 游标可以向前和向后滚动，结果集对创建结果集后其他人对数据库所做的更改不敏感。 |
| ResultSet.TYPE_SCROLL_SENSITIVE. | 游标可以向前和向后滚动，结果集对其他人在创建结果集后对数据库所做的更改很敏感。 |
结果集的并发
下面给出了可能的 RSConcurrency。如果您不指定任何并发类型，您将自动获得一个 CONCUR_READ_ONLY。
| Concurrency | 描述 |
|---|---|
| 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 接口中有几种涉及移动光标的方法，包括 –
| S.N. | 方法和说明 |
|---|---|
| 1 | public void beforeFirst() 抛出 SQLException
将光标移动到第一行之前。 |
| 2 | public void afterLast() 抛出 SQLException
将光标移动到最后一行之后。 |
| 3 | public boolean first() 抛出 SQLException
将光标移动到第一行。 |
| 4 | public void last() 抛出 SQLException
将光标移动到最后一行。 |
| 5 | public boolean absolute(int row) 抛出 SQLException
将光标移动到指定的行。 |
| 6 | public boolean relative(int row) 抛出 SQLException
将光标从当前指向的位置向前或向后移动给定的行数。 |
| 7 | public boolean previous() 抛出 SQLException
将光标移动到上一行。如果前一行不在结果集中，则此方法返回 false。 |
| 8 | public boolean next() 抛出 SQLException
将光标移动到下一行。如果结果集中没有更多行，则此方法返回 false。 |
| 9 | public int getRow() 抛出 SQLException
返回光标指向的行号。 |
| 10 | public void moveToInsertRow() 抛出 SQLException
将光标移动到结果集中的特殊行，该行可用于向数据库中插入新行。记住当前光标位置。 |
| 11 | public void moveToCurrentRow() 抛出 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 – 查看结果集
ResultSet 接口包含数十种获取当前行数据的方法。
每个可能的数据类型都有一个 get 方法，每个 get 方法都有两个版本 –
-
一个接受列名的人。
-
一个接受列索引的。
例如，如果您有兴趣查看的列包含一个 int，则需要使用 ResultSet 的 getInt() 方法之一 –
| S.N. | 方法和说明 |
|---|---|
| 1 | public int getInt(String columnName) 抛出 SQLException
返回名为 columnName 的列中当前行中的 int。 |
| 2 | public int getInt(int columnIndex) 抛出 SQLException
返回指定列索引中当前行中的 int。列索引从 1 开始，这意味着一行的第一列是 1，一行的第二列是 2，依此类推。 |
同样，在 ResultSet 接口中，对于八种 Java 原始类型中的每一种都有 get 方法，以及诸如 java.lang.String、java.lang.Object 和 java.net.URL 等常见类型。
还有获取 SQL 数据类型 java.sql.Date、java.sql.Time、java.sql.TimeStamp、java.sql.Clob 和 java.sql.Blob 的方法。查看文档以获取有关使用这些 SQL 数据类型的更多信息。
以下是使用所描述的几种查看方法的示例。
此示例代码是根据前几章中完成的环境和数据库设置编写的。
将以下示例复制并粘贴到 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 – 更新结果集
ResultSet 接口包含一组更新方法，用于更新结果集的数据。
与 get 方法一样，每种数据类型都有两种更新方法 –
-
一个接受列名的人。
-
一个接受列索引的。
例如，要更新结果集当前行的 String 列，您可以使用以下 updateString() 方法之一 –
| S.N. | 方法和说明 |
|---|---|
| 1 | public void updateString(int columnIndex, String s) 抛出 SQLException
将指定列中的 String 更改为 s 的值。 |
| 2 | public void updateString(String columnName, String s) 抛出 SQLException
与前面的方法类似，不同之处在于列由其名称而不是其索引指定。 |
java.sql 包中有八种原始数据类型以及 String、Object、URL 和 SQL 数据类型的更新方法。
更新结果集中的一行会更改 ResultSet 对象中当前行的列，但不会更改基础数据库中的列。要更新对数据库中行的更改，您需要调用以下方法之一。
| S.N. | 方法和说明 |
|---|---|
| 1 | 公共无效更新行（）
通过更新数据库中的相应行来更新当前行。 |
| 2 | 公共无效删除行（）
从数据库中删除当前行 |
| 3 | 公共无效refreshRow()
刷新结果集中的数据以反映数据库中的任何最近更改。 |
| 4 | public void cancelRowUpdates()
取消对当前行所做的任何更新。 |
| 5 | 公共无效插入行（）
在数据库中插入一行。该方法只能在光标指向插入行时调用。 |
以下是使用结果集教程中描述的ResultSet.CONCUR_UPDATABLE和ResultSet.TYPE_SCROLL_INSENSITIVE 的示例。此示例将解释对表的 INSERT、UPDATE 和 DELETE 操作。
应该注意的是，您正在处理的表应该正确设置主键。让我们先更新我们的参考表。
删除表并再次创建表员工如下 –
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://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 – 事务
如果您的 JDBC 连接处于自动提交模式（默认情况下），则每个 SQL 语句在完成后都会提交到数据库。
这对于简单的应用程序来说可能没问题，但是您可能想要关闭自动提交并管理您自己的交易的三个原因 –
-
以提高性能。
-
维护业务流程的完整性。
-
使用分布式事务。
事务使您能够控制是否以及何时将更改应用于数据库。它将单个 SQL 语句或一组 SQL 语句视为一个逻辑单元，如果任何语句失败，则整个事务失败。
要启用手动事务支持而不是JDBC 驱动程序默认使用的自动提交模式，请使用 Connection 对象的setAutoCommit()方法。如果将布尔值 false 传递给 setAutoCommit()，则关闭自动提交。您可以传递一个布尔值 true 以再次打开它。
例如，如果您有一个名为 conn 的 Connection 对象，请编写以下代码以关闭自动提交 –
conn.setAutoCommit(false);
提交和回滚
完成更改并希望提交更改后，请在连接对象上调用commit()方法，如下所示 –
conn.commit( );
否则，要回滚使用名为 conn 的连接对数据库进行的更新，请使用以下代码 –
conn.rollback( );
使用保存点
新的 JDBC 3.0 Savepoint 接口为您提供了额外的事务控制。
当您设置保存点时，您在事务中定义了一个逻辑回滚点。如果在保存点之后发生错误，您可以使用回滚方法撤消所有更改或仅撤消保存点之后所做的更改。
Connection 对象有两个新方法可以帮助您管理保存点 –
-
setSavepoint(String savepointName) – 定义一个新的保存点。它还返回一个 Savepoint 对象。
-
releaseSavepoint(Savepoint savepointName) – 删除一个保存点。请注意，它需要一个 Savepoint 对象作为参数。这个对象通常是一个由 setSavepoint() 方法生成的保存点。
有一个rollback (String savepointName)方法，它将工作回滚到指定的保存点。
Java 和 MySQL – 提交和回滚
完成更改并希望提交更改后，请在连接对象上调用commit()方法，如下所示 –
conn.commit( );
否则，要回滚使用名为 conn 的连接对数据库进行的更新，请使用以下代码 –
conn.rollback( );
以下示例说明了提交和回滚对象的使用 –
try{
//Assume a valid connection object conn
conn.setAutoCommit(false);
Statement stmt = conn.createStatement();
String SQL = "INSERT INTO Employees " +
"VALUES (106, 20, 'Rita', 'Tez')";
stmt.executeUpdate(SQL);
//Submit a malformed SQL statement that breaks
String SQL = "INSERTED IN Employees " +
"VALUES (107, 22, 'Sita', 'Singh')";
stmt.executeUpdate(SQL);
// If there is no error.
conn.commit();
}catch(SQLException se){
// If there is any error.
conn.rollback();
}
在这种情况下，上述 INSERT 语句都不会成功，所有内容都将回滚。
以下是使用提交和回滚描述的示例。
此示例代码是根据前几章中完成的环境和数据库设置编写的。
将以下示例复制并粘贴到 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和回滚描述的示例。
此示例代码是根据前几章中完成的环境和数据库设置编写的。
将以下示例复制并粘贴到 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 – 批处理
批处理允许您将相关的 SQL 语句分组为一个批处理，并通过一次调用将它们提交到数据库。
当您一次向数据库发送多条 SQL 语句时，可以减少通信开销，从而提高性能。
-
JDBC 驱动程序不需要支持此功能。您应该使用DatabaseMetaData.supportsBatchUpdates()方法来确定目标数据库是否支持批量更新处理。如果您的 JDBC 驱动程序支持此功能，则该方法返回 true。
-
Statement、PreparedStatement和CallableStatement的addBatch()方法用于将单个语句添加到批处理中。的则ExecuteBatch（）是用来启动所有组合在一起的语句的执行。
-
的则ExecuteBatch（）返回一个整数数组，并且阵列中的每个元素表示相应更新语句的更新计数。
-
就像您可以将语句添加到批处理中一样，您可以使用clearBatch()方法删除它们。此方法删除您使用 addBatch() 方法添加的所有语句。但是，您不能有选择地选择要删除的语句。
用语句对象批处理
以下是将批处理与语句对象一起使用的典型步骤序列 –
-
使用任一createStatement()方法创建 Statement 对象。
-
使用setAutoCommit()将自动提交设置为 false 。
-
在创建的语句对象上使用addBatch()方法将尽可能多的 SQL 语句添加到批处理中。
-
在创建的语句对象上使用executeBatch()方法执行所有 SQL 语句。
-
最后，使用commit()方法提交所有更改。
例子
以下代码片段提供了使用 Statement 对象进行批量更新的示例 –
// Create statement object
Statement stmt = conn.createStatement();
// Set auto-commit to false
conn.setAutoCommit(false);
// Create SQL statement
String SQL = "INSERT INTO Employees (id, first, last, age) " +
"VALUES(200,'Zia', 'Ali', 30)";
// Add above SQL statement in the batch.
stmt.addBatch(SQL);
// Create one more SQL statement
String SQL = "INSERT INTO Employees (id, first, last, age) " +
"VALUES(201,'Raj', 'Kumar', 35)";
// Add above SQL statement in the batch.
stmt.addBatch(SQL);
// Create one more SQL statement
String SQL = "UPDATE Employees SET age = 35 " +
"WHERE id = 100";
// Add above SQL statement in the batch.
stmt.addBatch(SQL);
// Create an int[] to hold returned values
int[] count = stmt.executeBatch();
//Explicitly commit statements to apply changes
conn.commit();
使用 PrepareStatement 对象进行批处理
这是将批处理与 PrepareStatement 对象一起使用的典型步骤序列 –
-
使用占位符创建 SQL 语句。
-
使用任一prepareStatement() 方法创建 PrepareStatement 对象。
-
使用setAutoCommit()将自动提交设置为 false 。
-
在创建的语句对象上使用addBatch()方法将尽可能多的 SQL 语句添加到批处理中。
-
在创建的语句对象上使用executeBatch()方法执行所有 SQL 语句。
-
最后，使用commit()方法提交所有更改。
以下代码片段提供了使用 PrepareStatement 对象进行批量更新的示例 –
// Create SQL statement
String SQL = "INSERT INTO Employees (id, first, last, age) " +
"VALUES(?, ?, ?, ?)";
// Create PrepareStatement object
PreparedStatemen pstmt = conn.prepareStatement(SQL);
//Set auto-commit to false
conn.setAutoCommit(false);
// Set the variables
pstmt.setInt( 1, 400 );
pstmt.setString( 2, "Pappu" );
pstmt.setString( 3, "Singh" );
pstmt.setInt( 4, 33 );
// Add it to the batch
pstmt.addBatch();
// Set the variables
pstmt.setInt( 1, 401 );
pstmt.setString( 2, "Pawan" );
pstmt.setString( 3, "Singh" );
pstmt.setInt( 4, 31 );
// Add it to the batch
pstmt.addBatch();
//add more batches
.
.
.
.
//Create an int[] to hold returned values
int[] count = stmt.executeBatch();
//Explicitly commit statements to apply changes
conn.commit();
Java & MySQL – 用语句对象批处理
以下是将批处理与语句对象一起使用的典型步骤序列 –
-
使用任一createStatement()方法创建 Statement 对象。
-
使用setAutoCommit()将自动提交设置为 false 。
-
在创建的语句对象上使用addBatch()方法将尽可能多的 SQL 语句添加到批处理中。
-
在创建的语句对象上使用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://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 – 使用 PrepareStatement 对象进行批处理
这是将批处理与 PrepareStatement 对象一起使用的典型步骤序列 –
-
使用占位符创建 SQL 语句。
-
使用任一prepareStatement() 方法创建 PrepareStatement 对象。
-
使用setAutoCommit()将自动提交设置为 false 。
-
在创建的语句对象上使用addBatch()方法将尽可能多的 SQL 语句添加到批处理中。
-
在创建的语句对象上使用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://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 – 流数据
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 – 创建数据库示例
本教程提供了一个关于如何使用 JDBC 应用程序创建数据库的示例。在执行以下示例之前，请确保您已准备好以下内容 –
-
您应该具有在给定架构中创建数据库的管理员权限。要执行以下示例，您需要将用户名和密码替换为您的实际用户名和密码。
-
您的 MySQL 已启动并正在运行。
所需步骤
使用 JDBC 应用程序创建新数据库需要执行以下步骤 –
-
导入包– 要求您包含包含数据库编程所需的 JDBC 类的包。大多数情况下，使用import java.sql.*就足够了。
-
打开连接– 需要使用DriverManager.getConnection()方法创建一个 Connection 对象，该对象代表与数据库服务器的物理连接。
-
要创建一个新的数据库，您在准备数据库 URL 时不需要提供任何数据库名称，如下例所述。
-
执行查询– 需要使用 Statement 类型的对象来构建 SQL 语句并将其提交到数据库。
-
清理环境– 尝试使用资源会自动关闭资源。
示例代码
将以下示例复制并粘贴到 TestApplication.java 中，编译并运行如下 –
import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.SQLException;
import java.sql.Statement;
public class TestApplication {
static final String DB_URL = "jdbc:mysql://localhost/";
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数据库建立连接。
-
清理环境– 尝试使用资源会自动关闭资源。
示例代码
将以下示例复制并粘贴到 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 – 删除数据库示例
本章提供了一个关于如何使用 JDBC 应用程序删除现有数据库的示例。在执行以下示例之前，请确保您已准备好以下内容 –
-
要执行以下示例，您需要将用户名和密码替换为您的实际用户名和密码。
-
您的 MySQL 已启动并正在运行。
注意– 这是一项严肃的操作，您必须在继续删除数据库之前做出坚定的决定，因为您在数据库中拥有的所有内容都将丢失。
所需步骤
使用 JDBC 应用程序创建新数据库需要执行以下步骤 –
-
导入包– 要求您包含包含数据库编程所需的 JDBC 类的包。大多数情况下，使用import java.sql.*就足够了。
-
打开连接– 需要使用DriverManager.getConnection()方法创建一个 Connection 对象，该对象表示与数据库服务器的物理连接。
-
删除数据库不需要在您的数据库 URL 中包含数据库名称。以下示例将删除STUDENTS数据库。
-
执行查询– 需要使用 Statement 类型的对象来构建和提交 SQL 语句以删除数据库。
-
清理环境– 尝试使用资源会自动关闭资源。
示例代码
将以下示例复制并粘贴到 TestApplication.java 中，编译并运行如下 –
import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.SQLException;
import java.sql.Statement;
public class TestApplication {
static final String DB_URL = "jdbc:mysql://localhost/";
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 语句以在选定的数据库中创建表。
-
清理环境– 尝试使用资源会自动关闭资源。
示例代码
将以下示例复制并粘贴到 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 – 删除表示例
本章提供了如何使用 JDBC 应用程序删除表的示例。在执行以下示例之前，请确保您已准备好以下内容 –
-
要执行以下示例，您可以将用户名和密码替换为您的实际用户名和密码。
-
您正在使用的 MySQL 数据库已启动并正在运行。
注意– 这是一项严肃的操作，您必须在继续删除表之前做出坚定的决定，因为您在表中拥有的所有内容都将丢失。
所需步骤
使用 JDBC 应用程序创建新数据库需要执行以下步骤 –
-
导入包– 要求您包含包含数据库编程所需的 JDBC 类的包。大多数情况下，使用import java.sql.*就足够了。
-
打开连接– 需要使用DriverManager.getConnection()方法创建一个 Connection 对象，该对象表示与数据库服务器的物理连接。
-
执行查询– 需要使用 Statement 类型的对象来构建和提交 SQL 语句以删除选定数据库中的表。
-
清理环境– 尝试使用资源会自动关闭资源。
示例代码
将以下示例复制并粘贴到 TestApplication.java 中，编译并运行如下 –
import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.SQLException;
import java.sql.Statement;
public class TestApplication {
static final String DB_URL = "jdbc:mysql://localhost/TUTORIALSPOINT";
static final String USER = "guest";
static final String PASS = "guest123";
public static void main(String[] args) {
// Open a connection
try(Connection conn = DriverManager.getConnection(DB_URL, USER, PASS);
Statement stmt = conn.createStatement();
) {
String sql = "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 语句以将记录插入表中。
-
清理环境– 尝试使用资源会自动关闭资源。
示例代码
将以下示例复制并粘贴到 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 – 选择记录示例
本章提供了如何使用 JDBC 应用程序从表中选择/获取记录的示例。在执行以下示例之前，请确保您已准备好以下内容 –
-
要执行以下示例，您可以将用户名和密码替换为您的实际用户名和密码。
-
您正在使用的 MySQL 数据库已启动并正在运行。
所需步骤
使用 JDBC 应用程序创建新数据库需要执行以下步骤 –
-
导入包– 要求您包含包含数据库编程所需的 JDBC 类的包。大多数情况下，使用import java.sql.*就足够了。
-
打开连接– 需要使用DriverManager.getConnection()方法创建一个 Connection 对象，该对象表示与数据库服务器的物理连接。
-
执行查询– 需要使用 Statement 类型的对象来构建和提交 SQL 语句以从表中选择（即获取）记录。
-
提取数据– 执行 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 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子句来更新条件记录。
-
清理环境– 尝试使用资源会自动关闭资源。
示例代码
将以下示例复制并粘贴到 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 – 删除记录示例
本章提供了如何使用 JDBC 应用程序从表中删除记录的示例。在执行以下示例之前，请确保您已准备好以下内容 –
-
要执行以下示例，您可以将用户名和密码替换为您的实际用户名和密码。
-
您正在使用的 MySQL 数据库已启动并正在运行。
所需步骤
使用 JDBC 应用程序创建新数据库需要执行以下步骤 –
-
导入包– 要求您包含包含数据库编程所需的 JDBC 类的包。大多数情况下，使用import java.sql.*就足够了。
-
注册 JDBC 驱动程序– 要求您初始化驱动程序，以便您可以打开与数据库的通信通道。
-
打开连接– 需要使用DriverManager.getConnection()方法创建一个 Connection 对象，该对象表示与数据库服务器的物理连接。
-
执行查询– 需要使用 Statement 类型的对象来构建和提交 SQL 语句以从表中删除记录。此查询使用WHERE子句删除条件记录。
-
清理环境– 尝试使用资源会自动关闭资源。
示例代码
将以下示例复制并粘贴到 TestApplication.java 中，编译并运行如下 –
import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.ResultSet;
import java.sql.SQLException;
import java.sql.Statement;
public class TestApplication {
static final String DB_URL = "jdbc:mysql://localhost/TUTORIALSPOINT";
static final String USER = "guest";
static final String PASS = "guest123";
static final String QUERY = "SELECT id, first, last, age FROM Registration";
public static void main(String[] args) {
// Open a connection
try(Connection conn = DriverManager.getConnection(DB_URL, USER, PASS);
Statement stmt = conn.createStatement();
) {
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子句来选择记录。
-
清理环境– 尝试使用资源会自动关闭资源。
示例代码
将以下示例复制并粘贴到 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 子句示例
本章提供了如何使用 JDBC 应用程序从表中选择记录的示例。这将在从表中选择记录时使用 LIKE 子句添加其他条件。在执行以下示例之前，请确保您已准备好以下内容 –
-
要执行以下示例，您可以将用户名和密码替换为您的实际用户名和密码。
-
您正在使用的 MySQL 数据库已启动并正在运行。
所需步骤
使用 JDBC 应用程序创建新数据库需要执行以下步骤 –
-
导入包– 要求您包含包含数据库编程所需的 JDBC 类的包。大多数情况下，使用import java.sql.*就足够了。
-
打开连接– 需要使用DriverManager.getConnection()方法创建一个 Connection 对象，该对象表示与数据库服务器的物理连接。
-
执行查询– 需要使用 Statement 类型的对象来构建和提交 SQL 语句，以从满足给定条件的表中获取记录。此查询使用LIKE子句选择记录以选择所有名字以“za”开头的学生。
-
清理环境– 尝试使用资源会自动关闭资源。
示例代码
将以下示例复制并粘贴到 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 – 排序数据示例
本章提供了一个示例，说明如何使用 JDBC 应用程序对表中的记录进行排序。这将使用asc和desc关键字按升序或降序对记录进行排序。在执行以下示例之前，请确保您已准备好以下内容 –
-
要执行以下示例，您可以将用户名和密码替换为您的实际用户名和密码。
-
您正在使用的 MySQL 数据库已启动并正在运行。
所需步骤
使用 JDBC 应用程序创建新数据库需要执行以下步骤 –
-
导入包– 要求您包含包含数据库编程所需的 JDBC 类的包。大多数情况下，使用import java.sql.*就足够了。
-
打开连接– 需要使用DriverManager.getConnection()方法创建一个 Connection 对象，该对象表示与数据库服务器的物理连接。
-
执行查询– 需要使用 Statement 类型的对象来构建和提交 SQL 语句以对表中的记录进行排序。这些查询使用asc和desc子句按升序和降序对数据进行排序。
-
清理环境– 尝试使用资源会自动关闭资源。
示例代码
将以下示例复制并粘贴到 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:\>
