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 necessitam 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 utiliza exemplos de casos limite para explorar as características de ambas as bibliotecas em diferentes parâmetros.

Visão Geral Breve de Jackson e Gson

Jackson

Jackson foi desenvolvido pela FasterXML e é utilizado em aplicações empresariais e frameworks como Spring Boot. Ele oferece análise, serialização e desserialização de dados JSON. As seguintes características 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) torna a correspondência entre a chave de entrada e o campo real de Java POJO perfeita.
4. Ele oferece suporte extenso e robusto para Databinding bidirecional (JSON para POJO e vice-versa), API de streaming (a API lê JSON em POJO) e análise do modelo de árvore (um mapa em memória de objetos JSON).
5. A biblioteca Jackson oferece alto desempenho devido à minimização da sobrecarga de memória e à otimização da serialização/desserialização (de JSON para POJO e vice-versa).
6. O Jackson suporta módulos adicionais como processamento XML, YAML e aprimoramentos específicos do Kotlin e Scala.
7. As anotações como @JsonTypeInfo e @JsonSubTypes lidam com tipos polimórficos.
8. Ele lida com campos ausentes ou adicionais em dados JSON devido à sua compatibilidade retroativa e prospectiva.
9. O Jackson oferece suporte para objetos imutáveis e classes com construtores, incluindo aqueles que usam padrões de construção.
10. A classe ObjectMapper é segura para threads e, portanto, permite um uso eficiente em aplicações multithread.

Gson

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

1. O Gson tem dependências externas mínimas, portanto, é fácil de integrar.
2. Ele suporta objetos aninhados e tipos de dados complexos como listas, mapas e classes personalizadas.
3. 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 implementações personalizadas.
5. Os valores nulos são excluídos na saída JSON por padrão e, se necessário, 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 seguros para threads e, portanto, podem ser usados em aplicativos 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 Especiais 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 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 main de análise JSON 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());

    }

}

A saída da classe acima é a seguinte:

Implementação do Gson

A dependência do 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 biblioteca GSON classe main:

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());

    }

}

A saída da classe principal acima é a seguinte:

Qual devo escolher?

Jackson oferece alto desempenho; portanto, deve ser usado quando 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 efetivamente com o conjunto de dados acima e são excelentes ao processar a análise 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 em Baeldung. A Documentação Oficial do Jackson oferece informações detalhadas sobre os recursos e configuração do Jackson. Da mesma forma, a Documentação Oficial do Gson fornece um guia de implementação detalhado.