【JDBC】Java连接MySQL数据库

---

一、数据库编程

数据库编程指的是通过编程语言与数据库进行交互和操作的过程，包括使用编程语言创建、连接、查询、更新和删除数据库中的数据，以及管理数据库结构和其他相关工作等。

另外，不同的数据库，对应不同的编程语言提供了不同的数据库驱动包，如：MySQL提供了Java的驱动包mysql-connector-java，如果要使用Java操作MySQL数据库就需要使用该驱动包。同样的，要基于Java操作Oracle数据库则需要Oracle的数据库对应的驱动包。

二、Java数据库编程JDBC

2.1 什么是JDBC

JDBC（Java Database Connectivity）是Java语言用于与关系型数据库进行交互的标志 API。这个 API 由java.sql以及javax.sql包中的一些类和接口组成，使Java应用程序能够通过标准化的方式连接和操作各种不同的数据库。

2.2 JDBC的工作原理

JDBC 为多种关系数据库提供了统一访问方式，作为特定厂商数据库访问API的一种高级抽象，它主要包含一些通用的接口类。

JDBC访问数据库层次结构：

JDBC访问数据库的层次结构主要就是上图所示的三个层次：应用层、JDBC接口层、JDBC驱动层。

1. 应用层就是指使用JDBC的Java应用程序的代码层。它包含了与数据库进行交互的业务逻辑和应用程序的其他组件。在应用层中，开发人员使用JDBC接口层提供的API来编写数据库连接、查询和更新等一系列操作的代码。

2. JDBC接口层是JDBC的核心组成部分，它提供了一组标志的接口和类，用于与不同数据库进行通信。JDBC的接口层定义了一套规范，定义了各种数据库操作的 API，使得开发人员能够以统一的方式和不同的数据库进行交互。

3. JDBC驱动层是实现JDBC接口层的具体数据库驱动程序。每个数据库供应商都提供了特定数据库的JDBC驱动程序，用于实现与该数据库的通信和相关操作。

   • JDBC驱动层的主要功能是将JDBC接口层的方法调用转换为数据库特定的协议和命令，以及处理与数据库的底层通信。
   • 驱动程序通过实现JDBC接口层定义的接口和类，提供了与特定数据库的交互功能。

三、JDBC基本操作

3.1 JDBC API

在Java JDBC编程中对数据库的操作均使用JDK自带的API统一处理，通常与特定数据库的驱动类是完全解耦的。所以掌握Java JDBC API （位于 java.sql 包下） 即可掌握Java数据库编程。

JDBC API的常见接口和类如下表所示：
以下是JDBC API的常见接口和类，以Markdown表格形式展示：

这些接口和类是JDBC API的核心组成部分，通过它们可以实现数据库的连接、查询、更新和事务管理等功能。根据实际需求，还可以使用这些API的具体实现类或其他辅助类来完成更复杂的数据库操作。

3.2 数据库连接Connection

在Java JDBC编程中获取数据库连接 Connection 的方式通常有两种：

1. 通过DriverManager（驱动管理类）的静态方法获取；
2. 通过DataSource（数据源）对象获取，实际应用中会使用DataSource对象。

1. 通过DriverManager获取连接

DriverManager是Java提供的一个用于管理不同数据库驱动程序的类。通过DriverManager，可以使用数据库驱动程序的URL、用户名和密码来获取数据库连接。这种方式是传统的连接方式，适用于简单的应用场景。

下面是一个通过DriverManager获取数据库连接的示例代码：

import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.SQLException;

public class Main {
    public static void main(String[] args) {
        String url = "jdbc:mysql://localhost:3306/mydatabase?CharacterEncoding=utf8&useSSL=false";
        String username = "root";
        String password = "mypassword";

        try {
            Connection conn = DriverManager.getConnection(url, username, password);
            // 使用连接执行数据库操作
            // ...
            conn.close();
        } catch (SQLException e) {
            e.printStackTrace();
        }
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20

在上述代码中，使用DriverManager.getConnection()方法传入数据库URL、用户名和密码来获取数据库连接。

2. 通过DataSource对象获取连接

DataSource是Java提供的一个接口，用于获取数据库连接。DataSource提供了更多的功能和配置选项，可以管理连接池、实现连接的缓存和复用等。在实际应用中，使用DataSource对象获取连接是更常见的方式，特别是在大型应用或需要高并发访问数据库的场景中。

使用DataSource获取连接的代码示例：

import com.mysql.cj.jdbc.MysqlDataSource;

import javax.sql.DataSource;
import java.sql.Connection;
import java.sql.SQLException;
public class Main {
    public static void main(String[] args) throws SQLException {
        // 使用 DataSource 体现了高内聚，有利于后面更改数据库
        DataSource dataSource = new MysqlDataSource();
        // 设置数据库所在位置，当前固定写法
        ((MysqlDataSource)dataSource).setUrl("jdbc:mysql://127.0.0.1:3306/mydatabase?characterEncoding=utf8&useSSl=false");
        ((MysqlDataSource)dataSource).setUser("root");
        ((MysqlDataSource)dataSource).setPassword("mypassword");

        /*  // 也可以这样写，但不推荐
        MysqlDataSource mysqlDataSource = new MysqlDataSource();
        mysqlDataSource.setUrl();*/

        // 和数据库建立网络连接
        Connection connection = dataSource.getConnection();

		// 后续操作
		// ...
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24

上面这段代码使用了MysqlDataSource作为具体的DataSource实现类，通过该实现类获取数据库连接。

需要注意的细节：
使用DataSource对象获取数据库连接的好处是可以通过更改具体的DataSource实现类来切换不同的数据库或者调整连接配置，而无需修改大量的代码。这样做提高了代码的灵活性和可维护性，特别是在多数据库支持或者切换数据库的场景中。因此这是更推荐的获取数据库连接的方法。

使用DataSource对象获取连接相比于DriverManager的方式，有以下一些优势：

• 连接池管理：DataSource可以实现连接池来管理数据库连接，提高连接的复用性和性能。
• 配置灵活：DataSource提供了更多的配置选项，可以根据需求设置连接超时、最大连接数、连接验证等参数。
• 适应多种数据源：DataSource可以适配多种数据库类型，即可以使用同一套代码连接不同的数据库，提高了代码的可移植性和扩展性。

因此，在实际应用中，使用DataSource对象获取数据库连接是更为常见和推荐的方式，特别是在复杂的应用场景中，可以更好地管理和优化数据库连接。

3.3 Statement对象

Statement对象的主要作用发送SQL语句到数据库并执行，Java API 中主要提供了三种Statement对象。

三种Statement对象的类型，它们分别是：Statement、PreparedStatement和CallableStatement。这些对象都是java.sql.Statement接口的实现类，用于发送SQL语句到数据库并执行。

以下是对这三种Statement对象的简要介绍：

1. Statement：
   Statement是最基本的Statement对象，用于执行静态的SQL语句。它通过执行executeQuery()方法执行查询语句，返回一个ResultSet对象，通过执行executeUpdate()方法执行更新语句，返回受影响的行数。

2. PreparedStatement：
   PreparedStatement是Statement的子接口，它是预编译的Statement对象。预编译是指在执行SQL语句之前，将SQL语句发送到数据库进行预处理，以提高执行效率和安全性。使用PreparedStatement可以通过占位符（如?）来代替具体的参数值，然后使用setXxx()方法设置参数的值。这样可以避免SQL注入攻击，并且在多次执行相同的SQL语句时可以提高性能。

3. CallableStatement：
   CallableStatement也是Statement的子接口，用于执行存储过程（Stored Procedure）的SQL语句。存储过程是在数据库中预先定义好的一段可重用的代码，可以接受参数并返回结果。CallableStatement允许调用存储过程，并传递参数，然后通过执行execute()方法执行存储过程，并获取返回的结果。

这些Statement对象在执行SQL语句时有各自的优势和适用场景。PreparedStatement的预编译特性使其在重复执行相同的SQL语句时效率更高，而CallableStatement适用于执行存储过程。需要根据具体的需求选择合适的Statement对象类型来进行操作。

例如向 Student 数据库表中新增数据：使用Statement对象

// 使用 jdbc 往 数据库 中插入数据
// 提前准备数据库（test）和数据表（student）

public class JDBCInsertDemo {
    public static void main(String[] args) throws SQLException {
        // 1. 创建数据源，描述了数据库服务器在哪

        // 使用 DataSource 体现了该内聚，有利于后面更改数据库
        DataSource dataSource = new MysqlDataSource();
        // 设置数据库所在位置，当前固定写法
        ((MysqlDataSource)dataSource).setUrl("jdbc:mysql://127.0.0.1:3306/test?characterEncoding=utf8&useSSl=false");
        ((MysqlDataSource)dataSource).setUser("root");
        ((MysqlDataSource)dataSource).setPassword("passwd");

        // 2. 和数据库建立网络连接
        Connection connection = dataSource.getConnection();

        // 通过控制台，输入用户信息
        Scanner scanner = new Scanner(System.in);
        System.out.println("请输入学号：");
        int id = scanner.nextInt();
        System.out.println("请输入姓名：");
        String name = scanner.next();

        // 3. 构建一个SQL语句，完成插入操作

        // 描述sql
        String sql = "insert into student values(" + id + ", '" + name +"');"; // 存在SQL注入

        Statement statement = connection.createStatement();


        // 4. 执行SQL语句，针对增、删、改 使用executeUpdate
        //               针对查，使用executeQuery
        int ret = statement.executeUpdate(sql); // 返回值表示影响了几行

        System.out.println("影响了：" + ret + "行！");

        // 5. 断开和数据库的链接，释放必要的资源
        statement.close();
        connection.close();
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43

这段代码是一个使用Statement对象进行插入操作的示例。但是，需要注意的是，代码中存在SQL注入的安全风险：

这里直接将用户输入的学号和姓名拼接到SQL语句中。然而，这种方式存在SQL注入的安全风险，因为用户的输入没有经过任何过滤或转义。恶意用户可能会利用这种情况来执行恶意的SQL语句。为了防止SQL注入，应该使用参数化查询或预编译语句。

例如向 Student 数据库表中新增数据：使用PreparedStatement对象

为了防止SQL注入攻击，改用参数化查询或预编译语句。使用参数化查询时，可以使用占位符（如?）来代替具体的参数值，然后使用setXxx()方法设置参数的值。这样，数据库驱动程序会正确处理参数，并避免了SQL注入的风险。

下面是一个改用参数化查询的示例：

String sql = "insert into student values(?, ?)";
PreparedStatement preparedStatement = connection.prepareStatement(sql);
preparedStatement.setInt(1, id);
preparedStatement.setString(2, name);
int ret = preparedStatement.executeUpdate();
1
2
3
4
5

在这个示例中，使用了参数化查询，通过占位符（?）来代替具体的参数值。然后，使用setXxx()方法设置占位符的值，再执行插入操作。这样，即使用户输入包含特殊字符，也会被正确处理，避免了SQL注入的风险。

3.4 ResultSet对象

ResultSet对象是Java中用于表示SQL查询结果集的接口，它是在java.sql包中定义的。

当使用Statement或PreparedStatement对象执行查询语句时，会返回一个ResultSet对象，它包含了查询结果的数据。通过ResultSet对象，可以遍历结果集的行，并获取每一行中的列数据。

以下是一些ResultSet对象的常用方法：

1. next()：将游标移动到结果集的下一行，并返回一个布尔值，表示是否还有更多的行。可以使用while循环来遍历整个结果集。

2. getXxx(int columnIndex)、getXxx(String columnLabel)：这些方法用于获取当前行中指定列的值。getXxx()中的Xxx表示具体的数据类型，如getInt()、getString()等。可以根据列的索引或列名来获取对应的值。

3. getMetaData()：返回一个ResultSetMetaData对象，用于获取结果集的元数据信息，如列名、列类型等。

4. close()：关闭ResultSet对象。

下面是一个简单的示例，展示了如何使用ResultSet对象遍历查询结果集：

import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.ResultSet;
import java.sql.SQLException;
import java.sql.Statement;

public class Main {
       public static void main(String[] args) throws SQLException {
        DataSource dataSource = new MysqlDataSource();
        ((MysqlDataSource)dataSource).setUrl("jdbc:mysql://127.0.0.1:3306/test?characterEncoding=utf8&useSSL=false");
        ((MysqlDataSource)dataSource).setUser("root");
        ((MysqlDataSource)dataSource).setPassword("passwd");

        Connection connection = dataSource.getConnection();

        String sql = "select * from student;";

        PreparedStatement statement = connection.prepareStatement(sql);

        // 结果集合
        ResultSet set = statement.executeQuery();

        // next相当于移动一下光标，光标指向下一行，移动到结尾时返回false
        // 初始位置：光标指向第一行的前一行
        while (set.next()){
            // 使用 getXX 方法获取每一列，参数是数据库表的列名
            int id = set.getInt("id");
            String name = set.getString("name");

            System.out.println("id = " + id + ", name = " + name + ".");
        }

        // 释放资源
        set.close();
        statement.close();
        connection.close();
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38

在上述示例中，使用Statement对象执行查询语句，返回一个ResultSet对象。通过next()方法将游标移动到下一行，并使用getXxx()方法获取每一行中指定列的值。这样可以遍历整个结果集并获取其中的数据。

需要注意的是，在使用ResultSet对象遍历结果集后，应当及时关闭它以释放资源，可以使用close()方法或通过try-with-resources语句块来确保资源的正确关闭。

四、应用案例

下面是一个综合案例，展示了使用JDBC进行数据库表student的增删改查操作的示例代码：

// 下面是一个综合案例，展示了使用JDBC进行数据库增删改查操作的示例代码：

import com.mysql.cj.jdbc.MysqlDataSource;

import javax.sql.DataSource;
import java.sql.Connection;
import java.sql.PreparedStatement;
import java.sql.ResultSet;
import java.sql.SQLException;

public class JDBCCrudExample {
    public static void main(String[] args) throws SQLException {
        DataSource dataSource = new MysqlDataSource();
        ((MysqlDataSource) dataSource).setUrl("jdbc:mysql://127.0.0.1:3306/test?characterEncoding=utf8&useSSL=false");
        ((MysqlDataSource) dataSource).setUser("root");
        ((MysqlDataSource) dataSource).setPassword("passwd");

        Connection connection = dataSource.getConnection();

        // 插入数据
        insertData(connection, 1, "张三");
        insertData(connection, 2, "李四");
        insertData(connection, 3, "王五");
        insertData(connection, 4, "赵六");

        // 查询数据
        selectData(connection);

        // 更新数据
        updateData(connection, 1, "张老三");

        // 查询更新后的数据
        selectData(connection);

        // 删除数据
        deleteData(connection, 1);

        // 查询删除后的数据
        selectData(connection);
    }

    private static void insertData(Connection connection, int id, String name) throws SQLException {
        String sql = "INSERT INTO student (id, name) VALUES (?, ?)";
        PreparedStatement statement = connection.prepareStatement(sql);
        statement.setInt(1, id);
        statement.setString(2, name);
        int rowsInserted = statement.executeUpdate();
        System.out.println(rowsInserted + " row(s) inserted.");
        statement.close();
    }

    private static void selectData(Connection connection) throws SQLException {
        String sql = "SELECT * FROM student";
        PreparedStatement statement = connection.prepareStatement(sql);
        ResultSet resultSet = statement.executeQuery();
        while (resultSet.next()) {
            int id = resultSet.getInt("id");
            String name = resultSet.getString("name");
            System.out.println("ID: " + id + ", Name: " + name);
        }
        resultSet.close();
        statement.close();
    }

    private static void updateData(Connection connection, int id, String name) throws SQLException {
        String sql = "UPDATE student SET name = ? WHERE id = ?";
        PreparedStatement statement = connection.prepareStatement(sql);
        statement.setString(1, name);
        statement.setInt(2, id);
        int rowsUpdated = statement.executeUpdate();
        System.out.println(rowsUpdated + " row(s) updated.");
        statement.close();
    }

    private static void deleteData(Connection connection, int id) throws SQLException {
        String sql = "DELETE FROM student WHERE id = ?";
        PreparedStatement statement = connection.prepareStatement(sql);
        statement.setInt(1, id);
        int rowsDeleted = statement.executeUpdate();
        System.out.println(rowsDeleted + " row(s) deleted.");
        statement.close();
    }
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85

这个示例展示了数据库的增删改查操作：

1. insertData() 方法用于插入数据，通过预编译的 PreparedStatement 对象执行插入操作。

2. selectData() 方法用于查询数据，通过预编译的 PreparedStatement 对象执行查询操作，并遍历结果集打印每一行的数据。

3. updateData() 方法用于更新数据，通过预编译的 PreparedStatement 对象执行更新操作。

4. deleteData() 方法用于删除数据，通过预编译的 PreparedStatement 对象执行删除操作。

在 main() 方法中，先连接到数据库，然后按顺序执行插入、查询、更新和删除操作，并输出操作结果。

运行结果：

查看数据库表中的数据：