引言

JDBC（Java Database Connectivity）是Java语言中用于连接和操作数据库的标准API。它提供了一套统一的接口，使得Java程序能够以一致的方式访问各种关系型数据库。无论你是Java初学者还是有经验的开发者，掌握JDBC都是进行数据库编程的基础。本手册将从基础概念开始，逐步深入到高级特性和最佳实践，帮助你全面掌握JDBC技术。

1. JDBC基础概念

1.1 什么是JDBC？

JDBC是Java平台的一部分，它定义了一组标准的API，用于执行SQL语句、处理结果集以及管理数据库连接。JDBC的核心优势在于其数据库无关性——通过使用不同的JDBC驱动程序，同一套Java代码可以连接到MySQL、Oracle、PostgreSQL等多种数据库。

1.2 JDBC架构

JDBC架构主要由以下组件构成：

  • JDBC API：Java标准库中提供的接口和类（位于java.sql和javax.sql包中）
  • JDBC驱动程序：由数据库厂商或第三方提供的具体实现，负责将JDBC调用转换为特定数据库的协议
  • 数据库：实际的数据存储系统

1.3 JDBC驱动类型

JDBC驱动程序分为四种类型：

  1. Type 1 (JDBC-ODBC桥)：通过ODBC连接数据库，已过时，不推荐使用
  2. Type 2 (本地API驱动)：部分Java代码+本地库，性能较好但依赖平台
  3. Type 3 (网络协议驱动)：纯Java，通过中间件连接数据库
  4. Type 4 (纯Java驱动)：直接使用数据库网络协议，纯Java实现，性能最佳，推荐使用

2. 环境准备与配置

2.1 添加JDBC驱动依赖

以Maven项目为例，添加MySQL驱动依赖：

<!-- pom.xml -->
<dependencies>
    <!-- MySQL Connector/J -->
    <dependency>
        <groupId>mysql</groupId>
        <artifactId>mysql-connector-java</artifactId>
        <version>8.0.33</version>
    </dependency>
    
    <!-- PostgreSQL驱动 -->
    <dependency>
        <groupId>org.postgresql</groupId>
        <artifactId>postgresql</artifactId>
        <version>42.6.0</version>
    </dependency>
    
    <!-- Oracle驱动（需要从Oracle官网下载） -->
    <dependency>
        <groupId>com.oracle.database.jdbc</groupId>
        <artifactId>ojdbc8</artifactId>
        <version>21.9.0.0</version>
    </dependency>
</dependencies>

2.2 数据库连接信息

创建配置文件database.properties：

# MySQL配置
db.url=jdbc:mysql://localhost:3306/mydatabase?useSSL=false&serverTimezone=UTC
db.username=root
db.password=yourpassword
db.driver=com.mysql.cj.jdbc.Driver

# PostgreSQL配置
# db.url=jdbc:postgresql://localhost:5432/mydatabase
# db.username=postgres
# db.password=yourpassword
# db.driver=org.postgresql.Driver

3. 基础操作：连接与查询

3.1 建立数据库连接

import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.SQLException;
import java.util.Properties;
import java.io.FileInputStream;
import java.io.IOException;

public class DatabaseConnector {
    
    public static Connection getConnection() throws SQLException, IOException {
        // 加载配置文件
        Properties props = new Properties();
        try (FileInputStream fis = new FileInputStream("database.properties")) {
            props.load(fis);
        }
        
        String url = props.getProperty("db.url");
        String username = props.getProperty("db.username");
        String password = props.getProperty("db.password");
        String driver = props.getProperty("db.driver");
        
        // 加载驱动（JDBC 4.0+可自动加载，但显式加载更安全）
        try {
            Class.forName(driver);
        } catch (ClassNotFoundException e) {
            throw new SQLException("JDBC驱动未找到: " + driver, e);
        }
        
        // 建立连接
        return DriverManager.getConnection(url, username, password);
    }
    
    public static void main(String[] args) {
        try (Connection conn = getConnection()) {
            System.out.println("数据库连接成功！");
            System.out.println("连接信息: " + conn.getMetaData().getURL());
        } catch (SQLException | IOException e) {
            System.err.println("连接失败: " + e.getMessage());
            e.printStackTrace();
        }
    }
}

3.2 执行查询操作

import java.sql.*;

public class BasicQueryExample {
    
    public static void main(String[] args) {
        String sql = "SELECT id, name, email FROM users WHERE age > ?";
        
        try (Connection conn = DatabaseConnector.getConnection();
             PreparedStatement stmt = conn.prepareStatement(sql)) {
            
            // 设置参数
            stmt.setInt(1, 18);
            
            // 执行查询
            try (ResultSet rs = stmt.executeQuery()) {
                System.out.println("查询结果:");
                System.out.println("ID\t姓名\t邮箱");
                System.out.println("----------------------------");
                
                // 遍历结果集
                while (rs.next()) {
                    int id = rs.getInt("id");
                    String name = rs.getString("name");
                    String email = rs.getString("email");
                    
                    System.out.printf("%d\t%s\t%s%n", id, name, email);
                }
            }
            
        } catch (SQLException e) {
            System.err.println("查询失败: " + e.getMessage());
            e.printStackTrace();
        }
    }
}

3.3 执行更新操作

import java.sql.*;

public class UpdateExample {
    
    public static void main(String[] args) {
        String sql = "UPDATE users SET email = ? WHERE id = ?";
        
        try (Connection conn = DatabaseConnector.getConnection();
             PreparedStatement stmt = conn.prepareStatement(sql)) {
            
            // 设置参数
            stmt.setString(1, "newemail@example.com");
            stmt.setInt(2, 101);
            
            // 执行更新
            int rowsAffected = stmt.executeUpdate();
            System.out.println("更新了 " + rowsAffected + " 行数据");
            
        } catch (SQLException e) {
            System.err.println("更新失败: " + e.getMessage());
            e.printStackTrace();
        }
    }
}

4. 核心组件详解

4.1 Connection接口

Connection对象代表与数据库的会话，主要方法包括：

public class ConnectionExample {
    
    public static void demonstrateConnection(Connection conn) throws SQLException {
        // 1. 创建Statement
        Statement stmt = conn.createStatement();
        
        // 2. 设置事务隔离级别
        conn.setTransactionIsolation(Connection.TRANSACTION_READ_COMMITTED);
        
        // 3. 手动控制事务
        conn.setAutoCommit(false); // 开始事务
        
        try {
            // 执行多个SQL操作
            stmt.executeUpdate("INSERT INTO users (name) VALUES ('Alice')");
            stmt.executeUpdate("INSERT INTO users (name) VALUES ('Bob')");
            
            // 提交事务
            conn.commit();
            System.out.println("事务提交成功");
            
        } catch (SQLException e) {
            // 回滚事务
            conn.rollback();
            System.err.println("事务回滚: " + e.getMessage());
        } finally {
            // 恢复自动提交
            conn.setAutoCommit(true);
            stmt.close();
        }
    }
}

4.2 Statement与PreparedStatement

Statement vs PreparedStatement对比：

特性 Statement PreparedStatement
SQL预编译 否 是
防SQL注入 否 是
性能 较低（每次执行都编译） 较高（预编译一次）
适用场景 静态SQL，无参数 动态SQL，带参数

PreparedStatement示例（防SQL注入）：

import java.sql.*;

public class PreparedStatementExample {
    
    public static void main(String[] args) {
        // 危险的Statement用法（易受SQL注入攻击）
        String userInput = "admin' OR '1'='1";
        String dangerousSQL = "SELECT * FROM users WHERE username = '" + userInput + "'";
        
        // 安全的PreparedStatement用法
        String safeSQL = "SELECT * FROM users WHERE username = ?";
        
        try (Connection conn = DatabaseConnector.getConnection();
             PreparedStatement stmt = conn.prepareStatement(safeSQL)) {
            
            stmt.setString(1, userInput);
            
            try (ResultSet rs = stmt.executeQuery()) {
                // 这将只查询username为"admin' OR '1'='1"的用户，而不是所有用户
                System.out.println("安全查询结果:");
                while (rs.next()) {
                    System.out.println("用户名: " + rs.getString("username"));
                }
            }
            
        } catch (SQLException e) {
            e.printStackTrace();
        }
    }
}

4.3 ResultSet接口

ResultSet提供对查询结果的访问，支持多种游标类型：

import java.sql.*;

public class ResultSetExample {
    
    public static void demonstrateResultSet(Connection conn) throws SQLException {
        // 1. 创建可滚动、可更新的ResultSet
        String sql = "SELECT id, name, salary FROM employees ORDER BY salary DESC";
        
        try (PreparedStatement stmt = conn.prepareStatement(
                sql, 
                ResultSet.TYPE_SCROLL_INSENSITIVE, 
                ResultSet.CONCUR_UPDATABLE)) {
            
            try (ResultSet rs = stmt.executeQuery()) {
                
                // 2. 导航结果集
                System.out.println("总记录数: " + rs.last()); // 移动到最后
                int totalRows = rs.getRow();
                System.out.println("总记录数: " + totalRows);
                
                rs.beforeFirst(); // 回到开头
                
                // 3. 遍历结果集
                while (rs.next()) {
                    int id = rs.getInt("id");
                    String name = rs.getString("name");
                    double salary = rs.getDouble("salary");
                    
                    System.out.printf("ID: %d, 姓名: %s, 薪资: %.2f%n", id, name, salary);
                    
                    // 4. 更新结果集（需要CONCUR_UPDATABLE）
                    if (salary < 5000) {
                        rs.updateDouble("salary", 5000);
                        rs.updateRow();
                    }
                }
                
                // 5. 获取元数据
                ResultSetMetaData meta = rs.getMetaData();
                System.out.println("\n列数: " + meta.getColumnCount());
                for (int i = 1; i <= meta.getColumnCount(); i++) {
                    System.out.printf("列%d: %s (%s)%n", 
                        i, meta.getColumnName(i), meta.getColumnTypeName(i));
                }
            }
        }
    }
}

5. 高级特性

5.1 事务管理

import java.sql.*;

public class TransactionExample {
    
    public static void transferMoney(Connection conn, int fromAccount, int toAccount, double amount) 
            throws SQLException {
        
        // 保存当前自动提交状态
        boolean originalAutoCommit = conn.getAutoCommit();
        
        try {
            // 开始事务
            conn.setAutoCommit(false);
            
            // 检查余额
            String checkBalance = "SELECT balance FROM accounts WHERE id = ?";
            try (PreparedStatement stmt = conn.prepareStatement(checkBalance)) {
                stmt.setInt(1, fromAccount);
                try (ResultSet rs = stmt.executeQuery()) {
                    if (rs.next()) {
                        double balance = rs.getDouble("balance");
                        if (balance < amount) {
                            throw new SQLException("余额不足");
                        }
                    }
                }
            }
            
            // 扣款
            String deductSQL = "UPDATE accounts SET balance = balance - ? WHERE id = ?";
            try (PreparedStatement stmt = conn.prepareStatement(deductSQL)) {
                stmt.setDouble(1, amount);
                stmt.setInt(2, fromAccount);
                int updated = stmt.executeUpdate();
                if (updated != 1) {
                    throw new SQLException("扣款失败");
                }
            }
            
            // 存款
            String depositSQL = "UPDATE accounts SET balance = balance + ? WHERE id = ?";
            try (PreparedStatement stmt = conn.prepareStatement(depositSQL)) {
                stmt.setDouble(1, amount);
                stmt.setInt(2, toAccount);
                int updated = stmt.executeUpdate();
                if (updated != 1) {
                    throw new SQLException("存款失败");
                }
            }
            
            // 提交事务
            conn.commit();
            System.out.println("转账成功");
            
        } catch (SQLException e) {
            // 回滚事务
            conn.rollback();
            System.err.println("转账失败，已回滚: " + e.getMessage());
            throw e;
        } finally {
            // 恢复自动提交状态
            conn.setAutoCommit(originalAutoCommit);
        }
    }
    
    public static void main(String[] args) {
        try (Connection conn = DatabaseConnector.getConnection()) {
            // 执行转账
            transferMoney(conn, 1001, 1002, 100.0);
        } catch (SQLException e) {
            e.printStackTrace();
        }
    }
}

5.2 批处理操作

import java.sql.*;

public class BatchExample {
    
    public static void main(String[] args) {
        String sql = "INSERT INTO users (name, email) VALUES (?, ?)";
        
        try (Connection conn = DatabaseConnector.getConnection();
             PreparedStatement stmt = conn.prepareStatement(sql)) {
            
            // 禁用自动提交以提高性能
            conn.setAutoCommit(false);
            
            // 添加批处理
            stmt.setString(1, "Alice");
            stmt.setString(2, "alice@example.com");
            stmt.addBatch();
            
            stmt.setString(1, "Bob");
            stmt.setString(2, "bob@example.com");
            stmt.addBatch();
            
            stmt.setString(1, "Charlie");
            stmt.setString(2, "charlie@example.com");
            stmt.addBatch();
            
            // 执行批处理
            int[] results = stmt.executeBatch();
            
            // 提交事务
            conn.commit();
            
            System.out.println("批处理结果:");
            for (int i = 0; i < results.length; i++) {
                System.out.printf("第%d条: %d 行受影响%n", i+1, results[i]);
            }
            
        } catch (SQLException e) {
            System.err.println("批处理失败: " + e.getMessage());
            e.printStackTrace();
        }
    }
}

5.3 连接池管理

使用HikariCP连接池（推荐）：

<!-- Maven依赖 -->
<dependency>
    <groupId>com.zaxxer</groupId>
    <artifactId>HikariCP</artifactId>
    <version>5.0.1</version>
</dependency>

import com.zaxxer.hikari.HikariConfig;
import com.zaxxer.hikari.HikariDataSource;
import java.sql.Connection;
import java.sql.SQLException;
import java.util.Properties;

public class ConnectionPoolExample {
    
    private static HikariDataSource dataSource;
    
    static {
        try {
            // 加载配置
            Properties props = new Properties();
            props.load(ConnectionPoolExample.class.getResourceAsStream("/database.properties"));
            
            // 配置连接池
            HikariConfig config = new HikariConfig();
            config.setJdbcUrl(props.getProperty("db.url"));
            config.setUsername(props.getProperty("db.username"));
            config.setPassword(props.getProperty("db.password"));
            config.setDriverClassName(props.getProperty("db.driver"));
            
            // 连接池配置
            config.setMaximumPoolSize(10);          // 最大连接数
            config.setMinimumIdle(5);               // 最小空闲连接
            config.setConnectionTimeout(30000);     // 连接超时30秒
            config.setIdleTimeout(600000);          // 空闲超时10分钟
            config.setMaxLifetime(1800000);         // 连接最大存活时间30分钟
            config.setLeakDetectionThreshold(2000); // 泄漏检测阈值2秒
            
            // 创建数据源
            dataSource = new HikariDataSource(config);
            
        } catch (Exception e) {
            throw new RuntimeException("初始化连接池失败", e);
        }
    }
    
    public static Connection getConnection() throws SQLException {
        return dataSource.getConnection();
    }
    
    public static void close() {
        if (dataSource != null && !dataSource.isClosed()) {
            dataSource.close();
        }
    }
    
    public static void main(String[] args) {
        try (Connection conn = getConnection()) {
            System.out.println("从连接池获取连接成功");
            System.out.println("连接池状态: " + dataSource.getHikariPoolMXBean().getTotalConnections());
        } catch (SQLException e) {
            e.printStackTrace();
        } finally {
            close();
        }
    }
}

6. 最佳实践与性能优化

6.1 资源管理

使用try-with-resources自动关闭资源：

// 推荐写法
try (Connection conn = DatabaseConnector.getConnection();
     PreparedStatement stmt = conn.prepareStatement(sql);
     ResultSet rs = stmt.executeQuery()) {
    
    // 处理结果
    while (rs.next()) {
        // ...
    }
    
} catch (SQLException e) {
    // 异常处理
}

6.2 防止SQL注入

永远不要使用字符串拼接SQL：

// 错误示例（危险！）
String userInput = "admin' OR '1'='1";
String sql = "SELECT * FROM users WHERE username = '" + userInput + "'";

// 正确示例（安全）
String sql = "SELECT * FROM users WHERE username = ?";
try (PreparedStatement stmt = conn.prepareStatement(sql)) {
    stmt.setString(1, userInput);
    // ...
}

6.3 性能优化技巧

  1. 使用PreparedStatement预编译
  2. 合理使用批处理
  3. 控制事务大小
  4. 使用连接池
  5. 优化SQL查询
public class PerformanceOptimization {
    
    // 优化1：使用PreparedStatement
    public void optimizedQuery(Connection conn, String name) throws SQLException {
        String sql = "SELECT * FROM users WHERE name = ?";
        try (PreparedStatement stmt = conn.prepareStatement(sql)) {
            stmt.setString(1, name);
            // ...
        }
    }
    
    // 优化2：使用批处理
    public void batchInsert(Connection conn, List<User> users) throws SQLException {
        String sql = "INSERT INTO users (name, email) VALUES (?, ?)";
        try (PreparedStatement stmt = conn.prepareStatement(sql)) {
            conn.setAutoCommit(false);
            
            for (User user : users) {
                stmt.setString(1, user.getName());
                stmt.setString(2, user.getEmail());
                stmt.addBatch();
            }
            
            stmt.executeBatch();
            conn.commit();
        }
    }
    
    // 优化3：使用连接池
    public void useConnectionPool() {
        // 使用HikariCP等连接池
    }
}

7. 异常处理

7.1 JDBC异常层次结构

java.lang.Exception
└── java.sql.SQLException
    ├── java.sql.SQLWarning
    ├── java.sql.BatchUpdateException
    ├── java.sql.SQLRecoverableException
    ├── java.sql.SQLNonTransientException
    └── java.sql.SQLTransientException

7.2 异常处理示例

import java.sql.*;

public class ExceptionHandlingExample {
    
    public static void main(String[] args) {
        try (Connection conn = DatabaseConnector.getConnection()) {
            // 执行可能抛出异常的操作
            executeQuery(conn);
            
        } catch (SQLException e) {
            // 处理SQL异常
            handleSQLException(e);
        } catch (Exception e) {
            // 处理其他异常
            System.err.println("未知错误: " + e.getMessage());
        }
    }
    
    private static void executeQuery(Connection conn) throws SQLException {
        String sql = "SELECT * FROM non_existent_table";
        try (Statement stmt = conn.createStatement();
             ResultSet rs = stmt.executeQuery(sql)) {
            // ...
        }
    }
    
    private static void handleSQLException(SQLException e) {
        System.err.println("SQL错误: " + e.getMessage());
        System.err.println("SQL状态码: " + e.getSQLState());
        System.err.println("错误码: " + e.getErrorCode());
        
        // 处理特定错误
        if (e.getSQLState().startsWith("42")) {
            System.err.println("语法错误或表不存在");
        } else if (e.getSQLState().startsWith("23")) {
            System.err.println("完整性约束违反");
        }
        
        // 打印完整堆栈
        e.printStackTrace();
    }
}

8. 实际项目应用示例

8.1 用户管理系统

// User.java - 实体类
public class User {
    private int id;
    private String name;
    private String email;
    private int age;
    
    // 构造函数、getter/setter省略
}

// UserDAO.java - 数据访问对象
import java.sql.*;
import java.util.ArrayList;
import java.util.List;

public class UserDAO {
    
    private ConnectionPoolExample connectionPool;
    
    public UserDAO() {
        this.connectionPool = new ConnectionPoolExample();
    }
    
    // 创建用户
    public boolean createUser(User user) throws SQLException {
        String sql = "INSERT INTO users (name, email, age) VALUES (?, ?, ?)";
        
        try (Connection conn = connectionPool.getConnection();
             PreparedStatement stmt = conn.prepareStatement(sql)) {
            
            stmt.setString(1, user.getName());
            stmt.setString(2, user.getEmail());
            stmt.setInt(3, user.getAge());
            
            int rows = stmt.executeUpdate();
            return rows > 0;
        }
    }
    
    // 查询用户
    public User getUserById(int id) throws SQLException {
        String sql = "SELECT * FROM users WHERE id = ?";
        
        try (Connection conn = connectionPool.getConnection();
             PreparedStatement stmt = conn.prepareStatement(sql)) {
            
            stmt.setInt(1, id);
            
            try (ResultSet rs = stmt.executeQuery()) {
                if (rs.next()) {
                    User user = new User();
                    user.setId(rs.getInt("id"));
                    user.setName(rs.getString("name"));
                    user.setEmail(rs.getString("email"));
                    user.setAge(rs.getInt("age"));
                    return user;
                }
            }
        }
        return null;
    }
    
    // 查询所有用户
    public List<User> getAllUsers() throws SQLException {
        List<User> users = new ArrayList<>();
        String sql = "SELECT * FROM users ORDER BY id";
        
        try (Connection conn = connectionPool.getConnection();
             Statement stmt = conn.createStatement();
             ResultSet rs = stmt.executeQuery(sql)) {
            
            while (rs.next()) {
                User user = new User();
                user.setId(rs.getInt("id"));
                user.setName(rs.getString("name"));
                user.setEmail(rs.getString("email"));
                user.setAge(rs.getInt("age"));
                users.add(user);
            }
        }
        return users;
    }
    
    // 更新用户
    public boolean updateUser(User user) throws SQLException {
        String sql = "UPDATE users SET name = ?, email = ?, age = ? WHERE id = ?";
        
        try (Connection conn = connectionPool.getConnection();
             PreparedStatement stmt = conn.prepareStatement(sql)) {
            
            stmt.setString(1, user.getName());
            stmt.setString(2, user.getEmail());
            stmt.setInt(3, user.getAge());
            stmt.setInt(4, user.getId());
            
            int rows = stmt.executeUpdate();
            return rows > 0;
        }
    }
    
    // 删除用户
    public boolean deleteUser(int id) throws SQLException {
        String sql = "DELETE FROM users WHERE id = ?";
        
        try (Connection conn = connectionPool.getConnection();
             PreparedStatement stmt = conn.prepareStatement(sql)) {
            
            stmt.setInt(1, id);
            
            int rows = stmt.executeUpdate();
            return rows > 0;
        }
    }
}

// Main.java - 测试类
import java.sql.SQLException;
import java.util.List;

public class Main {
    
    public static void main(String[] args) {
        UserDAO userDAO = new UserDAO();
        
        try {
            // 创建用户
            User newUser = new User();
            newUser.setName("张三");
            newUser.setEmail("zhangsan@example.com");
            newUser.setAge(25);
            
            if (userDAO.createUser(newUser)) {
                System.out.println("用户创建成功");
            }
            
            // 查询用户
            User user = userDAO.getUserById(1);
            if (user != null) {
                System.out.println("查询到用户: " + user.getName());
            }
            
            // 查询所有用户
            List<User> allUsers = userDAO.getAllUsers();
            System.out.println("总用户数: " + allUsers.size());
            
            // 更新用户
            user.setAge(26);
            if (userDAO.updateUser(user)) {
                System.out.println("用户更新成功");
            }
            
            // 删除用户
            if (userDAO.deleteUser(1)) {
                System.out.println("用户删除成功");
            }
            
        } catch (SQLException e) {
            System.err.println("数据库操作失败: " + e.getMessage());
            e.printStackTrace();
        }
    }
}

9. 现代JDBC扩展

9.1 使用JDBC 4.0+特性

import java.sql.*;
import java.util.ServiceLoader;

public class JDBC4Features {
    
    public static void demonstrateJDBC4() throws SQLException {
        // 1. 自动加载驱动（JDBC 4.0+）
        // 不需要显式调用 Class.forName()
        
        // 2. 可关闭的资源（try-with-resources）
        try (Connection conn = DriverManager.getConnection("jdbc:mysql://localhost/test", "user", "pass");
             Statement stmt = conn.createStatement();
             ResultSet rs = stmt.executeQuery("SELECT 1")) {
            
            // 3. RowId支持
            if (conn.getMetaData().supportsRowId()) {
                System.out.println("数据库支持RowId");
            }
            
            // 4. SQLXML支持
            if (conn.getMetaData().supportsSQLXML()) {
                System.out.println("数据库支持SQLXML");
            }
            
            // 5. 服务提供者机制
            ServiceLoader<Driver> drivers = ServiceLoader.load(Driver.class);
            for (Driver driver : drivers) {
                System.out.println("已加载驱动: " + driver.getClass().getName());
            }
        }
    }
}

9.2 与ORM框架的对比

特性 JDBC ORM框架 (Hibernate/JPA)
抽象级别 低（直接操作SQL） 高（操作对象）
学习曲线 平缓 较陡
性能 高（直接控制） 中等（有开销）
灵活性 高（可写任意SQL） 中等（受框架限制）
开发效率 低（需要写SQL） 高（自动映射）
适用场景 简单应用、性能敏感、复杂SQL 复杂业务逻辑、快速开发

10. 学习路径建议

10.1 初学者阶段（1-2周）

  1. 理解JDBC基本概念和架构
  2. 掌握Connection、Statement、PreparedStatement、ResultSet的使用
  3. 学会基本的CRUD操作
  4. 理解try-with-resources资源管理

10.2 进阶阶段（2-3周）

  1. 深入理解事务管理
  2. 掌握批处理操作
  3. 学习连接池配置和使用
  4. 理解JDBC异常处理机制

10.3 高级阶段（1-2周）

  1. 性能优化技巧
  2. 与ORM框架的对比和选择
  3. 实际项目中的应用模式
  4. JDBC 4.0+新特性

10.4 推荐学习资源

  1. 官方文档：

    • Oracle JDBC官方文档
    • MySQL Connector/J文档

  2. 书籍推荐：

    • 《JDBC Database Programming with J2EE》
    • 《Java Database Programming》

  3. 在线教程：

    • Baeldung JDBC教程
    • JavaTpoint JDBC教程

  4. 实践项目：

    • 简单的用户管理系统
    • 图书管理系统
    • 在线商城后台

11. 常见问题与解决方案

11.1 连接超时问题

// 在连接URL中添加超时参数
String url = "jdbc:mysql://localhost:3306/mydb?connectTimeout=5000&socketTimeout=30000";

11.2 内存泄漏问题

// 确保关闭所有资源
// 使用try-with-resources或finally块
try (Connection conn = ...; Statement stmt = ...) {
    // 操作
} catch (SQLException e) {
    // 异常处理
}

11.3 性能问题

// 1. 使用PreparedStatement
// 2. 使用批处理
// 3. 使用连接池
// 4. 优化SQL查询
// 5. 合理使用索引

12. 总结

JDBC是Java数据库编程的基石。通过本手册的学习，你应该能够：

  1. 理解JDBC架构：掌握JDBC的核心组件和工作原理
  2. 掌握基础操作：熟练进行数据库连接、查询、更新操作
  3. 使用高级特性：管理事务、批处理、连接池等
  4. 编写健壮代码：正确处理异常、管理资源、防止SQL注入
  5. 优化性能：应用最佳实践提升应用性能

记住，JDBC是底层API，虽然学习曲线平缓，但需要更多的手动操作。在实际项目中，可以根据需求选择是否使用ORM框架（如Hibernate、MyBatis）来简化开发。无论选择哪种方式，深入理解JDBC都将帮助你更好地处理数据库相关问题。

下一步建议：

  1. 选择一个数据库（如MySQL）进行实践
  2. 创建一个简单的CRUD应用
  3. 尝试使用连接池优化性能
  4. 学习与Spring框架的集成（Spring JDBC）
  5. 探索更高级的数据库技术（如NoSQL、分布式数据库）

通过持续实践和深入学习，你将能够熟练掌握JDBC技术，并在实际项目中游刃有余地处理各种数据库需求。