Gson Tojson e Fromjson para JSON

Serialização e desserialização

Um arquivo pode ser salvo para o disco ou enviado pela rede apenas enviando o arquivo como é, byte byte, desde o início (como código -fonte, bytecode ou código binário). Isso não é serialização. A serialização é o processo de converter um objeto em um fluxo de bytes, para armazenamento ou transmissão, ainda como o objeto. Não é o mesmo que apenas ler os bytes desde o início e enviar ou salvar. O oposto da serialização é a deserialização. Não a serialização da pinça, como processo, é feita com objetos primitivos por conta própria.

JSON significa notação de objeto JavaScript. JSON é um formato para serialização. Um objeto Java (definido) pode ser convertido em uma representação JSON (String) para transmissão ou salvamento. Para reutilização, a representação JSON é convertida de volta ao objeto Java. GSON é uma biblioteca Java usada para conversão em qualquer direção.

Para serializar, use o método tojson () do objeto GSON. Para deseralizar, use o método Fromjson () do objeto GSON. Este artigo explica o básico da serialização dos objetos Java para a representação JSON, com o método Tojson () e a deserialização da representação JSON (String), para o objeto Java, com o método dejson ().

Conteúdo do artigo

• Baixando e configurando a biblioteca GSON
• Objetos java primitivos
• Variedade
• Objeto
• Conclusão

Baixando e configurando a biblioteca GSON

A biblioteca GSON vem como um arquivo jar. Uma biblioteca como o GSON é chamada de dependência. É gratuito para download. O restante desta seção explica o que o autor fez com seu anfitrião Ubuntu OS Computer. O leitor pode repetir ou modificar a abordagem.

Ele criou um diretório, chamado dependências, in/home/user/ter:/home/user/dependências, onde um usuário deve ser substituído pelo nome do usuário.

Ele baixou o arquivo da biblioteca, GSON-2.8.9.jar, do hiperlink:

https: // pesquisa.Maven.org/remoteContent?filepath = com/google/code/gson/gson/2.8.9/GSON-2.8.9.jarra

e salvou, como está, no diretório de dependências.

Em seguida, no prompt de comando, ele configurou (inseriu) uma variável de classe, como segue:

exportar classe de classe =/home/usuário/dependências

O programa Java deve ter, no mínimo, o seguinte:

importar com.Google.GSON.GSON;
classe pública theClass
public static void main (string [] args)
Gsongson = novo gson ();
/ *Resto de código */

O nome do arquivo de código -fonte é o teclass.Java. Observe o nome do pacote importado, que está no GSON-2.8.9.arquivo jar. A seguinte linha de comando foi usada para compilar o programa em código de bytes:

javac -classpath/home/user:/home/user/dependências/gson -2.8.9.Jar theClass.Java

Observe o interruptor, -Classpath . Existem dois caminhos aqui, separados por um cólon (sem espaço ao redor do cólon). O primeiro é o caminho para o arquivo principal, o teclass.Java; E o segundo é o caminho para o arquivo da biblioteca, GSON-2.8.9.jarra.

O bytecode resultante é executado com a seguinte linha de comando:

java -classpath/home/user:/home/user/dependências/gson -2.8.9.Jar theClass

O interruptor e os dois caminhos ainda estão lá, em suas posições, pelos mesmos motivos. O bytecode deve ser executado com sucesso, tudo sendo igual.

Objetos java primitivos

Esta seção ilustra que valor um objeto primitivo terá após a serialização, como string json, e que valor ele terá após a desertalização. Para usar os métodos Tojson () e Fromjson (), o objeto GSON deve ser criado com uma declaração como:

Gson gson = new gson ();

Onde GSON é o objeto GSON a ser usado com seus métodos: Tojson () para serialização e Fromjson () para deserialização.

byte

Considere o seguinte código dentro do método Main ():

Gsongson = novo gson ();
byte bt = 56;
String str = gson.Tojson (BT);
byte btr = gson.Fromjson (str, byte.aula);
Sistema.fora.println (btr);

A saída é 56. Este código serializa e desapealiza. Observe o segundo argumento de Fromjson (), que é byte.aula. A serialização de um objeto de tipo se torna uma string json, e a deserialização deve voltar ao mesmo tipo. É por isso que byte.A classe está presente.

int

Considere o seguinte código dentro do método Main ():

Gsongson = novo gson ();
int in = 0;
String str = gson.tojson (in);
int inr = gson.Fromjson (str, int.aula);
Sistema.fora.println (INR);

A saída é 0. Observe o segundo argumento de Fromjson (), que é int.aula.

dobro

Considere o seguinte código dentro do método Main ():

Gsongson = novo gson ();
duplo dB = 7.8;
String str = gson.Tojson (dB);
duplo dbr = gson.Fromjson (STR, Double.aula);
Sistema.fora.println (dbr);

A saída é 7.8. Observe o segundo argumento para Fromjson (), que é o dobro.aula.

Caracteres

Considere o seguinte código dentro do método Main ():

Gsongson = novo gson ();
char ch = 'e';
String str = gson.Tojson (CH);
char chr = gson.Fromjson (str, char.aula);
Sistema.fora.println (chr);

A saída é E. Observe o segundo argumento para Fromjson (), que é char.aula.

boleano

Considere o seguinte código dentro do método Main ():

Gson gson = new gson ();
booleano bl = false;
String str = gson.Tojson (BL);
Boolean Blr = GSON.Fromjson (STR, booleano.aula);
Sistema.fora.println (blr);

A saída é falsa. Observe o segundo argumento para Fromjson (), que é booleano.aula.

nulo

Considere o seguinte código dentro do método Main ():

Gson gson = new gson ();
String nl = null;
String str = gson.Tojson (NL);
String nlr = gson.Fromjson (str, string.aula);
Sistema.fora.println (nlr);

A saída é nula. Observe o segundo argumento para Fromjson (), que é uma corda.classe, para o tipo de nulo.

Variedade

Array literal

Considere o seguinte código:

Gson gson = new gson ();
duplo [] dbs = 1.1, 2.2, 3.3, 4.4;
String str = gson.Tojson (DBS);
duplo [] dbsr = gson.Fromjson (STR, Double [].aula);
Sistema.fora.println (dbsr [0]+""+dbsr [1]+""+dbsr [2]+""+dbsr [3]);

A saída é:

1.1 2.2 3.3 4.4

Depois de criar o objeto GSON, uma matriz dupla Java é criada. Em seguida, a matriz literal é convertida em uma corda JSON. Sim, embora o código esteja preocupado com uma matriz aqui e não com um tipo primitivo, o método tojson () ainda é usado e, correspondentemente, dejson () ainda será usado no receptor. O JSON String Array literal é:

"[1.1, 2.2, 3.3, 4.4] "

Esta picada é o que é instalado no fluxo que é transmitido ou salvo localmente. O método Fromjson () converte o JSON Array String literal para o Java Array (literal) no final do recebimento.

Considere o código a seguir, que começa com uma variedade de cordas Java, onde cada string é um item em uma tabela de leitura:

Gson gson = new gson ();
String [] strs = "Pen", "Livro de Exercício", Null, "Livro de Texto";
String str = gson.Tojson (STRS);
String [] strsr = gson.Fromjson (str, string [].aula);
Sistema.fora.println (strsr [0]+","+strsr [1]+","+strsr [2]+","+strsr [3]);

A saída é:

caneta, livro de exercícios, nulo, livro de texto

Depois de criar o objeto GSON, uma matriz de string java é criada. Em seguida, a matriz literal é convertida em uma corda JSON. O JSON String Array literal é:

"[" caneta "," livro de exercícios ", nulo," livro de texto "]"

Esta picada é o que é instalado no fluxo que é transmitido ou salvo localmente. O método Fromjson () converte o JSON Array String literal de strings de volta ao Java Array (literal) no final do recebimento. Observe que o tipo de classe (string []) é necessário para conversão para trás.

Enviando matriz literal com o nome da matriz

O problema com o esquema acima é que, no destino, é provável que a matriz tenha outro nome para o código Java reconstruído. O nome da matriz pode ser enviado, como uma única matriz de palavras, precedindo a variedade de interesse para resolver esse problema. O programa Java receberá duas matrizes no final do recebimento e as interpretará adequadamente.

Objeto

Conteúdo do objeto

Considere o seguinte código:

importar com.Google.GSON.GSON;
ACLASS DE CLASSE

int num = 10;
String str1 = null;
String str2;
String str3 = "três";
int mthd (int it)

devolver;

Começa com a importação do pacote GSON e depois há a descrição de uma classe, chamada Aclass. A classe tem quatro campos (propriedades) e um método. Um dos valores dos campos é nulo e outro não tem nenhum valor. Um código adequado na função principal () para esta classe é:

Gsongson = novo gson ();
Aclass obj = new aclass ();
String str = gson.Tojson (OBJ);
AclassObjr = gson.Fromjson (STR, Aclass.aula);
Sistema.fora.println (objr.num+","+objr.str1+","+objr.str2+","+objr.str3);
int in = objr.MTHD (5);
Sistema.fora.println (in);

A saída consiste em duas linhas, que é:

10, nulo, nulo, três
5

Depois de criar o objeto GSON, outro objeto, OBJ é instanciado da classe, Aclass. Em seguida, a matriz literal é convertida em uma corda JSON. Sim, embora o código esteja preocupado com um objeto instanciado aqui e não com um tipo primitivo, o método Tojson () ainda é usado e, correspondentemente, dejson () ainda será usado no receptor. A sequência de conteúdo do objeto instanciada (classe) JSON é assim:

"num": 10, "str1": null, "str2: null," str3 ":" três "," mthd ":" int mthd (int it) return It; "

Observe os aparelhos delimitadores em vez de suportes quadrados para diferenciá -los do JSON. Consiste em pares de chave/valor. A chave é separada de seu valor com um cólon. Os pares são separados um do outro por vírgulas.

Isso deve ser montado no fluxo para transmissão ou salvar localmente. Na verdade, a sequência JSON para o objeto é:

"num": 10, "str3": "três"

O par para o campo com valor nulo é omitido. O par para o campo com o nome, mas sem um valor também é omitido. O nome do método e sua definição também são omitidos. Isso significa que as informações da classe também devem ser transmitidas. Isso pode ser feito com uma matriz JSON anterior. Nada foi transmitido nas amostras de código deste artigo, para que as informações da classe ainda estejam disponíveis para serem usadas em Fromjson () .

O método Fromjson () converte a sequência de objeto instanciada JSON em um objeto Java no final da recepção. Para ter o mesmo nome para o objeto, o nome do objeto deve ser transmitido (separadamente) no final do recebimento. Depois que o objeto foi recriado no final do recebimento, os campos e métodos podem ser acessados ​​(chamados). No código acima, o método é chamado para resultar em 5.

Conclusão

JSON é um formato serializado. Objetos Java podem ser serializados para o formato JSON para transmissão para outro computador ou para salvar localmente. No outro extremo, a desertalização ocorre para ter o mesmo objeto que reside na fonte. A desserialização não ocorre quando o objeto é salvo. Não apenas matrizes e objetos instantados podem ser serializados. Outros objetos, como mapas e coleções, podem ser serializados e desserializados. A biblioteca Java que pode ser usada para esses processos é a biblioteca GSON. Seu método, Tojson () é usado para serialização, e seu outro método, dejson (), é usado para deseralização.