Como usar o protobuf

---

typora-copy-images-to: assets
typora-root-url: assets

Buffers de protocolo

Introdução aos buffers de protocolo

• Protocal Buffers (protobuf para abreviar) é uma tecnologia do Google usada para serialização e desserialização de dados estruturados e costuma ser usada em sistemas RPC e sistemas de armazenamento contínuo de dados.
• É semelhante à geração e análise de XML, mas protobuf é mais eficiente que XML, mas protobuf gera bytecode , que é menos legível que XML, semelhante a json, Java's Serializable, etc.
• É muito adequado para armazenamento de dados ou formato de troca de dados RPC. Ele pode ser usado para formatos de dados estruturados serializados extensíveis e independentes de linguagem em protocolos de comunicação, armazenamento de dados e outros campos.
• Referência: https://zhuanlan.zhihu.com/p/53339153

Ideia de instalação do plugin protobuf

Instale o plug-in protobuf Support e reinicie

• Encontre o protobuf-jetbrains-plugin-0.13.0.zip no pacote de dados e instale o plug-in no IDEA

Use ProtoBuf para serializar dados

Configurar dependências e plug-ins do Maven

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

    <build>
        <extensions>
            <extension>
                <groupId>kr.motd.maven</groupId>
                <artifactId>os-maven-plugin</artifactId>
                <version>1.6.2</version>
            </extension>
        </extensions>
        <plugins>
            <!-- Protobuf插件 src/main/java/proto -->
            <plugin>
                <groupId>org.xolstice.maven.plugins</groupId>
                <artifactId>protobuf-maven-plugin</artifactId>
                <version>0.5.0</version>
                <configuration>
                    <protoSourceRoot>${project.basedir}/src/main/java/proto</protoSourceRoot>
                    <protocArtifact>
                        com.google.protobuf:protoc:3.1.0:exe:${os.detected.classifier}
                    </protocArtifact>
                </configuration>
                <executions>
                    <execution>
                        <goals>
                            <goal>compile</goal>
                        </goals>
                    </execution>
                </executions>
            </plugin>
        </plugins>
    </build>

Gravar arquivo proto

• A gramática do protobuf3 refere-se à "gramática do protobuf3" no folheto

• Na pasta principal, crie o diretório proto e grave o arquivo proto

syntax = "proto3";
option java_package = "com.wangjie.protobuf";
option java_outer_classname = "Msg";

message User {
    int32 id = 1;
    string name = 2;
    string sex = 3;
}
message Stats{
    int32 hp =1;
    int32 mp = 2;
    int32 exp =3;
    int32 atk =4;
    int32 def =5;
}

Nota: o nome da classe não pode ser igual ao nome da mensagem

protobuf e tabela de comparação de tipo java

.proto Type	Tipo Java	Observações
em dobro	em dobro
flutuador	flutuador
int32	int	Use codificação de comprimento variável. A codificação negativa é ineficiente - se seu campo pode ter valores negativos, use sint32 em vez disso.
int64	longo	Use codificação de comprimento variável. A codificação negativa é ineficiente - se seu campo pode ter valores negativos, use sint64 em vez disso.
uint32	int	Use codificação de comprimento variável.
uint64	longo	Use codificação de comprimento variável.
Sint32	int	Use codificação de comprimento variável. Valor int assinado. Comparados com o int32 normal, eles codificam números negativos com mais eficiência.
Sint64	longo	Use codificação de comprimento variável. Valor int assinado. Em comparação com o int64 regular, eles codificam números negativos com mais eficiência.
corrigido 32	int	São sempre quatro bytes. Se o valor geralmente for maior do que 2 ^ 28, é mais eficiente do que uint32.
fixo 64	longo	São sempre oito bytes. Se o valor normalmente for maior que 2 ^ 56, é mais eficiente que uint64.
sfixed32	int	São sempre quatro bytes.
sfixed64	longo	São sempre oito bytes.
bool	boleano
fragmento	Fragmento	A string deve sempre conter codificação UTF-8 ou texto ASCII de 7 bits.
bytes	ByteString	Pode conter qualquer sequência de bytes.

Execute protobuf: comando compilar compilação

• Compile o arquivo proto em código java

Escreva o código usando a serialização e desserialização ProtoBuf

package com.wangjie.protobuf;

import com.google.protobuf.InvalidProtocolBufferException;

public class ProtoBufMsg {
    
    
    public static void main(String[] args) {
    
    
        Msg.User.Builder builder = Msg.User.newBuilder();
        builder.setId(1);
        builder.setName("saber");
        builder.setSex("female");

        byte[] bytes = builder.build().toByteArray();
        System.out.println("--protobuf---");
        for (byte b : bytes) {
    
    
            System.out.print(b);
        }
        System.out.println();
        System.out.println("---");

        try {
    
    
            Msg.User user = Msg.User.parseFrom(bytes);
            System.out.println(user);
        } catch (InvalidProtocolBufferException e) {
    
    
            e.printStackTrace();
        }

        Msg.Stats.Builder statsBuild = Msg.Stats.newBuilder();
        statsBuild.setHp(10);
        statsBuild.setMp(10);
        statsBuild.setExp(10);
        statsBuild.setDef(10);
        statsBuild.setAtk(10);

        byte[] bytes1 = statsBuild.build().toByteArray();
        System.out.println("--protobuf---");
        for (byte b : bytes1) {
    
    
            System.out.print(b);
        }
        System.out.println();
        System.out.println("---");

        Msg.Stats stats = null;
        try {
    
    
            stats = Msg.Stats.parseFrom(bytes1);
        } catch (InvalidProtocolBufferException e) {
    
    
            e.printStackTrace();
        }
        System.out.println(stats);
    }

}