最简单的TCP网络封包解包(补充)-序列化

将数据能够在TCP中进行传输的两种方法
1.直接拷贝struct就可以了；
2.序列化。

拷贝Struct存在的问题
1.不能应付可变长类型的数据，比如STL中的那些容器，他们的长度都是不确定的。当然，STL的容器归根到底就是一个class；
2.内存对齐的问题，Windows默认的对齐是4字节，如果不去刻意关闭掉对齐的话，那么可能会多出不少没必要的字节数，有时候，这个损耗是客观的。但是如果关闭了，内存拷贝又会慢一些，内存IO相对于网络IO来说，速度是快的，略微的增加内存IO的压力来调优网络IO是可行的。

序列化是怎么序列化的？
其实很简单，就是按位拷贝。在这里，我们使用一个uint8类型的变长数组作为一个容器。假设我们这里有一个uint16类型的数据，那么我们就把它拷贝进去uint8的数组里面，那么它就占了两个元素，如果是uint32，则这个数据占了4个元素位。它的原理是非常的简单的。至于具体请参考下面代码里面的ByteBuffer::append()方法。而那些class神马的，只要我们序列化的顺序和反序列化的顺序是配对的，我们就可以按照这个顺序进行序列化和反序列化了。这个在BytBuffer里面已经默认支持了常用的几个STL容器（vector，list等）。

类型定义


#if defined(_MSC_VER)
    //
    // Windows/Visual C++
    //
    typedef signed __int8            int8;
    typedef unsigned __int8            uint8;
    typedef signed __int16            int16;
    typedef unsigned __int16        uint16;
    typedef signed __int32            int32;
    typedef unsigned __int32        uint32;
    typedef signed __int64            int64;
    typedef unsigned __int64        uint64;
#endif

有的类型的长度会因硬件或者操作系统而异，如果直接使用c++关键字中的类型定义可能会出现问题。因此，需要自己定义以上这样的类型。利用宏去适配各个操作系统或者硬件平台。

ByteBuffer的代码

//////////////////////////////////////////////////////////////////////////
/// 字节流缓冲类，可以进行序列化和解序列化操作，并且可以缓冲字节流数据。
//////////////////////////////////////////////////////////////////////////
class ByteBuffer
{
public:
    const static size_t DEFAULT_SIZE = 0x1000;

    ByteBuffer()
        : mReadPos(0)
        , mWritePos(0)
    {
        mStorage.reserve(DEFAULT_SIZE);
    }

    ByteBuffer(size_t res)
        : mReadPos(0)
        , mWritePos(0)
    {
        mStorage.reserve(res);
    }

    ByteBuffer(const ByteBuffer &buf) 
        : mReadPos(buf.mReadPos)
        , mWritePos(buf.mWritePos)
        , mStorage(buf.mStorage)
    {}

    //////////////////////////////////////////////////////////////////////////
public:
    void clear()
    {
        mStorage.clear();
        mReadPos = mWritePos = 0;
    }

    template <typename T>
        void append(T value)
    {
        append((uint8*)&value, sizeof(value));
    }

    template <typename T>
        void put(size_t pos, T value)
    {
        put(pos, (uint8*)&value, sizeof(value));
    }

    //////////////////////////////////////////////////////////////////////////
public:
    ByteBuffer& operator<<(bool value)
    {
        append<char>((char)value);
        return *this;
    }
    ByteBuffer& operator<<(uint8 value)
    {
        append<uint8>(value);
        return *this;
    }
    ByteBuffer& operator<<(uint16 value)
    {
        append<uint16>(value);
        return *this;
    }
    ByteBuffer& operator<<(uint32 value)
    {
        append<uint32>(value);
        return *this;
    }
    ByteBuffer& operator<<(uint64 value)
    {
        append<uint64>(value);
        return *this;
    }

    ByteBuffer& operator<<(int8 value)
    {
        append<int8>(value);
        return *this;
    }
    ByteBuffer& operator<<(int16 value)
    {
        append<int16>(value);
        return *this;
    }
    ByteBuffer& operator<<(int32 value)
    {
        append<int32>(value);
        return *this;
    }
    ByteBuffer& operator<<(int64 value)
    {
        append<int64>(value);
        return *this;
    }

    ByteBuffer& operator<<(float value)
    {
        append<float>(value);
        return *this;
    }
    ByteBuffer& operator<<(double value)
    {
        append<double>(value);
        return *this;
    }
    ByteBuffer& operator<<(time_t value)
    {
        append<time_t>(value);
        return *this;
    }

    ByteBuffer& operator<<(const std::string& value)
    {
        append((uint8 const *)value.c_str(), value.length());
        append((uint8)0);
        return *this;
    }
    ByteBuffer& operator<<(const char* str)
    {
        append( (uint8 const *)str, str ? strlen(str) : 0);
        append((uint8)0);
        return *this;
    }

    //////////////////////////////////////////////////////////////////////////
public:
    ByteBuffer& operator>>(bool& value)
    {
        value = read<char>() > 0 ? true : false;
        return *this;
    }
    ByteBuffer& operator>>(uint8& value)
    {
        value = read<uint8>();
        return *this;
    }
    ByteBuffer& operator>>(uint16& value)
    {
        value = read<uint16>();
        return *this;
    }
    ByteBuffer& operator>>(uint32& value)
    {
        value = read<uint32>();
        return *this;
    }
    ByteBuffer& operator>>(uint64& value)
    {
        value = read<uint64>();
        return *this;
    }

    ByteBuffer& operator>>(int8& value)
    {
        value = read<int8>();
        return *this;
    }
    ByteBuffer& operator>>(int16& value)
    {
        value = read<int16>();
        return *this;
    }
    ByteBuffer& operator>>(int32& value)
    {
        value = read<int32>();
        return *this;
    }
    ByteBuffer& operator>>(int64& value)
    {
        value = read<int64>();
        return *this;
    }

    ByteBuffer& operator>>(float &value)
    {
        value = read<float>();
        return *this;
    }
    ByteBuffer& operator>>(double &value)
    {
        value = read<double>();
        return *this;
    }
    ByteBuffer& operator>>(time_t& value)
    {
        value = read<time_t>();
        return *this;
    }

    ByteBuffer& operator>>(std::string& value)
    {
        value.clear();
        while (rpos() < size())
        {
            char c = read<char>();
            if (c == 0)
            {
                break;
            }
            value += c;
        }
        return *this;
    }

    ByteBuffer& operator>>(char value[])
    {
        std::string strValue;
        strValue.clear();
        while (rpos() < size())
        {
            char c = read<char>();
            if (c == 0)
            {
                break;
            }
            strValue += c;
        }
        strncpy(value, strValue.c_str(), strValue.size());
        return *this;
    }

    //////////////////////////////////////////////////////////////////////////
public:
    uint8 operator[](size_t pos)
    {
        return read<uint8>(pos);
    }

    size_t rpos() const
    {
        return mReadPos;
    };

    size_t rpos(size_t rpos_)
    {
        mReadPos = rpos_;
        return mReadPos;
    };

    size_t wpos() const
    {
        return mWritePos;
    }

    size_t wpos(size_t wpos_)
    {
        mWritePos = wpos_;
        return mWritePos;
    }

    template <typename T> T read()
    {
        T r = read<T>(mReadPos);
        mReadPos += sizeof(T);
        return r;
    };
    template <typename T> T read(size_t pos) const
    {
        assert(pos + sizeof(T) <= size() || PrintPosError(false,pos,sizeof(T)));
        return *((T const*)&mStorage[pos]);
    }

    void read(uint8 *dest, size_t len)
    {
        assert(mReadPos  + len  <= size() || PrintPosError(false, mReadPos,len));
        memcpy(dest, &mStorage[mReadPos], len);
        mReadPos += len;
    }

    const uint8* contents() const { return &mStorage[mReadPos]; }

    size_t size() const { return mStorage.size(); }

    bool empty() const { return mStorage.empty(); }

    void resize(size_t _NewSize)
    {
        mStorage.resize(_NewSize);
        mReadPos = 0;
        mWritePos = size();
    };

    void reserve(size_t _Size)
    {
        if (_Size > size()) mStorage.reserve(_Size);
    };

    void append(const std::string& str)
    {
        append((uint8 const*)str.c_str(), str.size() + 1);
    }
    void append(const char *src, size_t cnt)
    {
        return append((const uint8 *)src, cnt);
    }
    void append(const uint8 *src, size_t cnt)
    {
        if (!cnt) return;

        assert(size() < 10000000);

        if (mStorage.size() < mWritePos + cnt)
        {
            mStorage.resize(mWritePos + cnt);
        }
        memcpy(&mStorage[mWritePos], src, cnt);
        mWritePos += cnt;
    }
    void append(const ByteBuffer& buffer)
    {
        if (buffer.size()) append(buffer.contents(),buffer.size());
    }

    void put(size_t pos, const uint8 *src, size_t cnt)
    {
        assert(pos + cnt <= size() || PrintPosError(true,pos,cnt));
        memcpy(&mStorage[pos], src, cnt);
    }

    //////////////////////////////////////////////////////////////////////////
public:
    void print_storage()
    {
    }

    void textlike()
    {
    }

    void hexlike()
    {
    }

    bool PrintPosError(bool add, size_t pos, size_t esize) const
    {
        printf("ERROR: Attempt %s in ByteBuffer (pos: %u size: %u) value with size: %u",(add ? "put" : "get"), pos, size(), esize);
        return false;
    }

protected:
    size_t                mReadPos;
    size_t                mWritePos;
    std::vector<uint8>    mStorage;
};


//////////////////////////////////////////////////////////////////////////
// std::vector
//////////////////////////////////////////////////////////////////////////
#ifdef _VECTOR_
template <typename T>
ByteBuffer& operator<<(ByteBuffer& b, const std::vector<T>& v)
{
    b << (uint32)v.size();

    typename std::vector<T>::const_iterator iter    = v.begin();
    typename std::vector<T>::const_iterator& iEnd    = v.end();
    for (; iter != iEnd; ++iter)
    {
        b << *iter;
    }
    return b;
}

template <typename T>
ByteBuffer& operator>>(ByteBuffer& b, std::vector<T>& v)
{
    uint32 vsize;
    b >> vsize;
    v.clear();
    while (vsize--)
    {
        T t;
        b >> t;
        v.push_back(t);
    }
    return b;
}
#endif

//////////////////////////////////////////////////////////////////////////
// std::list
//////////////////////////////////////////////////////////////////////////
#ifdef _LIST_
template <typename T>
ByteBuffer& operator<<(ByteBuffer& b, const std::list<T>& v)
{
    b << (uint32)v.size();

    typename std::list<T>::const_iterator iter    = v.begin();
    typename std::list<T>::const_iterator& iEnd    = v.end();
    for (; iter != iEnd; ++iter)
    {
        b << *iter;
    }
    return b;
}

template <typename T>
ByteBuffer& operator>>(ByteBuffer& b, std::list<T>& v)
{
    uint32 vsize;
    b >> vsize;
    v.clear();
    while (vsize--)
    {
        T t;
        b >> t;
        v.push_back(t);
    }
    return b;
}
#endif

//////////////////////////////////////////////////////////////////////////
// std::map
//////////////////////////////////////////////////////////////////////////
#ifdef _MAP_
template <typename K, typename V>
ByteBuffer& operator<<(ByteBuffer& b, const std::map<K, V>& m)
{
    b << (uint32)m.size();

    typename std::map<K, V>::const_iterator iter = m.begin();
    typename std::map<K, V>::const_iterator iEnd = m.end();
    for (; iter != iEnd; ++iter)
    {
        b << iter->first << iter->second;
    }
    return b;
}

template <typename K, typename V>
ByteBuffer &operator>>(ByteBuffer& b, std::map<K, V>& m)
{
    uint32 msize;
    b >> msize;
    m.clear();
    while (msize--)
    {
        K k;
        V v;
        b >> k >> v;
        m.insert(std::make_pair(k, v));
    }
    return b;
}
#endif

如何利用ByteBuffer序列化和反序列化
假设我们要序列化std::string的数据，那么我们这样做：

std::string str;
ByteBuffer buf;
buf << str;
那么，如何将这个str反序列化出来呢？这样做：

std::string str;
ByteBuffer buf;
buf >> str;
So Easy！是吧。具体在TCP收发包的实际场景中怎样做，我也不多废话，请看下面下载提供的代码便是了。

在实用下细节上的一些区别
通常情况下，一个协议的数据集会定义为一个struct，然后重载其<<和>>算符用于序列化和反序列化。这个如果仅仅是在C++下倒还好，但如若放置在混合语言编程的情况下，这可能就不行了，很多语言是不支持算符重载的。如若纯逻辑都在lua或者python神马里面做，我们只能为每个基本类型写一个read和write的方法：readInt8,readInt16,,readString,writeInt8,writeInt16,writeString等等。然后在每个协议处理方法里面按照顺序逐个的处理协议数据集的数据，这样是很容易出问题的，却也是没有办法的办法了。

Google Protocol Buffer(ProtoBuf)
在开源工具里面，不得不提到的就是它了，它很适合于混合语言的情况下使用。它自己有一套自己的数据描述语言，数据序列化的描述都写在.proto。只需要写一次.proto文件，便可以在多语言里面使用了该协议了。比如，我曾经做过一个VC+Flash AS3的项目，就是用的它。如果没有它，网络协议我必须在c++里面定义一次，flash里面再定义一次，那可真真是麻烦死了，麻烦倒还是小事情，如果两边的定义不同步的话，序列化或者反序列化就会发生错误，那可就糟糕了。
如果有多语言的需求，最好就是使用像ProtoBuf这样的解决方案。当然，如果没有跨语言的需求，还是尽量简单为好，比如上面的ByteBuffer，毕竟简单的东西自己可以比较轻松的掌控。
主页地址：http://code.google.com/p/protobuf/

代码下载：testByteBuffer.rar 

EDIT:
time_t解序列化写错了，参数应该是一个传出值，为一个引用，但是我把引用符给忘记了。特此订正！

 ByteBuffer& operator>>(time_t& value)
 {
 value = read<time_t>();
 return *this;
 }

时间： 2024-10-24 21:36:50

最简单的TCP网络封包解包(补充)-序列化的相关文章

最简单的TCP网络封包解包

TCP为什么需要进行封包解包?        TCP采用字节流的方式,即以字节为单位传输字节序列.那么,我们recv到的就是一串毫无规则的字节流.如果要让这无规则的字节流有规则,那么,就需要我们去定义一个规则.那便是所谓的"封包规则". 封包结构是怎么样的?        封包就像是信,信是由:信封.信内容.两部分组成.而网络封包也是由两部分组成:包头.数据.包头域是定长的,数据域是不定长的.包头必然包含两个信息:操作码.包长度.包头可能还包含别的信息,这个呢就要视乎情况去定了.操作码

c语言-C语言实现封包解包，有一个消息由标识位，消息头，消息体和校验码组成，如何用C实现对它的封包和解包？

问题描述 C语言实现封包解包,有一个消息由标识位,消息头,消息体和校验码组成,如何用C实现对它的封包和解包? 有一个消息由标识位,消息头,消息体和校验码组成,如何用C实现对它的封包和解包? 解决方案 直接定义成结构体 解决方案二: 定义结构体,然后里面用不同字段定义标识位,消息头,消息体,校验码等 解决方案三: 是呀,如果都是按字节来分的,定位为结构体是一个好方法.

TCP网络编程封包解包问题

问题描述 用socket+TCP协议编程存在读取数据100字节但是,数据不足100字节的问题,转换数据总是有问题,看了一些书籍,都说发送前封包,接收的时候解包为对象,但是没有例子不是很直观,到底在发送前怎么封装,接收时怎么解封,如果我读取100条数据,前50是我要的,后50是下一条的,那么又要怎么处理呢?请各位指教,谢谢,最好有实例 解决方案 解决方案二:你可以首先发送整条数据的长度,当接收到指定长度之后就可以算下一条了解决方案三:c#传送的是byte[],先把这个数组的长度传过去,然后等响应后

解决TCP网络传输“粘包”问题

当前在网络传输应用中,广泛采用的是TCP/IP通信协议及其标准的socket应用开发编程接口(API).TCP/IP传输层有两个并列的协议:TCP和UDP.其中TCP(transport control protocol,传输控制协议)是面向连接的,提供高可靠性服务.UDP(user datagram protocol,用户数据报协议)是无连接的,提供高效率服务.在实际工程应用中,对可靠性和效率的选择取决于应用的环境和需求.一般情况下,普通数据的网络传输采用高效率的udp,重要数据的网络传输采用

处理TCP网络传输“粘包”疑难

在应用开发过程中,笔者发现基于TCP网络传输的应用程序有时会出现粘包现象(即发送方发送的若干包数据到接收方接收时粘成一包).针对这种情况,我们进行了专题研究与实验.本文重点分析了TCP网络粘包问题,并结合实验结果提出了解决该问题的对策和方法,供有关工程技术人员参考. 一.TCP协议简介 TCP是一个面向连接的传输层协议,虽然TCP不属于iso制定的协议集,但由于其在商业界和工业界的成功应用,它已成为事实上的网络标准,广泛应用于各种网络主机间的通信. 作为一个面向连接的传输层协议,TCP的目标是为

解决TCP网络传输“粘包”问题，互联网营销

当前在网络传输应用中,广泛采用的是TCP/IP通信协议及其标准的socket应用开发编程接口(API).TCP/IP传输层有两个并列的协议:TCP和UDP.其中TCP(transport control protocol,传输控制协议)是面向连接的,提供高可靠性服务.UDP(user datagram protocol,用户数据报协议)是无连接的,提供高效率服务.在实际工程应用中,对可靠性和效率的选择取决于应用的环境和需求.一般情况下,普通数据的网络传输采用高效率的udp,重要数据的网络传输采用

JAVA包装类及自动封包解包示例代码

在学习上是一个知识点,但不知如何与实际串起来... 悲哀,真是悲哀!!! 代码: 1 public class Wrapper { 2 public static void main(String[] args) { 3 int i = 500; 4 Integer t = new Integer(i); 5 int j = t.intValue(); 6 String s = t.toString(); 7 System.out.println(t); 8 Integer t1 = new I

JAVA包装类及自动封包解包实例代码_java

复制代码 代码如下: public class Wrapper {     public static void main(String[] args) {         int i = 500;         Integer t = new Integer(i);         int j = t.intValue();         String s = t.toString();         System.out.println(t);         Integer t1 =

Linux下套接字详解（四）----简单的TCP套接字应用（迭代型）

前面我们已经将了TCP/UDP的基本知识,还说了并发服务器与迭代服务器的区别,我们大致了解大多数TCP服务器是并发的,大多数UDP服务器是迭代的 ,即我们在进行数据传送的时候,往往使用服务器与客户但之间无连接的UDP报文,但是在用户需要上传下载文件时,就会在客户端和服务器之间建立一条TCP连接,进行文件的传送 那么我们下面就来实现一个简单的TCP服务器. TCP套接字编程模型图 我们首先看一下TCP客户端与服务端的编程模型和流程. 此模型不仅适合迭代服务器,也适合并发服务器,不管服务器是并发的还