Eu acredito que todo mundo sabe o que é JSON. Se você não sabe, está realmente saindo. GOOGLE. Não vou apresentar nada aqui.
Acho que todo mundo raramente ouve sobre o Protobuffer, mas se for feito pelo Google, acredito que todos estarão interessados em experimentá -lo. Afinal, as exportações do Google são principalmente produtos de alta qualidade.
O Protobuffer é um protocolo de transmissão semelhante ao JSON. De fato, não se pode dizer que seja um protocolo, é apenas uma coisa de transmissão de dados.
Então, qual é a diferença entre ele e JSON?
Languagem cruzada, essa é uma de suas vantagens. Ele vem com um compilador, Protoc, que só precisa ser compilado com ele e pode ser compilado no código Java, Python e C ++. Por enquanto, existem apenas esses três, então não pense nos outros por enquanto e você pode usá -los diretamente sem escrever nenhum outro código. Até os analisados já vêm com eles. O JSON é obviamente em linguagem cruzada, mas esse idioma cruzado é baseado na escrita.
Se você quiser saber mais, pode conferir:
https://developers.google.com/protocol-buffers/docs/overview
Ok, sem mais delongas, vamos dar uma olhada no motivo pelo qual precisamos comparar o Protobuffer (a seguir referido como GPB) e JSON.
1. Como o JSON tem um determinado formato e existe em caracteres, ainda há espaço para compressão na quantidade de dados. Quando a quantidade de big data no GPB é muito menor que a do JSON, podemos ver o exemplo abaixo.
2. A diferença de eficiência entre as bibliotecas JSON é bastante grande, e há uma lacuna de cerca de 5 a 10 entre as bibliotecas Jackson e o GSON (isso só foi testado uma vez, se houver algum erro, por favor, por favor, dê um tapinha). O GPB precisa apenas de um, e não há diferença entre as chamadas bibliotecas. Obviamente, esse ponto é compensado apenas para os números e pode ser ignorado.
A conversa é barata, basta me mostrar o código.
No mundo da programação, o código é sempre o rei, então vamos ao código.
Antes de enviar o código, você precisa baixar o protobuffer primeiro, aqui:
https://github.com/google/protobuf
1. Primeiro de tudo, o GPB precisa ter um arquivo com definições de classe semelhantes, chamadas de arquivo proto.
Vamos dar o exemplo de alunos e professores para dar um exemplo:
Temos os dois arquivos a seguir: Student.proto
opção java_package = "com.shun"; opção java_outer_className = "StudentProto"; aluno de mensagem {exigido int32 id = 1; Nome da string opcional = 2; Int32 opcional Idade = 3; } </span> Professor.proto
importar "Student.proto"; opção java_package = "com.shun"; opção java_outer_className = "ProfessorProto"; Professor de mensagens {exigido int32 id = 1; Nome da string opcional = 2; estudante repetido estudante_list = 3; } </span> Aqui encontramos algumas coisas estranhas:
importar, int32, repetido, exigido, opcional, opção etc.
1) Importar significa importar outros arquivos proto
2) Necessário e opcional indica se o campo é opcional. Isso determina qual processamento será feito pelo Protobuffer se o campo tiver um valor ou não. Se necessário, estiver marcado, mas ao processamento, o campo não passa o valor, um erro será relatado; Se opcional estiver marcado, nenhum valor será transmitido, não haverá problema.
3) Acredito que você possa entender repetido, o que significa se é repetido, é semelhante à lista em Java.
4) A mensagem é equivalente à classe
5) A opção representa a opção, onde Java_package representa o nome do pacote, ou seja, o nome do pacote usado ao gerar código Java. java_outer_className é o nome da classe. Observe que esse nome de classe não pode ser o mesmo que o nome da classe na mensagem abaixo.
Quanto a outras opções e tipos relacionados, visite a documentação oficial.
2. Com esses documentos, o que podemos fazer?
Lembre -se do compilador baixado acima. Descompactá -lo e obtemos um protoc.exe. Obviamente, isso é baseado no Windows. Eu não fiz outros sistemas. Se você estiver interessado, pode experimentar.
Adicione ao caminho (é fácil adicionar ou não, é inconveniente) e você pode gerar o arquivo de classe que precisamos através do arquivo acima.
protoc --java_out = caminho para armazenar código fonte --proto_path = caminho para o arquivo proto proto arquivo específico
--proto_path Especifica o caminho da pasta do arquivo proto, não um único arquivo, ele é usado principalmente para pesquisa de arquivo de importação e pode ser omitido
Se eu precisar colocar o código -fonte em d:/protobufferversjson/src, meu arquivo proto é armazenado em d:/protofiles
Então meu comando de compilação é:
protoc --java_out = d:/protobuffertsjson/src d: /protofiles/teacher.proto d: /protofiles/student.proto
Observe que no último arquivo aqui, precisamos especificar todos os arquivos que precisam ser compilados.
Após a compilação, você pode ver o arquivo gerado.
O código não foi publicado, muito. Você pode dar uma olhada em particular. Existem muitos construtores no código. Eu acredito que você saberá que é o modo construtor de relance.
Neste momento, você pode colar o código em seu projeto e, é claro, há muitos erros.
Lembra do código -fonte que baixamos anteriormente? Descompacte, não seja implacável. Em seguida, encontre SRC/Main/Java/para copiar um deles para o seu projeto. Claro, você também pode compilar Ant ou Maven, mas não estou familiarizado com essas duas coisas, então não ficarei mais feio. Ainda estou acostumado a copiá -los diretamente para o projeto.
O erro de código, haha, normal. Por alguma razão, o Google insiste em deixar esse poço para nós.
Volte para /java no diretório Protobuffer e veja um readme.txt e encontre uma frase:
Depois de olhar para ele, sinto que esse código será um pouco estranho, como se estivesse errado. Enfim, eu não o executei, e meu comando é:
<span style = "font-size: 16px;"> protoc --java_out = ou o caminho do arquivo proto em que o código é colocado (aqui está o caminho do arquivo descritor.proto) </span>
Após a execução, podemos ver que não há erros no código.
3. O próximo passo é, obviamente, testes.
Vamos realizar o teste de gravação do GPB primeiro:
pacote com.shun.test; importar java.io.fileOutputStream; importar java.io.ioException; importar java.util.arraylist; importar java.util.list; importação com.shun.studentproto.student; importação com.shun.teacherproto.teacher; classe pública protowritEtest {public static void main (string [] args) lança ioexception {student.builder stubuilder = student.newbuilder (); stubuilder.setage (25); stubuilder.setId (11); stubuilder.setName ("Shun"); // Lista de construtas Lista <estudante> StubuilderList = new ArrayList <very Student> (); stubuilderList.add (stubuilder.build ()); Professor.Builder Teabuilder = professor.newbuilder (); tebuilder.setId (1); tebuilder.setName ("testTea"); tebuilder.addallstudentlist (StubuilderList); // grava GPB para arquivo FileOutputStream fos = new FileOutputStream ("c: //users//shun//desktop//test//test.protoout"); tebuilder.build (). writeto (fos); fos.close (); }} </span> Vejamos o arquivo, se nada inesperado acontecer, ele deveria ter sido gerado.
Depois de gerado, devemos lê -lo de volta.
pacote com.shun.test; importar java.io.fileInputStream; importar java.io.filenotfoundException; importar java.io.ioException; importação com.shun.studentproto.student; importação com.shun.teacherproto.teacher; public class ProtoreadTest {public static void main (string [] args) lança fileNotfoundException, ioexception {professor professor = professor.parsefrom (new FileInputStream ("c: //users//shun//desktop//test//test.protooutout)); System.out.println ("Professor ID:" + professor.getid () + ", nome:" + professor.getName ()); para (Student stu: professor.getStudentList ()) {System.out.println ("ID do aluno:" + stu.getid () + ", nome:" + stu.getName () + ", idade:" + stu.getage ()); }}}} </span> O código é muito simples porque todo o código gerado pelo GPB é feito para nós.
O exposto acima conhece o uso básico. Vamos nos concentrar na diferença entre os tamanhos de arquivo gerados por GPB e JSON. Não vou postar o código detalhado do JSON aqui. Vou postar um exemplo mais tarde. Se você estiver interessado, pode baixá -lo.
Aqui usamos o GSON para analisar JSON. A seguir, é apenas o código para converter o objeto em JSON e escrever o arquivo:
Não vou escrever as definições básicas das duas aulas, aluno e professor, apenas faça isso como você quiser, o código é o seguinte:
pacote com.shun.test; importar java.io.filewriter; importar java.io.ioException; importar java.util.arraylist; importar java.util.list; importar com.google.gson.gson; importar com.shun.student; importar com.shun.teacher; classe pública GSONWRITETEST {public static void main (string [] args) lança ioexception {Student stu = new Student (); STU.setage (25); stu.setId (22); stu.setName ("Shun"); List <very Student> estulista = new ArrayList <very Student> (); estulista.add (stu); Professor = novo professor (); professor.setId (22); professor.setName ("Shun"); professor.setstulist (estulista); Resultado da string = new Gson (). Tojson (professor); FileWriter fw = new FileWriter ("c: // usuários // shun/desktop // test // json"); fw.write (resultado); fw.close (); }} </span> Em seguida, inserimos oficialmente nosso código de teste real. No começo, apenas colocamos um objeto na lista. Em seguida, testamos os tamanhos de arquivo gerados pelo GPB e JSON, por sua vez.
Melhore o código GPB anterior, deixe -o gerar um número diferente de listas e regenerar arquivos:
pacote com.shun.test; importar java.io.fileOutputStream; importar java.io.ioException; importar java.util.arraylist; importar java.util.list; importação com.shun.studentproto.student; importação com.shun.teacherproto.teacher; classe pública protowritEtest {public static final int size = 100; public static void main (string [] args) lança IoException {// Lista de construtos da lista <Dentudy> stubuilderList = new ArrayList <vertware> (); for (int i = 0; i <tamanho; i ++) {student.builder stubuilder = student.newbuilder (); stubuilder.setage (25); stubuilder.setId (11); stubuilder.setName ("Shun"); stubuilderList.add (stubuilder.build ()); } Professor.builder teaBuilder = professor.newbuilder (); tebuilder.setId (1); tebuilder.setName ("testTea"); tebuilder.addallstudentlist (StubuilderList); // grava GPB para arquivo FileOutputStream fos = new FileOutputStream ("c: // usuários // shun // desktop // test // proto-" + size); tebuilder.build (). writeto (fos); fos.close (); }} </span> O tamanho aqui é alterado para o número de teste que dissemos acima, e você pode obter o seguinte:
Então vamos dar uma olhada no código de teste JSON:
pacote com.shun.test; importar java.io.filewriter; importar java.io.ioException; importar java.util.arraylist; importar java.util.list; importar com.google.gson.gson; importar com.shun.student; importar com.shun.teacher; classe pública GSONWRITETEST {public static final int size = 100; public static void main (string [] args) lança ioexception {list <ver -se> estulist = new ArrayList <vertware> (); for (int i = 0; i <tamanho; i ++) {Student stu = new Student (); STU.setage (25); stu.setId (22); stu.setName ("Shun"); estulista.add (stu); } Professor = novo professor (); professor.setId (22); professor.setName ("Shun"); professor.setstulist (estulista); Resultado da string = new Gson (). Tojson (professor); FileWriter fw = new FileWriter ("c: // usuários // shun // desktop // test // json" + size); fw.write (resultado); fw.close (); }} </span> O mesmo método é usado para modificar o tamanho e executar testes correspondentes.
Pode -se ver claramente que o tamanho do arquivo de JSON e GPB terá uma grande diferença quando o volume de dados aumentar gradualmente. JSON é obviamente muito maior.
A tabela acima deve ser mais clara. O GPB do Big Data é muito dominante, mas, em geral, o cliente e o servidor não interagem diretamente com esses big data. O big data ocorre principalmente na transmissão do servidor. Se você enfrentar as necessidades, precisa transmitir centenas de m de arquivos de log para outro servidor todos os dias, o GPB aqui pode ser uma grande ajuda.
Diz -se que é uma comparação de profundidade, mas a principal comparação é o tamanho, e a comparação de tempo não é muito, nem há muita diferença.
Para o analisador GSON selecionado no artigo, amigos interessados podem escolher Jackson ou Fastjson, ou outro, mas o tamanho do arquivo gerado é o mesmo, mas o tempo de análise é diferente.