TOC

Serialize apenas campos que atendem a um critério personalizado com Jackson

Serialize apenas campos que atendem a um critério personalizado com Jackson

1. Visão geral

Este tutorial vai ilustrar como podemosuse Jackson to only serialize a field if it meets a specific, custom criteria.

Por exemplo, digamos que queremos serializar um valor inteiro apenas se for positivo - e queremos ignorá-lo totalmente se não for.

Se você quiser se aprofundar e aprenderother cool things you can do with the Jackson 2, vá parathe main Jackson tutorial.

2. Use o filtro Jackson para controlar o processo de serialização

Primeiro, precisamos definir o filtro em nossa entidade, usando a anotação@JsonFilter: 

@JsonFilter("myFilter")
public class MyDto {
    private int intValue;

    public MyDto() {
        super();
    }

    public int getIntValue() {
        return intValue;
    }

    public void setIntValue(int intValue) {
        this.intValue = intValue;
    }
}

Então, precisamos definir nossoPropertyFilter personalizado: 

PropertyFilter theFilter = new SimpleBeanPropertyFilter() {
   @Override
   public void serializeAsField
    (Object pojo, JsonGenerator jgen, SerializerProvider provider, PropertyWriter writer)
     throws Exception {
      if (include(writer)) {
         if (!writer.getName().equals("intValue")) {
            writer.serializeAsField(pojo, jgen, provider);
            return;
         }
         int intValue = ((MyDtoWithFilter) pojo).getIntValue();
         if (intValue >= 0) {
            writer.serializeAsField(pojo, jgen, provider);
         }
      } else if (!jgen.canOmitFields()) { // since 2.3
         writer.serializeAsOmittedField(pojo, jgen, provider);
      }
   }
   @Override
   protected boolean include(BeanPropertyWriter writer) {
      return true;
   }
   @Override
   protected boolean include(PropertyWriter writer) {
      return true;
   }
};

Este filtro contém a lógica real que decide se o campointValue seráserialized or not, com base em seu valor.

Em seguida, conectamos esse filtro emObjectMappere serializamos uma entidade: 

FilterProvider filters = new SimpleFilterProvider().addFilter("myFilter", theFilter);
MyDto dtoObject = new MyDto();
dtoObject.setIntValue(-1);

ObjectMapper mapper = new ObjectMapper();
String dtoAsString = mapper.writer(filters).writeValueAsString(dtoObject);

E, finalmente, podemos verificar se o campointValue é de fatonot part of the marshalled JSON output: 

assertThat(dtoAsString, not(containsString("intValue")));

3. Pular Objetos Condicionalmente

Agora - vamos discutir como pular objetos durante a serialização com base na propriedadevalue. Vamos pular todos os objetos onde a propriedadehidden étrue:

3.1. Classes Hidable

Primeiro, vamos dar uma olhada em nossa interfaceHidable: 

@JsonIgnoreProperties("hidden")
public interface Hidable {
    boolean isHidden();
}

E temos duas classes simples implementando esta interfacePerson,Address:

ClassePerson: 

public class Person implements Hidable {
    private String name;
    private Address address;
    private boolean hidden;
}

E classeAddress: 

public class Address implements Hidable {
    private String city;
    private String country;
    private boolean hidden;
}

Observação: usamos@JsonIgnoreProperties(“hidden”) para garantir que a propriedadehidden em si não esteja incluída em JSON

3.2. Serializador Personalizado

Em seguida - aqui está o nosso serializador personalizado: 

public class HidableSerializer extends JsonSerializer {

    private JsonSerializer defaultSerializer;

    public HidableSerializer(JsonSerializer serializer) {
        defaultSerializer = serializer;
    }

    @Override
    public void serialize(Hidable value, JsonGenerator jgen, SerializerProvider provider)
      throws IOException, JsonProcessingException {
        if (value.isHidden())
            return;
        defaultSerializer.serialize(value, jgen, provider);
    }

    @Override
    public boolean isEmpty(SerializerProvider provider, Hidable value) {
        return (value == null || value.isHidden());
    }
}





Observe que: 






    

  • 

    Quando o objeto não será ignorado, delegamos a serialização ao serializador injetado padrão. 
    

    • 

  • 

    Substituímos o métodoisEmpty() - para garantir que, no caso de objeto Hidable ser uma propriedade, o nome da propriedade também será excluído do JSON. 
    

    • 








3.3. UsandoBeanSerializerModifier 




Finalmente, precisaremos usarBeanSerializerModifier para injetar o serializador padrão em nossoHidableSerializer personalizado - da seguinte forma: 








ObjectMapper mapper = new ObjectMapper();
mapper.setSerializationInclusion(Include.NON_EMPTY);
mapper.registerModule(new SimpleModule() {
    @Override
    public void setupModule(SetupContext context) {
        super.setupModule(context);
        context.addBeanSerializerModifier(new BeanSerializerModifier() {
            @Override
            public JsonSerializer modifySerializer(
              SerializationConfig config, BeanDescription desc, JsonSerializer serializer) {
                if (Hidable.class.isAssignableFrom(desc.getBeanClass())) {
                    return new HidableSerializer((JsonSerializer) serializer);
                }
                return serializer;
            }
        });
    }
});






3.4. Saída de amostra 




Aqui está um exemplo simples de serialização: 








Address ad1 = new Address("tokyo", "jp", true);
Address ad2 = new Address("london", "uk", false);
Address ad3 = new Address("ny", "usa", false);
Person p1 = new Person("john", ad1, false);
Person p2 = new Person("tom", ad2, true);
Person p3 = new Person("adam", ad3, false);

System.out.println(mapper.writeValueAsString(Arrays.asList(p1, p2, p3)));








E a saída é: 








[
    {
        "name":"john"
    },
    {
        "name":"adam",
        "address":{
            "city":"ny",
            "country":"usa"
        }
    }
]










3.5. Test 




Finalmente - aqui estão alguns casos de teste: 






Primeiro caso,nothing is hidden: 








@Test
public void whenNotHidden_thenCorrect() throws JsonProcessingException {
    Address ad = new Address("ny", "usa", false);
    Person person = new Person("john", ad, false);
    String result = mapper.writeValueAsString(person);

    assertTrue(result.contains("name"));
    assertTrue(result.contains("john"));
    assertTrue(result.contains("address"));
    assertTrue(result.contains("usa"));
}








A seguir,only address is hidden: 








@Test
public void whenAddressHidden_thenCorrect() throws JsonProcessingException {
    Address ad = new Address("ny", "usa", true);
    Person person = new Person("john", ad, false);
    String result = mapper.writeValueAsString(person);

    assertTrue(result.contains("name"));
    assertTrue(result.contains("john"));
    assertFalse(result.contains("address"));
    assertFalse(result.contains("usa"));
}








Agora,entire person is hidden: 








@Test
public void whenAllHidden_thenCorrect() throws JsonProcessingException {
    Address ad = new Address("ny", "usa", false);
    Person person = new Person("john", ad, true);
    String result = mapper.writeValueAsString(person);

    assertTrue(result.length() == 0);
}












4. Conclusão 






Esse tipo de filtragem avançada é incrivelmente poderoso e permite uma personalização muito flexível do json ao serializar objetos complexos com Jackson. 






Uma alternativa mais flexível, mas também mais complexa, seria usar um serializador totalmente personalizado para controlar a saída JSON - então, se esta solução não for flexível o suficiente, pode valer a pena dar uma olhada nisso. 






A implementação de todos esses exemplos e fragmentos de códigocan be found in my github project - este é um projeto baseado no Eclipse, portanto, deve ser fácil de importar e executar como está. 







                    

                        


    
    
    
    
    
    
    
    
    
    
    
    





                    

                
                



            
            

                

    
    
    


                

    
    
    


                

    
Related