Include.NON_NULL does not work on Java 8 Optional

Following is a minimal reproduction of the issue. In short, I would have expected that, when using the Jdk8Module, empty Optionals wouldn’t be serialized when using the Include.NON_NULL serialization inclusion.

public class Issue {

    public static void main(String[] args) throws Exception {
        Model model = new Model();
        model.setId(OptionalLong.empty());
        model.setOrder(null);
        model.setName(Optional.ofNullable(null));
        model.setType(null);

        ObjectMapper mapper = new ObjectMapper()
            .registerModule(new Jdk8Module())
            .setSerializationInclusion(NON_NULL);

        mapper.writeValue(System.out, model); // prints {"id":null,"name":null}
    }

    static class Model {
        private OptionalLong id;
        private Long order;
        private Optional<String> name;
        private String type;

        public OptionalLong getId() {
            return id;
        }

        public void setId(OptionalLong id) {
            this.id = id;
        }

        public Long getOrder() {
            return order;
        }

        public void setOrder(Long order) {
            this.order = order;
        }

        public Optional<String> getName() {
            return name;
        }

        public void setName(Optional<String> name) {
            this.name = name;
        }
        
        public String getType() {
            return type;
        }

        public void setType(String type) {
            this.type = type;
        }
    }

}

[cowtowncoder]

Right, “NULL” means exactly and only Java null. Not Optional.empty(). This is intentional. There is also value NON_ABSENT which would include Optional (and equivalent, AtomicReference) without content, but not empty Collections.

So if you want absent optionals to work like Java nulls, use setting of NON_ABSENT.

[garethsb]

@cowtowncoder Apologies for commenting on a closed issue, but this seems relevant.

I’ve found that NON_EMPTY did not have the behaviour I expected, when trying to map a tri-state JSON property (i.e. one which may be omitted, present or null).

If I have:

@JsonInclude(value = JsonInclude.Include.NON_EMPTY)
private Optional<String> foo;

I expected that the correspondences would be between an explicit null JSON value and a null Java value on the one hand, and an Optional.empty() value and the omission of the property in the JSON. However, actually what I think I found was that both Java null and Optional.empty() result in the omission of the property in the JSON.

It seems that if I want a tri-state mapping, I have to use:

@JsonInclude(value = JsonInclude.Include.NON_NULL)
private Optional<String> foo;

Then a null value causes the property to be omitted, and an empty value is serialized - as null. This seems backwards to me, but I think that’s the only way of mapping all three possibilities?