杰克逊-有什么方法可以避免在运行时对父实体进行序列化？

Question

Suppose I have two simple classes

@JsonFilter("filter properties by name")
public class Foo
{
    private Integer id;
    private String name;
}

@JsonFilter("filter properties by name")
public class Bar
{
    private Integer id;
    private String name;
    private Foo foo;
}

I'd like to serialize an instance of Bar in which the foo field has only its id. It all should be done at runtime. I tried to do this using filters

FilterProvider filter = new SimpleFilterProvider().addFilter(
            "filter properties by name", SimpleBeanPropertyFilter
                .serializeAllExcept(/*name of the field to exclude*/));
objectMapper.writer(filter).writeValuAsString(bar);

However, in doing so, I have to manually exclude all the fields of the parent class; also, if one of this field has the same name of a field of the child class, they are both excluded. In my example, I can't exclude the field name in this way because it impacts also the field name of the Bar class.

So, how can I solve in a most concise/elegant way? Is there something similar to the above code, maybe using dot notations or something like that?

Eg until now in my example filter I'm able to write something like [...].serializeAllExcept("name", "foo")); , but it was great to have [...].serializeAllExcept("foo.name")); or similar.

Answer 1

You don't need any filters for it. No changes in Foo and Bar classes.

New MixInFoo class:

public class MixInFoo {
    @JsonProperty("mixinFooId")
    private Integer id;
    @JsonIgnore
    private String name;

}

I've changed 'id' property name just to illustrate that you can change response completely without modifying original Foo class.

ObjectMapper objectMapper = new ObjectMapper();
objectMapper.getSerializationConfig().addMixInAnnotations(Foo.class, MixInFoo.class);
objectMapper.getDeserializationConfig().addMixInAnnotations(Foo.class, MixInFoo.class);

String result = objectMapper.writeValueAsString(json);

You will need to register MixIn classes as shown.

******* Filter based implementation ***********

Yes, you can use Filter to achieve the same result. You need to add @JsonFilter to the Foo class and name it like "FooFilter". Then you can add Filter that will apply only to the Foo class:

@JsonFilter("FooFilter")
public class Foo {
    private Integer id;
    private String name;
}

public class Bar {
    private Integer id;
    private String name;
    private Foo foo;
}

public static void main(String []args) throws IOException {
    ObjectMapper objectMapper = new ObjectMapper();

    String []fooIgnore = {"name"};
    SimpleBeanPropertyFilter propertyFilter = SimpleBeanPropertyFilter.serializeAllExcept(fooIgnore);
    FilterProvider filterProvider = new SimpleFilterProvider().addFilter("FooFilter", propertyFilter);

    ObjectWriter objectWriter = objectMapper.writer(filterProvider);
    String result = objectWriter.writeValueAsString(json);

    System.out.println(result);
}

In that implementation you don't need to extend and implement you custom SimpleBeanProvider to apply the filter only to the Foo class.

Answer 2

It is possible using filters. You can write a custom property filter which would take into account the declaring class of the serialised properties.

You should extend the SimpleBeanPropertyFilter and override the include(PropertyWriter writer) method. If the given writer parameter is an instance of BeanPropertyWriter class, you can extract the information about the property origin and apply your custom the filtering logic.

Here is an example:

public class JacksonParentFilter {
    @JsonFilter("filter")
    public static class A {
        public final String field1;

        public A(final String field1) {this.field1 = field1;}
    }

    @JsonFilter("filter")
    public static class B {
        public final String field1;
        public final String field2;

        public B(final String field1, final String field2) {
            this.field1 = field1;
            this.field2 = field2;
        }
    }

    public static class MyFilter extends SimpleBeanPropertyFilter {
        private final Class<?> excludeClass;
        private final Set<String> excludeProperties;

        public MyFilter(final Class<?> excludeClass, final Set<String> excludeProperties) {
            this.excludeClass = excludeClass;
            this.excludeProperties = excludeProperties;
        }

        @Override
        protected boolean include(final BeanPropertyWriter writer) {
            return false;
        }

        @Override
        protected boolean include(final PropertyWriter writer) {
            if (writer instanceof BeanPropertyWriter) {
                final Class<?> cls = ((BeanPropertyWriter) writer).getMember().getDeclaringClass();
                if (cls == excludeClass) {
                    return !excludeProperties.contains(writer.getName());
                }
            }
            return true;
        }
    }

    public static void main(String[] args) throws JsonProcessingException {
        final A a = new A("A");
        final B b = new B("B1", "B2");
        final ObjectMapper mapper = new ObjectMapper();
        final SimpleFilterProvider filters = new SimpleFilterProvider();
        filters.addFilter("filter", new MyFilter(B.class, Collections.singleton("field1")));
        mapper.setFilters(filters);
        final ObjectWriter objectWriter = mapper.writerWithDefaultPrettyPrinter();
        System.out.println(objectWriter.writeValueAsString(Arrays.asList(a, b)));
    }

}

Output:

[ {
  "field1" : "A"
}, {
  "field2" : "B2"
} ]