六丶 Protobuf联网传输

最新推荐文章于 2024-07-17 09:42:23 发布
最新推荐文章于 2024-07-17 09:42:23 发布
阅读量257 收藏 1
点赞数
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_33951440/article/details/80415334
版权

`````````````````````````````````protobuf`````````````````````````````

package cs;

message CSLoginInfo
{
	required string UserName = 1;//账号
	required string Password = 2;//密码
}

//发送登录请求
message CSLoginReq
{
	required CSLoginInfo LoginInfo = 1; 
}
//登录请求回包数据
message CSLoginRes
{
	required uint32 result_code = 1; 
}
package cs;  
  
enum EnmCmdID  
{  
    CS_LOGIN_REQ = 10001;//登录请求协议号  
    CS_LOGIN_RES = 10002;//登录请求回包协议号  
}

文件格式.proto

然后用protogen.exe 使用提示命令进行编译。会得到两个.cs文件。 注意看里面可以发现usingnamespace  cs

`````````````````````````````````````````更改Client与Server的消息传输``````````````````````````````

Client:(U3D)

    挂载摄像机上：

        

using System.Collections;
using System.Collections.Generic;
using UnityEngine;
using cs;
using TcpClinet;
public class testProto : MonoBehaviour {
    
	// Use this for initialization
	void Start () {
        MyClient.Connect("192.168.200.1",88);

        CSLoginInfo mLoginInfo = new CSLoginInfo();
        mLoginInfo.UserName = "ycb";
        mLoginInfo.Password = "1234565";
        CSLoginReq mReq = new CSLoginReq();
        mReq.LoginInfo = mLoginInfo;

        MyClient.Send((int)EnmCmdID.CS_LOGIN_REQ, mReq);

    }

}


Client主体逻辑部分

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading;
using System.Net;
using System.Net.Sockets;
using UnityEngine;
using ProtoBuf;
using cs;

namespace TcpClinet
{   
    class MyClient
    {
        static byte[] data = new byte[1024];
        public static Socket socketClient;
        static Message msg = new Message();

        public static void Connect(string ip,int port)
        {

            socketClient = new Socket(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp);
            socketClient.Connect(new IPEndPoint(IPAddress.Parse(ip), port));

            socketClient.BeginReceive(msg.Data, msg.StartIndex, msg.RemainSize, SocketFlags.None, ReceiveCallBack, socketClient);
        }   
            
        static void ReceiveCallBack(IAsyncResult ar)
        {   
            //            ar.AsyncState 可以获得之前传递的object
            Socket socketClient = null;
            try
            {
                socketClient = ar.AsyncState as Socket;
                int count = socketClient.EndReceive(ar);
                if (count == 0)
                {
                    //即便是空数据也不会是0，客户端不会发送空数据，  只有在结束时才有0的可能性
                    socketClient.Close();
                    return;
                }
                msg.AddCount(count);
                msg.ReadProtoMessage();
                socketClient.BeginReceive(msg.Data, msg.StartIndex, msg.RemainSize, SocketFlags.None, ReceiveCallBack, socketClient);
            }
            catch (Exception e)
            {
                Console.WriteLine(e);
                if (socketClient != null)
                {
                    socketClient.Close();
                }
            }
        }
        //protobuf
        public static void Send(int typeId,IExtensible msgStr)
        {
            byte[] typeBytes = BitConverter.GetBytes(typeId);
            byte[] dataBytes = PackCodec.Serialize(msgStr);
            int msgLen = typeBytes.Length + dataBytes.Length;
            byte[] lengthBytes = BitConverter.GetBytes(msgLen);
            byte[] newBytes = lengthBytes.Concat(typeBytes).ToArray().Concat(dataBytes).ToArray();
            socketClient.Send(newBytes);
            //总长度(int32) + typeid(int32) + 报文    
        }
        //非protobuf
        public static void Send(string msgStr)
        { 
            int count = socketClient.Receive(msg.Data);
            byte[] dataBytes = Encoding.UTF8.GetBytes(msgStr);
            int msgLen = msgStr.Length;
            byte[] lengthBytes = BitConverter.GetBytes(msgLen);
            byte[] newBytes = lengthBytes.Concat(dataBytes).ToArray();
            socketClient.Send(newBytes);
         
        }

        public static void Close()
        {
            socketClient.Close();
        }   
    }
}


Message报文部分：

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading;
using UnityEngine;
using ProtoBuf;
using cs;

namespace TcpClinet
{
    class Message
    {
        private byte[] data = new byte[1024];
        private int startIndex = 0;

        public byte[] Data
        {
            get { return data; }
        }
        public int StartIndex
        {
            get { return startIndex; }
        }
        public int RemainSize
        {
            get { return data.Length - startIndex; }
        }
        public void AddCount(int count)
        {
            startIndex += count;
        }   
        /// <summary>
        /// 解析数据
        /// </summary>
        public void ReadMessage()
        {
            while (true)
            {
                if (startIndex <= 4)
                {
                    return;
                }
                int count = BitConverter.ToInt32(data, 0);
                if ((startIndex - 4) >= count)
                {   
                    string s = System.Text.Encoding.UTF8.GetString(data, 4, count); 
                    Array.Copy(data, count + 4, data, 0, startIndex - 4 - count);   
                    startIndex -= count + 4;
                    //Debug.Log(count+" "+s); 
                }
                else break;
            }
        }
        public void ReadProtoMessage()
        {
            while (true)
            {
                if (startIndex <= 4)
                    return;
                int count = BitConverter.ToInt32(data, 0);
                if ((startIndex - 4) >= count)
                {
                    int typeId = BitConverter.ToInt32(data, 4);
                    if (typeId == (int)EnmCmdID.CS_LOGIN_RES)
                    {
                        byte[] msg = new byte[count - 4];
                        Array.Copy(data, 8, msg, 0, count - 4);
                        CSLoginRes ServerRes = PackCodec.Deserialize<CSLoginRes>(msg);
                        UInt32 res = ServerRes.result_code;
                        Debug.Log("数据内容：res =" + res);
                        Array.Copy(data, count + 4, data, 0, startIndex - 4 - count);
                        startIndex -= count + 4;
                    }
                }
            }
        }
    }
}

解码部分：

using UnityEngine;
using System.Collections;
using System.IO;
using System;
using ProtoBuf;

/// <summary>
/// 网络协议数据打包和解包类
/// </summary>
public class PackCodec
{
    /// <summary>
    /// 序列化
    /// </summary>
    /// <typeparam name="T"></typeparam>
    /// <param name="msg"></param>
    /// <returns></returns> [[
    static public byte[] Serialize<T>(T msg)
    {
        byte[] result = null;
        if (msg != null)
        {
            using (var stream = new MemoryStream())
            {
                Serializer.Serialize<T>(stream, msg);
                result = stream.ToArray();
            }
        }
        return result;
    }

    /// <summary>
    /// 反序列化
    /// </summary>
    /// <typeparam name="T"></typeparam>
    /// <param name="message"></param>
    /// <returns></returns>
    static public T Deserialize<T>(byte[] message)
    {
        T result = default(T);
        if (message != null)
        {
            using (var stream = new MemoryStream(message))
            {
                result = Serializer.Deserialize<T>(stream);
            }
        }
        return result;  
    }
}


服务器：

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using System.Net.Sockets;
using System.Net;
using ProtoBuf;
using cs;

namespace TcpServer
{
    class Program
    {
        static Socket socketServer;
        static byte[] dataBuffer = new byte[1024];
        static void Main(string[] args)
        {
            StartServerAsync();
            Console.ReadKey();
        }
        static void StartServerAsync()
        {   
            socketServer = new Socket(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp);
            IPAddress iPAddress = IPAddress.Parse("192.168.200.1");
            IPEndPoint iPEndPoint = new IPEndPoint(iPAddress, 88);
            socketServer.Bind(iPEndPoint);

            socketServer.Listen(10);
            //Socket clientSocket = socketServer.Accept(); 下面支持多个客户端，改为异步， 之前c++服务器用的epoll这里似乎不需要关注
            socketServer.BeginAccept(AcceptCallBack, socketServer);
        }
        static Message msg = new Message();

        static void AcceptCallBack(IAsyncResult ar)
        {
            Socket socketServer = ar.AsyncState as Socket;
            Socket socketClient = socketServer.EndAccept(ar);

            CSLoginRes res = new CSLoginRes();
            res.result_code = 0;
            Send(socketClient, (int)EnmCmdID.CS_LOGIN_RES, res);

            socketClient.BeginReceive(msg.Data, msg.StartIndex, msg.RemainSize, SocketFlags.None, ReceiveCallBack, socketClient);
            socketServer.BeginAccept(AcceptCallBack, socketServer);
        }
        static void SendMessage(Socket socketClient,string msgStr)
        {

            byte[] dataBytes = Encoding.UTF8.GetBytes(msgStr);
            int msgLen = msgStr.Length;
            byte[] lengthBytes = BitConverter.GetBytes(msgLen);
            byte[] newBytes = lengthBytes.Concat(dataBytes).ToArray();
            socketClient.Send(newBytes);
        }
        //protobuf
        public static void Send(Socket socketClient,int typeId, IExtensible msgStr)
        {
            byte[] typeBytes = BitConverter.GetBytes(typeId);
            byte[] dataBytes = PackCodec.Serialize(msgStr);
            int msgLen = typeBytes.Length + dataBytes.Length;
            byte[] lengthBytes = BitConverter.GetBytes(msgLen);
            byte[] newBytes = lengthBytes.Concat(typeBytes).ToArray().Concat(dataBytes).ToArray();
            socketClient.Send(newBytes);
            //总长度(int32) + typeid(int32) + 报文    
        }
        static void ReceiveCallBack(IAsyncResult ar)
        {
            //            ar.AsyncState 可以获得之前传递的object
            Socket socketClient = null;
            try
            {
                socketClient = ar.AsyncState as Socket;
                int count = socketClient.EndReceive(ar);
                if (count == 0)
                {
                    //即便是空数据也不会是0，客户端不会发送空数据，  只有在结束时才有0的可能性
                    socketClient.Close();
                    return;
                }
                msg.AddCount(count);
                msg.ReadProtoMessage();
                socketClient.BeginReceive(msg.Data, msg.StartIndex, msg.RemainSize, SocketFlags.None, ReceiveCallBack, socketClient);
            }

            catch (Exception e)
            {
                Console.WriteLine(e);
                if (socketClient != null)
                {
                    socketClient.Close();
                }
            }
        }
    }
}


Message:与上面不同

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using cs;

namespace TcpServer
{
    class Message
    {
        private byte[] data = new byte[1024];
        private int startIndex = 0;

        public byte[] Data
        {
            get { return data; }
        }
        public int StartIndex
        {
            get { return startIndex; }
        }
        public int RemainSize
        {
            get { return data.Length - startIndex; }
        }
        public void AddCount(int count)
        {   
            startIndex += count;
        }   
        /// <summary>
        /// 解析数据
        /// </summary>
        public void ReadMessage()
        {
            while (true)
            {
                if (startIndex <= 4)
                {
                    return;
                }
                int count = BitConverter.ToInt32(data, 0);
                if ((startIndex - 4) >= count)
                {   
                    string s = System.Text.Encoding.UTF8.GetString(data, 4, count);
                    Array.Copy(data, count + 4, data, 0, startIndex - 4 - count);
                    startIndex -= count + 4;
                    Console.WriteLine(count  );
                }
                else break;
            }
        }  
        public void ReadProtoMessage()
        {
            while (true)
            {
                if (startIndex <= 4)
                    return;
                int count = BitConverter.ToInt32(data, 0);
                if((startIndex-4)>=count )
                {   
                    int typeId = BitConverter.ToInt32(data, 4);
                    if (typeId == (int)EnmCmdID.CS_LOGIN_REQ)
                    {   
                        byte[] msg = new byte[count-4];
                        Array.Copy(data, 8, msg, 0, count-4);
                        CSLoginReq clientReq = PackCodec.Deserialize<CSLoginReq>(msg);
                        string user_name = clientReq.LoginInfo.UserName;
                        string pass_word = clientReq.LoginInfo.Password;
                        Console.WriteLine("数据内容：UserName={0},Password={1}", user_name, pass_word);
                        Array.Copy(data, count + 4, data, 0, startIndex - 4 - count);
                        startIndex -= count + 4;
                    }
                }
            }
        }
    }
}

ProtoBuf的解码部分 同上面，并且生成的.cs文件也需要扔进来，还需要引入protobuf-net.dll

using System.Collections;
using System.IO;
using System;
using ProtoBuf;

/// <summary>
/// 网络协议数据打包和解包类
/// </summary>
public class PackCodec
{
    /// <summary>
    /// 序列化
    /// </summary>
    /// <typeparam name="T"></typeparam>
    /// <param name="msg"></param>
    /// <returns></returns> [[
    static public byte[] Serialize<T>(T msg)
    {
        byte[] result = null;
        if (msg != null)
        {
            using (var stream = new MemoryStream())
            {
                Serializer.Serialize<T>(stream, msg);
                result = stream.ToArray();
            }
        }
        return result;
    }

    /// <summary>
    /// 反序列化
    /// </summary>
    /// <typeparam name="T"></typeparam>
    /// <param name="message"></param>
    /// <returns></returns>
    static public T Deserialize<T>(byte[] message)
    {
        T result = default(T);
        if (message != null)
        {
            using (var stream = new MemoryStream(message))
            {
                result = Serializer.Deserialize<T>(stream);
            }
        }
        return result;  
    }
}


YYyyCCCcccBb
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
Protobuf 数据传输实例
m0_55623367的博客
10-17 1455
Protubuf 数据传输详解远程数据传输协议欢迎使用Markdown编辑器新的改变功能快捷键合理的创建标题，有助于目录的生成如何改变文本的样式插入链接与图片如何插入一段漂亮的代码片生成一个适合你的列表创建一个表格设定内容居中、居左、居右SmartyPants创建一个自定义列表如何创建一个注脚注释也是必不可少的KaTeX数学公式新的甘特图功能，丰富你的文章UML 图表FLowchart流程图导出与导入导出导入 远程数据传输协议 我们以 Spring-Boot 为服务器端开发框架，接收由客户端发送的 Prot
protobuf网络传输协议的优缺点
weixin_44587820的博客
12-09 3359
为什么使用protobuf？ protobuf常使用于作为C/S之间的数据传输的序列化工具，可以使用protobuf实现rpc框架的通信传输。 对于App网络传输协议，我们比较常见的、可选的，有三种，分别是json/xml/protobuf，我们先分别来看看这三种格式的优缺点： 三种格式优点： json优点就是较XML格式更加小巧，传输效率较xml提高了很多，可读性还不错。 xml优点就是可读性强，解析方便。 protobuf优点就是传输效率快（据说在数据量大的时候，传输效率比xml和json快10-2
.NET的Socket+KCP+Protobuf的Unity局域网联机测试范例， 大量功能待补充。
02-27
.NET的Socket+KCP+Protobuf的Unity局域网联机测试范例， 大量功能待补充。
C#语言使用gRPC、protobuf(Google Protocol Buffers)实现文件传输功能
01-21
初识gRPC还是一位做JAVA的同事在项目中用到了它，为了C#的客户端程序和java的服务器程序进行通信和数据交换，当时还是对方编译成C#，我直接调用。 　　后来，自己下来做了C#版本gRPC编写，搜了很多资料，但许多都是从入门开始？调用说“Say Hi!”这种官方标准的入门示例，然后遇到各种问题…… 　　关于gRPC和Protobuf介绍，就不介绍了，网络上一搜一大把，随便一抓都是标准的官方，所以直接从使用说起。 　　gPRC源代码：https://github.com/grpc/grpc； 　　protobuf的代码仓库： github仓库地址：https://github.com/goo
protobuf message定义_学习笔记第5篇之数据传输神器Protobuf
weixin_39994627的博客
11-23 589
疫情当前，世事无常，普遍有点儿人心惶惶，然而要想对抗焦虑，最有力的武器还是学习！前面的4篇文章我们介绍了数据是怎么在网络进行传输的，不仅有理论知识还有实际的代码操作，需要复习的小伙伴们请点击下面的链接?如何通俗的讲解UDP基础知识学习笔记第2篇之UDP数据的收发学习笔记第3篇之TCP基础知识学习笔记第4篇之TCP数据的收发介绍完了数据传输，这回我们来讲讲数据解析。由前面的学习可知，应用层...
如何从零开始开发一个实时联机游戏？
wubaohu1314的博客
09-18 2084
https://www.fgba.net/sitemap.xml
protobuf协议传输的最大值
h799710的博客
01-24 2576
一、直接看源码： 这是序列化打包的源代码： bool MessageLite::SerializePartialToArray(void* data, int size) const { const size_t byte_size = ByteSizeLong(); if (byte_size > INT_MAX) { // 只要不大于 2GB，那么都可以序列化 GOOGLE_LOG(ERROR) << GetTypeName() <&
Unity中使用Protobuf 来传输消息
*LYZY*的博客
09-14 3331
好久没有更新博客了哦!难得有空出来写写博客，现在好多unity项目中都使用protobuf来传输我们的网络消息了，为什么呢？之前使用的xml，json不是挺好的吗？为什么要用这个东东呢？这又是什么东西？ 首先我们来了解一下protobuf这个东西吧！ 要知道Protobuf是google的一个开源项目 那么他能用来干什么呢？ 1.数据存储（序列化和反序列化），这个功能类似xml和json等...
Protobuf传输协议解析与应用
weixin_44976692的博客
07-17 4982
Protocol Buffers（protobuf）是一种轻量级、高效的数据交换格式和接口描述语言，由Google开发并开源。它被广泛应用于各种分布式系统中，如RPC（远程过程调用）、数据存储与通信协议等。本文将深入探讨protobuf的工作原理、优势、使用场景以及与其他格式的比较。
protobuf高效传输
05-20 5141
protobuffer cesium大数据量高效传输
采用netty与protobuf进行文件传输
07-15
本话题聚焦于使用Netty和Protocol Buffers（Protobuf）来实现文件传输，这是一种现代且高性能的技术组合，尤其适用于大规模分布式系统。 Netty是一个开源的异步事件驱动的网络应用程序框架，用于快速开发可维护的高...
基于Protobuf的数据传输协议_聂晓旭.pdf
05-19
基于Protobuf的数据传输协议 Protobuf是一种轻便高效的结构化数据存储格式，用于结构化数据的串行化。它是Google开发的一种语言无关、平台无关、可扩展的序列化结构，能够生成非常紧凑的二进制数据，序列化速度快...
基于netty与protobuf的Android手机视频实时传输
07-15
本项目“基于Netty与Protobuf的Android手机视频实时传输”利用了高性能的网络库Netty和高效的序列化框架Protobuf，实现了高效、低延迟的视频流传输。下面将详细介绍这两个关键技术及其在该项目中的应用。 **Netty**...
socket通过传输protobuf通信
10-03
标题 "socket通过传输protobuf通信" 描述了在Linux环境下，两个客户端（a和b）如何利用socket进行通信，并且为了确保字节对齐和高效的数据交换，采用了Protocol Buffers（protobuf）作为数据序列化工具。这里我们将...
protobuf 3.11版本，静态编译
04-28
protobuf是Protocol Buffers的简称，它是Google开发的一种数据序列化协议，用于结构化数据的序列化，类似于XML、JSON，但更小、更快、更简单。protobuf 3.11版本是一个稳定且广泛使用的版本，提供了许多改进和新特性...
四丶TCP解决拆包问题
GameRoad
04-10 238
由于TCP在发送时，会将若干条消息合并到一起发送，所以会导致一条信息中有多条内容。这次的做法和之前的自己的demo相同， 也是转为4字节的int，放到每条要发送信息的首部，逐步进行解析using System; using System.Collections.Generic; using System.Linq; using System.Text; using System.Threading...
java毕设&课设-ASP校友录设计(源代码+论文).zip
最新发布
07-21
计算机毕业设计资源包含（项目部署视频+源码+LW+开题报告等等），所有项目经过助教老师跑通，有问题可以私信博主解决，可以免费帮部署。
ASP网上书店售书系统设计(源代码+论文).rar
07-21
ASP网上书店售书系统设计(源代码+论文)
protobuf传输map
11-29
可以使用protobuf传输map。在protobuf中，可以使用map类型来定义键值对。在.proto文件中，可以使用以下语法定义map类型： ``` map, value_type> map_field = N; ``` 其中，key_type和value_type可以是任何protobuf...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值