Introdução ao Jackson ObjectMapper

1. Visão geral

Este artigo se concentra em entender a classe JacksonObjectMapper - e como serializar objetos Java em JSON e desserializar a string JSON em objetos Java. Para entender mais sobre a biblioteca Jackson em geral, oJackson Tutorial é um bom lugar para começar.

Leitura adicional:

Herança com Jackson

Este tutorial demonstrará como lidar com a inclusão de metadados de subtipo e como ignorar propriedades herdadas das superclasses com Jackson.

Visualizações JSON de Jackson

Como usar a anotação @JsonView em Jackson para controlar perfeitamente a serialização de seus objetos (sem e com Spring).

Jackson - Serializador personalizado

Controle sua saída JSON com o Jackson 2 usando um serializador personalizado.

2. Dependências

Vamos primeiro adicionar as seguintes dependências aopom.xml:


    com.fasterxml.jackson.core
    jackson-databind
    2.9.8

Essa dependência também adicionará transitivamente as seguintes bibliotecas ao caminho de classe:

jackson-annotations-2.9.8.jar
jackson-core-2.9.8.jar
jackson-databind-2.9.8.jar

Sempre use as versões mais recentes no repositório central Maven paraJackson databind.

3. Leitura e escrita usandoObjectMapper

Vamos começar com as operações básicas de leitura e gravação.

The simple readValue API of the ObjectMapper is a good entry point. Podemos usá-lo para analisar ou desserializar o conteúdo JSON em um objeto Java.

Além disso, no lado da escrita das coisas,we can use the writeValue API to serialize any Java object as JSON output.

Usaremos a seguinte classeCar com dois campos como o objeto para serializar ou desserializar ao longo deste artigo:

public class Car {

    private String color;
    private String type;

    // standard getters setters
}

3.1. Objeto Java para JSON

Vejamos um primeiro exemplo de serialização de um objeto Java em JSON usando o métodowriteValue da classeObjectMapper:

ObjectMapper objectMapper = new ObjectMapper();
Car car = new Car("yellow", "renault");
objectMapper.writeValue(new File("target/car.json"), car);

A saída acima no arquivo será:

{"color":"yellow","type":"renault"}

Os métodoswriteValueAsStringewriteValueAsBytes da classeObjectMapper geram um JSON a partir de um objeto Java e retorna o JSON gerado como uma string ou como uma matriz de bytes:

String carAsString = objectMapper.writeValueAsString(car);

3.2. Objeto JSON para Java

Abaixo está um exemplo simples de conversão de uma string JSON em um objeto Java usando a classeObjectMapper:

String json = "{ \"color\" : \"Black\", \"type\" : \"BMW\" }";
Car car = objectMapper.readValue(json, Car.class);

A funçãoreadValue() também aceita outras formas de entrada, como um arquivo contendo string JSON:

Car car = objectMapper.readValue(new File("src/test/resources/json_car.json"), Car.class);

ou um URL:

Car car = objectMapper.readValue(new URL("file:src/test/resources/json_car.json"), Car.class);

3.3. JSON para JacksonJsonNode

Como alternativa, um JSON pode ser analisado em um objetoJsonNode e usado para recuperar dados de um nó específico:

String json = "{ \"color\" : \"Black\", \"type\" : \"FIAT\" }";
JsonNode jsonNode = objectMapper.readTree(json);
String color = jsonNode.get("color").asText();
// Output: color -> Black

3.4. Criação de uma lista Java a partir de uma string de array JSON

Podemos analisar um JSON na forma de uma matriz em uma lista de objetos Java usando umTypeReference:

String jsonCarArray =
  "[{ \"color\" : \"Black\", \"type\" : \"BMW\" }, { \"color\" : \"Red\", \"type\" : \"FIAT\" }]";
List listCar = objectMapper.readValue(jsonCarArray, new TypeReference>(){});

3.5. Criação de mapa Java a partir de string JSON

Da mesma forma, podemos analisar um JSON em um JavaMap:

String json = "{ \"color\" : \"Black\", \"type\" : \"BMW\" }";
Map map
  = objectMapper.readValue(json, new TypeReference>(){});

4. Características avançadas

Um dos pontos fortes da biblioteca Jackson é o processo de serialização e desserialização altamente personalizável.

Nesta seção, veremos alguns recursos avançados em que a resposta JSON de entrada ou saída pode ser diferente do objeto que gera ou consome a resposta.

4.1. Configurando o recurso de serialização ou desserialização

Ao converter objetos JSON em classes Java, caso a sequência JSON possua alguns novos campos, o processo padrão resultará em uma exceção:

String jsonString
  = "{ \"color\" : \"Black\", \"type\" : \"Fiat\", \"year\" : \"1970\" }";

A string JSON no exemplo acima no processo de análise padrão para o objeto Java paraClass Car resultará na exceçãoUnrecognizedPropertyException.

Por meio do métodoconfigure, podemos estender o processo padrão para ignorar os novos campos:

objectMapper.configure(DeserializationFeature.FAIL_ON_UNKNOWN_PROPERTIES, false);
Car car = objectMapper.readValue(jsonString, Car.class);

JsonNode jsonNodeRoot = objectMapper.readTree(jsonString);
JsonNode jsonNodeYear = jsonNodeRoot.get("year");
String year = jsonNodeYear.asText();

Ainda outra opção é baseada emFAIL_ON_NULL_FOR_PRIMITIVES que define se os valoresnull para valores primitivos são permitidos:

objectMapper.configure(DeserializationFeature.FAIL_ON_NULL_FOR_PRIMITIVES, false);

Da mesma forma,FAIL_ON_NUMBERS_FOR_ENUM controla se os valores enum podem ser serializados / desserializados como números:

objectMapper.configure(DeserializationFeature.FAIL_ON_NUMBERS_FOR_ENUMS, false);

Você pode encontrar a lista abrangente de recursos de serialização e desserialização emofficial site.

4.2. Criação de serializador ou desserializador personalizado

Outro recurso essencial da classeObjectMapper é a capacidade de registrarserializeredeserializer personalizados. O serializador e o desserializador customizados são muito úteis em situações em que a resposta JSON de entrada ou de saída tem estrutura diferente da classe Java na qual deve ser serializada ou desserializada.

Abaixo está um exemplo de serializador JSON personalizado:

public class CustomCarSerializer extends StdSerializer {

    public CustomCarSerializer() {
        this(null);
    }

    public CustomCarSerializer(Class t) {
        super(t);
    }

    @Override
    public void serialize(
      Car car, JsonGenerator jsonGenerator, SerializerProvider serializer) {
        jsonGenerator.writeStartObject();
        jsonGenerator.writeStringField("car_brand", car.getType());
        jsonGenerator.writeEndObject();
    }
}

Este serializador personalizado pode ser chamado assim:

ObjectMapper mapper = new ObjectMapper();
SimpleModule module =
  new SimpleModule("CustomCarSerializer", new Version(1, 0, 0, null, null, null));
module.addSerializer(Car.class, new CustomCarSerializer());
mapper.registerModule(module);
Car car = new Car("yellow", "renault");
String carJson = mapper.writeValueAsString(car);

Aqui está a aparência deCar (como saída JSON) no lado do cliente:

var carJson = {"car_brand":"renault"}

E aqui está um exemplo dea custom JSON deserializer:

public class CustomCarDeserializer extends StdDeserializer {

    public CustomCarDeserializer() {
        this(null);
    }

    public CustomCarDeserializer(Class vc) {
        super(vc);
    }

    @Override
    public Car deserialize(JsonParser parser, DeserializationContext deserializer) {
        Car car = new Car();
        ObjectCodec codec = parser.getCodec();
        JsonNode node = codec.readTree(parser);

        // try catch block
        JsonNode colorNode = node.get("color");
        String color = colorNode.asText();
        car.setColor(color);
        return car;
    }
}

Este desserializador personalizado pode ser chamado da seguinte maneira:

String json = "{ \"color\" : \"Black\", \"type\" : \"BMW\" }";
ObjectMapper mapper = new ObjectMapper();
SimpleModule module =
  new SimpleModule("CustomCarDeserializer", new Version(1, 0, 0, null, null, null));
module.addDeserializer(Car.class, new CustomCarDeserializer());
mapper.registerModule(module);
Car car = mapper.readValue(json, Car.class);

4.3. Tratamento de formatos de data

A serialização padrão dejava.util.Date produz um número, ou seja, registro de data e hora da época (número de milissegundos desde 1º de janeiro de 1970, UTC). Mas isso não é muito legível por humanos e requer uma conversão adicional a ser exibida em formato legível por humanos.

Vamos envolver a instânciaCar que usamos até agora dentro da classeRequest com a propriedadedatePurchased:

public class Request
{
    private Car car;
    private Date datePurchased;

    // standard getters setters
}

Para controlar o formato String de uma data e defina-o como por exemplo yyyy-MM-dd HH:mm a z, considere o seguinte snippet:

ObjectMapper objectMapper = new ObjectMapper();
DateFormat df = new SimpleDateFormat("yyyy-MM-dd HH:mm a z");
objectMapper.setDateFormat(df);
String carAsString = objectMapper.writeValueAsString(request);
// output: {"car":{"color":"yellow","type":"renault"},"datePurchased":"2016-07-03 11:43 AM CEST"}

Para saber mais sobre como serializar datas com Jackson, leiaour more in-depth write-up.

4.4. Manipulação de coleções

Outro recurso pequeno, mas útil, disponível por meio da classeDeserializationFeature, é a capacidade de gerar o tipo de coleção que queremos a partir de uma resposta de array JSON.

Por exemplo, podemos gerar o resultado como uma matriz:

String jsonCarArray =
  "[{ \"color\" : \"Black\", \"type\" : \"BMW\" }, { \"color\" : \"Red\", \"type\" : \"FIAT\" }]";
ObjectMapper objectMapper = new ObjectMapper();
objectMapper.configure(DeserializationFeature.USE_JAVA_ARRAY_FOR_JSON_ARRAY, true);
Car[] cars = objectMapper.readValue(jsonCarArray, Car[].class);
// print cars

Ou comoList:

String jsonCarArray =
  "[{ \"color\" : \"Black\", \"type\" : \"BMW\" }, { \"color\" : \"Red\", \"type\" : \"FIAT\" }]";
ObjectMapper objectMapper = new ObjectMapper();
List listCar = objectMapper.readValue(jsonCarArray, new TypeReference>(){});
// print cars

Mais informações sobre como lidar com coleções com Jackson estão disponíveishere.

5. Conclusão

Jackson é uma biblioteca de serialização / desserialização JSON sólida e madura para Java. A APIObjectMapper fornece uma maneira direta de analisar e gerar objetos de resposta JSON com muita flexibilidade.

O artigo discute os principais recursos que tornam a biblioteca tão popular. O código-fonte que acompanha o artigo pode ser encontradoover on GitHub.

TOC

Introdução ao Jackson ObjectMapper