Go语言消息序列化 JSON、ProtoBuf与MsgPack对比

type JSONSerializer struct{}

func (s *JSONSerializer) Serialize(v interface{}) ([]byte, error) {
    return json.Marshal(v)
}

func (s *JSONSerializer) Deserialize(data []byte, v interface{}) error {
    return json.Unmarshal(data, v)
}

type JSONMessage struct {
    Topic string
    Key   string
    Value interface{}
}

func (j *JSONMessage) Serialize() ([]byte, error) {
    return json.Marshal(j)
}

func DeserializeJSONMessage(data []byte) (*JSONMessage, error) {
    var msg JSONMessage
    err := json.Unmarshal(data, &msg)
    if err != nil {
        return nil, err
    }
    return &msg, nil
}

syntax = "proto3";

package message;

option go_package = "./;message";

message Person {
    string name = 1;
    int32 age = 2;
    string email = 3;
}

message Message {
    string topic = 1;
    string key = 2;
    bytes value = 3;
    int64 timestamp = 4;
}

message BatchMessage {
    repeated Message messages = 1;
}

package protobuf

import (
    "fmt"

    "github.com/golang/protobuf/proto"
)

type ProtoSerializer struct{}

func (s *ProtoSerializer) Serialize(v proto.Message) ([]byte, error) {
    return proto.Marshal(v)
}

func (s *ProtoSerializer) Deserialize(data []byte, v proto.Message) error {
    return proto.Unmarshal(data, v)
}

type Message struct {
    Topic     string `protobuf:"bytes,1,opt,name=topic"`
    Key       string `protobuf:"bytes,2,opt,name=key"`
    Value     []byte `protobuf:"bytes,3,opt,name=value"`
    Timestamp int64  `protobuf:"varint,4,opt,name=timestamp"`
}

func (m *Message) Reset()         {}
func (m *Message) String() string { return fmt.Sprintf("%v", *m) }
func (m *Message) ProtoMessage()  {}

package msgpack

import (
    "github.com/vmihailenco/msgpack/v5"
)

type MsgPackSerializer struct{}

func (s *MsgPackSerializer) Serialize(v interface{}) ([]byte, error) {
    return msgpack.Marshal(v)
}

func (s *MsgPackSerializer) Deserialize(data []byte, v interface{}) error {
    return msgpack.Unmarshal(data, v)
}

type Message struct {
    Topic     string
    Key       string
    Value     []byte
    Timestamp int64
}

func (m *Message) Encode() ([]byte, error) {
    return msgpack.Marshal(m)
}

func DecodeMessage(data []byte) (*Message, error) {
    var m Message
    err := msgpack.Unmarshal(data, &m)
    if err != nil {
        return nil, err
    }
    return &m, nil
}