使用protobuf实现跨语言序列化 Java和Python实例

使用protobuf实现跨语言序列化 Java和Python实例

首先下载安装protoc

  • github.releases
  • 对于OS X可以通过brew直接安装 brew install protobuf
  • 安装完可以通过protoc --version查看版本信息

创建proto文件-带Any类型的版本

带Any类型的只能导出pb2类型的Python文件，没法导出Python3 的版本，暂时不知道如何解决

  • Any类型的字段可以在java中实现泛型的功能

  • MessageDto.proto

    syntax = "proto3";
import "google/protobuf/any.proto";
message MessageDto {
  string action=1;
  int32 statte=2;
  google.protobuf.Any data=3;
}

  • RpcCmd.proto

    syntax = "proto3";
import "MessageDto.proto";
message RpcCmd {
  MessageDto message=1;
  string randomKey=2;
  string remoteAddressKey=3;
}

  • Point2PointMessage.proto

    syntax = "proto3";
message Point2PointMessage {
  string targetAddressKey;
  string message;
}

  • BytesData.proto

    syntax = "proto3";
message BytesData {
    bytes content=1;
}

导出相应的对象定义文件

Python版

  • protoc --python_out=./gen_pb2 RpcCmd.proto MessageDto.proto Point2PointMessage.proto BytesData.proto

  • 生成的文件名为XXX_pb2.py

    Java版

  • protoc --java_out=./gen_java RpcCmd.proto MessageDto.proto Point2PointMessage.proto BytesData.proto

  • 生成的文件名为XXXOuterClass.java

在Python中使用

  • 首先要导入生成的文件，放到自己喜欢的包下，然后修改导入包的地址，比如RpcCmd_pb2.py中修改

    import com.tony.proto.py2.MessageDto_pb2 as MessageDto__pb2

  • 然后开始使用

    from com.tony.proto.py2 import RpcCmd_pb2, Point2PointMessage_pb2, BytesData_pb2, MessageDto_pb2


def serialize_to_file(file_path):
    p2p_msg = Point2PointMessage_pb2.Point2PointMessage()
    p2p_msg.message = "Hello, p2p from python"
    p2p_msg.targetAddressKey = "/127.0.0.1:38211"

    # bytes_data = BytesData_pb2.BytesData()
    # bytes_data.content = b"Hello, bytes data from python"

    rpc_cmd = RpcCmd_pb2.RpcCmd()
    rpc_cmd.randomKey = "random-key-key-random"
    rpc_cmd.remoteAddressKey = "/127.0.0.1:1234"
    rpc_cmd.message.action = "p2p"
    rpc_cmd.message.state = 100
    rpc_cmd.message.data.Pack(p2p_msg)
    # rpc_cmd.message.data.Pack(bytes_data)

    bytes_write = rpc_cmd.SerializeToString()

    fw = open(file_path, mode="wb")
    fw.write(bytes_write)
    fw.flush()
    fw.close()
    print("write bytes to file:", bytes_write)


def deserialize_from_file(file_path):
    fo = open(file_path, mode="rb")
    bytes_read = fo.read()
    fo.close()
    print("read bytes from file:", bytes_read)
    rpc_cmd = RpcCmd_pb2.RpcCmd()
    rpc_cmd.ParseFromString(bytes_read)
    print(rpc_cmd)

    p2p_msg = Point2PointMessage_pb2.Point2PointMessage()
    # bytes_data = BytesData_pb2.BytesData()
    # rpc_cmd.message.data.Unpack(bytes_data)
    rpc_cmd.message.data.Unpack(p2p_msg)
    
    print("msg_content:", p2p_msg.message)
    print("msg_target:", p2p_msg.targetAddressKey)
    # print("bytes_data:", str(bytes_data.content, 'utf-8'))


if __name__ == "__main__":
    serialize_file_path = "/trans-data-pb2.dat"
    serialize_to_file(serialize_file_path)
    deserialize_from_file(serialize_file_path)

  • 执行结果如下，可以将bytes_data相关的注释取消同时注释掉p2p_msg相关的测试BytesData类型的序列化和反序列化

    write bytes to file: b'\n]\n\x03p2p\x10d\x1aT\n&type.googleapis.com/Point2PointMessage\x12*\n\x10/127.0.0.1:38211\x12\x16Hello, p2p from python\x12\x15random-key-key-random\x1a\x0f/127.0.0.1:1234'
read bytes from file: b'\n]\n\x03p2p\x10d\x1aT\n&type.googleapis.com/Point2PointMessage\x12*\n\x10/127.0.0.1:38211\x12\x16Hello, p2p from python\x12\x15random-key-key-random\x1a\x0f/127.0.0.1:1234'
message {
  action: "p2p"
  state: 100
  data {
    type_url: "type.googleapis.com/Point2PointMessage"
    value: "\n\020/127.0.0.1:38211\022\026Hello, p2p from python"
  }
}
randomKey: "random-key-key-random"
remoteAddressKey: "/127.0.0.1:1234"

msg_content: Hello, p2p from python
msg_target: /127.0.0.1:38211

在Java中使用

  • 同样导入到喜欢的包下，修改对应的包名即可

    @Slf4j
public class ProtobufSerializeDemo {

    @Test
    public void serializeToFile() throws Exception {
        Point2PointMessageOuterClass.Point2PointMessage.Builder p2pMsgBuilder = Point2PointMessageOuterClass.Point2PointMessage.newBuilder();
        p2pMsgBuilder.setTargetAddressKey("/127.0.0.1:1233");
        p2pMsgBuilder.setMessage("hello from java");

//        BytesDataOuterClass.BytesData.Builder bytesBuilder = BytesDataOuterClass.BytesData.newBuilder();
//        bytesBuilder.setContent(ByteString.copyFrom("bytes data from java".getBytes(StandardCharsets.UTF_8)));


        MessageDtoOuterClass.MessageDto.Builder messageBuilder = MessageDtoOuterClass.MessageDto.newBuilder();
        messageBuilder.setAction("p2p");
        messageBuilder.setState(100);
        messageBuilder.setData(Any.pack(p2pMsgBuilder.build()));
//        messageBuilder.setData(Any.pack(bytesBuilder.build()));


        RpcCmdOuterClass.RpcCmd.Builder builder = RpcCmdOuterClass.RpcCmd.newBuilder();
        builder.setRandomKey("RANDOM_KEY_JAVA");
        builder.setRemoteAddressKey("/127.0.0.1:1234");
        builder.setMessage(messageBuilder.build());

        builder.build().writeTo(new FileOutputStream("java_protobuf.dat"));
    }


    @Test
    public void deserializeFromFile() throws Exception {
        RpcCmdOuterClass.RpcCmd rpcCmd = RpcCmdOuterClass.RpcCmd.parseFrom(new FileInputStream("java_protobuf.dat"));
        Point2PointMessageOuterClass.Point2PointMessage p2pMsg = rpcCmd.getMessage().getData().unpack(Point2PointMessageOuterClass.Point2PointMessage.class);
//        BytesDataOuterClass.BytesData bytesData = rpcCmd.getMessage().getData().unpack(BytesDataOuterClass.BytesData.class);
        log.info("deserialize rpcCmd: \n{}", rpcCmd);
        log.info("deserialize p2pMsg: \n{}", p2pMsg);
//        log.info("deserialize bytesData: \n{}", bytesData);
    }
}

  • 执行结果，可以将bytes_data相关的注释取消同时注释掉p2p_msg相关的测试BytesData类型的序列化和反序列化

    10:22:03.118 [main] INFO com.tony.proto.ProtobufSerializeDemo - deserialize rpcCmd: 
message {
  action: "p2p"
  state: 100
  data {
    type_url: "type.googleapis.com/Point2PointMessage"
    value: "\n\017/127.0.0.1:1233\022\017hello from java"
  }
}
randomKey: "RANDOM_KEY_JAVA"
remoteAddressKey: "/127.0.0.1:1234"

10:22:03.168 [main] INFO com.tony.proto.ProtobufSerializeDemo - deserialize p2pMsg: 
targetAddressKey: "/127.0.0.1:1233"
message: "hello from java"

然后是Java和Python之间互相序列化和反序列化

  • 只需要修改对应的文件地址就可以进行测试
Python反序列化Java
java_serialize_file_path = $path_to_java_serialized$
deserialize_from_file(java_serialize_file_path)

  • 执行结果，这里演示的是BytesData类型的

    read bytes from file: b'\n@\n\x03p2p\x10d\x1a7\n\x1dtype.googleapis.com/BytesData\x12\x16\n\x14bytes data from java\x12\x0fRANDOM_KEY_JAVA\x1a\x0f/127.0.0.1:1234'
message {
  action: "p2p"
  state: 100
  data {
    type_url: "type.googleapis.com/BytesData"
    value: "\n\024bytes data from java"
  }
}
randomKey: "RANDOM_KEY_JAVA"
remoteAddressKey: "/127.0.0.1:1234"

bytes_data: bytes data from java
Java反序列化Python
    @Test
    public void deserializeFromPythonFile() throws Exception {
        RpcCmdOuterClass.RpcCmd rpcCmd = RpcCmdOuterClass.RpcCmd.parseFrom(new FileInputStream($path_to_python_serialize$));
//        Point2PointMessageOuterClass.Point2PointMessage p2pMsg = rpcCmd.getMessage().getData().unpack(Point2PointMessageOuterClass.Point2PointMessage.class);
        BytesDataOuterClass.BytesData bytesData = rpcCmd.getMessage().getData().unpack(BytesDataOuterClass.BytesData.class);
        log.info("deserialize rpcCmd: \n{}", rpcCmd);
//        log.info("deserialize p2pMsg: \n{}", p2pMsg);
        log.info("deserialize bytesData: \n{}", bytesData);
    }

  • 执行结果，同样是BytesData类型的

    10:33:03.360 [main] INFO com.tony.proto.ProtobufSerializeDemo - deserialize rpcCmd: 
message {
  action: "p2p"
  state: 100
  data {
    type_url: "type.googleapis.com/BytesData"
    value: "\n\035Hello, bytes data from python"
  }
}
randomKey: "random-key-key-random"
remoteAddressKey: "/127.0.0.1:1234"

10:33:03.402 [main] INFO com.tony.proto.ProtobufSerializeDemo - deserialize bytesData: 
content: "Hello, bytes data from python"

在Java平台，还有个更好用的工具可以不用手写proto文件

  • 这个工具是io.protostuff

  • 通过maven导入依赖

    <dependency>
  <groupId>io.protostuff</groupId>
  <artifactId>protostuff-core</artifactId>
  <version>1.6.0</version>
</dependency>
<dependency>
  <groupId>io.protostuff</groupId>
  <artifactId>protostuff-runtime</artifactId>
  <version>1.6.0</version>
</dependency>
<!-- 用于创建对象 -->
<dependency>
  <groupId>org.objenesis</groupId>
  <artifactId>objenesis</artifactId>
  <version>2.2</version>
</dependency>

创建序列化工具类

import io.protostuff.LinkedBuffer;
import io.protostuff.ProtobufIOUtil;
import io.protostuff.Schema;
import io.protostuff.runtime.DefaultIdStrategy;
import io.protostuff.runtime.RuntimeSchema;
import lombok.extern.slf4j.Slf4j;
import org.objenesis.Objenesis;
import org.objenesis.ObjenesisStd;

import java.io.ByteArrayInputStream;
import java.io.ByteArrayOutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;

/**
 * 基于Protostuff优化版的ProtobufIOUtil实现序列化，理论上可以支持跨语言序列化
 *
 * @author jiangwenjie 2019/10/30
 */
@Slf4j
public class ProtobufSerializer {


    private final static Objenesis OBJENESIS = new ObjenesisStd(true);

    private ProtobufSerializer() {
    }

    private static class SingletonHolder {
        final static ProtobufSerializer INSTANCE = new ProtobufSerializer();
    }

    public static ProtobufSerializer getInstance() {
        return ProtobufSerializer.SingletonHolder.INSTANCE;
    }

    public void serialize(Object obj, OutputStream outputStream) {
        Class clz = obj.getClass();
        LinkedBuffer buffer = LinkedBuffer.allocate(LinkedBuffer.DEFAULT_BUFFER_SIZE);
        try {
            Schema schema = getSchema(clz);
            ProtobufIOUtil.writeTo(outputStream, obj, schema, buffer);
        } catch (IOException e) {
            log.error("序列化对象失败", e);
        } finally {
            buffer.clear();
        }
    }

    public byte[] serialize(Object obj) {
        Class clz = obj.getClass();
        LinkedBuffer buffer = LinkedBuffer.allocate(LinkedBuffer.DEFAULT_BUFFER_SIZE);
        try (ByteArrayOutputStream arrayOutputStream = new ByteArrayOutputStream()) {
            Schema schema = getSchema(clz);
            ProtobufIOUtil.writeTo(arrayOutputStream, obj, schema, buffer);
            return arrayOutputStream.toByteArray();
        } catch (IOException e) {
            log.error("序列化对象失败", e);
        } finally {
            buffer.clear();
        }
        return new byte[0];
    }

    public <T> T deSerialize(InputStream inputStream, Class<T> clazz) {
        T object = OBJENESIS.newInstance(clazz);
        Schema<T> schema = getSchema(clazz);
        try {
            ProtobufIOUtil.mergeFrom(inputStream, object, schema);
            return object;
        } catch (IOException e) {
            log.error("反序列化对象失败", e);
        }
        return null;
    }

    public <T> T deSerialize(byte[] param, Class<T> clazz) {
        T object = OBJENESIS.newInstance(clazz);
        Schema<T> schema = getSchema(clazz);
        try (ByteArrayInputStream inputStream = new ByteArrayInputStream(param)) {
            ProtobufIOUtil.mergeFrom(inputStream, object, schema);
            return object;
        } catch (IOException e) {
            log.error("反序列化对象失败", e);
        }
        return null;
    }


    private <T> Schema<T> getSchema(Class<T> clz) {
        return RuntimeSchema.createFrom(clz, new DefaultIdStrategy());
    }
}

创建序列化对象

import lombok.Data;
import lombok.extern.slf4j.Slf4j;

import java.io.Serializable;

/**
 * @author jiangwenjie 2019/10/22
 */
@Data
@Slf4j
public class RpcCmd implements Serializable {
    private MessageDto message;
    private String randomKey;
    /**
     * 目标地址，不需要序列化传输
     */
    private transient String remoteAddressKey;
}



import com.tony.constants.EnumNettyState;
import com.tony.serializer.impl.ProtobufSerializer;
import lombok.Data;
import lombok.EqualsAndHashCode;
import lombok.ToString;
import lombok.extern.slf4j.Slf4j;

import java.io.Serializable;

/**
 * 消息对象
 *
 * @author jiangwenjie 2019/10/22
 */
@Slf4j
@Data
@ToString
@EqualsAndHashCode
public class MessageDto implements Serializable {

    private String action;

    private int state = 100;

    /**
     * 跨语言使用Protostuff中提供的protobuff序列化传递复杂对象
     */
    private byte[] bytesData;

    private Serializable serialData;

    public <T> T dataOfClazz(Class<T> clazz, boolean isStuff) {
        if (isStuff) {
            return serialDataOfClazz(clazz);
        } else {
            return bytesDataOfClass(clazz);
        }
    }

    public <T extends Serializable> void setData(T object, boolean isStuff) {
        if (isStuff) {
            setSerialData(object);
        } else {
            setBytesData(object);
        }
    }

    @SuppressWarnings("unchecked")
    private <T> T serialDataOfClazz(Class<T> clazz) {
        if (serialData == null) {
            return null;
        }
        if (clazz.isInstance(serialData)) {
            return (T)serialData;
        } else {
            throw new IllegalArgumentException("data is not instance of class:" + clazz.getName());
        }
    }

    private <T> T bytesDataOfClass(Class<T> clazz) {
        if (bytesData == null) {
            return null;
        }
        try {
            return ProtobufSerializer.getInstance().deSerialize(bytesData, clazz);
        } catch (Exception e) {
            log.error("反序列化data对象失败，请确认对象是否为：{} 类型", clazz);
        }
        return null;
    }

    private <T extends Serializable> void setBytesData(T data) {
        this.bytesData = ProtobufSerializer.getInstance().serialize(data);
    }
}


import lombok.Data;

import java.io.Serializable;

/**
 * 点对点通信data对象
 *
 * @author jiangwenjie 2019/10/26
 */
@Data
public class Point2PointMessage implements Serializable {
    private String targetAddressKey;
    private String message;
}

序列化测试

import lombok.extern.slf4j.Slf4j;
import org.junit.Test;

import java.io.FileInputStream;
import java.io.FileOutputStream;

/**
 * @author jiangwenjie 2019/11/1
 */
@Slf4j
public class JavaProtostuffSerializeDemo {

    @Test
    public void serializeToFile() throws Exception {
        Point2PointMessage p2pMsg = new Point2PointMessage();
        p2pMsg.setTargetAddressKey("/127.0.0.1:1233");
        p2pMsg.setMessage("message from java");
        MessageDto messageDto = new MessageDto();
        messageDto.setAction("p2p");
        messageDto.setState(100);
        messageDto.setData(p2pMsg, false);

        RpcCmd rpcCmd = new RpcCmd();
        rpcCmd.setMessage(messageDto);
        rpcCmd.setRandomKey("RANDOM_KEY_JAVA");
        rpcCmd.setRemoteAddressKey("/127.0.0.1:1234");
        ProtobufSerializer.getInstance().serialize(rpcCmd, new FileOutputStream("java_proto_simple.dat"));
    }

    @Test
    public void deserializeFromFile() throws Exception {
        RpcCmd rpcCmd = ProtobufSerializer.getInstance().deSerialize(new FileInputStream("java_proto_simple.dat"), RpcCmd.class);
        log.info("deserialize cmd:\n{}", rpcCmd);
        log.info("deserialize p2p msg:\n{}", rpcCmd.getMessage().dataOfClazz(Point2PointMessage.class, false));
    }
}

测试输出

11:02:45.646 [main] INFO com.tony.simple.JavaProtostuffSerializeDemo - deserialize cmd:
RpcCmd(message=MessageDto(action=p2p, state=100, bytesData=[10, 15, 47, 49, 50, 55, 46, 48, 46, 48, 46, 49, 58, 49, 50, 51, 51, 18, 17, 109, 101, 115, 115, 97, 103, 101, 32, 102, 114, 111, 109, 32, 106, 97, 118, 97], serialData=null, isFromBuff=false), randomKey=RANDOM_KEY_JAVA, remoteAddressKey=null)
11:02:45.651 [main] INFO com.tony.simple.JavaProtostuffSerializeDemo - deserialize p2p msg:
Point2PointMessage(targetAddressKey=/127.0.0.1:1233, message=message from java)

MessageDto中的Data 可以泛型化使用

/**
 * 跨语言使用Protostuff中提供的protobuff序列化传递复杂对象
 */
private byte[] bytesData;
private Serializable serialData;

  • 当序列化和反序列化不需要跨平台使用时，可以直接使用Serializable类型，反之需要用byte数组保存数据，进行二次序列化和反序列化。同时可以在序列化工具类ProtobufSerializer中将ProtobufIOUtil修改为ProtostuffIOUtil

  • 通过setData方法进行响应的操作

    public <T extends Serializable> void setData(T object, boolean isStuff) {
  if (isStuff) {
    setSerialData(object);
  } else {
    setBytesData(object);
  }
}

跨语言Python中反序列化

创建proto文件

  • MessageDto.proto

    syntax = "proto3";

message MessageDto {
    string action=1;
    int32 state=2;
    bytes data=3;
}

  • RpcCmd.proto

    syntax = "proto3";
import "MessageDto.proto";

message RpcCmd {
    MessageDto message = 1;
    string randomKey = 2;
    string remoteAddressKey = 3;
}

  • Point2PointMessage.proto

    syntax = "proto3";

message Point2PointMessage {
    bytes java_class = 127;
    string targetAddressKey = 1;
    string message = 2;
}

  • BytesData.proto

    syntax = "proto3";
message BytesData {
    bytes content=1;
}
导出Python3对象定义文件
  • 此时没有用到Any类型 可以直接导出为Python3的py文件
  • protoc --python3_out=./gen RpcCmd.proto MessageDto.proto Point2PointMessage.proto BytesData.proto
  • 和pb2的区别是序列化和反序列化的方法名称进行了修改
    • pb2中用的是ParseFromString和SerializeToString
    • pb3中修改成了encode_to_bytes和parse_from_bytes
在Python中使用

  • 同样的放到喜欢的包下，修改对应包名 这里不赘述

    #!/usr/bin/python3
# -*-coding: utf-8 -*-
from com.tony.proto.py3 import RpcCmd, Point2PointMessage, MessageDto, BytesData


def serialize_to_file(file_path):
    p2p_msg = Point2PointMessage.Point2PointMessage()
    p2p_msg.message = "Hello, p2p from python"
    p2p_msg.targetAddressKey = "/127.0.0.1:38211"

    # bytes_data = BytesData.BytesData()
    # bytes_data.content = "bytes data from python"

    rpc_cmd = RpcCmd.RpcCmd()
    rpc_cmd.randomKey = "random-key-key-random"
    rpc_cmd.remoteAddressKey = "/127.0.0.1:1234"
    rpc_cmd.message.action = "p2p"
    rpc_cmd.message.state = 100
    rpc_cmd.message.data = p2p_msg.encode_to_bytes()
    # rpc_cmd.message.data = bytes_data.encode_to_bytes()
    bytes_write = rpc_cmd.encode_to_bytes()

    fw = open(file_path, mode="wb")
    fw.write(bytes_write)
    fw.flush()
    fw.close()
    print("write bytes to file:", bytes_write)


def deserialize_from_file(file_path):
    fo = open(file_path, mode="rb")
    bytes_read = fo.read()
    fo.close()
    print("read bytes from file:", bytes_read)
    rpc_cmd = RpcCmd.RpcCmd()
    rpc_cmd.parse_from_bytes(bytes_read)
    print(rpc_cmd)

    msg_bytes = rpc_cmd.message.data
    print("message bytes", msg_bytes)
    p2p_msg = data_of(rpc_cmd.message, Point2PointMessage.Point2PointMessage)
    # bytes_data = data_of(rpc_cmd.message, BytesData.BytesData)
    print("msg_content:", p2p_msg.message)
    print("msg_target:", p2p_msg.targetAddressKey)
    # print("bytes_data:", bytes_data.content)


def data_of(message: RpcCmd.MessageDto, message_identify):
    content = message_identify()
    content.parse_from_bytes(message.data)
    return content


if __name__ == "__main__":
    serialize_file_path = "./trans-data.dat"
    serialize_to_file(serialize_file_path)
    deserialize_from_file(serialize_file_path)

  • 执行结果如下，同样的可以将bytes_data相关的注释取消同时注释掉p2p_msg相关的测试BytesData类型的序列化和反序列化

    write bytes to file: b'\n3\n\x03p2p\x10d\x1a*\n\x10/127.0.0.1:38211\x12\x16Hello, p2p from python\x12\x15random-key-key-random\x1a\x0f/127.0.0.1:1234'
read bytes from file: b'\n3\n\x03p2p\x10d\x1a*\n\x10/127.0.0.1:38211\x12\x16Hello, p2p from python\x12\x15random-key-key-random\x1a\x0f/127.0.0.1:1234'
<Message(RpcCmd)>
    <MessageField(id=1, optional)>:
        <Message(MessageDto)>            <StringField(id=1, optional)>:                p2p            <Int32Field(id=2, optional)>:                100            <BytesField(id=3, optional)>:                b'\n\x10/127.0.0.1:38211\x12\x16Hello, p2p from python'
    <StringField(id=2, optional)>:
        random-key-key-random
    <StringField(id=3, optional)>:
        /127.0.0.1:1234
message bytes b'\n\x10/127.0.0.1:38211\x12\x16Hello, p2p from python'
msg_content: Hello, p2p from python
msg_target: /127.0.0.1:38211
Python和Java互转
  • 同样是仅仅修改序列化文件地址即可
Python反序列化Java
  • java_serialize_file_path = $path_to_java_serialized$
deserialize_from_file(java_serialize_file_path)

  • 执行结果

    read bytes from file: b'\n-\n\x03p2p\x10d\x1a$\n\x0f/127.0.0.1:1233\x12\x11message from java\x12\x0fRANDOM_KEY_JAVA'
<Message(RpcCmd)>
    <MessageField(id=1, optional)>:
        <Message(MessageDto)>            <StringField(id=1, optional)>:                p2p            <Int32Field(id=2, optional)>:                100            <BytesField(id=3, optional)>:                b'\n\x0f/127.0.0.1:1233\x12\x11message from java'
    <StringField(id=2, optional)>:
        RANDOM_KEY_JAVA
message bytes b'\n\x0f/127.0.0.1:1233\x12\x11message from java'
msg_content: message from java
msg_target: /127.0.0.1:1233
Java反序列化Python
  • @Test
public void deserializeFromPythonFile() throws Exception {
  RpcCmd rpcCmd = ProtobufSerializer.getInstance()
    .deSerialize(new FileInputStream($python_serialize_path$), RpcCmd.class);
  log.info("deserialize cmd:\n{}", rpcCmd);
  log.info("deserialize p2p msg:\n{}", rpcCmd.getMessage().dataOfClazz(Point2PointMessage.class, false));
}

  • 执行结果

    13:15:17.821 [main] INFO com.tony.simple.JavaProtostuffSerializeDemo - deserialize cmd:
RpcCmd(message=MessageDto(action=p2p, state=100, bytesData=[10, 16, 47, 49, 50, 55, 46, 48, 46, 48, 46, 49, 58, 51, 56, 50, 49, 49, 18, 22, 72, 101, 108, 108, 111, 44, 32, 112, 50, 112, 32, 102, 114, 111, 109, 32, 112, 121, 116, 104, 111, 110], serialData=null), randomKey=random-key-key-random, remoteAddressKey=null)
13:15:17.828 [main] INFO com.tony.simple.JavaProtostuffSerializeDemo - deserialize p2p msg:
Point2PointMessage(targetAddressKey=/127.0.0.1:38211, message=Hello, p2p from python)

io.protostuff使用总结

  • 在java平台可以直接定义普通的POJO而不需要手写proto文件并生成对应的对象文件，仅仅通过其所提供的ProtobufIOUtil或者ProtostuffIOUtil来实现序列化和反序列化即可。
  • 当需要进行跨语言序列化和反序列化时，需要其他语言中编写对应的proto文件并生成对象文件，而在Java中的泛型实例变量则需要进行修改，改成二次序列化的byte数组，方便在Python等语言中进行解析。Java中的序列化也应采用ProtobufIOUtil来实现。此时，Python中可以根据业务类型反序列化成指定的对象，Java中也以该对象来序列化，反过来也是一样的操作。以此来达到的目的是定义MessageDto之后如果需要扩展，不需要修改MessageDto，仅仅需要定义更多的data类型然后赋值给MessageDto.$data。
  • 对比纯protobuf实现的来说，在编码上更加简单，不需要写大量的Any.pack()和Any.unpack()

原文发布在我的github blog

最后编辑于 ：
©著作权归作者所有,转载或内容合作请联系作者
  • 人面猴
    序言：七十年代末，一起剥皮案震惊了整个滨河市，随后出现的几起案子，更是在滨河造成了极大的恐慌，老刑警刘岩，带你破解...
    沈念sama阅读 194,242评论 5赞 459
  • 死咒
    序言：滨河连续发生了三起死亡事件，死亡现场离奇诡异，居然都是意外死亡，警方通过查阅死者的电脑和手机，发现死者居然都...
    沈念sama阅读 81,769评论 2赞 371
  • 救了他两次的神仙让他今天三更去死
    文/潘晓璐 我一进店门，熙熙楼的掌柜王于贵愁眉苦脸地迎上来，“玉大人，你说我怎么就摊上这事。” “怎么了？”我有些...
    开封第一讲书人阅读 141,484评论 0赞 319
  • 道士缉凶录：失踪的卖姜人
    文/不坏的土叔 我叫张陵，是天一观的道长。 经常有香客问我，道长，这世上最难降的妖魔是什么？ 我笑而不...
    开封第一讲书人阅读 52,133评论 1赞 263
  • 港岛之恋（遗憾婚礼）
    正文 为了忘掉前任，我火速办了婚礼，结果婚礼上，老公的妹妹穿的比我还像新娘。我一直安慰自己，他们只是感情好，可当我...
    茶点故事阅读 61,007评论 4赞 355
  • 恶毒庶女顶嫁案：这布局不是一般人想出来的
    文/花漫 我一把揭开白布。 她就那样静静地躺着，像睡着了一般。 火红的嫁衣衬着肌肤如雪。 梳的纹丝不乱的头发上，一...
    开封第一讲书人阅读 46,080评论 1赞 272
  • 城市分裂传说
    那天，我揣着相机与录音，去河边找鬼。 笑死，一个胖子当着我的面吹牛，可吹牛的内容都是我干的。 我是一名探鬼主播，决...
    沈念sama阅读 36,496评论 3赞 381
  • 双鸳鸯连环套：你想象不到人心有多黑
    文/苍兰香墨 我猛地睁开眼，长吁一口气：“原来是场噩梦啊……” “哼！你这毒妇竟也来了？” 一声冷哼从身侧响起，我...
    开封第一讲书人阅读 35,190评论 0赞 253
  • 万荣杀人案实录
    序言：老挝万荣一对情侣失踪，失踪者是张志新（化名）和其女友刘颖，没想到半个月后，有当地人在树林里发现了一具尸体，经...
    沈念sama阅读 39,464评论 1赞 290
  • 护林员之死
    正文 独居荒郊野岭守林人离奇死亡，尸身上长有42处带血的脓包…… 初始之章·张勋 以下内容为张勋视角 年9月15日...
    茶点故事阅读 34,549评论 2赞 309
  • 白月光启示录
    正文 我和宋清朗相恋三年，在试婚纱的时候发现自己被绿了。 大学时的朋友给我发了我未婚夫和他白月光在一起吃饭的照片。...
    茶点故事阅读 36,330评论 1赞 326
  • 活死人
    序言：一个原本活蹦乱跳的男人离奇死亡，死状恐怖，灵堂内的尸体忽然破棺而出，到底是诈尸还是另有隐情，我是刑警宁泽，带...
    沈念sama阅读 32,205评论 3赞 312
  • 日本核电站爆炸内幕
    正文 年R本政府宣布，位于F岛的核电站，受9级特大地震影响，放射性物质发生泄漏。R本人自食恶果不足惜，却给世界环境...
    茶点故事阅读 37,567评论 3赞 298
  • 男人毒药：我在死后第九天来索命
    文/蒙蒙 一、第九天 我趴在偏房一处隐蔽的房顶上张望。 院中可真热闹，春花似锦、人声如沸。这庄子的主人今日做“春日...
    开封第一讲书人阅读 28,889评论 0赞 17
  • 一桩弑父案，背后竟有这般阴谋
    文/苍兰香墨 我抬头看了看天上的太阳。三九已至，却和暖如春，着一层夹袄步出监牢的瞬间，已是汗流浃背。 一阵脚步声响...
    开封第一讲书人阅读 30,160评论 1赞 250
  • 情欲美人皮
    我被黑心中介骗来泰国打工， 没想到刚下飞机就差点儿被人妖公主榨干…… 1. 我叫王不留，地道东北人。 一个月前我还...
    沈念sama阅读 41,475评论 2赞 341
  • 代替公主和亲
    正文 我出身青楼，却偏偏与公主长得像，于是被迫代替她去往敌国和亲。 传闻我的和亲对象是个残疾皇子，可洞房花烛夜当晚...
    茶点故事阅读 40,650评论 2赞 335