[自己做个游戏服务器]搞清楚游戏通信协议之protobuf的方方面面

    <dependency>
            <groupId>com.google.protobuf</groupId>
            <artifactId>protobuf-java</artifactId>
            <version>3.18.0</version>
        </dependency>

syntax = "proto3";
message SearchRequest {
  string query = 1;
  int32 page_number = 2;
  int32 result_per_page = 3;
}

/* SearchRequest represents a search query, with pagination options to
 * indicate which results to include in the response. */
message SearchRequest {
  string query = 1;
  int32 page_number = 2;  // Which page number do we want?
  int32 result_per_page = 3;  // Number of results to return per page.
}

message SearchResponse {
  repeated Result results = 1;
}
message Result {
  string url = 1;
  string title = 2;
  repeated string snippets = 3;
}

option java_package = "com.example.foo";
option java_outer_classname = "GameMsg";
option java_multiple_files = true;
option optimize_for = CODE_SIZE;
option java_package = "com.example.foo"; 生成的java文件所在的包名


option java_outer_classname = "GameMsg";生成的类的名字

protoc --java_out=./ XX.proto

        SimpleMessage.Builder builder = SimpleMessage.newBuilder();
        builder.setName("香菜");
        builder.setId(1);
        builder.setIsSimple(true);
        byte[] result=builder.build().toByteArray();//序列化
        SimpleMessage msg;
        try {
            msg = SimpleMessage.parseFrom(result);
            System.out.println(msg);
        } catch (InvalidProtocolBufferException e) {
            e.printStackTrace();
        }

import com.google.protobuf.Parser;
import com.xin.msg.login.SimpleMessage;
import java.util.HashMap;
import java.util.Map;
public class MsgMgr {
    public static Map<Integer, Parser> msgMap = new HashMap<>();
    static {
        //  msgId - parser
        msgMap.put(1, SimpleMessage.parser());
    }
}

        Parser parser = MsgMgr.msgMap.get(headId);
        int canReadBytes = decode.readableBytes();
        byte[] data = new byte[canReadBytes];
        decode.readBytes(data);
        Object o = parser.parseFrom(data);

<dependency>
  <groupId>io.protostuff</groupId>
  <artifactId>protostuff-core</artifactId>
  <version>1.7.4</version>
</dependency>
<dependency>
  <groupId>io.protostuff</groupId>
  <artifactId>protostuff-runtime</artifactId>
  <version>1.7.4</version>
</dependency>

public final class Foo
{
    String name;
    int id;
    
    public Foo(String name, int id)
{
        this.name = name;
        this.id = id;
    }
}
static void roundTrip()
{
    Foo foo = new Foo("foo", 1);
    // this is lazily created and cached by RuntimeSchema
    // so its safe to call RuntimeSchema.getSchema(Foo.class) over and over
    // The getSchema method is also thread-safe
    Schema<Foo> schema = RuntimeSchema.getSchema(Foo.class);
    // Re-use (manage) this buffer to avoid allocating on every serialization
    LinkedBuffer buffer = LinkedBuffer.allocate(512);
    // ser
    final byte[] protostuff;
    try
    {
        protostuff = ProtostuffIOUtil.toByteArray(foo, schema, buffer);
    }
    finally
    {
        buffer.clear();
    }
    // deser
    Foo fooParsed = schema.newMessage();
    ProtostuffIOUtil.mergeFrom(protostuff, fooParsed, schema);
}