¿Cómo serializar Joda DateTime con el procesador Jackson JSON?

¿Cómo hago para que Jackson serialice mi objeto Joda DateTime de acuerdo con un patrón simple (como "dd-MM-aaaa")?

He intentado:

@JsonSerialize(using=DateTimeSerializer.class)
private final DateTime date;

También he probado:

ObjectMapper mapper = new ObjectMapper()
    .getSerializationConfig()
    .setDateFormat(df);

¡Gracias!

Esto se ha vuelto muy fácil con Jackson 2.0 y el módulo Joda.

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

Dependencia de Maven:

<dependency>
  <groupId>com.fasterxml.jackson.datatype</groupId>
  <artifactId>jackson-datatype-joda</artifactId>
  <version>2.1.1</version>
</dependency>  

Código y documentación: https://github.com/FasterXML/jackson-datatype-joda

Binarios: http://repo1.maven.org/maven2/com/fasterxml/jackson/datatype/jackson-datatype-joda/

En el objeto que estás mapeando:

@JsonSerialize(using = CustomDateSerializer.class)
public DateTime getDate() { ... }

En CustomDateSerializer:

public class CustomDateSerializer extends JsonSerializer<DateTime> {

    private static DateTimeFormatter formatter = 
        DateTimeFormat.forPattern("dd-MM-yyyy");

    @Override
    public void serialize(DateTime value, JsonGenerator gen, 
                          SerializerProvider arg2)
        throws IOException, JsonProcessingException {

        gen.writeString(formatter.print(value));
    }
}

Como ha dicho @Kimble, con Jackson 2, usar el formato predeterminado es muy fácil; simplemente regístrese JodaModuleen su ObjectMapper.

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

Para la serialización / deserialización personalizada de DateTime, debe implementar su propia StdScalarSerializery StdScalarDeserializer; es bastante complicado, pero de todos modos.

Por ejemplo, aquí hay un DateTimeserializador que usa ISODateFormatcon la zona horaria UTC:

public class DateTimeSerializer extends StdScalarSerializer<DateTime> {

    public DateTimeSerializer() {
        super(DateTime.class);
    }

    @Override
    public void serialize(DateTime dateTime,
                          JsonGenerator jsonGenerator,
                          SerializerProvider provider) throws IOException, JsonGenerationException {
        String dateTimeAsString = ISODateTimeFormat.withZoneUTC().print(dateTime);
        jsonGenerator.writeString(dateTimeAsString);
    }
}

Y el deserializador correspondiente:

public class DateTimeDesrializer extends StdScalarDeserializer<DateTime> {

    public DateTimeDesrializer() {
        super(DateTime.class);
    }

    @Override
    public DateTime deserialize(JsonParser jsonParser,
                                DeserializationContext deserializationContext) throws IOException, JsonProcessingException {
        try {
            JsonToken currentToken = jsonParser.getCurrentToken();
            if (currentToken == JsonToken.VALUE_STRING) {
                String dateTimeAsString = jsonParser.getText().trim();
                return ISODateTimeFormat.withZoneUTC().parseDateTime(dateTimeAsString);
            }
        } finally {
            throw deserializationContext.mappingException(getValueClass());
        }
    }

Luego, une estos con un módulo:

public class DateTimeModule extends SimpleModule {

    public DateTimeModule() {
        super();
        addSerializer(DateTime.class, new DateTimeSerializer());
        addDeserializer(DateTime.class, new DateTimeDeserializer());
    }
}

Luego registre el módulo en su ObjectMapper:

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

La solucion facil

Me he encontrado con un problema similar y mi solución es mucho más clara que la anterior.

Simplemente usé el patrón en la @JsonFormat anotación.

Básicamente, mi clase tiene un DateTimecampo, así que puse una anotación alrededor del captador:

@JsonFormat(pattern = "yyyy-MM-dd HH:mm:ss")
public DateTime getDate() {
    return date;
}

Serializo la clase con ObjectMapper

    ObjectMapper mapper = new ObjectMapper();
    mapper.registerModule(new JodaModule());
    mapper.disable(SerializationFeature.WRITE_DATES_AS_TIMESTAMPS);
    ObjectWriter ow = mapper.writer();
    try {
        String logStr = ow.writeValueAsString(log);
        outLogger.info(logStr);
    } catch (IOException e) {
        logger.warn("JSON mapping exception", e);
    }

Usamos Jackson 2.5.4

https://stackoverflow.com/a/10835114/1113510

Aunque puede poner una anotación para cada campo de fecha, es mejor hacer una configuración global para su mapeador de objetos. Si usa jackson, puede configurar su resorte de la siguiente manera:

<bean id="jacksonObjectMapper" class="com.company.CustomObjectMapper" />

<bean id="jacksonSerializationConfig" class="org.codehaus.jackson.map.SerializationConfig"
    factory-bean="jacksonObjectMapper" factory-method="getSerializationConfig" >
</bean>

Para CustomObjectMapper:

public class CustomObjectMapper extends ObjectMapper {

    public CustomObjectMapper() {
        super();
        configure(Feature.WRITE_DATES_AS_TIMESTAMPS, false);
        setDateFormat(new SimpleDateFormat("EEE MMM dd yyyy HH:mm:ss 'GMT'ZZZ (z)"));
    }
}

Por supuesto, SimpleDateFormat puede usar cualquier formato que necesite.

Mientras tanto, Jackson registra el módulo Joda automáticamente cuando JodaModule está en classpath. Acabo de agregar jackson-datatype-joda a Maven y funcionó al instante.

<dependency>
  <groupId>com.fasterxml.jackson.datatype</groupId>
  <artifactId>jackson-datatype-joda</artifactId>
  <version>2.8.7</version>
</dependency>

Salida JSON:

{"created" : "2017-03-28T05:59:27.258Z"}

Para aquellos con Spring Boot, debe agregar el módulo a su contexto y se agregará a su configuración de esta manera.

@Bean
public Module jodaTimeModule() {
    return new JodaModule();
}

Y si desea utilizar el nuevo módulo de tiempo java8 jsr-310.

@Bean
public Module jodaTimeModule() {
    return new JavaTimeModule();
}

Parece que para Jackson 1.9.12 no existe tal posibilidad de forma predeterminada, debido a:

public final static class DateTimeSerializer
    extends JodaSerializer<DateTime>
{
    public DateTimeSerializer() { super(DateTime.class); }

    @Override
    public void serialize(DateTime value, JsonGenerator jgen, SerializerProvider provider)
        throws IOException, JsonGenerationException
    {
        if (provider.isEnabled(SerializationConfig.Feature.WRITE_DATES_AS_TIMESTAMPS)) {
            jgen.writeNumber(value.getMillis());
        } else {
            jgen.writeString(value.toString());
        }
    }

    @Override
    public JsonNode getSchema(SerializerProvider provider, java.lang.reflect.Type typeHint)
    {
        return createSchemaNode(provider.isEnabled(SerializationConfig.Feature.WRITE_DATES_AS_TIMESTAMPS)
                ? "number" : "string", true);
    }
}

Esta clase serializa datos utilizando el método toString () de Joda DateTime.

El enfoque propuesto por Rusty Kuntz funciona perfecto para mi caso.

Estoy usando Java 8 y esto funcionó para mí.

Agregue la dependencia en pom.xml

<dependency>
    <groupId>com.fasterxml.jackson.datatype</groupId>
    <artifactId>jackson-datatype-jsr310</artifactId>
    <version>2.4.0</version>
</dependency>

y agregue JodaModule en su ObjectMapper

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