C/C++ Linux protobuf2 简单用法记录

最新推荐文章于 2023-07-19 20:55:30 发布
最新推荐文章于 2023-07-19 20:55:30 发布
阅读量924 收藏 2
点赞数 1
分类专栏： c++ 文章标签： linux C/C++ protobuf
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/cpp_learner/article/details/129973154
版权

简单记录以下protobuf2的用法，以后忘记了可以回顾一下！（这是谷歌的一个库）

一、protobuf安装

mirrors / google / protobuf · GitCodeProtocol Buffers - Google's data interchange format 🚀 Github 镜像仓库 🚀 源项目地址 ⬇...https://gitcode.net/mirrors/google/protobuf?utm_source=csdn_github_accelerator点击上面的连接去下载！

然后执行命令安装必要条件：

apt-get install autoconf automake libtool curl make g++ unzip 

centos系统将apt-get 改为 yum

依次执行以下命令安装：(进入root用户) 

unzip protobuf-master.zip

cd protobuf-master/

./autogen.sh

./configure

make

make check

make install

ldconfig

头文件所在路径：/usr/local/include/

库所在路径：/usr/local/lib

 安装完毕！

二、编写.proto文件

编写按照如下格式去编写：

message 名字
{
    required 类型 变量名   = 1;   
    required 类型 变量名  = 2;   
    optional 类型 变量名  = 3;   
}

message是固定的，开头需要写上；

required是属性，一共有三种属性，分别是，required、optional、repeated

  • required：表示该值是必须要设置的；
  • optional：消息格式中该字段可以有0个或1个值（不超过1个）；即可以不用设置它；
  • repeated：在一个格式良好的消息中，该值可以被设置多个值；

也就是说，设置了required，就必须给他设置值；

repeated int32 code= 4 [packed=true];        // 定义时可以这样，效率会高点

设置了optional，可以不用给他设置值，但要设置默认值，如下：

optional std::string data = 3 [default = 10];

设置了repeated，(可以说是枚举)也要给他设置值，且它可以被设置多个值；

类型可以是以下：（在其他博客截图的）

后面赋值 1， 2， 3，根据顺序赋值，从1开始，自增赋值即可！

如下编写案例：

ptb.proto

syntax = "proto2";

package tutorial;



message response
{
    required int32 code   = 1;   
    required int32 icode  = 2;   
    optional string data  = 3;   
}



message list_account_records_response
{
    required int32   code   = 1;    
    optional string  desc   = 2;    
    message account_record
    {
        required int32  type      = 1; 
        required int32  limit     = 2; 
        required uint64 timestamp = 3; 
    }

    repeated account_record records = 3;
}

开头一定要写上：

syntax = "proto2";        // 用的是protobuf2,所以这里写proto2

package tutorial;        // 这个是命名空间

三、编译.proto文件

编译语法：

protoc -I=$SRC_DIR --cpp_out=$DST_DIR  ptb.proto

SRC_DIR 表示proto文件所在的目录，cpp_out指定了生成的代码的路径， ptb.proto指proto文件名。

protoc -I=./ --cpp_out=./ ptb.proto

这样在当前目录生成了ptb.pb.cc和ptb.pb.h两个文件。

四、代码使用

接下来使用代码去操作。

set_变量名();        // 设置属性值

变量名();                // 获取值

SerializeToString();        // 将类格式化为stirng类型字符处

 ParseFromString();        // 将字符串转换为类

 add_变量名()；                // 生成一个repeated 对象返回

编译命令：g++ -std=c++11 test.cc ptb.pb.cc -lprotobuf

test.cc 

#include "ptb.pb.h"
#include <string>
#include <iostream>


using namespace std;
using namespace tutorial;


int main(void) {
    
    /* 1、 */
    {
        std::string data;    // 存储序列化的消息
       
        // 模拟客户端发送请求
        {
            response res;
            res.set_code(200);
            res.set_icode(123);
            res.set_data("字符串");
        
            // 将类格式化为stirng类型字符处
            res.SerializeToString(&data);
        
            // 客户端将data发送给服务器
        }
        
        // 模拟服务器接受请求
        {
            response res;
        
            // 将字符串转换为
            res.ParseFromString(data);
        
            std::cout << "code = " << res.code() << std::endl;
            std::cout << "icode = " << res.icode() << std::endl;
            std::cout << "data = " << res.data() << std::endl;
        }   
    }
    
    printf("-------------华丽的分隔符-------------\n");
    
    /* 2、 */
    {
        std::string data;    // 存储序列化的消息

        // 模拟客户端发送请求
        {
            list_account_records_response larr;
            
            larr.set_code(200);
            larr.set_desc("ok");

            for (int i = 0; i < 2; i++) {
                // 分配一个对象
                list_account_records_response_account_record *ar = larr.add_records();
                ar->set_type(i);
                ar->set_limit(i * 100);
                ar->set_timestamp(time(NULL));
            }

            // 输出records的个数
            printf("client：recoreds size : %d\n", larr.records_size());

            // 将类格式化为stirng类型字符处
            larr.SerializeToString(&data);

            // 客户端将data发送给服务器
        }

        // 模拟服务器接受请求
        {
            list_account_records_response larr;

            larr.ParseFromString(data);

            // 输出records的个数
            printf("server：recoreds size : %d\n", larr.records_size());
            
            printf("code: %d\n", larr.code());
            printf("desc: %s\n", larr.desc().c_str());

            for (int i = 0; i < 2; i++) {
                const list_account_records_response_account_record &ar = larr.records(i);
                printf("type: %d\n", ar.type());
                printf("limit: %d\n", ar.limit());
                printf("timestamp: %lu\n", ar.timestamp());
            }
        }
    }

    return 0;
}

五、protobuf与libevent结合使用

client.cc

g++ -std=c++11 client.cc ptb.pb.cc -lprotobuf -levent -o client.exe 

#include <sys/types.h>
#include <sys/socket.h>
#include <netinet/in.h>
#include <arpa/inet.h>
#include <errno.h>
#include <unistd.h>

#include <stdio.h>
#include <string.h>
#include <stdlib.h>

#include <event.h>
#include <event2/util.h>

#include "ptb.pb.h"
#include <string>
#include <time.h>



using namespace std;
using namespace tutorial;

#define COUNT 3

int connect_server(const char *server_ip, int port);
void cmd_read_data(int fd, short events, void *arg);
void socket_read_data(int fd, short events, void *arg);


int main(int argc, char **argv) {
    
    if (argc < 3) {
        printf("please input 2 parameters!\n");
        return -1;
    }
    
    // 两个参数依次是服务器的IP地址和端口号
    int sockfd = connect_server(argv[1], atoi(argv[2]));
    if (-1 == sockfd) {
        perror("tcp_connect error!");
        return -1;
    }
    
    printf("connect to server successfully\n");
    
    
    struct event_base *base = event_base_new();
    
    // 监听服务端发送的消息
    struct event *ev_sockfd = event_new(base, sockfd, EV_READ | EV_PERSIST, socket_read_data, NULL);
    event_add(ev_sockfd, NULL);
    
    // 监听终端输入事件
    struct event *ev_cmd = event_new(base, STDIN_FILENO, EV_READ | EV_PERSIST, cmd_read_data, (void *)&sockfd);
    event_add(ev_cmd, NULL);
    
    // 事件循环
    event_base_dispatch(base);
    
    event_base_free(base);
    
    printf("finished\n");
    
    return 0;
}


void cmd_read_data(int fd, short events, void *arg) {
    char msg[1024] = { '\0' };
    std::string data = "";
    
    int ret = read(fd, msg, sizeof(msg) - 1);
    if (0 == ret) {
        printf("connection close. exit!\n");
        exit(1);
    }
    if (ret < 0) {
        perror("read failed!");
        exit (1);
    }
    
    int sockfd = *((int *)arg);
    
    if (msg[ret - 1] == '\n') {
        msg[ret - 1] = '\0';
    } else {
        msg[ret] = '\0';
    }
    

    {
        list_account_records_response larr;
        
        larr.set_code(200);
        larr.set_desc(msg);

        for (int i = 0; i < COUNT; i++) {
            // 分配一个对象
            list_account_records_response_account_record *ar = larr.add_records();
            ar->set_type(i + 1);
            ar->set_limit((i+1)*10);
            ar->set_timestamp(time(NULL));
        }
        
       //printf("recoreds size: %d\n", larr.records_size());

        // 将类格式化为stiring类型字符串
        larr.SerializeToString(&data);
    }


    // 把终端的消息发送给服务器端，客户端忽略性能考虑，直接利用阻塞方式发送
    //printf("write to server >>> %s\n", msg);
    ret = write(sockfd, data.c_str(), data.length());
    if (ret == -1) {
        perror("write to server failed!");
        exit(1);
    }
    //printf("ret  =  %d\n", ret);
    
    if (strncmp(msg, "exit", 4) == 0) {   
        memset(msg, 0, sizeof(msg));
        write(sockfd, msg, sizeof(msg));
        usleep(100000); // 100ms
        close(sockfd);
        exit(1);
    }

}


void socket_read_data(int fd, short events, void *arg) {
    char msg[1024] = { '\0' };
    
    // 不考虑一次读不完数据的情况
    int len = read(fd, msg, sizeof(msg) - 1);
    if (0 == len) {
        printf("connection close. exit!\n");
        exit(1);
    } else if (len < 0) {
        perror("read failed!");
        return ;
    }
    
    msg[len] = '\0';
   
    std::string data = msg;
    list_account_records_response larr;

    // 字符串转化为对象
    larr.ParseFromString(data);

    printf("code: %d\n", larr.code());
    printf("desc: %s\n", larr.desc().c_str());

    for (int i = 0; i < COUNT; i++) {
        const list_account_records_response_account_record &ar = larr.records(i);
        printf("type: %d\n", ar.type());
        printf("limit: %d\n", ar.limit());
        printf("time: %lu\n", ar.timestamp());
    }
 
    //printf("recv from server <<< %s\n", msg);
}


typedef struct sockaddr SA;
int connect_server(const char *server_ip, int port) {
    int sockfd, status, save_errno;
    struct sockaddr_in server_addr;
    
    memset(&server_addr, 0, sizeof(server_addr));
    
    server_addr.sin_family = AF_INET;
    server_addr.sin_port = htons(port);
    status = inet_aton(server_ip, &server_addr.sin_addr);
    
    if (0 == status) {
        errno = EINVAL;
        return -1;
    }
    
    sockfd = socket(PF_INET, SOCK_STREAM, 0);
    
    status = connect(sockfd, (SA *)&server_addr, sizeof(server_addr));
    if (-1 == status) {
        save_errno = errno;
        close(sockfd);
        errno = save_errno;     // the close may be error
        return -1;
    }
    
    return sockfd;
}

  

server.cc

g++ -std=c++11 server.cc ptb.pb.cc -lprotobuf -levent -o server.exe 

#include <stdio.h>
#include <string.h>
#include <errno.h>
#include <stdlib.h>
#include <unistd.h>
#include <event.h>
#include <event2/event.h>
#include <event2/listener.h>
#include <assert.h>
#include <arpa/inet.h>

#include <string>
#include <time.h>

#include "ptb.pb.h"


using namespace std;
using namespace tutorial;


#define COUNT	3
#define BUFLEN  1024


typedef struct _ConnectStat {
    struct bufferevent *bev;
    char buf[BUFLEN];
}ConnectStat;


ConnectStat *stat_init(struct bufferevent *bev);
void do_echo_request(struct bufferevent *bev, void *arg);           // 读数据
void do_echo_response(struct bufferevent *bev, void *arg);          // 写数据
void event_cb(struct bufferevent *bev, short event, void *arg);     // 出错处理函数
int tcp_server_init(int port, int listen_num);
void listener_cb(struct evconnlistener *listener, evutil_socket_t fd, struct sockaddr *sock, int socklen, void *arg);   // 监听函数



struct event_base *base;

int main(int argc, char **argv) {
 
    struct sockaddr_in sin;
    memset(&sin, 0, sizeof(struct sockaddr_in));
    
    sin.sin_family = AF_INET;
    sin.sin_port = htons(9999);
    //server_addr.sin_addr.s_addr = inet_addr("127.0.0.1");
    
    base = event_base_new();
    
    
    // 创建socket，绑定、监听、接受链接
    // 创建监听对象，在指定的地址上监听接下来的TCP连接
    // listen、connect、bind、accept；  LEV_OPT_REUSEABLE：可重用，LEV_OPT_CLOSE_ON_FREE：自动关闭
    struct evconnlistener *listener = evconnlistener_new_bind(base, listener_cb, base,
                                                             LEV_OPT_REUSEABLE | LEV_OPT_CLOSE_ON_FREE,
                                                             1024, (struct sockaddr *)&sin,
                                                             sizeof(struct sockaddr_in));
                                                             
    // 监听集合中的事件
    event_base_dispatch(base);
    
    // 释放
    evconnlistener_free(listener);
    event_base_free(base);
    
    return 0;
}


ConnectStat *stat_init(struct bufferevent *bev) {
    ConnectStat *temp = NULL;
    temp = (ConnectStat *)malloc(sizeof(ConnectStat));
    
    if (!temp) {
        fprintf(stderr, "malloc failed. reason: %s\n", strerror(errno));
        return NULL;
    }
    
    memset(temp, '\0', sizeof(ConnectStat));
    temp->bev = bev;
    
    return temp;
}


void do_echo_request(struct bufferevent *bev, void *arg) {
    ConnectStat *stat = (ConnectStat *)arg;
    char *msg = stat->buf;
    std::string data = "";
    
    // 从缓冲区中获取数据
    size_t len = bufferevent_read(bev, msg, BUFLEN);
    if (0 == len) {
        return;
    }
    msg[len] = '\0';
    data = msg;

    {
        list_account_records_response larr;

        // 将字符串转换
        larr.ParseFromString(data);
//printf("recoreds size: %d\n", larr.records_size());

        // 输出接收到的数据
        printf("code: %d\n", larr.code());
        printf("desc: %s\n", larr.desc().c_str());

        for (int i = 0; i < COUNT; i++) {
            const list_account_records_response_account_record &ar = larr.records(i); 
            printf("type: %d\n", ar.type());
            printf("limit: %d\n", ar.limit());
            printf("time: %lu\n", ar.timestamp());
        }
        
        larr.set_desc(larr.desc() + "123");
    }


    //printf("recv from client <<< %s\n", msg);
    
    // 将数据添加到缓冲区
    bufferevent_write(bev, msg, strlen(msg));
}


void do_echo_response(struct bufferevent *bev, void *arg) {
    return ;
}

void event_cb(struct bufferevent *bev, short event, void *arg) {
    ConnectStat *stat = (ConnectStat *)arg;
    
    if (event & BEV_EVENT_EOF) {
        printf("connect cloase\n");
    } else if (event & BEV_EVENT_ERROR) {
        printf("some other error\n");
    }
    
    // 自动close套接字和free读写缓冲区
    bufferevent_free(bev);// 释放bufferevent对象
    free(stat);
}


typedef struct sockaddr SA;
int tcp_server_init(int port, int listen_num) {
    int errno_save;
    evutil_socket_t listener;   // int listener
    
    listener = socket(AF_INET, SOCK_STREAM, 0);
    if (-1 == listener) {
        return -1;
    }
    
    // 允许多次绑定同一个地址，要用在socket和bind之间
    evutil_make_listen_socket_reuseable(listener);
    
    struct sockaddr_in sin;
    sin.sin_family = AF_INET;
    sin.sin_addr.s_addr = 0;
    sin.sin_port = htons(port);
    
    if (bind(listener, (SA *)&sin, sizeof(sin)) < 0) {
        errno_save = errno;
        evutil_closesocket(listener);
        errno = errno_save;
        
        return -1;
    }
    
    if (listen(listener, listen_num) < 0) {
        errno_save = errno;
        evutil_closesocket(listener);
        errno = errno_save;
        
        return -1;
    }
    
    // 跨平台统一接口，将套接字设置为非阻塞状态
    evutil_make_socket_nonblocking(listener);
    
    return listener;
}


// 一个客户端连接上服务器此函数就会被调用；当此函数被调用时，libevent已经帮我们accept了这个客户端
void listener_cb(struct evconnlistener *listener, evutil_socket_t fd, struct sockaddr *sock, int socklen, void *arg) {
    printf("accept a client %d \n", fd);
    
    struct event_base *base = (struct event_base *)arg;
    
    // 针对已经存在的socket创建bufferevent对象
    // BEV_OPT_CLOSE_ON_FREE:如果释放bufferevent对象，则关闭连接
    struct bufferevent *bev = bufferevent_socket_new(base, fd, BEV_OPT_CLOSE_ON_FREE);
    // BEV_OPT_CLOSE_ON_FREE:释放bufferevent时关闭底层传输端口。这将关闭底层套接字，释放底层bufferevent等。
    
    ConnectStat *stat = stat_init(bev);
    
    // 给bufferevent设置回调函数
    // bufferevent对象、读事件回调函数、写事件回调函数、其他事件回调函数、参数
    bufferevent_setcb(bev, do_echo_request, do_echo_response, event_cb, stat);  // evnet_set
    
    bufferevent_enable(bev, EV_READ | EV_PERSIST);  // evnet_add,使bufferevent 生效
}

六、总结

简单用法介绍完毕，现阶段学习中，我是这样去使用的；日后如果接触的项目有用到再来更新。 

cpp_learners
关注
  • 1
    点赞
  • 踩
  • 2
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 1
    评论
专栏目录
protobuf-cpp-3.0.0.zip_Linux/Unix编程_C/C++_
08-10
Google Protocol Buffer(简称 Protobuf)是一种轻便高效的结构化数据存储格式
ProtoBuf—2
冯同学的博客
06-28 421
ProtoBuf—2
linux下编译安装protobuf
qq_46490027的博客
01-05 4952
linux下源码编译安装protobuf
protobuf-c之linux编译
hezhanran的博客
05-06 576
编译前工作         需要先安装好protocol buffer库并配置好环境变量，请参考protocol buffer之linux编译。         解压源码，例如：protobuf-c.zip到目录/home/workspac...
protocol buffer之linux编译
hezhanran的博客
04-30 965
编译前配置         安装依赖库：automake ，autoconf ，libtool。         解压源码，例如：protobuf-3.11.4.zip到目录/home/workspace/protobuf-3.11.4，通...
Linux C++ protoBuf
帅的没拼音
08-19 427
一：编译protoBuf源码 二：引用头文件和库文件 三：事例
protobuf2简单介绍及在IDEA中的使用
no_hot的博客
01-19 2787
文章目录一、protobuf2简单介绍1. 数据类型2. 简单示例二、在IDEA中使用1. 安装protobuf support2. pom.xml添加maven插件3. pom.xml添加依赖4. 添加.proto文件import path5. 生成.java文件 一、protobuf2简单介绍 protobuf相较于xml和json，更注重于数据序列化 优点：拥有更高的时间效率和空间效率 缺点：可读性差 1. 数据类型 .proto Notes Java double double
C++编程中使用框架protobuf
hsy12342611的专栏
04-02 3505
C++语言使用protobuf框架
linux环境下protobuf的安装与使用
mijichui2153的博客
08-22 2万+
一、protobuf的下载安装 1、protobuf的下载：这里。此处下载的是protobuf-cpp-3.9.1.tar.gz。 2、安装准备：安装protobuf前确保以下软件都已经被安装。方法也很简单yum -y install XXXX即可。 autoconf automake libtool make g++ unzip 注：值得注意的是我们要将g++设为默认使...............
【Protobuf】Linux 下源码编译 Protobuf 库
unonoi的博客
07-19 668
本文记录如何在 Linux 下源码编译 Protobuf 库文件。
Protobuf语法指南（proto2）
freshman94的博客
04-09 1万+
本文是一篇译文，原文地址为：https://developers.google.com/protocol-buffers/docs/proto#generating 定义一个消息类型 先来看一个非常简单的例子。假设你想定义一个“搜索请求”的消息格式，每一个请求含有一个查询字符串、你感兴趣的查询结果所在的页数，以及每一页多少条查询结果。可以采用如下的方式来定义消息类型的.proto文件了： mess...
Google protobuf RPC框架的轻量级RPC实现。-C/C++开发
05-26
支持三级（服务/方法/请求）超时。 请参阅“ ./sample/timeout_sample”。 支持透明压缩。 请参阅“ ./sample/compress_sample”。 支持模拟测试。 请参阅“ ./sample/mock_sample”。 支持网络
protobuf 在 linux 和window 安装教程，
01-20
2. protobuf的安装 2.1 windows 平台 （vs2017） 安装protobuf 下载protobuf的C++版本的源代码，地址：https://github.com/google/protobuf/releases 下载 protobuf-cpp-3.8.0.zip/tar.gz 这个包 解压源码 （路径...
protobuf linux protobuf linux protobuf linux
最新发布
03-26
protobuf linux
C++ 智能指针 - 全部用法详解
热门推荐
cpp_learner的博客
08-02 5万+
血的教训？不学智能指针，本人丢了一份工作。
C/C++ 四种清空输入缓冲区的方法
cpp_learner的博客
02-05 3万+
一、 fflush(stdin); C语言：清空输入缓冲区的所有内容，在VS中没有效果 ============================================================= 二、 cin.sync(); C++：清除输入缓冲区的所有内容，在VS中没有效果 =====================================================...
C/C++ for循环的几种用法
cpp_learner的博客
05-30 2万+
你以为for循环就只有常用的那用吗？这你可就错了，还有两种C++11新标准的用法。
C/C++ 三种方式获得文件的大小
cpp_learner的博客
03-16 2万+
使用最简单的方式获取文件的大小！
C++ 文件流详解
cpp_learner的博客
02-05 2万+
C++使用流进行操作文件
为什么版本没有变化：PS D:\GoProgram\hdyx\api\protobuf> go get -u github.com/golang/protobuf/pro[email protected] go: downloading github.com/golang/protobuf v1.4.3 go: module github.com/golang/protobuf is deprecated: Use the "google.golang.org/protobuf" module instead. go: upgraded github.com/golang/protobuf v1.4.2 => v1.4.3 PS D:\GoProgram\hdyx\api\protobuf> protoc-gen-go --version protoc-gen-go.exe v1.30.0
06-07
如果你想使用 `v1.4.3` 版本的 `protoc-gen-go` 工具，可以使用以下命令： ``` $ go get -u google.golang.org/protobuf/cmd/protoc-gen-go ``` 该命令将下载最新版本的 `protoc-gen-go` 工具，并将其安装在 `$...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

cpp_learners

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值