简短介绍 JDBC 及其重要性。
简短介绍 JDBC
JDBC（Java Database Connectivity）是一种用于执行 SQL 语句的 Java API 并且独立于特定的数据库厂商。它允许开发者以一种标准的方式从 Java 应用程序中访问关系型数据库，这意味着一旦你掌握了 JDBC 的基本操作，你可以轻松地将你的应用程序与多种数据库连接起来，而不需要更改大量的代码。
JDBC 的重要性
1. 标准化: JDBC 提供了一套标准接口，使得开发者能够以一致的方式与各种数据库交互。这降低了对不同数据库产品的依赖，增强了应用程序的可移植性和可维护性。
2. 平台无关性: 由于 JDBC 是 Java 技术的一部分，因此它继承了 Java “一次编写，到处运行”的特性，可以在任何支持 Java 的平台上使用。
3. 增强的开发效率: JDBC 的引入简化了数据库访问的复杂性，开发者可以通过简单的 API 调用来执行 SQL 命令，减少了代码量和出错的机会。
4. 丰富的功能: JDBC 支持多种数据库操作，包括查询、更新、事务处理等，同时还提供了对高级功能的支持，如存储过程调用、结果集的滚动和更新等。
5. 安全性: 通过使用预编译的 SQL 语句（PreparedStatement），可以有效防止 SQL 注入攻击，提高了应用程序的安全性。
为什么学习 JDBC？
学习 JDBC（Java Database Connectivity）对于 Java 开发者来说非常重要，原因如下：
1. 广泛的应用: 几乎所有的企业级应用都需要与数据库交互，无论是进行数据存储还是数据检索。JDBC 提供了一个统一的接口来实现这一需求，使得开发者能够更专注于业务逻辑而不是底层的数据访问细节。
2. 跨平台能力: 由于 JDBC 是基于 Java 的，所以它继承了 Java 语言的跨平台特性。这意味着使用 JDBC 编写的数据库应用程序可以在不同的操作系统上运行，无需对数据库访问代码进行修改。
3. 广泛的数据库支持: JDBC 支持多种数据库管理系统（DBMS），如 MySQL、Oracle、SQL Server、PostgreSQL 等。这意味着开发者只需要掌握一套技能——即使用 JDBC 访问数据库的技术——就可以将其应用于多种数据库环境中。
4. 易于学习和使用: JDBC 的设计旨在简化数据库访问操作，提供了直观的 API 来执行 SQL 命令。即使你是数据库操作的新手，也可以快速上手并开始构建具有数据库交互功能的应用程序。
5. 强大的功能: JDBC 不仅支持基本的 SQL 操作，还支持更高级的功能，比如存储过程调用、事务管理和结果集的滚动访问等。这使得开发者能够根据需要选择最适合的工具来完成任务。
6. 社区支持: 由于 JDBC 已经存在了很长时间并且被广泛采用，所以围绕它有一个庞大的开发者社区。这意味着当你遇到问题时，很容易找到解决方案或者寻求帮助。
7. 与框架的兼容性: 很多流行的 Java 框架（如 Spring、Hibernate 等）都内置了对 JDBC 的支持，了解 JDBC 可以让你更好地理解和使用这些框架。
JDBC 是什么？
解释 JDBC 的全称以及它的目的。
JDBC 的全称是 Java Database Connectivity，中文翻译为“Java 数据库连接”。它是 Java 编程语言中用于与关系型数据库通信的一组 API（应用程序编程接口）。JDBC 的主要目的是为 Java 应用程序提供一个标准的方法来访问和操作关系型数据库，从而使得开发者能够在不同的数据库管理系统之间轻松切换，而不需要改变他们的核心数据库访问代码。
具体来说，JDBC 的目标包括：
1. 提供标准的数据库访问接口：JDBC 规定了一个标准的接口集，这些接口定义了如何与数据库进行交互的方法，包括连接数据库、执行 SQL 命令、处理结果集等。
2. 跨数据库兼容性：JDBC 允许 Java 应用程序以相同的方式与不同的数据库管理系统（如 Oracle、MySQL、Microsoft SQL Server、DB2 等）进行交互。这样，如果需要更换数据库供应商，只需要改变 JDBC 驱动程序即可，而不需要对应用程序的其余部分进行大量修改。
3. 简化数据库编程：JDBC 将复杂的数据库操作抽象成一组简单的 API 调用，使开发者能够更加专注于应用程序的业务逻辑而非具体的数据库操作细节。
4. 提高安全性：通过使用 JDBC 的预编译语句（PreparedStatement），可以有效地防止 SQL 注入攻击，从而提高应用程序的安全性。
JDBC 通过一系列的类和接口（如 java.sql.* 包中的类）来实现上述目标，这些类和接口为开发者提供了创建数据库连接、执行 SQL 查询、处理结果集等功能的方法。JDBC 驱动程序充当了桥梁的角色，将这些标准的 API 调用转换为特定数据库的实际命令。
JDBC 在 Java 生态系统中的位置。
在 Java 生态系统中，JDBC（Java Database Connectivity）占据了一个非常重要的位置，尤其是在那些需要与关系型数据库交互的企业级应用中。以下是 JDBC 在 Java 生态系统中的位置及其作用的一些概述：
1. Java 标准库的一部分：
JDBC 是 Java 标准库的一部分，被包含在 Java SE（Standard Edition）和 Java EE（Enterprise Edition）中。这意味着任何支持 Java 的环境都可以直接使用 JDBC 来访问数据库，而无需额外安装其他组件。
2. 数据库访问的抽象层：
JDBC 作为数据库访问的抽象层，它提供了一套标准的接口和类，使得开发者可以编写与数据库无关的代码。这种抽象性意味着只要数据库供应商提供了相应的 JDBC 驱动程序，你就可以使用相同的代码来访问不同的数据库。
3. 企业级应用的关键组件：
对于 Java Web 应用、服务器端应用以及其他需要持久化数据的企业级应用来说，JDBC 是一个关键组件。它使得应用程序能够与后端数据库进行高效、安全的交互。
4. ORM 框架的基础：
许多 ORM（Object-Relational Mapping）框架，如 Hibernate、MyBatis 等，都是基于 JDBC 构建的。这些框架提供了一种更高层次的抽象，使得开发者可以更方便地在对象和关系型数据库之间进行映射。
5. 与 Java EE 的集成：
在 Java EE 环境中，JDBC 经常与诸如 JNDI（Java Naming and Directory Interface）一起使用，来实现数据源（DataSource）的配置和管理，从而简化了在集群或多实例环境下共享数据库连接的工作。
6. 与 Spring 框架的整合：
Spring 框架也提供了对 JDBC 的支持，Spring 的 JDBC 模块封装了 JDBC 的复杂性，并且提供了一些高级特性，如异常转换和事务管理等。
JDBC 架构
JDBC 驱动程序模型
JDBC 驱动程序模型描述了如何将 Java 应用程序与数据库连接起来。这个模型定义了不同类型的 JDBC 驱动程序以及它们如何与数据库交互。JDBC 驱动程序是连接 Java 应用程序和数据库管理系统（DBMS）之间的桥梁，它们负责将 JDBC API 调用转换为数据库特定的协议。
JDBC 驱动程序类型
根据 Sun Microsystems（现在的 Oracle）的分类，JDBC 驱动程序可以分为四类：
1. JDBC-ODBC 桥接驱动程序 (Type 1):
这是最简单的一种驱动程序类型，它实际上并不直接与数据库通信。相反，它通过 ODBC（Open Database Connectivity）桥接到数据库。这种方式现在较少使用，因为性能较差且依赖于 ODBC 驱动程序。
2. 部分 Java 驱动程序 (Type 2):
Type 2 驱动程序直接与数据库通信，但仍然需要一个本地（通常是 C 语言编写的）驱动程序。尽管比 Type 1 性能更好，但仍然不是纯 Java 解决方案，因此可能需要针对不同的操作系统安装不同的版本。
3. 纯 Java 驱动程序 (Type 3):
Type 3 驱动程序也是通过中间层（通常称为网络适配器或网络驱动程序）与数据库通信，但是这个中间层是用 Java 编写的。这种驱动程序允许客户端应用程序通过网络适配器与数据库通信，使得部署更为灵活。然而，这种类型现在也不太常见了，因为它引入了额外的网络延迟和复杂性。
4. 网络纯 Java 驱动程序 (Type 4):
Type 4 驱动程序是纯 Java 实现的，直接与数据库通信，没有中间层。这是最理想的解决方案，因为它既不需要本地驱动程序也不需要网络适配器，同时提供了最佳的性能和最大的平台独立性。Type 4 驱动程序是目前使用最广泛的一种。
选择合适的 JDBC 驱动程序
当选择 JDBC 驱动程序时，通常会倾向于选择 Type 4 驱动程序，因为它提供了最好的性能和可移植性。不过，在某些情况下，可能由于历史原因或其他限制因素，可能会继续使用其他类型的驱动程序。
关键 JDBC 接口和类
1. DriverManager
DriverManager类是 JDBC 的入口点，它负责管理 JDBC 驱动程序的加载和数据库连接的建立。DriverManager提供了静态方法来获取数据库连接，并且它还可以用来管理事务。
方法：
getConnection(String url, Properties info)：根据给定的数据库 URL 和属性集来建立数据库连接。
getConnection(String url, String user, String password)：使用用户名和密码来建立数据库连接。
getDrivers()：返回所有已注册的 JDBC 驱动程序列表。
getConnection(String url)：无参数版本的 getConnection 方法，适用于默认连接。
2. Connection
Connection接口代表与数据库的连接。它是所有数据库操作的基础，比如创建 Statement 或 PreparedStatement。
方法：
createStatement()：创建一个新的 Statement 对象，用于发送 SQL 语句给数据库。
prepareStatement(String sql)：创建一个新的 PreparedStatement 对象，用于发送预编译的 SQL 语句给数据库。
commit()：提交当前事务。
rollback()：回滚当前事务。
close()：关闭连接。
3. Statement
Statement接口用于向数据库发送 SQL 语句。它可以执行简单的 SQL 语句，但不适合用于带有用户输入的动态 SQL 语句，因为那样容易导致 SQL 注入攻击。
方法：
executeQuery(String sql)：执行查询语句，并返回一个ResultSet。
executeUpdate(String sql)：执行更新（INSERT, UPDATE 或 DELETE）语句，并返回受影响的行数。
execute(String sql)：执行任意 SQL 语句，并返回一个布尔值指示是否返回了ResultSet。
4. PreparedStatement
PreparedStatement接口扩展了Statement接口，它提供了预编译 SQL 语句的能力。预编译的语句可以多次执行，每次执行时只需设置不同的参数值。这对于执行重复的 SQL 语句特别有用，可以提高性能并增加安全性。
方法：
setX(int index, Object value)：设置参数值。
executeQuery()：执行预编译的查询语句，并返回一个 ResultSet。
executeUpdate()：执行预编译的更新语句，并返回受影响的行数。
5. ResultSet
ResultSet接口表示由执行查询语句得到的结果集。你可以通过ResultSet来获取查询结果，并遍历结果集中的每一行。
方法：
next()：移动游标到结果集的下一行，并返回是否还有更多行。
getString(String columnName)：根据列名获取字符串值。
getInt(String columnName)：根据列名获取整数值。
wasNull()：检查最近获取的值是否为 SQL NULL。
close()：关闭结果集。
连接数据库
1. 加载 JDBC 驱动
在使用 JDBC 连接数据库之前，你需要先加载相应的 JDBC 驱动。这通常通过调用 Class.forName()方法来完成，该方法会加载指定的 JDBC 驱动类。加载驱动程序的目的是为了让 JVM 知道如何处理特定数据库的连接请求。
2. 获取数据库连接
一旦 JDBC 驱动被加载，你就可以使用 DriverManager.getConnection()方法来获取数据库连接。这通常需要提供数据库的连接 URL、用户名和密码。
3. 示例代码展示如何使用 DriverManager建立连接
下面是一个简单的示例代码，展示了如何使用 JDBC 连接到 MySQL 数据库：
import java.sql.Connection; // 导入Connection接口
import java.sql.DriverManager; // 导入用于数据库连接的DriverManager类
import java.sql.Statement; // 导入Statement接口
public class Main {
public static void main(String[] args) throws Exception {
// 加载MySQL JDBC驱动
Class.forName("com.mysql.cj.jdbc.Driver");
// 定义数据库连接信息
String url = "jdbc:mysql://localhost:3306/my_db"; // 数据库URL
String user = ""; // 数据库用户名
String password = ""; // 数据库密码
// 获取数据库连接
Connection connection = DriverManager.getConnection(url, user, password);
}
}注意事项
1. 驱动程序加载：确保你已经下载了相应的 JDBC 驱动程序，并将其添加到项目的类路径中。例如，对于 MySQL 数据库，你需要将 `mysql-connector-java-x.x.x.jar` 文件添加到项目中。
2. 连接 URL：确保你提供的连接 URL 是正确的，包括主机名、端口号、数据库名等信息。例如，上面的示例中，my_db 应该替换为你实际的数据库名称。
3. 异常处理：务必处理可能出现的ClassNotFoundException和SQLException，以确保程序的健壮性。
通过上述步骤和示例代码，你可以建立起一个基本的 JDBC 连接到数据库的过程。这只是一个起点，实际应用中可能还需要进行更复杂的数据库操作和错误处理。
执行 SQL 查询
在 JDBC 中执行 SQL 查询通常涉及以下几个步骤：使用 Statement或PreparedStatement对象来发送 SQL 命令到数据库，并处理返回的ResultSet。下面分别介绍这两种方式，并提供示例代码。
1. 使用 Statement对象执行查询
Statement对象用于执行不带参数的 SQL 命令。这是一个简单但不太安全的方法，因为它不适合用于带有用户输入的动态 SQL 语句，因为那样容易导致 SQL 注入攻击。
示例代码：
import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.ResultSet;
import java.sql.Statement;
import java.sql.SQLException;
public class ExecuteQuery {
public static void main(String[] args) {
// JDBC 驱动名称与数据库 URL
String driverName = "com.mysql.cj.jdbc.Driver";
String serverURL = "jdbc:mysql://localhost:3306/yourdatabase";
String user = "root";
String pass = "";
try {
// 加载 JDBC 驱动
Class.forName(driverName);
// 获取连接
Connection conn = DriverManager.getConnection(serverURL, user, pass);
// 创建 Statement 对象
Statement stmt = conn.createStatement();
// 执行 SQL 查询
String sql = "SELECT * FROM your_table";
ResultSet rs = stmt.executeQuery(sql);
// 处理 ResultSet
while (rs.next()) {
// 读取结果集中的数据
int id = rs.getInt("id");
String name = rs.getString("name");
int age = rs.getInt("age");
System.out.println("ID: " + id + ", Name: " + name + ", Age: " + age);
}
// 关闭资源
rs.close();
stmt.close();
conn.close();
} catch (ClassNotFoundException e) {
e.printStackTrace();
} catch (SQLException e) {
e.printStackTrace();
}
}
}2. 使用PreparedStatement对象执行参数化查询
PreparedStatement对象提供了预编译 SQL 语句的能力，使得每次执行时只需要设置不同的参数值即可。这种方法不仅可以提高性能，还可以增强安全性，因为它可以有效地防止 SQL 注入攻击。示例代码：
import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.PreparedStatement;
import java.sql.ResultSet;
import java.sql.SQLException;
public class ExecutePreparedQuery {
public static void main(String[] args) {
// JDBC 驱动名称与数据库 URL
String driverName = "com.mysql.cj.jdbc.Driver";
String serverURL = "jdbc:mysql://localhost:3306/yourdatabase";
String user = "root";
String pass = "";
try {
// 加载 JDBC 驱动
Class.forName(driverName);
// 获取连接
Connection conn = DriverManager.getConnection(serverURL, user, pass);
// 创建 PreparedStatement 对象
String sql = "SELECT * FROM your_table WHERE id = ?";
PreparedStatement pstmt = conn.prepareStatement(sql);
// 设置参数
pstmt.setInt(1, 1); // 假设要查询 ID 为 1 的记录
// 执行 SQL 查询
ResultSet rs = pstmt.executeQuery();
// 处理 ResultSet
while (rs.next()) {
int id = rs.getInt("id");
String name = rs.getString("name");
int age = rs.getInt("age");
System.out.println("ID: " + id + ", Name: " + name + ", Age: " + age);
}
// 关闭资源
rs.close();
pstmt.close();
conn.close();
} catch (ClassNotFoundException e) {
e.printStackTrace();
} catch (SQLException e) {
e.printStackTrace();
}
}
}处理ResultSet
无论使用Statement还是PreparedStatement来执行查询，处理ResultSet的方式都类似。你需要通过ResultSet的方法来遍历结果集，并提取需要的数据。在上述示例代码中，我们展示了如何使用ResultSet的next()方法来遍历每一行数据，并使用getInt()和getString()等方法来获取列值。
注意事项
1. 资源管理：确保在完成操作后关闭所有打开的资源（如 ResultSet、Statement和Connection），以避免资源泄漏。
2. 异常处理：妥善处理可能出现的异常，如ClassNotFoundException和SQLException，确保程序的健壮性。
3. 安全性：使用PreparedStatement而不是Statement来处理带有用户输入的 SQL 语句，以防止 SQL 注入攻击。
事务处理
在 JDBC 中，事务处理是指对数据库的一系列操作作为一个整体来执行。如果事务中的所有操作都成功完成，则整个事务被提交；如果其中任何一个操作失败，则整个事务会被回滚，以保持数据的一致性和完整性。
如何在 JDBC 中管理事务。
在 JDBC 中，你可以通过以下步骤来管理事务：
1. 禁用自动提交：默认情况下，每当执行一个更新语句（如INSERT, UPDATE, DELETE）时，JDBC 会立即提交事务。为了手动控制事务，需要先将Connection的autoCommit属性设置为false。
2. 执行 SQL 语句：执行你的 SQL 更新语句。
3. 提交或回滚事务：根据需要，提交事务（使用Connection.commit()）或将事务回滚（使用 Connection.rollback()）。
4. 恢复自动提交模式：最后，可以将autoCommit属性重新设置为true，以便于后续的操作能够自动提交。
示例代码下面是一个示例代码，展示了如何在 JDBC 中管理事务：
import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.PreparedStatement;
import java.sql.SQLException;
public class TransactionExample {
public static void main(String[] args) {
// JDBC 驱动名称与数据库 URL
String driverName = "com.mysql.cj.jdbc.Driver";
String serverURL = "jdbc:mysql://localhost:3306/yourdatabase";
String user = "root";
String pass = "";
try {
// 加载 JDBC 驱动
Class.forName(driverName);
// 获取连接
Connection conn = DriverManager.getConnection(serverURL, user, pass);
// 禁用自动提交
conn.setAutoCommit(false);
// 创建 PreparedStatement 对象
String sql1 = "INSERT INTO your_table (column1, column2) VALUES (?, ?)";
PreparedStatement pstmt1 = conn.prepareStatement(sql1);
pstmt1.setString(1, "value1");
pstmt1.setString(2, "value2");
// 执行第一条 SQL 插入语句
pstmt1.executeUpdate();
// 创建另一个 PreparedStatement 对象
String sql2 = "UPDATE your_table SET column2 = ? WHERE column1 = ?";
PreparedStatement pstmt2 = conn.prepareStatement(sql2);
pstmt2.setString(1, "updated_value");
pstmt2.setString(2, "value1");
// 执行第二条 SQL 更新语句
pstmt2.executeUpdate();
// 提交事务
conn.commit();
// 关闭资源
pstmt1.close();
pstmt2.close();
conn.close();
System.out.println("Transaction completed successfully.");
} catch (ClassNotFoundException e) {
e.printStackTrace();
} catch (SQLException e) {
// 如果事务中的任何部分失败，则回滚整个事务
try {
if (conn != null) {
conn.rollback(); // 回滚事务
conn.close();
}
} catch (SQLException ex) {
ex.printStackTrace();
}
e.printStackTrace();
}
}
}示例代码说明
1. 禁用自动提交：通过调用conn.setAutoCommit(false)来禁止自动提交。
2. 执行 SQL 语句：在这个例子中，我们创建了两个PreparedStatement对象，分别用于插入和更新数据。
3. 提交事务：如果一切顺利，通过调用conn.commit()来提交事务。
4. 回滚事务：如果在执行过程中出现了任何异常，可以通过捕获异常并在catch块中调用conn.rollback()来回滚整个事务。
5. 恢复自动提交模式：在事务处理完成后，最好将autoCommit属性重新设置为true，以便于后续的操作能够自动提交。
异常处理
常见的 JDBC 异常
在使用 JDBC 进行数据库操作时，可能会遇到多种异常。了解这些异常的类型和如何处理它们对于编写健壮的应用程序至关重要。以下是一些常见的 JDBC 异常：
1.SQLException：
这是 JDBC 中最常见的一种异常，几乎所有的数据库访问错误都会抛出这个异常。SQLException 是所有其他特定异常的父类，比如SQLTimeoutException、SQLWarning等。
SQLException可以携带一个 SQL 状态码和一个错误消息，可以帮助开发者诊断问题。
2. SQLNonTransientException：
表示非瞬态的条件，即在重试后不会消失的条件。例如，当尝试访问不存在的对象时，可能会抛出此异常。
3. SQLSyntaxErrorException：
当 SQL 语法有误时抛出，例如拼写错误或语法结构错误。
4. SQLDataException：
当数据与预期不符时抛出，例如试图将一个整数放入需要字符串的字段中。
5. SQLIntegrityConstraintViolationException：
当违反了数据库完整性约束时抛出，例如尝试插入重复的主键值。
6. SQLFeatureNotSupportedException：
当请求的功能不受支持时抛出，例如使用了不支持的 JDBC 特性或方法。
7. SQLRecoverableException：
表示数据库或连接可以恢复的条件。例如，连接丢失但可以重新建立连接的情况。
8. SQLTransactionRollbackException：
当事务被强制回滚时抛出，例如因为违反了事务隔离级别。
如何捕获和处理这些异常
处理 JDBC 异常的最佳实践是使用适当的异常处理机制，确保应用程序能够优雅地处理错误并给出适当的反馈。以下是如何捕获和处理这些异常的示例：
import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.PreparedStatement;
import java.sql.SQLException;
public class ExceptionHandlingExample {
public static void main(String[] args) {
// JDBC 驱动名称与数据库 URL
String driverName = "com.mysql.cj.jdbc.Driver";
String serverURL = "jdbc:mysql://localhost:3306/yourdatabase";
String user = "root";
String pass = "";
Connection conn = null;
PreparedStatement pstmt = null;
try {
// 加载 JDBC 驱动
Class.forName(driverName);
// 获取连接
conn = DriverManager.getConnection(serverURL, user, pass);
// 禁用自动提交
conn.setAutoCommit(false);
// 创建 PreparedStatement 对象
String sql = "INSERT INTO your_table (column1, column2) VALUES (?, ?)";
pstmt = conn.prepareStatement(sql);
pstmt.setString(1, "value1");
pstmt.setString(2, "value2");
// 执行 SQL 插入语句
pstmt.executeUpdate();
// 提交事务
conn.commit();
System.out.println("Transaction completed successfully.");
} catch (ClassNotFoundException e) {
// 处理找不到驱动的异常
e.printStackTrace();
} catch (SQLException e) {
// 处理 SQL 相关异常
System.err.println("SQL Exception occurred: " + e.getMessage());
// 如果事务中的任何部分失败，则回滚整个事务
if (conn != null) {
try {
conn.rollback(); // 回滚事务
} catch (SQLException ex) {
ex.printStackTrace();
}
}
e.printStackTrace();
} finally {
// 确保所有资源都被关闭
try {
if (pstmt != null) pstmt.close();
if (conn != null) conn.close();
} catch (SQLException e) {
e.printStackTrace();
}
}
}
}异常处理要点
1. 捕获异常：使用try-catch块来捕获可能抛出的异常。
2. 处理异常：在catch块中处理异常，可以打印错误信息、记录日志或者根据具体情况采取相应的措施。
3. 回滚事务：如果事务中有任何部分失败，应该回滚整个事务以确保数据一致性。
4. 关闭资源：在finally块中关闭所有打开的资源，如PreparedStatement和Connection。这一步非常重要，可以防止资源泄露。
5. 异常层次结构：了解异常层次结构，捕获更具体的异常类型（如SQLException而不是 Exception），以便更好地定位问题。