MySQL++ C++ API 完整开发指南

本文还有配套的精品资源，点击获取

简介：MySQL++ 是一个为MySQL数据库提供C++接口的开源库，它使得开发者能以C++的强类型和面向对象方式构建高效且易于维护的数据库应用。本指南将介绍MySQL++库的基本概念、用法、安装配置及示例代码，帮助用户深入理解并实践MySQL++ C++ API，以实现高性能的数据库交互。

1. MySQL++ C++ 库简介

MySQL++库是MySQL数据库的一个高级封装，为C++程序员提供了一个方便且功能丰富的接口来与MySQL数据库进行交互。它不是一个简单的C API包装器，而是在其之上提供了一个更加面向对象的接口，使得数据库操作更加符合C++的编程习惯。使用MySQL++可以简化数据库编程工作，使开发者能够更加专注于业务逻辑的实现，而不是数据库通信的细节。

1.1 MySQL++的特点

与标准的MySQL C API相比，MySQL++具有以下特点： - 封装性 ：隐藏了底层的数据库通信细节，通过更加抽象的接口减少代码量。 - 异常安全 ：采用了异常处理机制，使得数据库操作在发生错误时能自动进行恢复和资源清理。 - 类型安全 ：使用现代C++的特性，如STL容器和智能指针，来增强数据类型的安全性。

1.2 MySQL++的应用场景

MySQL++适用于以下几种场景： - 中小型项目 ：需要快速集成数据库功能的C++应用。 - 复杂查询处理 ：需要执行复杂查询，并且要求高效的类型安全处理。 - 代码复用 ：在多个项目中复用数据库访问代码，保持代码风格一致。

下面章节将深入探讨如何连接到MySQL数据库，并介绍连接选项与安全方面的内容。

2. 连接到MySQL数据库

2.1 MySQL++的连接方式

2.1.1 基于TCP/IP的连接

MySQL++ 库支持多种连接方式，其中基于 TCP/IP 的连接是最常见的一种。TCP/IP 是一种网络通信协议，它允许在不同计算机上的客户端与 MySQL 服务器之间建立连接，无论它们位于同一局域网内还是通过 Internet 连接。

#include <mysql++/mysql++.h>

int main() {
    try {
        // 创建一个连接对象
        mysqlpp::Connection con;
        // 连接到本地服务器的 3306 端口
        con.connect("localhost", "db_user", "db_password", "database_name");
        // 检查连接是否成功
        if (con.is_connected()) {
            std::cout << "成功连接到数据库!" << std::endl;
        } else {
            std::cerr << "数据库连接失败!" << std::endl;
        }
        // 连接保持期间可以执行各种数据库操作...
    } catch (const mysqlpp::Exception& e) {
        std::cerr << e.what() << std::endl;
    }
    return 0;
}

在上述示例代码中， mysqlpp::Connection 对象 con 被用来建立到 MySQL 数据库的连接。 connect 方法接受四个参数：主机名、用户名、密码和数据库名。首先，该方法会尝试建立连接，如果连接成功，则 is_connected 方法返回 true ，否则返回 false 。异常处理机制确保了在发生错误时能够输出相关的错误信息。

2.1.2 Unix域套接字的连接

另一种常见的连接方式是使用 Unix 域套接字。这种方式相比 TCP/IP 连接具有较低的网络开销，并且更加安全，因为它仅限于在同一台主机上运行的进程之间通信。在 Linux 和其他 Unix 类系统中，这是一种常用的本地数据库连接方式。

#include <mysql++/mysql++.h>

int main() {
    try {
        // 创建一个连接对象
        mysqlpp::Connection con;
        // 连接到本地服务器的 Unix 域套接字
        con.connect("/tmp/mysql.sock", "db_user", "db_password", "database_name");
        // 检查连接是否成功
        if (con.is_connected()) {
            std::cout << "成功连接到数据库!" << std::endl;
        } else {
            std::cerr << "数据库连接失败!" << std::endl;
        }
        // 连接保持期间可以执行各种数据库操作...
    } catch (const mysqlpp::Exception& e) {
        std::cerr << e.what() << std::endl;
    }
    return 0;
}

这里， connect 方法的第二个参数是 Unix 域套接字的路径。注意，这里我们没有指定主机名，因为 Unix 域套接字仅限本地访问。其他代码逻辑与 TCP/IP 连接相同，包括异常处理。使用 Unix 域套接字的连接方式在性能上有所提升，尤其是在数据库服务器和应用程序在同一台机器上运行时。

2.2 连接选项与安全

2.2.1 连接超时与重试机制

在实际的生产环境中，数据库服务可能因为各种原因暂时不可用，如网络延迟、服务器维护等。因此，MySQL++ 提供了灵活的超时设置以及重试机制，以提高数据库连接的健壮性和可靠性。

#include <mysql++/mysql++.h>

int main() {
    try {
        // 创建一个连接对象
        mysqlpp::Connection con;
        // 设置超时时间和重试次数
        con.set_option(mysqlpp::opt_timeout, 10);  // 设置连接超时时间为10秒
        con.set_option(mysqlpp::opt_retry_count, 3);  // 设置重试次数为3

        // 尝试连接到数据库
        con.connect("localhost", "db_user", "db_password", "database_name");
        // 连接成功后的操作...
    } catch (const mysqlpp::Exception& e) {
        std::cerr << "数据库连接失败: " << e.what() << std::endl;
    }
    return 0;
}

在这个例子中，我们使用 set_option 方法设置了两个连接选项。第一个是 mysqlpp::opt_timeout ，它指定了连接尝试的超时时间（单位为秒）。第二个是 mysqlpp::opt_retry_count ，它指定了在放弃连接之前尝试重连的次数。这些设置可以帮助应用程序在面对短暂的网络或服务问题时，通过短暂等待和重试来恢复服务，从而提升整体的系统可用性。

2.2.2 SSL加密连接的配置与应用

出于安全考虑，数据库连接通常需要采取加密措施以防止敏感数据在传输过程中被截获或篡改。MySQL++ 支持通过 SSL 加密连接到 MySQL 数据库，以确保数据传输的安全性。

#include <mysql++/mysql++.h>

int main() {
    try {
        // 创建一个连接对象
        mysqlpp::Connection con;
        // 启用SSL加密连接
        con.set_option(mysqlpp::opt_use_ssl, true);
        // 指定SSL证书文件的路径
        con.set_option(mysqlpp::opt_ssl_cert, "/path/to/client-cert.pem");
        con.set_option(mysqlpp::opt_ssl_key, "/path/to/client-key.pem");
        con.set_option(mysqlpp::opt_ssl_ca, "/path/to/ca-cert.pem");
        // 连接到数据库
        con.connect("localhost", "db_user", "db_password", "database_name");
        // 加密连接成功后的操作...
    } catch (const mysqlpp::Exception& e) {
        std::cerr << "数据库连接失败: " << e.what() << std::endl;
    }
    return 0;
}

在上述代码段中， set_option 方法被用来启用 SSL 加密连接，并指定了客户端证书、密钥以及 CA 证书的路径。请注意，这些路径需要根据实际情况进行替换，并确保证书文件的有效性。启用 SSL 加密连接是保护数据库通信安全的一个重要步骤，尤其是在数据传输过程中包含敏感信息时。

通过上述示例，我们可以看到 MySQL++ 库提供的灵活连接选项可以满足不同场景下的需求，而加入 SSL 加密选项则进一步增强了连接的安全性。在下一章节中，我们将探讨如何创建和使用预处理语句，这是优化数据库操作的一个关键特性。

3. 预处理语句的创建与使用

3.1 预处理语句的基本概念

3.1.1 预处理语句的优势与用途

预处理语句（Prepared Statements），也称为参数化查询，是一种在数据库编程中广泛使用的技术。在MySQL++库中，预处理语句提供了一种安全高效的方式来执行SQL查询。

预处理语句的主要优势在于能够减少SQL注入的风险和提高查询效率。通过预编译SQL语句并仅更改参数值，预处理语句避免了重复编译相同查询的开销，这对于需要多次执行相同查询的应用来说，可以显著提高性能。

具体来说，预处理语句在以下场景中特别有用： - 当需要执行多次具有相同结构但不同参数的SQL语句时，如批量插入数据或批量更新。 - 对于需要频繁执行的查询，预处理可以利用数据库服务器的查询缓存。 - 防止SQL注入攻击，因为参数绑定确保了传入的数据不会被解释为SQL代码的一部分。

3.1.2 预处理语句与普通SQL语句的比较

预处理语句和普通SQL语句在使用上有本质的区别。普通SQL语句在每次执行时都会被数据库解释、优化并编译，而预处理语句只编译一次，之后只需发送参数即可。

从性能角度来看，预处理语句在编译阶段就确定了SQL语句的结构，因此后续的执行阶段可以快速执行，特别是对于复杂的查询或大量的数据操作，预处理语句可以大大减少数据库的处理时间。

在安全性方面，预处理语句的参数绑定机制可以有效防止SQL注入。使用预处理语句时，参数值在发送到数据库之前不会被解释为SQL代码的一部分，这就意味着，即使参数值中包含了恶意构造的SQL片段，也不会对数据库产生影响。

然而，预处理语句也有其局限性。例如，它们通常不支持动态SQL的某些特性，例如，不能动态地改变要查询的表名或列名。此外，预处理语句可能会占用更多的服务器资源，特别是在处理大量并发的数据库操作时。

3.2 预处理语句的实现与操作

3.2.1 创建与执行预处理语句

在MySQL++中创建和执行预处理语句涉及以下步骤：

1. 创建一个 PreparedStatement 对象，这将代表预编译的SQL语句。
2. 使用 PreparedStatement 的 prepare 方法来编译SQL语句。
3. 如果需要，设置任何必要的参数标记。
4. 使用 PreparedStatement 的 execute 方法来执行SQL语句，传入相应的参数值。

以下是一个简单的示例代码，展示了如何使用MySQL++创建和执行一个预处理插入语句：

#include <mysql_driver.h>
#include <mysql_connection.h>
#include <cppconn/prepared_statement.h>

int main() {
    try {
        // 初始化驱动
        sql::mysql::MySQL_Driver *driver;
        // 创建连接
        sql::Connection *con;
        // 创建语句
        sql::PreparedStatement *prep_stmt;

        // 初始化驱动
        driver = sql::mysql::get_mysql_driver_instance();
        con = driver->connect("tcp://***.*.*.*:3306", "username", "password");
        con->setSchema("database");

        // 创建预处理语句
        prep_stmt = con->prepareStatement("INSERT INTO users (username, password) VALUES (?, ?)");

        // 绑定参数并执行
        for (int i = 0; i < 1000; ++i) {
            prep_stmt->setString(1, "user" + std::to_string(i));
            prep_stmt->setString(2, "pass" + std::to_string(i));
            prep_stmt->executeUpdate();
        }

        delete prep_stmt;
        delete con;
    } catch (sql::SQLException &e) {
        std::cerr << "SQLException in " << __FILE__ << std::endl;
        std::cerr << "Error " << e.getErrorCode() << std::endl;
        std::cerr << e.what() << std::endl;
    }

    return 0;
}

在这个示例中，我们首先获取MySQL驱动的实例，并通过它来创建一个连接。之后，我们使用 prepareStatement 方法准备一个插入语句，并在循环中执行了1000次插入操作，每次都绑定不同的参数值。

3.2.2 参数绑定与占位符使用

在预处理语句中，参数占位符是一种特殊标记，用来指示参数在执行语句时将被替代的位置。在MySQL++中，占位符通常以问号（ ? ）表示，而在SQL查询中，它们必须按顺序绑定参数值。

参数绑定是通过调用预处理语句对象的 setInt , setDouble , setString , setNull 等方法完成的。每个方法都接受参数的位置索引作为第一个参数，以及要绑定的实际值作为第二个参数。

例如，如果有一个预处理查询如下：

SELECT * FROM orders WHERE order_id = ? AND customer_id = ?

可以通过以下方式绑定参数：

// 绑定第一个参数为整数
prep_stmt->setInt(1, 1001);

// 绑定第二个参数也为整数
prep_stmt->setInt(2, 2002);

这种方式提供了灵活性，并且允许在每次执行时使用不同的参数值。

参数绑定还有一个重要的安全性优势，它通过防止恶意用户构造的SQL代码执行来减少SQL注入的风险。当使用预处理语句时，SQL引擎会将占位符视为不可执行的代码，只允许传入的参数值按预期方式使用，避免了潜在的注入风险。

4. 结果集的遍历与访问

4.1 结果集的基本操作

4.1.1 结果集的获取与迭代

在使用MySQL++库进行数据库查询操作后，会得到一个结果集（ResultSet），这是一个包含查询结果的容器。为了访问这些数据，程序员需要进行结果集的获取与迭代操作。

首先，我们创建一个SQL查询，并执行它以获取结果集。假设我们要查询所有用户的信息：

#include <mysql++/query.h>
#include <mysql++/resultset.h>
#include <iostream>

int main() {
    mysqlpp::Connection con("tcp://***.*.*.*:3306", "database_name", "user_name", "password");
    mysqlpp::Query query = con.query("SELECT * FROM users;");
    mysqlpp::ResultSet result = query.store();
    // 迭代器用于遍历结果集
    mysqlpp::const_iterator it = result.begin();
    for (; it != result.end(); ++it) {
        // 输出结果集中的每个用户信息
        std::cout << it->get_string("username") << " " << it->get_string("email") << std::endl;
    }
    return 0;
}

上述代码中，我们首先创建了一个 mysqlpp::Query 对象并执行了一个SQL查询。然后，我们通过调用 store() 方法来存储结果集，并获得一个 mysqlpp::ResultSet 对象。通过 ResultSet 对象提供的迭代器，我们能够遍历每一个结果集中的记录。

4.1.2 结果集的字段类型处理

MySQL++库提供了一组重载的方法用于从结果集中检索不同数据类型的字段值。在处理结果集时，我们必须考虑到MySQL中存储的数据类型与C++中的数据类型之间的映射关系。

以下是一些常见的字段类型处理方法：

• get_int() : 用于获取整数类型的字段。
• get_string() : 用于获取字符类型字段。
• get_real() : 用于获取浮点数类型的字段。
• get_bool() : 用于获取布尔类型的字段。

例如，如果我们要获取用户ID和用户名，并将其打印出来，我们可以这样做：

while (it != result.end()) {
    int user_id = it->get_int("id");
    std::string username = it->get_string("username");
    std::cout << "User ID: " << user_id << ", Username: " << username << std::endl;
    ++it;
}

这里我们用 get_int 和 get_string 分别获取了用户的整型ID和字符串类型的用户名。

4.2 高级结果集处理

4.2.1 大对象LOB的处理

在数据库中处理大对象（LOB）类型的数据时，如BLOB或TEXT等，MySQL++库提供了专门的方法来进行读取和写入操作。由于LOB数据通常很大，因此它们不会直接存储在结果集中，而是作为一个特殊类型的对象处理。

为了获取LOB类型的数据，我们需要使用 getLOB() 方法：

mysqlpp::LOB lob = it->getLOB("large_image");
if (lob) {
    // 读取LOB数据
    std::cout << "LOB data size: " << lob.size() << std::endl;
    // 输出LOB数据或将其保存到文件等
}

4.2.2 结果集的过滤与排序

虽然MySQL++库本身不提供直接过滤和排序结果集的功能，但是我们可以在SQL查询中使用 WHERE 子句和 ORDER BY 子句来实现这些功能。

例如，如果我们想要获取年龄大于30岁的用户，并按照用户名进行排序，我们可以这样写SQL查询：

mysqlpp::Query query = con.query("SELECT * FROM users WHERE age > 30 ORDER BY username ASC;");

通过在SQL语句中加入过滤和排序条件，结果集会按照我们的要求返回数据，然后我们可以使用之前提到的迭代方法来访问这些数据。

表格示例：MySQL++中的字段类型与C++类型映射关系

| MySQL字段类型 | C++类型映射示例 | | --- | --- | | INT | int | | VARCHAR | std::string | | FLOAT | float | | BOOLEAN | bool | | BLOB | mysqlpp::LOB |

使用以上表格，开发者可以更好地理解如何将数据库中的字段类型映射为C++中的类型，并据此编写代码进行操作。需要注意的是，表中列出的只是部分示例映射关系，实际使用时应参考MySQL++库的官方文档以获得完整映射信息。

5. 事务处理的基本操作

5.1 事务处理机制概述

5.1.1 事务的基本原则ACID

在数据库管理中，事务是作为单个逻辑工作单元执行的一系列操作。事务必须遵循被称为ACID的四个关键属性，以确保数据的准确性和可靠性。ACID代表原子性（Atomicity）、一致性（Consistency）、隔离性（Isolation）和持久性（Durability）。MySQL++作为MySQL的一个C++接口，同样支持这些事务属性。

• 原子性（Atomicity） ：事务中的所有操作要么全部成功，要么全部失败回滚。这意味着事务内的操作是不可分割的最小工作单元。在MySQL++中，开发者可以通过代码逻辑确保这些操作要么全部执行，要么在遇到异常时全部撤销。
• 一致性（Consistency） ：事务必须确保数据库从一个一致性状态转移到另一个一致性状态。换句话说，事务执行的结果必须使数据库保持有效和一致的状态。
• 隔离性（Isolation） ：并发事务的执行是相互隔离的，一个事务的中间状态对其他事务是不可见的。隔离级别可以控制并发事务的执行方式和数据可见性。
• 持久性（Durability） ：一旦事务提交，其所做的修改就会永久保存到数据库中，即使发生系统故障。

理解ACID原则对于编写可靠的数据库操作代码至关重要，特别是在需要处理复杂逻辑和数据完整性规则时。

5.1.2 MySQL中的事务隔离级别

在MySQL中，可以设置不同的事务隔离级别，以在并发访问和数据一致性之间取得平衡。隔离级别从低到高分为以下几种：

• 读未提交（READ UNCOMMITTED） ：最低的隔离级别，允许读取尚未提交的数据变更，可能导致脏读。
• 读已提交（READ COMMITTED） ：允许读取并发事务已经提交的数据，避免脏读，但是可能会产生不可重复读。
• 可重复读（REPEATABLE READ） ：保证在同一个事务中多次读取同样数据的结果是一致的，但幻读问题仍然存在。
• 可串行化（SERIALIZABLE） ：最高的隔离级别，通过强制事务串行执行，避免了脏读、不可重复读和幻读问题。

MySQL++提供了与原生MySQL数据库相同的事务隔离级别设置。在代码中，开发者可以通过设置事务属性来选择适当的隔离级别，以避免如脏读或幻读等并发问题。

5.2 MySQL++中的事务控制

5.2.1 开启与提交事务

在MySQL++中，可以通过以下步骤来开启和提交事务：

1. 开启事务 ：在执行任何DML（数据操作语言）操作之前，先开始一个新的事务。
2. 执行SQL操作 ：在事务中执行SQL语句，如INSERT、UPDATE、DELETE等。
3. 提交事务 ：如果所有SQL操作都成功执行，则提交事务，使所有更改永久保存到数据库中。
4. 回滚事务 ：如果在执行过程中发生错误，或者需要放弃更改，则回滚事务以撤销所有更改。

下面的代码示例展示了如何使用MySQL++进行事务控制：

try {
    conn->start_transaction();  // 开启事务

    // 执行SQL语句
    conn->query("INSERT INTO table_name (column1, column2) VALUES (value1, value2)");
    conn->query("UPDATE table_name SET column1 = value1 WHERE condition");

    // 提交事务
    conn->commit();
} catch (sql::SQLException &e) {
    // 出现异常，回滚事务
    conn->rollback();
    std::cerr << "Error: " << e.what() << std::endl;
}

上述代码首先通过 start_transaction() 开启事务，然后执行一系列SQL操作。如果所有操作都成功，则调用 commit() 提交事务，使更改生效。如果在操作过程中捕捉到异常，则调用 rollback() 回滚事务，撤销所有未提交的更改。

5.2.2 回滚事务处理

在出现错误或意外情况时，需要回滚事务以撤销所有未提交的更改。在MySQL++中，回滚操作非常简单：

conn->rollback();

只要捕捉到任何异常，就可以调用 rollback() 来撤销当前事务中的所有操作。在进行复杂的数据操作时，开发者必须预见到所有可能的失败场景，并准备好相应的回滚策略。

事务控制是保持数据库一致性的重要机制。开发者必须根据应用需求选择合适的事务隔离级别，并且确保事务正确开启、提交或回滚。在本章节中，我们详细讲解了MySQL++如何通过C++代码实现事务的基本操作和控制。理解并正确应用这些事务管理技术，将有助于在处理需要高数据一致性和完整性的场景时，开发出更加健壮的应用程序。

6. 异常处理机制与连接池管理

6.1 MySQL++的异常处理

异常处理是程序开发中不可或缺的一部分，它有助于系统地处理运行时发生的错误情况。在MySQL++库中，异常处理机制为C++程序员提供了一种强大而灵活的方式来应对数据库操作中可能出现的错误和异常情况。

6.1.1 异常类的层次结构

MySQL++库定义了一系列异常类，它们继承自一个共同的基类 MySQL::Exception 。这个基类提供了基本的错误信息以及一些通用的处理方法。通过继承关系，不同的异常类可以反映不同类型的错误，例如，网络错误、数据错误、连接错误等。

例如， MySQL::ConnectionFailedException 会在连接失败时抛出，而 MySQL::StatementException 会在执行SQL语句时遇到问题时抛出。通过异常的类型，开发者可以快速定位问题所在，并采取相应的解决措施。

下面的代码展示了如何捕获和处理MySQL++的异常：

try {
    MySQL::Connection con(MYSQLADDR, MYSQLUSER, MYSQLPASSWD);
    // 执行数据库操作...
} catch (const MySQL::Exception &e) {
    std::cerr << "Exception: " << e.what() << std::endl;
    // 在此处进行错误处理
}

6.1.2 异常捕获与处理策略

在使用MySQL++进行数据库操作时，开发者应考虑到各种可能发生的异常。编写健壮的代码需要合理地捕获和处理异常，以确保程序的稳定性和用户的良好体验。

处理策略可以包括以下几个方面： - 日志记录 ：记录异常发生的时间、类型和相关数据，有助于后期的调试和分析。 - 用户反馈 ：向用户展示错误消息时，应尽量避免显示底层技术细节，而应提供清晰、友好的提示。 - 事务回滚 ：如果异常发生在事务处理中，应确保事务被正确回滚，以保证数据的一致性。 - 重试机制 ：某些异常可能是暂时性的，例如网络短暂的不稳定，可以通过设置重试机制来处理这些情况。

6.2 连接池的使用与管理

连接池是数据库连接管理的一种优化手段。它预先创建一定数量的数据库连接并保持空闲状态，当应用程序需要进行数据库操作时，可以直接从连接池中获取已创建的连接，而无需每次都创建新的连接。

6.2.1 连接池的基本概念与优势

连接池的主要优点包括： - 减少连接时间 ：预先建立的数据库连接减少了每次请求时建立和销毁连接的时间。 - 资源重用 ：连接在应用程序之间被重用，减少了系统资源的消耗。 - 负载均衡 ：可以更好地管理数据库负载，通过连接池对请求进行排队和调度。

6.2.2 连接池的配置与性能调优

正确配置和管理连接池对于发挥其性能至关重要。在MySQL++中，可以使用 MySQL::ConnectionPool 类来创建和管理连接池。

下面的代码展示了如何配置和使用连接池：

int max_connections = 10; // 连接池中最大连接数
int max_used_connections = 8; // 连接池中最大可使用的连接数
int connection_timeout = 10; // 连接超时时间

MySQL::ConnectionPool conn_pool(max_connections, max_used_connections, connection_timeout);
conn_pool.start_housekeeping_thread(); // 启动连接池的后台维护线程

try {
    MySQL::Connection *conn = conn_pool.check_out(); // 从连接池中获取连接
    // 执行数据库操作...
    conn_pool.check_in(conn); // 操作完成后，将连接归还到连接池
} catch (const MySQL::Exception &e) {
    std::cerr << "Exception: " << e.what() << std::endl;
}

在性能调优方面，需要关注以下几个参数： - 最小连接数 ：连接池中保持的最小连接数。 - 最大连接数 ：连接池中允许的最大连接数。 - 最大空闲时间 ：连接在连接池中可保持的最大空闲时间。 - 连接重试次数和间隔 ：在无法获取到可用连接时，连接池会尝试重试，这里可以设置重试的次数和间隔。

通过调整这些参数，可以满足不同的业务场景和性能需求。在实际部署时，建议根据应用程序的工作负载进行测试，并调整参数以达到最佳性能。

本文还有配套的精品资源，点击获取

简介：MySQL++ 是一个为MySQL数据库提供C++接口的开源库，它使得开发者能以C++的强类型和面向对象方式构建高效且易于维护的数据库应用。本指南将介绍MySQL++库的基本概念、用法、安装配置及示例代码，帮助用户深入理解并实践MySQL++ C++ API，以实现高性能的数据库交互。

本文还有配套的精品资源，点击获取