JDBC基础与MySQL连接实战指南

1. JDBC基础概念与工作原理

1.1 什么是JDBC？

JDBC（Java Database Connectivity）是Java语言中用于执行SQL语句的API规范，它为Java开发人员提供了一套标准的数据库访问接口。简单来说，JDBC就是Java程序与各种关系型数据库进行通信的桥梁。

JDBC API主要由两个包组成：

• java.sql包：包含核心JDBC功能
• javax.sql包：提供更高级的数据库访问特性

在实际开发中，我们通常使用JDBC来完成以下操作：

• 建立与数据库的连接
• 发送SQL语句
• 处理SQL执行结果
• 管理事务
• 处理数据库元数据

JDBC的设计遵循了"面向接口编程"的原则，这意味着我们编写的代码只依赖于JDBC接口，而不依赖于具体的数据库实现。这种设计使得我们的应用程序可以轻松切换不同的数据库系统，只需更换对应的JDBC驱动即可。

1.2 JDBC架构解析

JDBC采用分层架构设计，主要包含以下四个关键组件：

1. 应用程序层：开发者编写的Java程序代码
2. JDBC API层：java.sql和javax.sql包提供的接口
3. JDBC驱动管理层：DriverManager类负责加载和管理驱动
4. 数据库驱动层：各数据库厂商提供的具体实现

这种分层设计带来了几个显著优势：

• 标准化：统一了不同数据库的访问方式
• 可移植性：代码不依赖于特定数据库
• 灵活性：可以方便地更换底层数据库

1.3 JDBC驱动类型详解

JDBC规范定义了四种类型的驱动，每种类型有不同的实现方式和适用场景：

目前最常用的是Type 4驱动，它完全用Java实现，不依赖任何本地代码，具有最好的跨平台性和性能。MySQL Connector/J就是典型的Type 4驱动。

2. JDBC连接MySQL实战指南

2.1 环境准备与驱动安装

2.1.1 驱动版本选择

在开始编码前，我们需要获取与MySQL版本匹配的JDBC驱动。版本对应关系如下：

• MySQL 5.7.x → 选择5.1.x版本的驱动
• MySQL 8.0.x → 选择8.0.x版本的驱动

驱动版本与数据库版本的大版本号必须一致，小版本号可以不同。例如MySQL 5.7.32可以使用5.1.49的驱动，但不能使用8.0.25的驱动。

2.1.2 驱动获取方式

有三种主要方式获取MySQL JDBC驱动：

1. 官网下载：

   • 访问MySQL官网下载页面
   • 搜索"Connector/J"
   • 选择对应版本下载

2. Maven中央仓库：

   xml复制<!-- MySQL 5.7 -->
   <dependency>
       <groupId>mysql</groupId>
       <artifactId>mysql-connector-java</artifactId>
       <version>5.1.49</version>
   </dependency>
   
   <!-- MySQL 8.0 -->
   <dependency>
       <groupId>mysql</groupId>
       <artifactId>mysql-connector-java</artifactId>
       <version>8.0.25</version>
   </dependency>
   

3. Gradle：

   gradle复制// MySQL 5.7
   implementation 'mysql:mysql-connector-java:5.1.49'
   
   // MySQL 8.0
   implementation 'mysql:mysql-connector-java:8.0.25'
   

2.1.3 项目配置

如果手动下载了jar包，需要将其添加到项目的classpath中：

1. 在项目中创建lib目录
2. 将mysql-connector-java-x.x.x.jar放入该目录
3. 右键jar包 → Add as Library

2.2 建立数据库连接

2.2.1 连接URL详解

JDBC连接MySQL的URL格式如下：

code复制jdbc:mysql://[host][:port]/[database][?参数1=值1&参数2=值2...]

常见参数说明：

• characterEncoding：指定字符编码，通常设为utf8
• useSSL：是否使用SSL加密连接，开发环境可设为false
• serverTimezone：设置时区，建议设为Asia/Shanghai
• autoReconnect：连接断开后是否自动重连
• allowPublicKeyRetrieval：MySQL 8.0需要设置为true

示例URL：

java复制String url = "jdbc:mysql://localhost:3306/test?characterEncoding=utf8&useSSL=false&serverTimezone=Asia/Shanghai";

2.2.2 两种连接方式对比

JDBC提供了两种建立连接的方式：

1. DriverManager方式：

   java复制Class.forName("com.mysql.jdbc.Driver");
   Connection conn = DriverManager.getConnection(url, username, password);
   

2. DataSource方式（推荐）：

   java复制MysqlDataSource dataSource = new MysqlDataSource();
   dataSource.setURL(url);
   dataSource.setUser(username);
   dataSource.setPassword(password);
   Connection conn = dataSource.getConnection();
   

两种方式的区别：

生产环境强烈建议使用DataSource方式，因为它支持连接池，可以显著提高性能。常见的连接池实现有HikariCP、Druid等。

2.3 执行SQL语句

2.3.1 Statement与PreparedStatement

JDBC提供了三种执行SQL的接口：

1. Statement：

   • 最基本的接口
   • 直接执行静态SQL
   • 存在SQL注入风险

2. PreparedStatement（推荐）：

   • 预编译SQL语句
   • 使用参数占位符(?)
   • 防止SQL注入
   • 性能更好

3. CallableStatement：

   • 用于调用存储过程
   • 继承自PreparedStatement

2.3.2 CRUD操作示例

插入数据：

java复制String sql = "INSERT INTO users(id, name, age) VALUES(?, ?, ?)";
PreparedStatement pstmt = conn.prepareStatement(sql);
pstmt.setInt(1, 1);
pstmt.setString(2, "张三");
pstmt.setInt(3, 25);
int affectedRows = pstmt.executeUpdate();

查询数据：

java复制String sql = "SELECT * FROM users WHERE age > ?";
PreparedStatement pstmt = conn.prepareStatement(sql);
pstmt.setInt(1, 20);
ResultSet rs = pstmt.executeQuery();
while(rs.next()) {
    int id = rs.getInt("id");
    String name = rs.getString("name");
    int age = rs.getInt("age");
    System.out.println(id + ", " + name + ", " + age);
}

更新数据：

java复制String sql = "UPDATE users SET age = ? WHERE id = ?";
PreparedStatement pstmt = conn.prepareStatement(sql);
pstmt.setInt(1, 26);
pstmt.setInt(2, 1);
int affectedRows = pstmt.executeUpdate();

删除数据：

java复制String sql = "DELETE FROM users WHERE id = ?";
PreparedStatement pstmt = conn.prepareStatement(sql);
pstmt.setInt(1, 1);
int affectedRows = pstmt.executeUpdate();

2.3.3 批处理操作

当需要执行大量SQL时，使用批处理可以显著提高性能：

java复制String sql = "INSERT INTO users(name, age) VALUES(?, ?)";
PreparedStatement pstmt = conn.prepareStatement(sql);

for(int i=0; i<1000; i++) {
    pstmt.setString(1, "user" + i);
    pstmt.setInt(2, i % 50 + 18);
    pstmt.addBatch();  // 添加到批处理
    
    if(i % 100 == 0) { // 每100条执行一次
        pstmt.executeBatch();
    }
}

pstmt.executeBatch();  // 执行剩余的
conn.commit();         // 提交事务

3. 高级特性与最佳实践

3.1 事务管理

JDBC默认是自动提交模式，每条SQL作为一个独立事务执行。要手动控制事务：

java复制try {
    conn.setAutoCommit(false); // 关闭自动提交
    
    // 执行多个SQL操作
    updateAccount(conn, "A", -100);
    updateAccount(conn, "B", 100);
    
    conn.commit(); // 提交事务
} catch(SQLException e) {
    conn.rollback(); // 回滚事务
    e.printStackTrace();
} finally {
    conn.setAutoCommit(true); // 恢复自动提交
}

事务隔离级别：

java复制// 设置隔离级别
conn.setTransactionIsolation(Connection.TRANSACTION_READ_COMMITTED);

// 获取当前隔离级别
int level = conn.getTransactionIsolation();

3.2 连接池配置

生产环境建议使用连接池，以下是HikariCP的配置示例：

java复制HikariConfig config = new HikariConfig();
config.setJdbcUrl("jdbc:mysql://localhost:3306/test");
config.setUsername("root");
config.setPassword("password");
config.addDataSourceProperty("cachePrepStmts", "true");
config.addDataSourceProperty("prepStmtCacheSize", "250");
config.addDataSourceProperty("prepStmtCacheSqlLimit", "2048");

HikariDataSource ds = new HikariDataSource(config);

关键配置参数：

• maximumPoolSize：最大连接数（推荐10-20）
• minimumIdle：最小空闲连接
• connectionTimeout：连接超时时间
• idleTimeout：空闲连接超时时间
• maxLifetime：连接最大生命周期

3.3 资源管理与异常处理

正确的资源管理方式：

java复制// Java 7+ try-with-resources写法
try (Connection conn = dataSource.getConnection();
     PreparedStatement pstmt = conn.prepareStatement(sql);
     ResultSet rs = pstmt.executeQuery()) {
     
    while(rs.next()) {
        // 处理结果
    }
} catch(SQLException e) {
    // 处理异常
}

常见SQL异常处理：

• SQLException：基础异常
• SQLTimeoutException：执行超时
• SQLTransientException：可重试的临时异常
• SQLNonTransientException：不可重试的异常

3.4 性能优化技巧

1. 使用PreparedStatement：

   • 避免SQL注入
   • 利用预编译提高性能
   • 便于批处理操作

2. 合理设置FetchSize：

   java复制stmt.setFetchSize(100); // 每次从数据库获取100条记录
   

3. 使用连接池：

   • 减少连接创建开销
   • 合理控制连接数

4. 关闭自动提交：

   • 批量操作时关闭自动提交
   • 减少事务开销

5. 合理使用批处理：

   • 大量插入/更新时使用addBatch()
   • 适当设置批处理大小

4. 常见问题与解决方案

4.1 连接问题排查

问题1：连接超时

• 检查网络是否通畅
• 检查MySQL服务是否运行
• 检查连接URL中的主机名和端口
• 增加连接超时时间：&connectTimeout=5000

问题2：认证失败

• 检查用户名和密码
• MySQL 8.0可能需要设置&allowPublicKeyRetrieval=true

问题3：时区错误

• 添加参数：&serverTimezone=Asia/Shanghai
• 或者在MySQL中设置全局时区

4.2 SQL执行问题

问题1：SQL语法错误

• 检查SQL语句是否正确
• 在MySQL客户端中测试SQL
• 注意不同MySQL版本的语法差异

问题2：参数类型不匹配

• 检查setXXX方法的类型是否与列类型匹配
• 特别注意日期/时间类型的处理

问题3：主键冲突

• 插入前先查询是否存在
• 使用ON DUPLICATE KEY UPDATE语法
• 或者使用REPLACE INTO替代INSERT

4.3 性能问题优化

问题1：查询慢

• 添加合适的索引
• 优化SQL语句
• 减少返回的列数
• 使用分页查询

问题2：连接泄漏

• 确保所有Connection、Statement、ResultSet都被关闭
• 使用try-with-resources语法
• 监控连接池状态

问题3：内存溢出

• 处理大结果集时使用流式查询
• 设置合理的FetchSize
• 及时关闭不再使用的资源

5. 完整示例代码

5.1 基础CRUD实现

java复制public class JdbcCrudExample {
    private static final String URL = "jdbc:mysql://localhost:3306/test?useSSL=false&characterEncoding=utf8&serverTimezone=Asia/Shanghai";
    private static final String USER = "root";
    private static final String PASSWORD = "123456";

    public static void main(String[] args) {
        // 初始化数据源
        MysqlDataSource dataSource = new MysqlDataSource();
        dataSource.setURL(URL);
        dataSource.setUser(USER);
        dataSource.setPassword(PASSWORD);

        // 测试CRUD操作
        try (Connection conn = dataSource.getConnection()) {
            // 创建表
            createTable(conn);
            
            // 插入数据
            insertUser(conn, 1, "张三", 25);
            insertUser(conn, 2, "李四", 30);
            
            // 查询数据
            List<User> users = findAllUsers(conn);
            users.forEach(System.out::println);
            
            // 更新数据
            updateUserAge(conn, 1, 26);
            
            // 删除数据
            deleteUser(conn, 2);
        } catch (SQLException e) {
            e.printStackTrace();
        }
    }

    private static void createTable(Connection conn) throws SQLException {
        String sql = "CREATE TABLE IF NOT EXISTS users (" +
                     "id INT PRIMARY KEY, " +
                     "name VARCHAR(50) NOT NULL, " +
                     "age INT)";
        try (Statement stmt = conn.createStatement()) {
            stmt.execute(sql);
        }
    }

    private static void insertUser(Connection conn, int id, String name, int age) throws SQLException {
        String sql = "INSERT INTO users(id, name, age) VALUES(?, ?, ?)";
        try (PreparedStatement pstmt = conn.prepareStatement(sql)) {
            pstmt.setInt(1, id);
            pstmt.setString(2, name);
            pstmt.setInt(3, age);
            pstmt.executeUpdate();
        }
    }

    private static List<User> findAllUsers(Connection conn) throws SQLException {
        List<User> users = new ArrayList<>();
        String sql = "SELECT * FROM users";
        try (PreparedStatement pstmt = conn.prepareStatement(sql);
             ResultSet rs = pstmt.executeQuery()) {
            while (rs.next()) {
                users.add(new User(
                    rs.getInt("id"),
                    rs.getString("name"),
                    rs.getInt("age")
                ));
            }
        }
        return users;
    }

    private static void updateUserAge(Connection conn, int id, int newAge) throws SQLException {
        String sql = "UPDATE users SET age = ? WHERE id = ?";
        try (PreparedStatement pstmt = conn.prepareStatement(sql)) {
            pstmt.setInt(1, newAge);
            pstmt.setInt(2, id);
            pstmt.executeUpdate();
        }
    }

    private static void deleteUser(Connection conn, int id) throws SQLException {
        String sql = "DELETE FROM users WHERE id = ?";
        try (PreparedStatement pstmt = conn.prepareStatement(sql)) {
            pstmt.setInt(1, id);
            pstmt.executeUpdate();
        }
    }
}

class User {
    private int id;
    private String name;
    private int age;

    // 构造方法、getter、setter、toString等
}

5.2 事务处理示例

java复制public class JdbcTransactionExample {
    public static void transferMoney(DataSource dataSource, String from, String to, int amount) {
        Connection conn = null;
        try {
            conn = dataSource.getConnection();
            conn.setAutoCommit(false); // 开始事务
            
            // 扣款
            withdraw(conn, from, amount);
            
            // 存款
            deposit(conn, to, amount);
            
            conn.commit(); // 提交事务
        } catch (SQLException e) {
            if (conn != null) {
                try {
                    conn.rollback(); // 回滚事务
                } catch (SQLException ex) {
                    ex.printStackTrace();
                }
            }
            e.printStackTrace();
        } finally {
            if (conn != null) {
                try {
                    conn.setAutoCommit(true); // 恢复自动提交
                    conn.close();
                } catch (SQLException e) {
                    e.printStackTrace();
                }
            }
        }
    }

    private static void withdraw(Connection conn, String account, int amount) throws SQLException {
        String sql = "UPDATE accounts SET balance = balance - ? WHERE account_no = ? AND balance >= ?";
        try (PreparedStatement pstmt = conn.prepareStatement(sql)) {
            pstmt.setInt(1, amount);
            pstmt.setString(2, account);
            pstmt.setInt(3, amount);
            int rows = pstmt.executeUpdate();
            if (rows == 0) {
                throw new SQLException("扣款失败，余额不足或账户不存在");
            }
        }
    }

    private static void deposit(Connection conn, String account, int amount) throws SQLException {
        String sql = "UPDATE accounts SET balance = balance + ? WHERE account_no = ?";
        try (PreparedStatement pstmt = conn.prepareStatement(sql)) {
            pstmt.setInt(1, amount);
            pstmt.setString(2, account);
            pstmt.executeUpdate();
        }
    }
}

5.3 使用连接池的完整示例

java复制public class JdbcConnectionPoolExample {
    private static HikariDataSource dataSource;

    static {
        HikariConfig config = new HikariConfig();
        config.setJdbcUrl("jdbc:mysql://localhost:3306/test");
        config.setUsername("root");
        config.setPassword("123456");
        config.setMaximumPoolSize(10);
        config.setMinimumIdle(5);
        config.addDataSourceProperty("cachePrepStmts", "true");
        config.addDataSourceProperty("prepStmtCacheSize", "250");
        config.addDataSourceProperty("prepStmtCacheSqlLimit", "2048");
        
        dataSource = new HikariDataSource(config);
    }

    public static void main(String[] args) {
        // 使用连接池执行查询
        String sql = "SELECT * FROM users WHERE age > ?";
        try (Connection conn = dataSource.getConnection();
             PreparedStatement pstmt = conn.prepareStatement(sql)) {
            
            pstmt.setInt(1, 20);
            try (ResultSet rs = pstmt.executeQuery()) {
                while (rs.next()) {
                    System.out.println(rs.getInt("id") + ", " + 
                                     rs.getString("name") + ", " + 
                                     rs.getInt("age"));
                }
            }
        } catch (SQLException e) {
            e.printStackTrace();
        }
    }
}

6. 实际开发中的经验分享

6.1 封装JDBC工具类

在实际项目中，我们通常会封装一个JDBC工具类来简化操作：

java复制public class JdbcUtils {
    private static DataSource dataSource;
    
    static {
        // 初始化数据源
        MysqlDataSource ds = new MysqlDataSource();
        ds.setURL("jdbc:mysql://localhost:3306/test");
        ds.setUser("root");
        ds.setPassword("123456");
        dataSource = ds;
    }
    
    public static Connection getConnection() throws SQLException {
        return dataSource.getConnection();
    }
    
    public static void close(Connection conn, Statement stmt, ResultSet rs) {
        try {
            if (rs != null) rs.close();
            if (stmt != null) stmt.close();
            if (conn != null) conn.close();
        } catch (SQLException e) {
            e.printStackTrace();
        }
    }
    
    public static int executeUpdate(String sql, Object... params) {
        Connection conn = null;
        PreparedStatement pstmt = null;
        try {
            conn = getConnection();
            pstmt = conn.prepareStatement(sql);
            for (int i = 0; i < params.length; i++) {
                pstmt.setObject(i + 1, params[i]);
            }
            return pstmt.executeUpdate();
        } catch (SQLException e) {
            throw new RuntimeException(e);
        } finally {
            close(conn, pstmt, null);
        }
    }
    
    public static <T> List<T> executeQuery(String sql, RowMapper<T> rowMapper, Object... params) {
        Connection conn = null;
        PreparedStatement pstmt = null;
        ResultSet rs = null;
        List<T> list = new ArrayList<>();
        try {
            conn = getConnection();
            pstmt = conn.prepareStatement(sql);
            for (int i = 0; i < params.length; i++) {
                pstmt.setObject(i + 1, params[i]);
            }
            rs = pstmt.executeQuery();
            while (rs.next()) {
                list.add(rowMapper.mapRow(rs));
            }
            return list;
        } catch (SQLException e) {
            throw new RuntimeException(e);
        } finally {
            close(conn, pstmt, rs);
        }
    }
    
    public interface RowMapper<T> {
        T mapRow(ResultSet rs) throws SQLException;
    }
}

使用示例：

java复制// 插入数据
JdbcUtils.executeUpdate("INSERT INTO users(name, age) VALUES(?, ?)", "王五", 28);

// 查询数据
List<User> users = JdbcUtils.executeQuery(
    "SELECT * FROM users WHERE age > ?", 
    rs -> new User(rs.getInt("id"), rs.getString("name"), rs.getInt("age")), 
    20
);

6.2 处理大数据量

当处理大量数据时，需要注意内存使用：

流式查询：

java复制String sql = "SELECT * FROM large_table";
try (Connection conn = dataSource.getConnection();
     Statement stmt = conn.createStatement(
         ResultSet.TYPE_FORWARD_ONLY, 
         ResultSet.CONCUR_READ_ONLY)) {
    
    stmt.setFetchSize(Integer.MIN_VALUE); // MySQL流式读取
    try (ResultSet rs = stmt.executeQuery(sql)) {
        while (rs.next()) {
            // 处理每一行数据
        }
    }
}

分批处理：

java复制int batchSize = 1000;
int offset = 0;
List<User> batch;

do {
    batch = findUsersByBatch(offset, batchSize);
    processBatch(batch);
    offset += batchSize;
} while (!batch.isEmpty());

private List<User> findUsersByBatch(int offset, int limit) {
    String sql = "SELECT * FROM users ORDER BY id LIMIT ? OFFSET ?";
    return JdbcUtils.executeQuery(sql, 
        rs -> new User(rs.getInt("id"), rs.getString("name"), rs.getInt("age")),
        limit, offset);
}

6.3 监控与调优

监控连接池：

java复制HikariPoolMXBean poolMXBean = dataSource.getHikariPoolMXBean();
System.out.println("活跃连接: " + poolMXBean.getActiveConnections());
System.out.println("空闲连接: " + poolMXBean.getIdleConnections());
System.out.println("等待线程: " + poolMXBean.getThreadsAwaitingConnection());

SQL性能分析：

java复制// 开启MySQL慢查询日志
String sql = "SET GLOBAL slow_query_log = 'ON'";
String sql2 = "SET GLOBAL long_query_time = 1"; // 超过1秒的查询

// 使用EXPLAIN分析SQL
String explainSql = "EXPLAIN SELECT * FROM users WHERE age > 20";
try (Connection conn = dataSource.getConnection();
     Statement stmt = conn.createStatement();
     ResultSet rs = stmt.executeQuery(explainSql)) {
    
    ResultSetMetaData metaData = rs.getMetaData();
    while (rs.next()) {
        for (int i = 1; i <= metaData.getColumnCount(); i++) {
            System.out.println(metaData.getColumnName(i) + ": " + rs.getString(i));
        }
    }
}

7. 从JDBC到ORM框架

虽然JDBC是Java操作数据库的基础，但在实际企业开发中，我们通常会使用ORM框架来简化开发：

7.1 常见ORM框架对比

7.2 MyBatis基础使用

MyBatis配置示例：

xml复制<!-- mybatis-config.xml -->
<configuration>
    <environments default="development">
        <environment id="development">
            <transactionManager type="JDBC"/>
            <dataSource type="POOLED">
                <property name="driver" value="com.mysql.jdbc.Driver"/>
                <property name="url" value="jdbc:mysql://localhost:3306/test"/>
                <property name="username" value="root"/>
                <property name="password" value="123456"/>
            </dataSource>
        </environment>
    </environments>
    <mappers>
        <mapper resource="mapper/UserMapper.xml"/>
    </mappers>
</configuration>

Mapper接口：

java复制public interface UserMapper {
    @Select("SELECT * FROM users WHERE id = #{id}")
    User findById(int id);
    
    @Insert("INSERT INTO users(name, age) VALUES(#{name}, #{age})")
    @Options(useGeneratedKeys = true, keyProperty = "id")
    void insert(User user);
    
    @Update("UPDATE users SET name=#{name}, age=#{age} WHERE id=#{id}")
    void update(User user);
    
    @Delete("DELETE FROM users WHERE id=#{id}")
    void delete(int id);
}

7.3 何时直接使用JDBC

尽管ORM框架很方便，但在以下场景中直接使用JDBC可能更合适：

1. 性能敏感：需要极致优化的SQL
2. 复杂报表：涉及多表关联和复杂计算
3. 批量操作：大量数据的导入导出
4. 特殊需求：使用数据库特有功能
5. 学习阶段：理解底层原理

掌握JDBC的核心原理，才能更好地使用各种ORM框架，并在需要时灵活切换方案。