Usando Jackson ObjectMapper con Java 8 Valores opcionales

La clase Optional tiene un campo value, pero no un getter/setter estándar para él. Por defecto, Jackson busca getters / setters para encontrar propiedades de clase.

Puede agregar un Mixin personalizado para identificar el campo como una propiedad

final class OptionalMixin {
    private Mixin(){}
    @JsonProperty
    private Object value;
}

Y registrarlo con su ObjectMapper.

ObjectMapper mapper = new ObjectMapper();
mapper.addMixInAnnotations(Optional.class, OptionalMixin.class);

Ahora puede serializar su objeto.

System.out.println(mapper.writeValueAsString(new Test()));

Se imprimirá

{"field":{"value":"hello, world!","present":true}}

Considere también mirar jackson-datatype-guava. Hay una implementación de Jackson Module para los tipos de guayaba incluidos sus Optional. Es posiblemente más completo de lo que he mostrado anteriormente.

Similar a la respuesta de @Manikandan, pero agrega @JsonProperty al campo privado en lugar de un getter para que no expongas tu trabajo en la api pública.

public class Test {

    @JsonProperty("field")
    private String field;

    @JsonIgnore
    public Optional<String> getField() {
        return Optional.of(field); // or Optional.ofNullable(field);
    }
}

Definir nuevo getter que devolverá Cadena en lugar de Opcional.

public class Test {
    Optional<String> field = Optional.of("hello, world!");

    @JsonIgnore
    public Optional<String> getField() {
        return field;
    }

    @JsonProperty("field")
    public String getFieldName() {
        return field.orElse(null);
    }

}

Intente pasar las opciones a @JsonInclude anotación.
Por ejemplo, si no desea mostrar field cuando el valor es null. Es posible que necesite usar Jackson-Modules >2.8.5.

import com.fasterxml.jackson.annotation.JsonInclude;

public class Test {
    @JsonInclude(JsonInclude.Include.NON_NULL)
    Optional<String> field;
}

Si está utilizando la última versión de Spring-boot, podría lograr esto agregando la siguiente dependencia en el archivo pom

<dependency>
    <groupId>com.fasterxml.jackson.datatype</groupId>
    <artifactId>jackson-datatype-jdk8</artifactId>
</dependency>

Y auto wire el JacksonObjectMapper.

@Autowired
private ObjectMapper jacksonObjectMapper;

Luego use la instancia mapper del contenedor Spring anterior para convertir el objeto en Cadena

jacksonObjectMapper.writeValueAsString(user);

El blog de primavera dice:

Algunos módulos bien conocidos de Jackson se registran automáticamente si se detectan en el classpath:

• jackson-datatype-jdk7: Java 7 tipos como java.nio.file.Path (a partir de la versión 4.2.1)
• jackson-datatype-joda: Joda-Time types{[18]]}
• jackson-datatype-jsr310: Java 8 Tipos de datos API de fecha y hora
• jackson-datatype-jdk8: otros tipos de Java 8 como Opcional (a partir de la versión 4.2.0)

Solo necesita registrar el módulo Jdk8Module. Luego serializará cualquier Optional<T> como T si está presente o null de lo contrario.

ObjectMapper objectMapper = new ObjectMapper();
objectMapper.registerModule(new Jdk8Module());

Modifiquemos un poco la clase Test para que podamos probar un valor Optional.empty(). Esto es similar a la clase original Test cuando se serializa porque el mapeador de objetos está buscando el getter (ya que el campo es private). Sin embargo, usar la clase original Test también funcionará.

class Test {
    private final String field;

    public Test(String field) {
        this.field = field;
    }

    public Optional<String> getField() {
        return Optional.ofNullable(field);
    }
}

Luego en nuestra clase principal:

Test testFieldNull = new Test(null);
Test testFieldNotNull = new Test("foo");

// output: {"field":null}
System.out.println(objectMapper.writeValueAsString(testFieldNull)); 

// output: {"field":"foo"}
System.out.println(objectMapper.writeValueAsString(testFieldNotNull));