1. Overview

This tutorial will show how to ignore certain fields when serializing an object to JSON using Jackson 2.x.

This is very useful when the Jackson defaults aren't enough and we need to control exactly what gets serialized to JSON – and there are several ways to ignore properties.

If you want to dig deeper and learn other cool things you can do with the Jackson – head on over to the main Jackson tutorial.

2. Ignore Fields at the Class Level

We can ignore specific fields at the class level, using the @JsonIgnoreProperties annotation and specifying the fields by name:

@JsonIgnoreProperties(value = { "intValue" }) public class MyDto { private String stringValue; private int intValue; private boolean booleanValue; public MyDto() { super(); } // standard setters and getters are not shown }

We can now test that, after the object is written to JSON, the field is indeed not part of the output:

@Test public void givenFieldIsIgnoredByName_whenDtoIsSerialized_thenCorrect() throws JsonParseException, IOException { ObjectMapper mapper = new ObjectMapper(); MyDto dtoObject = new MyDto(); String dtoAsString = mapper.writeValueAsString(dtoObject); assertThat(dtoAsString, not(containsString("intValue"))); }

3. Ignore Field at the Field Level

We can also ignore a field directly via the @JsonIgnore annotation directly on the field:

public class MyDto { private String stringValue; @JsonIgnore private int intValue; private boolean booleanValue; public MyDto() { super(); } // standard setters and getters are not shown }

We can now test that the intValue field is indeed not part of the serialized JSON output:

@Test public void givenFieldIsIgnoredDirectly_whenDtoIsSerialized_thenCorrect() throws JsonParseException, IOException { ObjectMapper mapper = new ObjectMapper(); MyDto dtoObject = new MyDto(); String dtoAsString = mapper.writeValueAsString(dtoObject); assertThat(dtoAsString, not(containsString("intValue"))); }

4. Ignore All Fields by Type

Finally, we can ignore all fields of a specified type, using the @JsonIgnoreType annotation. If we control the type, then we can annotate the class directly:

@JsonIgnoreType public class SomeType { ... }

More often than not, however, we don't have control of the class itself; in this case, we can make good use of Jackson mixins.

First, we define a MixIn for the type we'd like to ignore, and annotate that with @JsonIgnoreType instead:

@JsonIgnoreType public class MyMixInForIgnoreType {}

Then we register that mixin to replace (and ignore) all String[] types during marshaling:

mapper.addMixInAnnotations(String[].class, MyMixInForIgnoreType.class);

At this point, all String arrays will be ignored instead of marshaled to JSON:

@Test public final void givenFieldTypeIsIgnored_whenDtoIsSerialized_thenCorrect() throws JsonParseException, IOException { ObjectMapper mapper = new ObjectMapper(); mapper.addMixIn(String[].class, MyMixInForIgnoreType.class); MyDtoWithSpecialField dtoObject = new MyDtoWithSpecialField(); dtoObject.setBooleanValue(true); String dtoAsString = mapper.writeValueAsString(dtoObject); assertThat(dtoAsString, containsString("intValue")); assertThat(dtoAsString, containsString("booleanValue")); assertThat(dtoAsString, not(containsString("stringValue"))); }

and here is our DTO:

public class MyDtoWithSpecialField { private String[] stringValue; private int intValue; private boolean booleanValue; }

Note: Since version 2.5 – it seems that we can not use this method to ignore primitive data types, but we can use it for custom data types and arrays.

5. Ignore Fields Using Filters

Finally, we can also use filters to ignore specific fields in Jackson. First, we need to define the filter on the Java object:

@JsonFilter("myFilter") public class MyDtoWithFilter { ... }

Then, we define a simple filter that will ignore the intValue field:

SimpleBeanPropertyFilter theFilter = SimpleBeanPropertyFilter .serializeAllExcept("intValue"); FilterProvider filters = new SimpleFilterProvider() .addFilter("myFilter", theFilter);

Now we can serialize the object and make sure that the intValue field is not present in the JSON output:

@Test public final void givenTypeHasFilterThatIgnoresFieldByName_whenDtoIsSerialized_thenCorrect() throws JsonParseException, IOException { ObjectMapper mapper = new ObjectMapper(); SimpleBeanPropertyFilter theFilter = SimpleBeanPropertyFilter .serializeAllExcept("intValue"); FilterProvider filters = new SimpleFilterProvider() .addFilter("myFilter", theFilter); MyDtoWithFilter dtoObject = new MyDtoWithFilter(); String dtoAsString = mapper.writer(filters).writeValueAsString(dtoObject); assertThat(dtoAsString, not(containsString("intValue"))); assertThat(dtoAsString, containsString("booleanValue")); assertThat(dtoAsString, containsString("stringValue")); System.out.println(dtoAsString); }

6. Conclusion

The article illustrated how to ignore fields on serialization – first by name, then directly, and finally – we ignored the entire java type with MixIns and we use filters for more control of the output.

The implementation of all these examples and code snippets can be found in my GitHub project.