C++ mysql数据库操作api接口的封装

最新推荐文章于 2025-03-13 12:10:33 发布
最新推荐文章于 2025-03-13 12:10:33 发布
阅读量3.7k 收藏 32
点赞数 10
分类专栏： C++ 文章标签： c++ mysql
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.youkuaiyun.com/qq_39519014/article/details/105946656
版权

目录

一：关键接口说明

一般预处理流程都是，连接数据库–>预处理–>绑定查询参数–>执行查询–>获取查询结果。
故api封装之后有如下几个关键的接口：

1：bool connect(); //连接数据库，初始化数据库连接等
2：bool prepare(const std::string &query);//预处理
3：template<typename T> void bindValue(int pos, const T &value);//给placeholder相对应的位置绑定参数
4：bool execute();//执行数据库查询
5：bool next();//移到下一条记录
6：template<typename T>T value(int index);//获取结果集index位置中T类型的结果

二：具体实现

1：首先需要封装数据库连接的参数配置

DatabaseOption.hpp

#include <string>
/**
 * 数据库配置类
 */
struct DatabaseOption {
    std::string host = "127.0.0.1";//数据库ip地址
    int port = 3307;//端口号
    std::string username = "root";//用户名
    std::string password = "123456";//数据库密码
    std::string databaseName = "test";//数据库名
    int connectTimeout = 0;//连接的超时时间
    std::string charsetName = "utf8";//编码
    int reconnectTime = 1;//超时重连次数
};

2：然后需要封装预处理的参数绑定

PrepareBinder.hpp


#include <vector>
#include <string>
#include <algorithm>
#include <mysql.h>
#include <iostream>

/**
 * mysql的预处理绑定器
 */
class PrepareBinder {
private:
    std::vector<MYSQL_BIND> paramBinds;//预处理的参数绑定
public:

    /**
     * 绑定的参数集的大小
     * @param resultBindNum
     */
    explicit PrepareBinder(int prepareBindNum) {
        paramBinds.resize(prepareBindNum);//初始化绑定参数列表
    }

    std::vector<MYSQL_BIND> &getParamBinds() {
        return paramBinds;
    }

    /**
     * 绑定整型
     * @param pos
     * @param value
     */
    void bindValue(int pos, const int &value) {
        paramBinds[pos].buffer_type = MYSQL_TYPE_LONG;
        paramBinds[pos].buffer = (void *) &value;
        paramBinds[pos].is_unsigned = false;
    }

    /**
     * 绑定无符号整型
     * @param pos
     * @param value
     */
    void bindValue(int pos, const unsigned int &value) {
        paramBinds[pos].buffer_type = MYSQL_TYPE_LONG;
        paramBinds[pos].buffer = (void *) &value;
        paramBinds[pos].is_unsigned = true;
    }

    /**
     * 绑定字符串
     * @param pos
     * @param value
     */
    void bindValue(int pos, const std::string &value) {
        paramBinds[pos].buffer_type = MYSQL_TYPE_STRING;
        paramBinds[pos].buffer = (void *) value.c_str();
        paramBinds[pos].buffer_length = value.size();
    }
};

3：再有需要对封装查询结果集进行封装

ResultBinder.hpp



#include <vector>
#include <map>
#include <mysql.h>
#include <functional>
#include <iostream>

/**
 * 结果集的绑定
 */
class ResultBinder {
private:
    /**
     * 负责类型转发
     * @tparam T
     */
    template<typename T>
    struct IndexWrapper {
        int index = 0;//索引

        explicit IndexWrapper(int index) : index(index) {}
    };

private:
    const static int STRING_MAX_LENGTH = 65535;

    std::vector<MYSQL_BIND> resultBinds;

    //字符串缓存
    std::vector<std::vector<char>> stringBuffer;
    //整型的缓存
    std::vector<int> intBuffer;

    //类型与处理函数映射
    std::map<int, std::function<void(int)>> typeProcessMap = {
            {MYSQL_TYPE_LONG,       std::bind(&ResultBinder::bindInt, this, std::placeholders::_1)},
            {MYSQL_TYPE_VAR_STRING, std::bind(&ResultBinder::bindString, this, std::placeholders::_1)}
    };
private:
    void bindInt(int index) {
        resultBinds[index].buffer_type = MYSQL_TYPE_LONG;
        resultBinds[index].buffer = &intBuffer[index];
    }

    void bindString(int index) {
        stringBuffer[index].clear();
        stringBuffer[index].resize(STRING_MAX_LENGTH);
        resultBinds[index].buffer_type = MYSQL_TYPE_STRING;
        resultBinds[index].buffer = stringBuffer[index].data();
        resultBinds[index].buffer_length = STRING_MAX_LENGTH;
    }

    /**
    * 提取结果集中的字符串结果
    * @param index
    * @return
    */
    std::string value(IndexWrapper<std::string> wrapper) {
        return stringBuffer[wrapper.index].data();
    }

    /**
    * 提取结果集中的整型结果
    * @param index
    * @return
    */
    int value(IndexWrapper<int> wrapper) {
        return intBuffer[wrapper.index];
    }

public:

    /**
     * 绑定的结果集的大小,即指列的数量
     * @param resultBindNum
     */
    explicit ResultBinder(int resultBindNum) {
        resultBinds.resize(resultBindNum);
        stringBuffer.resize(resultBindNum);
        intBuffer.resize(resultBindNum);
    }


    /**
     * 绑定数据库查询结果集
     * @param fieldTypes
     * @param index
     */
    void bindValue(enum_field_types fieldTypes, int index) {
        if (typeProcessMap.find(fieldTypes) == typeProcessMap.end()) {
            std::cerr << "[unsupported type]" << fieldTypes << std::endl;
            return;
        }
        //调用绑定函数
        typeProcessMap[fieldTypes](index);
    }

    /**
    * 提取结果集中的结果
    * @param index
    * @return
    */
    template<typename T>
    T value(int index) {
        return value(std::move(IndexWrapper<T>(index)));
    }

    std::vector<MYSQL_BIND> &getBindResult() {
        return resultBinds;
    }
};

4：最后是对mysql查询接口的封装

Connection.hpp


#include "DatabaseOption.hpp"
#include "PrepareBinder.hpp"
#include "ResultBinder.hpp"
#include <mysql.h>
#include <memory>
#include <vector>
#include <iostream>
#include <list>

/**
 * mysql数据库连接
 */
class Connection {
private:
    /**
     * 清除资源内容
     */
    void clear() {
        if (!mysqlRes)
            mysql_free_result(mysqlRes);
        if (!mysqlStmt)
            mysql_stmt_free_result(mysqlStmt);
        records.clear();
        prepareBinder.reset();
        resultBinder.reset();
    }

public:
    /**
    * 数据库连接的初始化配置
    * @param databaseOption
    */
    void setOption(const DatabaseOption &option) {
        this->option = option;
    }


    /**
     * 关闭连接
     */
    void close() {
        if (connection != nullptr) {
            mysql_close(connection);
            connection = nullptr;
        }
    }

    /**
     * 测试数据库连接是否能联通
     * @return
     */
    bool ping() {
        return mysql_ping(connection) == 0;
    }

    /**
     * 获取最后受影响的行数
     * @return
     */
    int getLastAffectedRows() {
        return (int) mysql_affected_rows(connection);
    }

    /**
     * 连接数据库
     * @return
     */
    bool connect() {
        //初始化mysql
        connection = mysql_init(nullptr);
        if (nullptr == connection) {
            setLastError("mysql init failed");
            return false;
        }
        //设置超时时间
        if (option.connectTimeout > 0) {
            if (0 != mysql_options(connection, MYSQL_OPT_CONNECT_TIMEOUT, &option.connectTimeout)) {
                setLastError("set option error");
                return false;
            }
        }
        //编码
        mysql_options(connection, MYSQL_SET_CHARSET_NAME, option.charsetName.c_str());
        mysql_options(connection, MYSQL_OPT_RECONNECT, &option.reconnectTime);
        if (!mysql_real_connect(connection, option.host.c_str(), option.username.c_str(), option.password.c_str(),
                                option.databaseName.c_str(), option.port, nullptr, 0)) {
            setLastError("failed to connect to database");
            return false;
        }
        return true;
    }


    void setLastError(const std::string &lastError) {
        this->lastError = "[" + lastError + "] " + mysql_error(connection);
        std::cerr << this->lastError << std::endl;
    }

    std::string getLastError() const {
        return this->lastError;
    }

    /**
     * 开启事务
     * @return
     */
    bool begin() {
        if (mysql_query(connection, "BEGIN")) {
            setLastError("begin error");
            return false;
        }
        return true;
    }

    /**
     * 提交事务
     * @return
     */
    bool commit() {
        if (mysql_query(connection, "COMMIT")) {
            setLastError("commit error");
            return false;
        }
        return true;
    }

    /**
     * 回滚事务
     * @return
     */
    bool rollback() {
        if (mysql_query(connection, "ROLLBACK")) {
            setLastError("rollback error");
            return false;
        }
        return true;
    }

    /**
     * 执行数据库查询
     * @return
     */
    bool execute() {

        //绑定查询参数
        if (mysql_stmt_bind_param(mysqlStmt, &prepareBinder->getParamBinds()[0])) {
            setLastError("mysql_stmt_bind_param error");
            return false;
        }

        //获取结果集元数据
        mysqlRes = mysql_stmt_result_metadata(mysqlStmt);
        auto columnNum = mysql_num_fields(mysqlRes);
        resultBinder = std::make_shared<ResultBinder>(columnNum);
        //根据表元数据绑定结果集
        for (int i = 0; i < mysqlRes->field_count; i++) {
            resultBinder->bindValue(mysqlRes->fields[i].type, i);
//            std::cout << "name:" << mysqlRes->fields[i].name << " type: " << mysqlRes->fields[i].type << std::endl;
        }
        //绑定查询结果
        if (mysql_stmt_bind_result(mysqlStmt, &resultBinder->getBindResult()[0])) {
            setLastError("mysql_stmt_bind_result");
            return false;
        }

        if (mysql_stmt_execute(mysqlStmt)) {
            setLastError("mysql_stmt_execute error");
            return false;
        }
        return true;
    }


    /**
     * 给placeholder相对应的位置绑定参数
     * @param pos 位置
     * @param value 值
     */
    template<typename T>
    void bindValue(int pos, const T &value) {
        prepareBinder->bindValue(pos, value);
    }

    /**
     * 预处理
     * @param query
     * @return
     */
    bool prepare(const std::string &query) {
        //初始化预处理环境
        mysqlStmt = mysql_stmt_init(connection);
        if (!mysqlStmt) {
            setLastError("mysql_stmt_init error");
            return false;
        }
        if (mysql_stmt_prepare(mysqlStmt, query.c_str(), query.size())) {
            setLastError("mysql_stmt_prepare error");
            return false;
        }
        //获取预处理绑定的参数个数
        auto paramCount = mysql_stmt_param_count(mysqlStmt);
        prepareBinder = std::make_shared<PrepareBinder>(paramCount);
        return true;
    }

    /**
     * 获取下一条记录
     * @return
     */
    bool next() {
        //0表示正确,其他情况返回错误
        if (mysql_stmt_fetch(mysqlStmt) != 0) {
            //若没有下一个了,就清除资源
            clear();
            return false;
        }
        return true;
    }

    /**
    * 提取结果集中的结果
    * @param index
    * @return
    */
    template<typename T>
    T value(int index) {
        return resultBinder->value<T>(index);
    }

private:
    MYSQL *connection = nullptr;
    MYSQL_STMT *mysqlStmt = nullptr;
    MYSQL_RES *mysqlRes = nullptr;//结果

    std::string lastError;//最后的错误信息
    DatabaseOption option;//数据库配置信息

    std::shared_ptr<PrepareBinder> prepareBinder = nullptr;
    std::shared_ptr<ResultBinder> resultBinder = nullptr;

};

三：接口测试

1：数据库的准备

mysql> create database test;
mysql> use test;
mysql> select * from user;
mysql> insert into user(id,name)values(1,"zhangsan"),(2,"lisi"),(3,"wangwu"),(4,"liwu");
mysql> select * from user;
+------+----------+
| id   | name     |
+------+----------+
|    1 | zhangsan |
|    2 | lisi     |
|    3 | wangwu   |
|    4 | liwu     |
+------+----------+

2：测试代码

main.cpp

#include <Connection.hpp>

int main() {

    Connection connection;
    connection.setOption(DatabaseOption());//初始化配置
    connection.connect();//连接数据库
    std::string sql = "select name,id from user where `id` > ? and `name` like ?";
    connection.prepare(sql);//预处理
    connection.bindValue(0, 1);//绑定查询参数
    connection.bindValue(1, "%wu");
    connection.execute();//执行查询
    while (connection.next()) {
    	//获取结果
        std::cout << "id = " << connection.value<int>(1);
        std::cout << " name = " << connection.value<std::string>(0) << std::endl;
    }

    return 0;
}

输出结果如下

id = 3 name = wangwu
id = 4 name = liwu

四：后续

后续加入数据库连接池

MySQL数据库专栏（五）连接MySQL数据库C API篇
11-09 565
本篇文章主要介绍通过C语言API接口链接MySQL数据库，各接口功能及使用方式，辅助类的封装及调用实例，可以直接移植到项目里面使用。
C++利用MySQL API连接和操作数据库实例详解
08-31
首先，C++连接和操作MySQL数据库有多种方式，其中包括了ADO、ODBC和直接使用MySQL API。ADO是一种基于COM的中间层技术，能够支持多种数据源，包括关系型和非关系型数据库。而ODBC是一种数据库访问协议，通过ODBC驱动...
c++ mysql数据库操作api接口的封装
12-14
目录一：关键接口说明二：具体实现三：接口测试四：后续 一：关键接口说明 一般预处理流程都是，连接数据库–>预处理–>绑定查询参数–>执行查询–>获取查询结果。 故api封装之后有如下几个关键的接口： 1：bool connect(); //连接数据库，初始化数据库连接等 2：bool prepare(const std::string &query);//预处理 3：template void bindValue(int pos, const T &value);//给placeholder相对应的位置绑定参数 4：bool execute();//执行数据库查询 5：bool next();
c++ 封装 API （一）
juluwangriyue的博客
10-29 723
1、.def的一些小知识: .def 文件中的第一条 LIBRARY 语句不是必须的， 但LIBRARY 语句后面的 DLL 的名称必须正确，即与生成的动态链接库的名称必须匹配。 此语句将 .def 文件标识为属于 DLL。 链接器将此名称放到 DLL 的导入库中。 EXPORTS 语句列出名称，可能的话还会列出 DLL 导出函数的序号值。通过在函数名的后面加上 @ 符和一个数字，给函数分配序号值。当指定序号值时，序号值的范围必须是从 1 到 N，其中 N 是 DLL 导出函数的个数。 LIB...
一招搞定：用QuickAPI把MySQL数据快速发布成API
最新发布
lgbingyu00的博客
03-13 1973
​开发中，把 MySQL 数据变成 API 是家常便饭，但传统方法——搭服务器、写代码、部署——实在太磨人。今天推荐个本地部署的神器：QuickAPI，麦聪软件出品的企业级低代码工具，3分钟就能把数据库数据发布成 API。
C++ API封装
Programer From Scrach
09-21 768
class API { public:     virtual void method1() = 0; }; class Factory { public:     API* CreateAPI(); };
C++ 访问MySql 接口封装
jeremy的博客
09-14 6778
一般操作mysql可以直接在使用sql语句来建立数据库，修改、查询以及删除等。如果在程序里想要访问数据库又该如何操作呢？下文便是一个简单的例子，能够完成基本的操作，可在此基础上扩充，这个例子也是我将一个开源项目对mysql的部分操作提取出来，加以修改而来。 环境要求linux 平台支持 C++11 安装 mysql 、mysql-devel以及mysqlclient。 源码地址 https:...
c语言 api封装方法,C++实现修改函数代码HOOK的封装方法
weixin_36433950的博客
05-20 369
本文实例讲述了C++实现修改函数代码HOOK的封装方法，分享给大家供大家参考。具体实现方法如下：一、对外的接口如下：1. 类初始化时对函数HOOK2. 取消挂钩：void UnHook();3. 重新挂钩：void ReHook();在初始化时HOOK的代码：复制代码 代码如下:*(DWORD*)(m_btNewBytes+1) = (DWORD)pfnHook;8个字节的代码地址 0xB8, 0...
C++ MySQL数据库操作API封装关键接口与实现
本文档主要介绍了如何在C++中封装MySQL数据库...通过本文档，读者可以了解到如何在C++中高效地利用MySQL数据库，以及如何通过API封装来提高代码的复用性和可维护性。这是一篇对数据库操作开发者非常有价值的参考材料。
埋点用例管理_API管理平台之SCF服务测试篇
weixin_39672011的博客
11-21 566
导语针对58自主研发RPC服务的测试平台，功能主要包含接口测试、接口文档自动生成、服务MOCK以及自动化用例管理等。简介API管理平台是集接口管理、文档管理、接口测试、MOCK、接口自动化和接口性能于一体的全新平台，致力于提升接口在接口设计、开发、测试和上线等整个生命周期各个环节的执行效率。API管理平台整体系统设计在前面文章《API管理平台之系统设计篇》已经做过介绍，本文主要是介绍58...
C++ 一个用api封装的串口类
04-23
C++ 一个用api封装的串口类。 一个用window api封装的串口类，此串口类已经在项目中使用，运行稳定可靠，方便使用，也能给初学串口的朋友一些参考，编译器用visual C++6.0，希望给用到的朋友一些帮助。 串口类
LUA的C++ API封装
12-13
一个自己随笔封装的LuaApi,未经大规模测试,可做参考使用,希望有人可以帮忙改进.
C++MYSQL API封装类及应用例子
06-10
封装类MYSQL的API函数，有一个例子，适合拿来用，不会的可以借鉴例子学习
通过C++方式实现mysql数据库的访问接口
11-08
通过C++方式实现mysql数据库的访问接口。 CRDBI.h/CRDBI.cpp 访问接口 MySqlHandle.h/MySqlHandle.cpp --支持mysql数据库 OracleHandle.h/OracleHandle.cpp --支持Oracle数据库（可扩充） 另可据此设计框架，实现不同数据库类型的访问。
私人博客定制----封装数据库接口
LXY的博客
11-10 389
封装MySQLAPI 我们先把初始化句柄和断开句柄进行一个封装 static MYSQL* MySQLInit(){ //1.初始化一个Mysql句柄建立连接 MYSQL* connect_fd = mysql_init(NULL); //2.和数据库建立连接 if (mysql_real_conne...
C++操作数据库——mysql接口
yinhaijing_ss的专栏
07-19 1132
1. mysql API编程步骤 初始化操作句柄； 通过句柄连接mysql服务器； 设置客户端字符集(utf8)； 选择使用的数据库； 执行语句： 增、删、改：执行语句——对数据库进行操作。 查询：执行语句——对数据库进行查询操作，并遍历访问查询到的结果集； 关闭句柄，释放资源。 2. mysql API介绍 2.1相关数据结构 MYSQL ：mysql结构体，用来作为操作句柄。 MYSQL_RES ：结果集，类似于二维数组，行表示结果集条数，列为每一条数据的各个字段。 MYS
C++封装mysql的基本API
Shreck66的专栏
09-09 4652
最近在做数据库的实验，觉得c语言提供的关于mysql的API用起来好麻烦，于是就用C++进行了简单的封装，同时也算对mysql的基本API的一个学习吧代码如下#include<iostream> #include<string> #include<mysql/mysql.h> class Sql { public: //构造函数用来初始化mysql和连接数据库
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值