Serialização em JSON

"Olá, amigo!"

"Oi, Ellie!"

"Como você já foi apresentado ao JSON, vamos falar mais sobre isso hoje."

"OK. Onde geralmente é usado?"

"É assim que geralmente funciona. Alguém (o cliente) solicita dados de um programa Java (o servidor). O programa cria objetos Java e os preenche com informações do banco de dados. Em seguida, os converte em um formato que o solicitante (o cliente ) pode entender, como JSON, e os envia de volta."

"Deixe-me dizer como trabalhar com JSON em Java. Essencialmente, só precisamos fazer duas coisas: serializar objetos Java no formato JSON e desserializar objetos Java do formato JSON."

"Em outras palavras, JSON é um padrão para enviar mensagens/dados de um programa para outro. Existem muitos padrões como esse. Mas se o programa for escrito em JavaScript, ele geralmente tenta usar JSON."

"OK, estou pronto."

"Ótimo. Então vamos começar."

"Como você já sabe, Java possui ferramentas de serialização padrão incorporadas. Mas elas não suportam JSON. Portanto, se você precisar serializar um objeto em JSON, poderá usar uma das estruturas populares (bibliotecas) que sabem como fazem isto."

"Qual é a diferença entre essas diferentes estruturas?"

"Eles geralmente diferem em seu nível de complexidade: existem frameworks que podem fazer apenas o básico, mas são muito pequenos e simples. E existem frameworks grandes e complexos que podem fazer muito mais."

"Jackson é um dos frameworks mais populares. Vamos usá-lo como um exemplo ao vermos como trabalhar com JSON."

"Primeiro, você precisa baixar este framework e adicioná-lo ao seu projeto. Você precisa fazer isso diretamente no IntelliJ IDEA. Você pode baixar o framework usando este link ."

"Feito."

"Ótimo. Vamos continuar, então."

"Converter um objeto Java em JSON é tão fácil quanto serializá-lo. Para fazer isso, existe uma classe ObjectMapper especial (com.fasterxml.jackson.databind.ObjectMapper)."

"Deixe-me mostrar um exemplo de trabalho e depois vamos analisá-lo:"

public static void main(String[] args) throws IOException
{
 // Create an object to be serialized into JSON
 Cat cat = new Cat();
 cat.name = "Missy";
 cat.age = 5;
 cat.weight = 4;

 // Write the result of the serialization to a StringWriter
 StringWriter writer = new StringWriter();

 // This is the Jackson object that performs the serialization
 ObjectMapper mapper = new ObjectMapper();

 // And here's the serialization itself: the first argument is where, and the second is what
 mapper.writeValue(writer, cat);

 // Convert everything written to the StringWriter into a String
 String result = writer.toString();
 System.out.println(result);
}

@JsonAutoDetect
class Cat
{
 public String name;
 public int age;
 public int weight;
Cat(){}
}

{"name":"Missy", "age":5, "weight":4}

"É assim que funciona:"

"Nas linhas 4-7, criamos um objeto Cat e o preenchemos com dados."

"Na linha 10, criamos um objeto Writer onde escreveremos uma representação de string JSON do objeto."

"Na linha 13, criamos um objeto ObjectMapper que executará toda a serialização."

"Na linha 16, escrevemos a representação JSON do objeto cat para o escritor ."

"Nas linhas 19-20, exibimos o resultado na tela."

"Tudo parece muito simples. Não é mais difícil do que a serialização nativa em Java."

"Como seria a desserialização?"

"É quase o mesmo, apenas mais curto:"

public static void main(String[] args) throws IOException
{
 String jsonString = "{ \"name\":\"Missy\", \"age\":5, \"weight\":4}";
 StringReader reader = new StringReader(jsonString);

 ObjectMapper mapper = new ObjectMapper();

 Cat cat = mapper.readValue(reader, Cat.class);
}

@JsonAutoDetect
class Cat
{
 public String name;
 public int age;
 public int weight;

 Cat() { }
}

"É ainda mais fácil. Pegamos o ObjectMapper e passamos para ele uma string ou um StringReader com JSON, bem como a classe do objeto a ser desserializado . Em seguida, chamamos o método readValue e, como saída, obtemos um objeto Java pronto com todos os dados."

"Bem, isso é exatamente como a desserialização em Java."

"Quase. Existem vários requisitos colocados em objetos serializados ou desserializados de JSON:"

" 1)  os campos devem ser visíveis: devem ser públicos ou ter getters e setters"

" 2)  deve haver um construtor padrão (um sem parâmetros)"

"Entendo. Isso não é muito surpreendente. Mas Java serializou tudo, até mesmo campos privados."

"Bem, isso era Java. Ele tem acesso a dados ocultos. Você não pode se esconder de si mesmo."

"Há um terceiro aspecto aqui. Espero que você tenha notado a anotação @JsonAutoDetect na classe Cat?"

"Sim. Eu estava prestes a perguntar o que era."

"É uma anotação: informações de manutenção para a estrutura Jackson. Ao usar as anotações corretas, você tem bastante controle flexível sobre os resultados da serialização em JSON."

"Legal! Que tipo de anotações existem?"

"Aqui estão alguns exemplos:"

"Que interessante! Tem mais?"

"Existem muitos. Mas não vamos cobri-los agora. Agora vamos retrabalhar um pouco nosso primeiro exemplo:"

public static void main(String[] args) throws IOException
{
 Cat cat = new Cat();
 cat.name = "Missy";
 cat.age = 5;
 cat.weight = 4;

 StringWriter writer = new StringWriter();

 ObjectMapper mapper = new ObjectMapper();

 mapper.writeValue(writer, cat);

 String result = writer.toString();
 System.out.println(result);
}

@JsonAutoDetect
class Cat
{
 @JsonProperty("alias")
 public String name;
 public int age;
 @JsonIgnore
 public int weight;

 Cat() {
 }
}

{"age":5, "alias":"Missy"}

"O código continua o mesmo, mas alterei as anotações: especifiquei outro nome para o campo de nome: alias. Também marquei o campo de peso como Ignorar, o que fez com que o objeto JSON mudasse."

"É bom que você possa personalizar tudo assim. Acho que definitivamente acharei isso útil."

"E a desserialização vai entender como trabalhar com isso? Ao desserializar de JSON para um objeto Java, o valor do campo alias será gravado no campo nome do objeto Cat?"

"Sim, a desserialização funcionará como deveria. É inteligente."

"O que há para não ser feliz então."

"Obrigado por esta lição interessante, Ellie."