Jackson vs Gson: Casos Limite na Análise de JSON para Aplicativos Java

JSON (Javascript Object Notation) é uma coleção de pares de chave-valor que podem ser facilmente analisados e gerados por aplicações. É um subconjunto do Padrão de Linguagem de Programação JavaScript ECMA-262. A análise de JSON é necessária na maioria das aplicações, como APIs restful ou aplicações que precisam de serialização de dados. 

No ecossistema Java, as duas bibliotecas mais populares para lidar com dados JSON são Jackson e Gson. Ambas são amplamente utilizadas e oferecem vantagens únicas. Este artigo usa exemplos de casos extremos para explorar os recursos de ambas as bibliotecas em diferentes parâmetros.

Visão Geral Rápida de Jackson e Gson

Jackson

Jackson foi desenvolvido pela FasterXML e é usado em aplicações empresariais e frameworks como Spring Boot. Ele oferece análise, serialização e desserialização de dados JSON. Os seguintes recursos tornam esta biblioteca popular entre os desenvolvedores:

1. O Jackson é a biblioteca padrão de processamento JSON no Spring Boot, o que elimina a configuração manual na maioria dos casos.
2. Facilita a desserialização de JSON em tipos genéricos usando TypeReference ou JavaType.
3. Fornece diferentes anotações para personalizar o comportamento de serialização e desserialização. Por exemplo, @JsonProperty(name) facilita a associação entre a chave de entrada e o campo Java POJO real.
4. Ele fornece suporte extenso e robusto para vinculação de dados bidirecional (JSON para POJO e vice-versa), API de streaming (a API lê JSON em POJO) e análise de modelo de árvore (um mapa em memória de objetos JSON).
5. A biblioteca Jackson oferece alto desempenho devido à minimização do uso de memória e à otimização da serialização/deserialização (de JSON para POJO e vice-versa).
6. Jackson suporta módulos adicionais, como processamento de XML, YAML e melhorias específicas para Kotlin e Scala.
7. Anotações como @JsonTypeInfo e @JsonSubTypes lidam com tipos polimórficos.
8. Ele lida com campos ausentes ou adicionais nos dados JSON devido à sua compatibilidade retroativa e para frente.
9. Jackson oferece suporte para objetos imutáveis e classes com construtores, incluindo aquelas que usam padrões de construtor.
10. A classe ObjectMapper é thread-safe e, portanto, permite um uso eficiente em aplicações multithread.

Gson

Gson foi desenvolvido pelo Google e projetado para converter JSON em objetos Java (POJO) e vice-versa. É simples e ideal para usar em aplicações menores que precisam de implementações rápidas. A biblioteca de código aberto oferece os seguintes recursos principais:

1. Gson tem dependências externas mínimas; portanto, é fácil de integrar.
2. Suporta objetos aninhados e tipos de dados complexos, como listas, mapas e classes personalizadas.
3. Ele pode desserializar JSON em coleções genéricas como List<T>, Map<K,V> usando TypeToken.
4. As interfaces JsonSerializer e JsonDeserializer da biblioteca Gson permitem uma implementação personalizada.
5. Os valores nulos são excluídos na saída JSON por padrão, e se necessário, os valores nulos podem ser incluídos na saída.
6. As anotações @SerializedName mapeiam chaves JSON para campos Java com nomes diferentes.
7. Os objetos Gson são thread-safe e, portanto, podem ser usados em aplicações multithread.
8. A classe GsonBuilder pode aplicar políticas de nomenclatura personalizadas para campos. Por exemplo, FieldNamingPolicy.IDENTITY é a política padrão, significando que o nome do campo não é alterado.

Casos extremos considerados nesta comparação

O JSON de entrada considerado para comparação com as bibliotecas Jackson e Gson está presente no GitHub.

A representação da classe de modelo do JSON está no GitHub.

Implementação do Jackson

O JSON acima é convertido em um objeto Java usando as bibliotecas Jackson abaixo:

        <!-- Jackson START-->

        <dependency>

            <groupId>com.fasterxml.jackson.core</groupId>

            <artifactId>jackson-databind</artifactId>

            <version>2.18.2</version>

        </dependency>

        <dependency>

            <groupId>com.fasterxml.jackson.datatype</groupId>

            <artifactId>jackson-datatype-jsr310</artifactId>

            <version>2.18.2</version>

        </dependency>

        <!-- Jackson END-->

Classe de análise JSON principal usando a biblioteca Jackson:

public class JacksonJsonMain {

    public static void main(String[] args) throws IOException {

        ObjectMapper mapper = new ObjectMapper();

        //Jackson Support for LocalDate using jackson-datatype-jsr310

        mapper.registerModule(new JavaTimeModule());

        //Configuration to ignore extra fields

        mapper.configure(DeserializationFeature.FAIL_ON_UNKNOWN_PROPERTIES, false);

​

        // Deserialize the JSON

        EmployeeModelData employeeModelData = mapper.readValue(json, EmployeeModelData.class);

        Employee employee=employeeModelData.getEmployee();

​

        // display Json fields

        System.out.println("Jackson Library parsing output");

        System.out.println("Employee Name: " + employee.getName());

        System.out.println("Department Name: " + employee.getDepartment().getName());

        System.out.println("Skills: " + employee.getSkills());

        System.out.println("Team Members Count: " + employeeModelData.getTeamMembers().size());

    }

}

O resultado da classe acima é o seguinte:

Implementação do Gson

A dependência Gson usada para converter o JSON acima em um objeto Java está abaixo:

       <!--GSON START -->

        <dependency>

            <groupId>com.google.code.gson</groupId>

            <artifactId>gson</artifactId>

            <version>2.11.0</version>

        </dependency>

        <!--GSON END -->

Análise JSON usando a classe principal da biblioteca GSON:

public class GsonJsonMain {

    public static void main(String[] args) {

        Gson gson = new GsonBuilder()

                .registerTypeAdapter(LocalDate.class, new LocalDateAdapter()) // Register LocalDate adapter

                .serializeNulls() // Handle null values

                .setPrettyPrinting() // Pretty print JSON

                .create();

​

        // Deserialize the JSON

        EmployeeModelData data = gson.fromJson(json, EmployeeModelData.class);

​

        // Print Employee information

        System.out.println("GSON Library parsing output");

        System.out.println("Employee Name: " + data.getEmployee().getName());

        System.out.println("Department Name: " + data.getEmployee().getDepartment().getName());

        System.out.println("Skills: " + data.getEmployee().getSkills());

        System.out.println("Team Members Count: " + data.getTeamMembers().size());

    }

}

O resultado da classe principal acima é o seguinte:

Qual Devo Escolher?

O Jackson oferece alto desempenho; portanto, deve ser usado quando os projetos envolvem estruturas de dados complexas ou grandes conjuntos de dados, enquanto o Gson deve ser usado quando há conjuntos de dados menores e a estrutura de dados é simples.

Conclusão

Ambas as bibliotecas podem lidar com o conjunto de dados acima de forma eficaz e são excelentes ao processar a análise de JSON em JAVA. A comparação mencionada acima ajuda a escolher a biblioteca certa com base nos requisitos do projeto.

Os trechos de código mencionados acima estão disponíveis no repositório do GitHub.

Uma comparação detalhada entre Jackson e Gson está disponível no Baeldung. A documentação oficial do Jackson oferece informações detalhadas sobre os recursos e a configuração do Jackson. Da mesma forma, a documentação oficial do Gson fornece um guia de implementação detalhado.