封装一个自己的mysql类

最新推荐文章于 2023-09-11 23:22:45 发布
最新推荐文章于 2023-09-11 23:22:45 发布
阅读量723 收藏 1
点赞数 1
分类专栏： 开发一个服务器 文章标签： c++ mysql 后端
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_41857871/article/details/124290449
版权

1.封装的目的

        mysql提供了较多的api，但是这些api的功能较为单一，而我们自己在使用的时候，经常为了实现一个简单的想法，但是要调用多个函数去实现我们的功能，我们可以根据自己的需求，重新封装一下mysql,这样便于我们项目的开发和提升代码的可读性。

        这里的代码是在前面博客的基础上开发的，如果比较熟悉mysql和proto的话，可以只看XMysql的实现。如果不熟悉的话，建议可以阅读博主前面几篇博客。

2.封装一个XMysql类

①这个类可以保证基本的增删改查需求。

②保证执行时mysql的服务连接。

③简化初始化连接过程。

④可以返回protobuf格式的操作结果。

⑤可以返回普通的字符串格式的操作结果。

XMysql.h的代码

#ifndef X_MYSQL
#define X_MYSQL

#include "mysqlToProtobuf.h"
#include "/usr/local/mysql/include/mysql.h"
#include <iostream>
#include <vector>

struct XMysqlRes
{
    bool suc = false;
    std::vector<std::vector<std::string>> res;
};

class XMysql
{
    public:
        //初始化数据库
        bool init(const char* host, const char* user, const char* pwd, const char* db, const uint32_t timeout = 2);
        //有返回的操作
        XMysqlRes exeSqlStore(const char* sql);
        //无返回的操作
        bool exeSql(const char* sql);
        //定义一个模板，针对不同的protobuf结构
        template<typename PROTO_TYPE>
        //这里必须再类内实现，在类外实现的话，进行外部链接的时候会出错
        bool exeSqlProtobuf(const char* sql, std::vector<std::shared_ptr<PROTO_TYPE>>& protoRes)
        {
            if (!exeSql(sql)) {
                std::cout << "XMysql exeSqlStore error! sql=" << sql << std::endl;
                return false;
            }
            //转成protobuf形式
            mysqlToProtobuf(mysql_store_result(&m_mysql), protoRes);
            return true;
        }
        //校验连接状态
        void check();
        //连接数据库
        bool connect();

    private:
        MYSQL m_mysql;
        std::string m_host = "";
        std::string m_user = "";
        std::string m_pwd = "";
        std::string m_db = "";
        uint32_t m_timeout = 0;
};

#endif

XMysql.cpp

#include "XMysql.h"

bool XMysql::init(const char* host, const char* user, const char* pwd, const char* db, const uint32_t timeout)
{
    m_host = host;
    m_user = user;
    m_pwd = pwd;
    m_db = db;
    m_timeout = timeout;

    if (connect()) {
        std::cout << "XMysql connect error" << std::endl;
        return false;
    }

    return true;
}

bool XMysql::exeSql(const char* sql)
{
    if (mysql_real_query(&m_mysql,sql,strlen(sql)) != 0) {
        std::cout << "XMysql exeSql error! sql=" << sql << std::endl;
        return false;
    }
   return true;
}

XMysqlRes XMysql::exeSqlStore(const char* sql)
{
    XMysqlRes res;
    check();
    if (!exeSql(sql)) {
        std::cout << "XMysql exeSqlStore error! sql=" << sql << std::endl;
        return res;
    }
    //执行成功
    res.suc = true;
    //查询结果
    auto result = mysql_store_result(&m_mysql);
    //行数
    auto rowNum = mysql_num_rows(result);
    //列数
    auto fiedNum = mysql_num_fields(result);
    for (int i = 0; i < rowNum; i++) {
        auto row = mysql_fetch_row(result);
        std::vector<std::string> rows;
        for (int j = 0; j < fiedNum; j++) {
            rows.push_back(row[j]);
        }
        res.res.push_back(rows);
    }

    return res;
}

void XMysql::check()
{
    //ping返回0时表示正常
    if (mysql_ping(&m_mysql) != 0) {
        std::cout << "XMysql ping == 0" << std::endl;
        //关闭mysql
        mysql_close(&m_mysql);
        return;
    }
    
    //重新连接
    connect();
}

bool XMysql::connect()
{
    //初始化
    if (!mysql_init(&m_mysql)) {
        std::cout << "XMysql init error!" << std::endl;
        return false;
    }
    //连接数据库
    if (!mysql_real_connect(&m_mysql, m_host.c_str(), m_user.c_str(), m_pwd.c_str(), m_db.c_str(), 0, NULL, CLIENT_MULTI_STATEMENTS)) {
        std::cout << "XMysql connect error!" << std::endl;
        return false;
    }
    //设置参数
    mysql_options(&m_mysql, MYSQL_OPT_READ_TIMEOUT, &m_timeout);
    mysql_options(&m_mysql, MYSQL_SET_CHARSET_NAME, "utf8");
}

mysqlToProtobuf.h

#ifndef FIRE_PROCESS_PROCESS_MYSQLER_MYSQL_PROTOBUF_H
#define FIRE_PROCESS_PROCESS_MYSQLER_MYSQL_PROTOBUF_H

#include "/usr/local/mysql/include/mysql.h"
#include <google/protobuf/stubs/common.h>
#include <google/protobuf/arena.h>
#include <google/protobuf/arenastring.h>
#include <google/protobuf/generated_message_util.h>
#include <google/protobuf/metadata.h>
#include <google/protobuf/message.h>
#include <google/protobuf/repeated_field.h>
#include <google/protobuf/extension_set.h>
#include <google/protobuf/unknown_field_set.h>

#include <vector>
#include <memory>
#include <iostream>

/*
把mysql查询出来的结果MYSQL_RES* 根据定义的protobuf去解析,
这样可以把结果转换成protobuf的格式，可以省去解析的流程。
*/
// 表行数据转为对应protobuf
template<typename PROTO_TYPE>
bool mysqlToProtobuf(MYSQL_RES* res, std::vector<std::shared_ptr<PROTO_TYPE>>& msgVec)
{
    //查询失败
    if (!res) {
        std::cout << "xmysql res == nullptr" << std::endl;
        return false;
    }
    //sql查询结果行数
    int rowNum = mysql_num_rows(res);
    //sql查询结果字段数量
    int fcount = mysql_num_fields(res);
    for (int i = 0; i < rowNum; ++i) {
        MYSQL_ROW row = mysql_fetch_row(res);
        if (!row) {
            std::cout << "xmysql fethRow = nullptr" << std::endl;
            return false;
        }

        //申请空间保存结果
        auto message = std::make_shared<PROTO_TYPE>();
        const google::protobuf::Reflection* reflection = message->GetReflection();
        const google::protobuf::Descriptor* descriptor = message->GetDescriptor();
        if (!reflection || !descriptor) {
            return false;
        }

        //判断是否匹配
        if (fcount != descriptor->field_count()) {
            std::cout << "mysql_field != proto_field" << std::endl;
            return false;
        }

        //遍历proto所有的字段
        for (int i = 0; i < descriptor->field_count(); ++i) {
            //得到对应proto的描述
            const google::protobuf::FieldDescriptor* desField = descriptor->field(i);
            // 剔除repeated类型
            if (desField->label() == google::protobuf::FieldDescriptor::LABEL_REPEATED) {
                return false;
            }
            //根据类型进行string转换
            switch (desField->type()) {
                // int32_t
                case google::protobuf::FieldDescriptor::TYPE_INT32:
                    {
                        reflection->SetInt32(message.get(), desField, std::stoi(row[i]));
                        break;
                    }
                    // int64_t
                case google::protobuf::FieldDescriptor::TYPE_INT64:
                    {
                        reflection->SetInt64(message.get(), desField, std::stoll(row[i]));
                        break;
                    }
                    // uint32_t
                case google::protobuf::FieldDescriptor::TYPE_UINT32:
                case google::protobuf::FieldDescriptor::TYPE_FIXED32:
                    {
                        reflection->SetUInt32(message.get(), desField, std::stoul(row[i]));
                        break;
                    }
                    // int64_t
                case google::protobuf::FieldDescriptor::TYPE_UINT64:
                case google::protobuf::FieldDescriptor::TYPE_FIXED64:
                    {
                        reflection->SetUInt64(message.get(), desField, std::stoull(row[i]));
                        break;
                    }
                    //string bytes
                case google::protobuf::FieldDescriptor::TYPE_STRING:
                    {
                        reflection->SetString(message.get(), desField, row[i]);
                        break;
                    }
                case google::protobuf::FieldDescriptor::TYPE_BYTES:
                    {
                        //获取结果的长度
                        auto len = mysql_fetch_lengths(res);
                        reflection->SetString(message.get(), desField, std::string(row[i], len[i]));
                        break;
                    }
                    // double 
                case google::protobuf::FieldDescriptor::TYPE_DOUBLE:
                    {
                        reflection->SetDouble(message.get(), desField, std::stod(row[i]));
                        break;
                    }
                    // bytes
                case google::protobuf::FieldDescriptor::TYPE_FLOAT:
                    {
                        reflection->SetFloat(message.get(), desField, std::stof(row[i]));
                        break;
                    }
                    // bool
                case google::protobuf::FieldDescriptor::TYPE_BOOL:
                    {
                        reflection->SetBool(message.get(), desField, std::stoi(row[i]));
                        break;
                    }
                    //暂时只写比较基础的类型，后面的再丰富
                default:
                    {
                        std::cout << "undeal mysql type " << desField->type() << "\n";
                    }
            }
        }
        msgVec.push_back(message);
    }
    return true;
}


#endif

main.cpp

#include <iostream>
#include "../proto/src/User.pb.h"
#include "XConfig.h"
#include "XMysql.h"

int main(int argc, char** argv)
{
    //加载配置
    XConfig config;
    if (!config.load(argv[1])) {
        std::cout << "load config error !" << std::endl;
        return -1;
    }

    //调用配置
    std::string host = config.getConfigValue("mysql", "host");
    std::string user = config.getConfigValue("mysql", "user");
    std::string pwd = config.getConfigValue("mysql", "pwd");
    std::string db = config.getConfigValue("mysql", "db");

    //试试封装好的类
    XMysql mysql;
    if (!mysql.init(host.c_str(), user.c_str(), pwd.c_str(), db.c_str())) {
        std::cout << "init mysql error!" << std::endl;
        return -1;
    }

    User user1;
    user1.set_id(200);
    user1.set_nickname("窑下村吴彦祖");
    std::string str = "";
    user1.SerializeToString(&str);

    //测试无返回类型的
    char sql[128];
    snprintf(sql, sizeof(sql), "insert into user_data(user_id, user_data) value (%d, \'%s\');", user1.id(), str.c_str());
    if (!mysql.exeSql(sql)) {
        return -1;
    }

    //测试返回普通结果
    char sql2[] = "select * from user_data;";
    auto res = mysql.exeSqlStore(sql2);
    if (res.suc == false) {
        return -1;
    }
    User user3;
    for (auto& rows : res.res) {
        for (auto& field : rows) {
            std::cout << field <<" ";
        }
        std::cout << std::endl;
    }

    //测试返回protobuf
    std::vector<std::shared_ptr<User>> protoRes;
    if (!mysql.exeSqlProtobuf(sql2, protoRes)) {
        return -1;
    }
    for (auto user : protoRes) {
        user3.ParseFromString(user->nickname());
        std::cout << "user_id = " << user3.id() << "nickname =" << user3.nickname() << std::endl;
    }

    return 0;
}

Makefile

cc=g++

cc_flags=-std=c++11 \
	 -I/usr/local/mysql/include \

ln_flags=-L/usr/local/lib -lprotobuf \
	 -L/usr/local/mysql/lib -lmysqlclient \
	 -lpthread \
	 -lm \
	 -ldl \

obj=main.o \
    XConfig.o \
    XMysql.o \
    ../proto/src/User.pb.o \
    
target=process

$(target) : $(obj)
	$(cc) $(ln_flags) $(obj) -o $(target)

%.o : %.cpp
	$(cc) $(cc_flags) -c $< -o $@

%.o: %.cc
	$(cc) $(cc_flags) -c $< -o $@

clean:
	rm -f $(obj) $(target)

3.执行结果

 4.小结

这里在处理返回结果的时候，用了两种方法，一种是把MYSQL_RES*映射成protobuf的message指针，另一种是把结果保存到struct XMysqlRes中,这两种方案都可以节省很多代码量，其中,protobuf和mysql的映射可以多花一点时间看看。

窑下村吴彦祖
关注
  • 1
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
操作mysql(封装类)
04-05
在vc中通过连接池操作mysql(封装类)
php mysql 封装类实例代码
10-21
主要介绍了php mysql 封装类实例代码，非常不错，具有参考借鉴价值,需要的朋友可以参考下
mysql中如何进行对象的封装_面向对象基础----封装数据库操作类
weixin_32973973的博客
02-18 623
思考：现在掌握了很多面向对象相关的内容，但是什么时候封装类？怎么封装？如果使用类成员？引入：其实类的封装没有多么复杂，但是需要一个熟练的过程来确定哪些东西可以放到类里，该用什么样的形式等。我们通过封装一个数据库的操作来综合练习下封装数据库类 掌握定义：封装数据库操作类，即根据数据库的操作需求，来确认数据库操作类该有什么样的功能，以及这些功能该如何实现。1.一个类通常就是一个文件，所以要先确定文件的...
mysql 封装类_封装mysql类
weixin_32264185的博客
01-18 121
类:header("content-type:text/html;charset=utf-8");//封装一个类/*掌握满足单例模式的必要条件(1)私有的构造方法-为了防止在类外使用new关键字实例化对象(2)私有的成员属性-为了防止在类外引入这个存放对象的属性(3)私有的克隆方法-为了防止在类外通过clone成生另一个对象(4)公有的静态方法-为了让用户进行实例化对象的操作*/class db{...
MySQL----MySQLi 类封装
Damys
07-21 1432
<?php class DB_mysqli { protected $mysqli; //mysqli实例对象 public $sql; //sql语句 protected $rs; //结果集 prote
mysql jdbc 封装类_【JDBC】Java 连接 MySQL 基本过程以及封装数据库工具类
weixin_35126737的博客
01-20 321
一. 常用的JDBC API1.DriverManager类 ： 数据库管理类，用于管理一组JDBC驱动程序的基本服务。应用程序和数据库之间可以通过此类建立连接。常用的静态方法如下static connection getConnection(String url, String user, String password)　　- 获取指定URL的数据库连接static Driver get...
Mysql类的封装
我的博客
11-02 512
封装一下Mysql类方便项目使用，如果又遇到后续的需求再进行添加，也可以制作成动态库更加方便
mysql数据库封装
最新发布
Hdmi764287459的博客
09-11 121
【代码】mysql数据库封装。
MySQL数据库模块代码DB
TABE_的博客
11-04 366
MySQL数据库代码封装db.hppdb.cpp 为了减少业务模块ChatService的复杂度，我们将数据库的增删改查操作封装成一个单独的类。 db.hpp 我们在include下的server下的db下，创建头文件db.hpp: #ifndef DB_H #define DB_H #include <mysql/mysql.h> #include <string> using namespace std; //数据库操作类 class MySQL { public:
【实战】nodejs 必会技能 —— 封装 mysql 数据库连接
程序边界
02-08 3208
运行中若遇到如下报错，请检查输入信息是否正确（host、port、user、password 等），jdbc配置中拿到的相关信息尤其是密码很可能是加密后的。若是担心网络问题造成连接失败，可以在连接reject部分添加定时并回调连接。数据库连接池 pool 可以有效避免频繁连接、断开导致的资源消耗。欢迎留言一起学习探讨。
php实现mysql封装类示例
10-25
主要介绍了php实现mysql封装类示例,需要的朋友可以参考下
一个不错的mysql封装类.zip
05-10
一个不错的mysql封装类 。一个不错的mysql封装类 。。。
Python3实现的Mysql数据库操作封装类
09-09
主要介绍了Python3实现的Mysql数据库操作封装类,涉及Python针对mysql数据库的连接、查询、更新及关闭连接等相关操作技巧,需要的朋友可以参考下
C#操作mysql数据库的封装类
07-07
C#操作mysql数据库的封装类，带注释，代码完整，适合企业级开发
python——MySQL封装操作
python全栈
10-06 2254
【代码】python——MySQL封装操作。
MYSQL封装
Duck_1024
08-26 217
MYSQL封装
mysql 封装类_mysql的c++封装类
weixin_42498487的博客
01-18 178
文件:cppmysql.rar大小:6KB下载:网上对mysql的c++封装类都不太好，这是我封装的mysql封装类，大家可以任意使用，如果有问题请与我联系。//.h////////////////////////////////////////////////////////////////////////////////// CppMysql - A C++ wrapper around th...
【MySQL】Java连接MySQL数据库（封装版只需会MySQL）
qq_61903414的博客
02-19 610
map是一组键值对，键是要查询数据库表的字段名，值是其对应的Java类型（如varchar(20)对应String)如果创建的是普通的Java项目，我们需要去maven仓库下载jdbc驱动包然导入项目中就能使用，具体步骤详见。如果创建的项目是maven项目，我们只需在pom.xml文件里引入一组依赖即可。创建实例JDBCDemo传入要操作的数据库的库名以及数据库密码。引入依赖后点击右侧的maven刷新即可。只需传入增加数据的SQL语句即可。只需传入修改的SQL语句即可。只需传入删除的SQL语句即可。
Java jdbc连接mysql 封装类
Amewin的博客
05-26 3030
Java jdbc连接mysql 封装类 开发工具与关键技术：java、 myelipse2017、jdk1.8 作者：Amewin 撰写时间：2019年5月26日 JDBC简介： JDBC全称为java database connectivity，是sun公司指定的java数据库连接技术的简称。 他是sun公司和数据库开发商共同开发出来的独立于DBMS的应用程序接口，它为java程序员进行...
使用python封装一个mysql类
03-21
好的，以下是一个简单的Python封装MySQL类的示例代码： ```python import mysql.connector class MySQL: def __init__(self, host, user, password, database): self.host = host self.user = user self....

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值