目录
4.2 使用PreparedStatement执行SQL语句
12.3 使用try-with-resources简化资源关闭
13.2 基于JDBC 4.2的try-with-resources改进
1.JDBC简介
1.1什么是JDBC？
JDBC全称为Java Database Connectivity，它是Java语言访问数据库的标准API。通过JDBC，我们可以实现在Java程序中与数据库进行连接、查询、更新等操作，从而实现与数据库的交互。
1.2JDBC的作用和重要性
JDBC在Java开发中具有重要的作用：
- 与数据库连接：JDBC允许Java程序连接到各种不同的数据库，如MySQL、Oracle、SQL Server等，实现数据的存取。
- 执行SQL语句：通过JDBC，我们可以在Java程序中执行各种SQL语句，包括查询、插入、更新和删除等。
- 事务处理：JDBC支持事务处理，确保数据库操作的一致性和完整性。
- 数据库元数据：JDBC提供了获取数据库元数据的功能，可以查询数据库的表、列信息等。
- 连接池：JDBC连接池技术可以提高数据库连接的效率和性能。
1.3JDBC基本流程
使用JDBC连接数据库的基本流程包括以下几个步骤：
①加载数据库驱动程序：在使用JDBC前，需要加载数据库驱动程序，以便JDBC能够与具体的数据库进行通信。
// 加载MySQL数据库的驱动程序
Class.forName("com.mysql.jdbc.Driver");
②建立数据库连接：使用JDBC的Connection对象来与数据库建立连接。
String url = "jdbc:mysql://localhost:3306/mydb"; // 数据库URL
String user = "root"; // 数据库用户名
String password = "password"; // 数据库密码
Connection conn = DriverManager.getConnection(url, user, password);
③创建Statement对象：通过Connection对象创建Statement对象，用于执行SQL语句。
Statement stmt = conn.createStatement();
④执行SQL语句：通过Statement对象执行SQL语句，并处理结果
String sql = "SELECT * FROM students";
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();
通过以上步骤，我们就可以在Java程序中连接数据库，并执行相关的SQL操作了。
1.4JDBC常见问题
在使用JDBC时，可能会遇到一些常见问题，比如数据库连接失败、SQL注入攻击等。对于数据库连接失败，需要检查数据库URL、用户名、密码等配置是否正确；而对于SQL注入攻击，可以使用PreparedStatement来预编译SQL语句，防止恶意攻击。
1.5总结
JDBC是Java访问数据库的标准API，通过它，我们可以连接数据库、执行SQL语句并处理查询结果。熟练掌握JDBC的基本操作对于Java开发者来说非常重要，它为我们在Java程序中操作数据库提供了强大的支持。在学习JDBC时，务必记住关闭资源，释放数据库连接，以避免资源泄露和性能问题。在后续学习中，我们将深入探讨JDBC的更多特性和高级应用。
2. JDBC开发环境准备
2.1安装数据库
在使用JDBC之前，首先需要安装一个数据库系统。常见的数据库系统有MySQL、Oracle、SQL Server等。以MySQL为例，以下是安装步骤：
-
下载MySQL：在MySQL官网下载对应操作系统的安装包，然后按照安装向导进行安装。
-
安装MySQL：按照安装向导的提示进行安装，设置root用户密码。
-
启动MySQL服务：安装完成后，启动MySQL数据库服务。
2.2导入数据库驱动
JDBC需要与具体的数据库驱动程序进行通信，因此我们需要将数据库驱动导入到Java项目中。通常，你可以在数据库官网下载相应的JDBC驱动JAR文件，然后将其导入到Java项目的classpath中。
2.3编写Java代码连接数据库
下面是一个简单的示例代码，演示如何使用JDBC连接到MySQL数据库。
import java.sql.*;
public class JDBCDemo {
public static void main(String[] args) {
String url = "jdbc:mysql://localhost:3306/mydb"; // 数据库URL
String user = "root"; // 数据库用户名
String password = "password"; // 数据库密码
try {
// 加载MySQL数据库的驱动程序
Class.forName("com.mysql.jdbc.Driver");
// 建立数据库连接
Connection conn = DriverManager.getConnection(url, user, password);
// 执行SQL语句
String sql = "SELECT * FROM students";
Statement stmt = conn.createStatement();
ResultSet rs = stmt.executeQuery(sql);
// 处理结果集
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 | SQLException e) {
e.printStackTrace();
}
}
}
在上述示例代码中，我们首先加载MySQL数据库的驱动程序，然后建立数据库连接，执行SQL查询语句并处理查询结果。最后，记得关闭资源以释放数据库连接。
2.4总结
在使用JDBC开发前，需要准备好数据库系统，并导入相应的数据库驱动。通过简单的Java代码示例，我们了解了如何连接到数据库、执行SQL语句和处理查询结果。JDBC为Java开发者提供了与数据库交互的基础，为后续开发提供了强大的支持。在实际开发中，可以根据具体需求，进一步学习和掌握JDBC的更多特性和高级用法。
3. 连接数据库
在使用JDBC进行数据库操作之前，首先需要建立与数据库的连接。JDBC使用Connection对象来表示与数据库的连接，通过这个连接可以执行SQL语句、获取查询结果等。
3.1步骤1：导入JDBC相关类
在Java代码中，首先需要导入JDBC相关的类。通常，我们需要导入以下类：
import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.SQLException;
3.2步骤2：加载数据库驱动
在使用JDBC连接特定数据库之前，需要加载对应数据库的驱动程序。不同数据库需要使用不同的驱动类，例如，连接MySQL数据库需要加载com.mysql.jdbc.Driver类。加载驱动的方式是使用Class.forName()方法。
try {
Class.forName("com.mysql.jdbc.Driver");
} catch (ClassNotFoundException e) {
e.printStackTrace();
}
3.3步骤3：建立数据库连接
加载完数据库驱动后，我们可以通过DriverManager.getConnection()方法建立数据库连接。需要提供连接数据库的URL、用户名和密码。
String url = "jdbc:mysql://localhost:3306/mydb"; // 数据库URL
String user = "root"; // 数据库用户名
String password = "password"; // 数据库密码
try {
Connection conn = DriverManager.getConnection(url, user, password);
// 连接成功，可以在这里执行SQL语句和数据库操作
} catch (SQLException e) {
e.printStackTrace();
}
3.4完整示例
下面是一个完整的示例代码，演示如何连接到MySQL数据库：
import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.SQLException;
public class ConnectDatabaseDemo {
public static void main(String[] args) {
String url = "jdbc:mysql://localhost:3306/mydb"; // 数据库URL
String user = "root"; // 数据库用户名
String password = "password"; // 数据库密码
try {
Class.forName("com.mysql.jdbc.Driver"); // 加载MySQL数据库的驱动程序
// 建立数据库连接
Connection conn = DriverManager.getConnection(url, user, password);
// 连接成功后的操作，可以在这里执行SQL语句和数据库操作
// 关闭数据库连接
conn.close();
} catch (ClassNotFoundException | SQLException e) {
e.printStackTrace();
}
}
}
3.5总结
连接数据库是使用JDBC进行数据库操作的第一步。通过导入JDBC相关类、加载数据库驱动和建立数据库连接，我们可以在Java程序中与数据库进行交互。连接数据库是JDBC开发中的重要步骤，为后续的SQL执行和数据操作打下了基础。在实际开发中，根据不同数据库系统，需要加载对应的数据库驱动，并按照需求提供连接数据库的URL、用户名和密码。
4. 执行SQL语句
连接成功后，我们可以使用Connection对象来执行SQL语句，从而实现数据库的增删改查操作。JDBC提供了Statement和PreparedStatement两种方式执行SQL语句。
4.1 使用Statement执行SQL语句
Statement对象用于执行静态的SQL语句，通常是在编译时已经确定的SQL语句。下面是使用Statement执行查询语句的示例：
import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.ResultSet;
import java.sql.SQLException;
import java.sql.Statement;
public class StatementDemo {
public static void main(String[] args) {
String url = "jdbc:mysql://localhost:3306/mydb";
String user = "root";
String password = "password";
try {
Class.forName("com.mysql.jdbc.Driver");
Connection conn = DriverManager.getConnection(url, user, password);
// 创建Statement对象
Statement statement = conn.createStatement();
// 执行SQL查询语句
String sqlQuery = "SELECT * FROM users";
ResultSet resultSet = statement.executeQuery(sqlQuery);
// 处理查询结果
while (resultSet.next()) {
int id = resultSet.getInt("id");
String username = resultSet.getString("username");
String email = resultSet.getString("email");
System.out.println("ID: " + id + ", Username: " + username + ", Email: " + email);
}
// 关闭结果集和Statement对象
resultSet.close();
statement.close();
conn.close();
} catch (ClassNotFoundException | SQLException e) {
e.printStackTrace();
}
}
}
4.2 使用PreparedStatement执行SQL语句
PreparedStatement对象用于执行动态的SQL语句，可以在运行时设置参数。相对于Statement，PreparedStatement更常用，也更安全，可以防止SQL注入攻击。下面是使用PreparedStatement执行插入语句的示例：
import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.PreparedStatement;
import java.sql.SQLException;
public class PreparedStatementDemo {
public static void main(String[] args) {
String url = "jdbc:mysql://localhost:3306/mydb";
String user = "root";
String password = "password";
try {
Class.forName("com.mysql.jdbc.Driver");
Connection conn = DriverManager.getConnection(url, user, password);
// 创建PreparedStatement对象
String sqlInsert = "INSERT INTO users (username, email) VALUES (?, ?)";
PreparedStatement preparedStatement = conn.prepareStatement(sqlInsert);
// 设置参数
preparedStatement.setString(1, "newuser");
preparedStatement.setString(2, "newuser@example.com");
// 执行插入语句
int rowsAffected = preparedStatement.executeUpdate();
System.out.println(rowsAffected + "行受影响");
// 关闭PreparedStatement对象
preparedStatement.close();
conn.close();
} catch (ClassNotFoundException | SQLException e) {
e.printStackTrace();
}
}
}
4.3总结
在JDBC中，可以通过Statement和PreparedStatement两种方式执行SQL语句。Statement用于执行静态的SQL语句，而PreparedStatement用于执行动态的SQL语句，并且可以防止SQL注入攻击。使用这两种方式，我们可以在Java程序中对数据库进行查询、插入、更新和删除等操作，从而实现数据的增删改查。在实际开发中，通常优先考虑使用PreparedStatement，尤其是涉及到用户输入数据的情况，以确保应用程序的安全性和可靠性。
5. 使用PreparedStatement
在上一节中，我们了解了JDBC中两种执行SQL语句的方式：Statement和PreparedStatement。在这一节中，我们将重点介绍如何使用PreparedStatement，它是更常用且更安全的执行SQL语句的方式。
5.1 创建PreparedStatement
首先，我们需要创建一个PreparedStatement对象。与Statement不同，PreparedStatement在创建时需要提供带有占位符（通常是问号）的SQL语句，占位符将在执行时动态地设置值。
import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.PreparedStatement;
import java.sql.SQLException;
public class PreparedStatementDemo {
public static void main(String[] args) {
String url = "jdbc:mysql://localhost:3306/mydb";
String user = "root";
String password = "password";
try {
Class.forName("com.mysql.jdbc.Driver");
Connection conn = DriverManager.getConnection(url, user, password);
// 创建PreparedStatement对象
String sqlInsert = "INSERT INTO users (username, email) VALUES (?, ?)";
PreparedStatement preparedStatement = conn.prepareStatement(sqlInsert);
// 设置参数
preparedStatement.setString(1, "newuser");
preparedStatement.setString(2, "newuser@example.com");
// 执行插入语句
int rowsAffected = preparedStatement.executeUpdate();
System.out.println(rowsAffected + "行受影响");
// 关闭PreparedStatement对象
preparedStatement.close();
conn.close();
} catch (ClassNotFoundException | SQLException e) {
e.printStackTrace();
}
}
}
5.2 设置参数
通过setXXX()方法（其中XXX是数据类型）可以为占位符设置具体的值。需要注意的是，参数的索引从1开始而不是0，第一个问号的索引是1，第二个问号的索引是2，依此类推。
在示例中，我们将"newuser"和"newuser@example.com"分别设置为第一个和第二个参数的值。
5.3 执行SQL语句
一旦设置了参数，我们可以使用executeUpdate()方法来执行SQL语句，如插入、更新或删除操作。该方法返回一个整数，表示受影响的行数。
5.4 使用PreparedStatement的好处
使用PreparedStatement相较于Statement有以下好处：
-
安全性：
PreparedStatement可以有效防止SQL注入攻击，因为参数的值是通过方法设置的，而不是直接拼接SQL语句。 -
性能：
PreparedStatement可以预编译SQL语句，从而在执行多次相同SQL语句时提高执行效率。 -
可读性：使用占位符的
PreparedStatement语句更易读和维护。
5.5总结
PreparedStatement是JDBC中更常用和推荐的执行SQL语句的方式。通过设置参数，我们可以动态地构建SQL语句，并确保应用程序的安全性和性能。在实际开发中，尤其涉及用户输入数据时，务必使用PreparedStatement来避免潜在的安全风险。
6. 事务处理
在数据库中，事务是一组相关的操作，它们被当作一个单独的工作单元来执行。事务具有以下四个特性，通常被称为ACID属性：
-
原子性（Atomicity）：事务是不可分割的单元，要么全部执行成功，要么全部失败回滚。
-
一致性（Consistency）：事务执行前后，数据库的状态应保持一致。
-
隔离性（Isolation）：并发执行的事务之间不应该相互干扰，每个事务都应该感觉像是在独立的环境中执行。
-
持久性（Durability）：一旦事务提交，其所做的修改将永久保存在数据库中，即使出现系统故障也不会丢失。
6.1 开启事务
在JDBC中，通过设置连接的自动提交模式为false来开启事务。
import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.SQLException;
public class TransactionDemo {
public static void main(String[] args) {
String url = "jdbc:mysql://localhost:3306/mydb";
String user = "root";
String password = "password";
try {
Class.forName("com.mysql.jdbc.Driver");
Connection conn = DriverManager.getConnection(url, user, password);
// 开启事务
conn.setAutoCommit(false);
// 执行一系列SQL操作
// 提交事务
conn.commit();
// 关闭连接
conn.close();
} catch (ClassNotFoundException | SQLException e) {
e.printStackTrace();
}
}
}
6.2 回滚事务
如果在事务过程中出现错误或异常，我们可以选择回滚事务，将数据库状态还原到事务开始之前的状态。
try {
// 开启事务
conn.setAutoCommit(false);
// 执行一系列SQL操作
// 提交事务
conn.commit();
} catch (SQLException e) {
e.printStackTrace();
// 出现异常，回滚事务
conn.rollback();
}
6.3 事务隔离级别
数据库支持不同的事务隔离级别，用于控制并发事务之间的可见性和影响范围。常见的隔离级别有：
-
读未提交（READ_UNCOMMITTED）：一个事务可以读取另一个未提交事务的修改，可能导致脏读、不可重复读和幻读。
-
读已提交（READ_COMMITTED）：一个事务只能读取已提交事务的修改，避免脏读，但可能出现不可重复读和幻读。
-
可重复读（REPEATABLE_READ）：一个事务在执行过程中看到的数据保持一致，防止脏读和不可重复读，但可能出现幻读。
-
串行化（SERIALIZABLE）：所有事务依次顺序执行，避免了所有并发问题，但性能较差。
在开启事务之前，可以使用setTransactionIsolation()方法设置事务的隔离级别。
// 设置事务隔离级别为可重复读
conn.setTransactionIsolation(Connection.TRANSACTION_REPEATABLE_READ);
6.4总结
事务是保证数据库操作完整性和一致性的重要机制。通过开启事务、提交或回滚事务，并设置合适的事务隔离级别，我们可以有效地管理复杂的数据库操作，确保数据的完整性和可靠性。在并发环境下，事务处理尤为重要，它能有效地处理多个用户同时操作数据库的场景，避免数据冲突和错误。
7. 批处理操作
在JDBC中，批处理是一种执行多个SQL语句的技术，它允许将一组相关的SQL语句发送到数据库执行，从而减少与数据库的通信次数，提高执行效率。批处理通常用于需要批量处理大量数据的场景，如数据导入、数据更新等。
7.1 批处理基础
要使用批处理，需要使用addBatch()方法将SQL语句添加到批处理中，然后使用executeBatch()方法执行批处理。执行批处理后，可以使用getUpdateCount()方法获取每个SQL语句执行的结果，返回影响的行数或SUCCESS_NO_INFO。
import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.SQLException;
import java.sql.Statement;
public class BatchProcessingDemo {
public static void main(String[] args) {
String url = "jdbc:mysql://localhost:3306/mydb";
String user = "root";
String password = "password";
try {
Class.forName("com.mysql.jdbc.Driver");
Connection conn = DriverManager.getConnection(url, user, password);
Statement stmt = conn.createStatement();
// 添加SQL语句到批处理
stmt.addBatch("INSERT INTO students (name, age) VALUES ('Alice', 25)");
stmt.addBatch("UPDATE students SET age = 30 WHERE name = 'Bob'");
stmt.addBatch("DELETE FROM students WHERE name = 'Charlie'");
// 执行批处理
int[] results = stmt.executeBatch();
// 处理执行结果
for (int result : results) {
if (result >= 0) {
// SQL语句执行成功，result为影响的行数
System.out.println("操作成功，影响了 " + result + " 行。");
} else if (result == Statement.SUCCESS_NO_INFO) {
// SQL语句执行成功，但影响的行数未知
System.out.println("操作成功，影响的行数未知。");
} else if (result == Statement.EXECUTE_FAILED) {
// SQL语句执行失败
System.out.println("操作失败。");
}
}
// 关闭连接
stmt.close();
conn.close();
} catch (ClassNotFoundException | SQLException e) {
e.printStackTrace();
}
}
}
7.2 批处理与事务
批处理可以和事务一起使用，以保证多个SQL语句的原子性。在开启事务后执行批处理，如果其中任何一个SQL语句执行失败，可以回滚整个批处理，保持数据的一致性。
try {
conn.setAutoCommit(false);
// 添加SQL语句到批处理
stmt.addBatch("INSERT INTO students (name, age) VALUES ('Alice', 25)");
stmt.addBatch("UPDATE students SET age = 30 WHERE name = 'Bob'");
stmt.addBatch("DELETE FROM students WHERE name = 'Charlie'");
// 执行批处理
int[] results = stmt.executeBatch();
// 处理执行结果
for (int result : results) {
// 处理结果...
}
// 提交事务
conn.commit();
} catch (SQLException e) {
e.printStackTrace();
// 出现异常，回滚事务
conn.rollback();
}
7.3总结
批处理是JDBC中执行多个SQL语句的高效方法，适用于需要处理大量数据的场景。通过将多个相关的SQL语句添加到批处理中，并使用executeBatch()方法一次性执行，可以减少与数据库的通信次数，提高性能。同时，批处理还可以与事务一起使用，确保多个SQL语句的原子性，保持数据的一致性。
8. 元数据和数据库信息
在JDBC中，元数据是描述数据库结构的数据，它包含了数据库、表、列等信息。通过元数据，我们可以在运行时获取数据库的结构，从而动态地操作数据库。JDBC提供了一组元数据接口，如DatabaseMetaData和ResultSetMetaData，可以用于获取数据库和查询结果的信息。
8.1 获取数据库元数据
通过DatabaseMetaData接口，我们可以获取数据库的一些基本信息，如数据库版本、支持的功能等。
import java.sql.Connection;
import java.sql.DatabaseMetaData;
import java.sql.DriverManager;
import java.sql.SQLException;
public class DatabaseMetadataDemo {
public static void main(String[] args) {
String url = "jdbc:mysql://localhost:3306/mydb";
String user = "root";
String password = "password";
try {
Class.forName("com.mysql.jdbc.Driver");
Connection conn = DriverManager.getConnection(url, user, password);
DatabaseMetaData metaData = conn.getMetaData();
// 获取数据库名称和版本
System.out.println("数据库名称：" + metaData.getDatabaseProductName());
System.out.println("数据库版本：" + metaData.getDatabaseProductVersion());
// 获取驱动名称和版本
System.out.println("驱动名称：" + metaData.getDriverName());
System.out.println("驱动版本：" + metaData.getDriverVersion());
// 判断数据库是否支持事务
System.out.println("是否支持事务：" + metaData.supportsTransactions());
// 更多元数据信息...
// 关闭连接
conn.close();
} catch (ClassNotFoundException | SQLException e) {
e.printStackTrace();
}
}
}
8.2 获取查询结果元数据
通过ResultSetMetaData接口，我们可以获取查询结果集的信息，如列名、列类型等。
import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.ResultSet;
import java.sql.ResultSetMetaData;
import java.sql.SQLException;
import java.sql.Statement;
public class ResultSetMetadataDemo {
public static void main(String[] args) {
String url = "jdbc:mysql://localhost:3306/mydb";
String user = "root";
String password = "password";
try {
Class.forName("com.mysql.jdbc.Driver");
Connection conn = DriverManager.getConnection(url, user, password);
Statement stmt = conn.createStatement();
ResultSet rs = stmt.executeQuery("SELECT * FROM students");
ResultSetMetaData metaData = rs.getMetaData();
// 获取查询结果列数
int columnCount = metaData.getColumnCount();
System.out.println("查询结果列数：" + columnCount);
// 获取列名和列类型
for (int i = 1; i <= columnCount; i++) {
String columnName = metaData.getColumnName(i);
String columnType = metaData.getColumnTypeName(i);
System.out.println("列名：" + columnName + "，类型：" + columnType);
}
// 关闭连接
rs.close();
stmt.close();
conn.close();
} catch (ClassNotFoundException | SQLException e) {
e.printStackTrace();
}
}
}
8.3总结
元数据是JDBC中用于获取数据库结构和查询结果信息的重要接口。通过DatabaseMetaData，我们可以获取数据库的基本信息，如名称、版本等；通过ResultSetMetaData，我们可以获取查询结果集的列信息，如列名、类型等。元数据提供了便利的方法，使得我们可以在运行时动态地了解数据库的结构，从而更灵活地操作数据库。
9. 数据库连接池
在JDBC中，每次与数据库建立连接都需要经过网络通信和身份验证，这是一个相对昂贵的操作。为了提高数据库访问的性能和效率，我们可以使用数据库连接池。数据库连接池是一组预先创建好的数据库连接，这些连接在应用程序启动时就被创建并保存在池中，应用程序在需要访问数据库时直接从连接池中获取连接，而不需要每次都重新建立连接。
9.1 使用数据库连接池
在Java中，常用的数据库连接池有HikariCP、Tomcat JDBC Pool、C3P0等。这里以HikariCP为例，简要介绍如何使用数据库连接池。
首先，需要在项目中引入HikariCP的依赖：
<!-- Maven 依赖 -->
<dependency>
<groupId>com.zaxxer</groupId>
<artifactId>HikariCP</artifactId>
<version>4.0.3</version>
</dependency>
然后，编写连接池配置和获取连接的代码：
import com.zaxxer.hikari.HikariConfig;
import com.zaxxer.hikari.HikariDataSource;
import javax.sql.DataSource;
import java.sql.Connection;
import java.sql.SQLException;
public class ConnectionPoolDemo {
public static void main(String[] args) {
// 连接池配置
HikariConfig config = new HikariConfig();
config.setJdbcUrl("jdbc:mysql://localhost:3306/mydb");
config.setUsername("root");
config.setPassword("password");
// 创建连接池
DataSource dataSource = new HikariDataSource(config);
// 从连接池获取连接并执行查询
try (Connection conn = dataSource.getConnection()) {
// 执行查询操作...
} catch (SQLException e) {
e.printStackTrace();
}
}
}
9.2 连接池参数配置
连接池可以根据实际需求进行配置，如最大连接数、最小空闲连接数、连接超时时间等。不同的连接池实现可能有略微不同的配置方式，但通常都提供了相应的参数供我们设置。
9.3 连接池的优势
使用数据库连接池有以下优势：
- 提高性能：避免了频繁建立和关闭数据库连接的开销。
- 节省资源：连接池可以重复利用连接，减少了资源消耗。
- 提高并发能力：连接池可以管理连接的数量，防止连接过多导致数据库性能下降。
9.4总结
数据库连接池是提高数据库访问性能和效率的重要手段。通过预先创建好的连接池，应用程序可以从中获取连接，而不需要频繁地重新建立连接。使用连接池可以有效地减少数据库访问的开销，提高应用程序的性能和并发能力。
10. 常见的数据库操作案例
在Java中，我们经常需要对数据库进行增删改查等操作。下面将介绍几个常见的数据库操作案例，并使用基础的代码来解释每个例子。
10.1 查询数据
查询数据是数据库操作中最常见的操作之一。假设我们有一个表名为students，包含字段id、name和age，现在我们要查询年龄小于等于20岁的学生信息。
import java.sql.*;
public class SelectExample {
public static void main(String[] args) {
String jdbcUrl = "jdbc:mysql://localhost:3306/mydb";
String username = "root";
String password = "password";
try (Connection conn = DriverManager.getConnection(jdbcUrl, username, password)) {
String sql = "SELECT id, name, age FROM students WHERE age <= ?";
try (PreparedStatement stmt = conn.prepareStatement(sql)) {
stmt.setInt(1, 20);
try (ResultSet rs = stmt.executeQuery()) {
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);
}
}
}
} catch (SQLException e) {
e.printStackTrace();
}
}
}
10.2 插入数据
插入数据是将新的记录添加到数据库中的操作。假设我们要往上面的students表中插入一条记录。
import java.sql.*;
public class InsertExample {
public static void main(String[] args) {
String jdbcUrl = "jdbc:mysql://localhost:3306/mydb";
String username = "root";
String password = "password";
try (Connection conn = DriverManager.getConnection(jdbcUrl, username, password)) {
String sql = "INSERT INTO students (name, age) VALUES (?, ?)";
try (PreparedStatement stmt = conn.prepareStatement(sql)) {
stmt.setString(1, "Alice");
stmt.setInt(2, 18);
int affectedRows = stmt.executeUpdate();
if (affectedRows > 0) {
System.out.println("插入成功！");
} else {
System.out.println("插入失败！");
}
}
} catch (SQLException e) {
e.printStackTrace();
}
}
}
10.3 更新数据
更新数据是修改数据库中已有记录的操作。假设我们要将年龄小于18岁的学生年龄更新为18岁。
import java.sql.*;
public class UpdateExample {
public static void main(String[] args) {
String jdbcUrl = "jdbc:mysql://localhost:3306/mydb";
String username = "root";
String password = "password";
try (Connection conn = DriverManager.getConnection(jdbcUrl, username, password)) {
String sql = "UPDATE students SET age = 18 WHERE age < 18";
try (Statement stmt = conn.createStatement()) {
int affectedRows = stmt.executeUpdate(sql);
System.out.println("影响的行数: " + affectedRows);
}
} catch (SQLException e) {
e.printStackTrace();
}
}
}
10.4 删除数据
删除数据是从数据库中删除指定记录的操作。假设我们要删除年龄大于20岁的学生信息。
import java.sql.*;
public class DeleteExample {
public static void main(String[] args) {
String jdbcUrl = "jdbc:mysql://localhost:3306/mydb";
String username = "root";
String password = "password";
try (Connection conn = DriverManager.getConnection(jdbcUrl, username, password)) {
String sql = "DELETE FROM students WHERE age > ?";
try (PreparedStatement stmt = conn.prepareStatement(sql)) {
stmt.setInt(1, 20);
int affectedRows = stmt.executeUpdate();
System.out.println("影响的行数: " + affectedRows);
}
} catch (SQLException e) {
e.printStackTrace();
}
}
}
10.5总结
通过以上例子，我们学习了常见的数据库操作，包括查询数据、插入数据、更新数据和删除数据。这些是在实际应用中最常用的数据库操作，掌握了这些基础知识，可以让我们更加灵活地操作数据库，满足不同业务需求。
11. 错误处理和异常处理
在数据库操作中，可能会遇到各种错误和异常情况，如数据库连接失败、SQL语句错误等。为了保证程序的稳定性和可靠性，我们需要进行错误处理和异常处理。下面将介绍如何处理这些错误和异常情况，并使用基础的代码来解释每个例子。
11.1 处理数据库连接异常
在连接数据库时，可能会出现数据库不可用或网络故障等情况导致连接失败。为了处理这种情况，我们需要捕获SQLException异常并采取相应措施。
import java.sql.*;
public class ConnectionExample {
public static void main(String[] args) {
String jdbcUrl = "jdbc:mysql://localhost:3306/mydb";
String username = "root";
String password = "password";
try (Connection conn = DriverManager.getConnection(jdbcUrl, username, password)) {
// 数据库连接成功，执行数据库操作
} catch (SQLException e) {
System.err.println("数据库连接失败：" + e.getMessage());
e.printStackTrace();
}
}
}
11.2 处理SQL语句执行异常
在执行SQL语句时，可能会出现语法错误或表字段不存在等情况导致执行失败。为了处理这种情况，我们需要捕获SQLException异常并进行适当的处理。
import java.sql.*;
public class ExecuteExample {
public static void main(String[] args) {
String jdbcUrl = "jdbc:mysql://localhost:3306/mydb";
String username = "root";
String password = "password";
try (Connection conn = DriverManager.getConnection(jdbcUrl, username, password)) {
String sql = "SELECT * FROM non_existent_table";
try (Statement stmt = conn.createStatement()) {
try (ResultSet rs = stmt.executeQuery(sql)) {
// 执行查询操作
} catch (SQLException e) {
System.err.println("执行查询失败：" + e.getMessage());
e.printStackTrace();
}
}
} catch (SQLException e) {
e.printStackTrace();
}
}
}
11.3 自定义异常处理
除了处理Java标准异常外，我们也可以自定义异常来处理特定情况。例如，当查询结果为空时，我们可以抛出自定义的NoDataFoundException异常。
import java.sql.*;
public class CustomExceptionExample {
public static void main(String[] args) throws NoDataFoundException {
String jdbcUrl = "jdbc:mysql://localhost:3306/mydb";
String username = "root";
String password = "password";
try (Connection conn = DriverManager.getConnection(jdbcUrl, username, password)) {
String sql = "SELECT * FROM students WHERE age > 25";
try (Statement stmt = conn.createStatement()) {
try (ResultSet rs = stmt.executeQuery(sql)) {
if (!rs.next()) {
throw new NoDataFoundException("未找到符合条件的记录");
}
// 处理查询结果
}
}
} catch (SQLException e) {
e.printStackTrace();
}
}
}
class NoDataFoundException extends Exception {
public NoDataFoundException(String message) {
super(message);
}
}
11.4总结
在进行数据库操作时，错误处理和异常处理是必不可少的。通过捕获和处理异常，我们可以保证程序的健壮性，及时处理错误情况，并给予用户或开发者相应的提示和反馈，提高系统的可靠性和用户体验。
12. 关闭资源
在Java中使用JDBC进行数据库操作时，涉及到数据库连接、Statement、ResultSet等资源的使用。为了释放这些资源并避免资源泄漏，我们需要在使用完毕后进行关闭。下面将介绍如何正确地关闭资源，并使用基础的代码来解释每个例子。
12.1 关闭Connection
在使用完数据库连接后，需要将其关闭以释放资源。通常使用Connection对象的close()方法进行关闭。
import java.sql.*;
public class CloseConnectionExample {
public static void main(String[] args) {
String jdbcUrl = "jdbc:mysql://localhost:3306/mydb";
String username = "root";
String password = "password";
Connection conn = null;
try {
conn = DriverManager.getConnection(jdbcUrl, username, password);
// 执行数据库操作
} catch (SQLException e) {
e.printStackTrace();
} finally {
if (conn != null) {
try {
conn.close();
} catch (SQLException e) {
e.printStackTrace();
}
}
}
}
}
12.2 关闭Statement和ResultSet
执行SQL语句时，需要创建Statement对象，执行查询时还需要使用ResultSet对象来存储查询结果。在使用完毕后，需要关闭这些资源。
import java.sql.*;
public class CloseStatementAndResultSetExample {
public static void main(String[] args) {
String jdbcUrl = "jdbc:mysql://localhost:3306/mydb";
String username = "root";
String password = "password";
try (Connection conn = DriverManager.getConnection(jdbcUrl, username, password)) {
String sql = "SELECT * FROM students";
try (Statement stmt = conn.createStatement()) {
try (ResultSet rs = stmt.executeQuery(sql)) {
// 处理查询结果
}
}
} catch (SQLException e) {
e.printStackTrace();
}
}
}
12.3 使用try-with-resources简化资源关闭
在Java 7及以上版本中，我们可以使用try-with-resources来简化资源的关闭。使用try-with-resources后，不需要手动关闭资源，系统会自动在作用域结束时关闭资源。
import java.sql.*;
public class TryWithResourcesExample {
public static void main(String[] args) {
String jdbcUrl = "jdbc:mysql://localhost:3306/mydb";
String username = "root";
String password = "password";
try (Connection conn = DriverManager.getConnection(jdbcUrl, username, password);
Statement stmt = conn.createStatement();
ResultSet rs = stmt.executeQuery("SELECT * FROM students")) {
// 处理查询结果
} catch (SQLException e) {
e.printStackTrace();
}
}
}
12.4总结
在使用JDBC进行数据库操作时，及时关闭资源是十分重要的。通过关闭资源，我们可以释放数据库连接、Statement和ResultSet等资源，避免资源泄漏，保持系统的稳定性和性能。使用try-with-resources语法可以更加简洁地处理资源关闭，是推荐的做法。
13. JDBC新特性
JDBC在不断发展和演进，Java的版本更新也带来了一些新的JDBC特性。本节将介绍一些较新的JDBC特性，让你了解JDBC的发展趋势。
13.1 基于JDBC 4.1的自动加载驱动
在JDBC 4.1及以上的版本中，不再需要显式地加载数据库驱动。JDBC将自动根据classpath中的驱动类来加载相应的数据库驱动，无需调用Class.forName()方法。
import java.sql.*;
public class AutoLoadDriverExample {
public static void main(String[] args) {
String jdbcUrl = "jdbc:mysql://localhost:3306/mydb";
String username = "root";
String password = "password";
try (Connection conn = DriverManager.getConnection(jdbcUrl, username, password)) {
// 执行数据库操作
} catch (SQLException e) {
e.printStackTrace();
}
}
}
13.2 基于JDBC 4.2的try-with-resources改进
JDBC 4.2对try-with-resources进行了改进，支持在try-with-resources语句中捕获SQL异常。
import java.sql.*;
public class TryWithResourcesEnhancementExample {
public static void main(String[] args) {
String jdbcUrl = "jdbc:mysql://localhost:3306/mydb";
String username = "root";
String password = "password";
try (Connection conn = DriverManager.getConnection(jdbcUrl, username, password);
Statement stmt = conn.createStatement();
ResultSet rs = stmt.executeQuery("SELECT * FROM students")) {
// 处理查询结果
} catch (SQLException e) {
e.printStackTrace();
SQLWarning warning = e.getWarnings();
while (warning != null) {
System.out.println("SQL Warning: " + warning.getMessage());
warning = warning.getNextWarning();
}
}
}
}
13.3 使用DataSource
在JDBC中，我们可以使用DataSource来管理数据库连接，它提供了一种连接池的方式来管理连接，更加高效地处理数据库连接。
import javax.sql.DataSource;
import org.apache.commons.dbcp2.BasicDataSource;
public class DataSourceExample {
public static void main(String[] args) {
BasicDataSource dataSource = new BasicDataSource();
dataSource.setUrl("jdbc:mysql://localhost:3306/mydb");
dataSource.setUsername("root");
dataSource.setPassword("password");
try (Connection conn = dataSource.getConnection();
Statement stmt = conn.createStatement();
ResultSet rs = stmt.executeQuery("SELECT * FROM students")) {
// 处理查询结果
} catch (SQLException e) {
e.printStackTrace();
}
}
}
13.4 批处理操作的改进
JDBC 4.2引入了新的方法executeLargeBatch()和getLargeUpdateCount()来支持更大批量的SQL操作。
import java.sql.*;
public class BatchProcessingExample {
public static void main(String[] args) {
String jdbcUrl = "jdbc:mysql://localhost:3306/mydb";
String username = "root";
String password = "password";
try (Connection conn = DriverManager.getConnection(jdbcUrl, username, password);
Statement stmt = conn.createStatement()) {
conn.setAutoCommit(false);
stmt.addBatch("INSERT INTO students (name, age) VALUES ('Alice', 25)");
stmt.addBatch("INSERT INTO students (name, age) VALUES ('Bob', 30)");
int[] result = stmt.executeBatch();
conn.commit();
System.out.println("Number of rows affected: " + result.length);
} catch (SQLException e) {
e.printStackTrace();
}
}
}
13.5总结
JDBC不断更新，新的版本带来了许多便利的特性，如自动加载驱动、改进的try-with-resources、使用DataSource管理连接和批处理操作的改进。熟悉这些新特性，可以使我们更加高效地进行数据库操作，提高开发效率。
14. 实际项目中的JDBC应用
JDBC是Java程序连接和操作数据库的标准方式，它在实际项目中广泛应用于各种数据库操作。本节将介绍一些实际项目中常见的JDBC应用场景和示例代码。
14.1 数据库初始化
在实际项目中，通常需要在应用启动时对数据库进行初始化，例如创建表格、插入初始数据等。以下是一个简单的数据库初始化示例：
import java.sql.*;
public class DatabaseInitializer {
public static void main(String[] args) {
String jdbcUrl = "jdbc:mysql://localhost:3306/mydb";
String username = "root";
String password = "password";
try (Connection conn = DriverManager.getConnection(jdbcUrl, username, password);
Statement stmt = conn.createStatement()) {
// 创建表格
String createTableSQL = "CREATE TABLE students (id INT PRIMARY KEY AUTO_INCREMENT, name VARCHAR(50), age INT)";
stmt.execute(createTableSQL);
// 插入初始数据
String insertDataSQL = "INSERT INTO students (name, age) VALUES ('Alice', 25), ('Bob', 30)";
stmt.execute(insertDataSQL);
System.out.println("Database initialized successfully!");
} catch (SQLException e) {
e.printStackTrace();
}
}
}
14.2 数据库连接管理
在实际项目中，数据库连接的管理非常重要。一般情况下，我们会使用连接池来管理数据库连接，以减少连接的创建和销毁开销，提高性能。常见的连接池有HikariCP、Apache DBCP等。以下是使用HikariCP连接池的示例：
import com.zaxxer.hikari.HikariConfig;
import com.zaxxer.hikari.HikariDataSource;
import javax.sql.DataSource;
import java.sql.*;
public class ConnectionPoolExample {
public static void main(String[] args) {
HikariConfig config = new HikariConfig();
config.setJdbcUrl("jdbc:mysql://localhost:3306/mydb");
config.setUsername("root");
config.setPassword("password");
DataSource dataSource = new HikariDataSource(config);
try (Connection conn = dataSource.getConnection();
Statement stmt = conn.createStatement();
ResultSet rs = stmt.executeQuery("SELECT * FROM students")) {
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);
}
} catch (SQLException e) {
e.printStackTrace();
}
}
}
14.3 数据库事务管理
在实际项目中，涉及到涉及多个数据库操作时，为了保持数据的一致性和完整性，我们通常需要使用数据库事务。以下是一个简单的数据库事务管理示例：
import java.sql.*;
public class TransactionExample {
public static void main(String[] args) {
String jdbcUrl = "jdbc:mysql://localhost:3306/mydb";
String username = "root";
String password = "password";
try (Connection conn = DriverManager.getConnection(jdbcUrl, username, password);
Statement stmt = conn.createStatement()) {
conn.setAutoCommit(false);
// 更新操作1
String updateSQL1 = "UPDATE students SET age = age + 1 WHERE name = 'Alice'";
stmt.executeUpdate(updateSQL1);
// 更新操作2
String updateSQL2 = "UPDATE students SET age = age - 1 WHERE name = 'Bob'";
stmt.executeUpdate(updateSQL2);
// 提交事务
conn.commit();
System.out.println("Transaction completed successfully!");
} catch (SQLException e) {
e.printStackTrace();
}
}
}
14.4总结
在实际项目中，JDBC是数据库操作的重要工具，我们可以通过JDBC来进行数据库初始化、数据库连接管理、数据库事务管理等操作。在开发过程中，务必注意正确地处理数据库连接和事务，以保证数据库操作的稳定和高效。
2668
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
