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.

To dig deeper and learn other cool things we can do with 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 marshalling:

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

At this point, all String arrays will be ignored instead of marshalled 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’t 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

This article illustrated how to ignore fields on serialization. We did this first by name and then directly, and finally, we ignored the entire java type with MixIns and used filters for more control of the output.