How to include only specific properties when serializing with Jackson

Question

I am trying to implement a universal method which serializes the given object to JSON, but only those properties which are passed in a collection. If possible I want to get

Answer 1

Based on http://www.cowtowncoder.com/blog/archives/2011/09/entry_461.html an alternate way to set up the filter is setting up a class that extends JacksonAnnotationIntrospector and overrides findFilterId. You can then specify to find your filter in the findFilterId. This could be made to be as robust if you want based on some other map or algorithm. Below is sample code. Not sure if the performance is better than the solution above but it seems to be simpler and probably more easily extensible. I was doing this for serializing CSV using Jackson. Any feedback is welcome!

public class JSON {

private static String FILTER_NAME = "fieldFilter";

public static String serializeOnlyGivenFields(Object o,
                                              Collection<String> fields) throws JsonProcessingException {
    if ((fields == null) || fields.isEmpty()) fields = new HashSet<String>();

    Set<String> properties = new HashSet<String>(fields);

    SimpleBeanPropertyFilter filter =
            new SimpleBeanPropertyFilter.FilterExceptFilter(properties);
    SimpleFilterProvider fProvider = new SimpleFilterProvider();
    fProvider.addFilter(FILTER_NAME, filter);

    ObjectMapper mapper = new ObjectMapper();
    mapper.setAnnotationIntrospector( new AnnotationIntrospector() );

    String json = mapper.writer(fProvider).writeValueAsString(o);
    return json;
}

private static class AnnotationIntrospector extends JacksonAnnotationIntrospector {
    @Override
    public Object findFilterId(Annotated a) {
        return FILTER_NAME;
    }
}

}

Answer 2

I have found a solution based on Jackson: How to add custom property to the JSON without modifying the POJO. I override BeanSerializer#serializeFields to always use BeanSerializer#serializeFieldsFiltered instead. This way the filter is always applied.

Performance-wise not a very good solution, since an ObjectMapper has to be constructed at every method call. Feel free to post improvements or suggestions!

Module implementation:

public class FilteredModule extends SimpleModule {
    private static final long serialVersionUID = 1L;

    @Override
    public void setupModule(SetupContext context) {
        super.setupModule(context);

        context.addBeanSerializerModifier(new BeanSerializerModifier() {

            @Override
            public JsonSerializer<?> modifySerializer(
                    SerializationConfig config,
                    BeanDescription beanDesc,
                    JsonSerializer<?> serializer) {
                if (serializer instanceof BeanSerializerBase) { 
                    return new FilteredBeanSerializer(
                            (BeanSerializerBase) serializer);
                } 
                return serializer; 

            }                   
        });
    }

    private class FilteredBeanSerializer extends BeanSerializer {

        public FilteredBeanSerializer(BeanSerializerBase source) {
            super(source);
        }

        @Override
        protected void serializeFields(Object arg0, JsonGenerator arg1,
                SerializerProvider arg2) throws IOException,
                JsonGenerationException {
            super.serializeFieldsFiltered(arg0, arg1, arg2);
        }

    }
}

API method:

public static String serializeOnlyGivenFields(Object o,
            Collection<String> fields) throws JsonProcessingException {
    if ((fields == null) || fields.isEmpty()) fields = new HashSet<String>();

    Set<String> properties = new HashSet<String>(fields);

    SimpleBeanPropertyFilter filter =
            new SimpleBeanPropertyFilter.FilterExceptFilter(properties);
    SimpleFilterProvider fProvider = new SimpleFilterProvider();
    fProvider.addFilter("fieldFilter", filter);
    fProvider.setDefaultFilter(filter);

    ObjectMapper mapper = new ObjectMapper();
    mapper.registerModule(new FilteredModule());

    String json = mapper.writer(fProvider).writeValueAsString(o);
    return json;
}

Example

Entity e = new Entity("Test entity", "Test description");   
Set<String> fields = new HashSet<String>(); fields.add("name");
String json = JSON.serializeOnlyGivenFields(e, fields);
System.out.println(json);

{"name":"Test entity"}

Benchmark: 1000 iterations on the same object

serializeOnlyGivenFields:           536 ms
serialize (reuses ObjectMapper):    23 ms

Answer 3

One additional thing is that you have to indicate Java classes for which filter is to be used by @JsonFilter annotation:

@JsonFilter("fieldFilter") public class MyType { }

and then it should apply.