serialize / deserialize java 8 java.time dengan Jackson JSON mapper

Bagaimana cara menggunakan mapper Jackson JSON dengan Java 8 LocalDateTime?

org.codehaus.jackson.map.JsonMappingException: Tidak dapat membuat instantiate nilai tipe [tipe sederhana, kelas java.time.LocalDateTime] dari JSON String; tidak ada metode String-konstruktor / pabrik tunggal (melalui rantai referensi: MyDTO ["field1"] -> SubDTO ["date"])

Tidak perlu menggunakan serializers / deserializers khusus di sini. Gunakan modul datetime jackson-modules-java8 :

Modul Datatype untuk membuat Jackson mengenali tipe data Java 8 Date & Time API (JSR-310).

Modul ini menambahkan dukungan untuk beberapa kelas:

• Durasi
• Instan
• LocalDateTime
• Tanggal lokal
• Waktu lokal
• Bulan hari
• OffsetDateTime
• OffsetTime
• Titik
• Tahun
• Tahun bulan
• ZonedDateTime
• ZoneId
• ZoneOffset

Pembaruan: Meninggalkan jawaban ini karena alasan historis, tetapi saya tidak merekomendasikannya. Silakan lihat jawaban yang diterima di atas.

Beri tahu Jackson untuk memetakan menggunakan kelas serialisasi kustom [de] Anda:

@JsonSerialize(using = LocalDateTimeSerializer.class)
@JsonDeserialize(using = LocalDateTimeDeserializer.class)
private LocalDateTime ignoreUntil;

menyediakan kelas khusus:

public class LocalDateTimeSerializer extends JsonSerializer<LocalDateTime> {
    @Override
    public void serialize(LocalDateTime arg0, JsonGenerator arg1, SerializerProvider arg2) throws IOException {
        arg1.writeString(arg0.toString());
    }
}

public class LocalDateTimeDeserializer extends JsonDeserializer<LocalDateTime> {
    @Override
    public LocalDateTime deserialize(JsonParser arg0, DeserializationContext arg1) throws IOException {
        return LocalDateTime.parse(arg0.getText());
    }
}

fakta acak: jika saya bersarang di atas kelas dan tidak membuatnya statis, pesan kesalahannya aneh: org.springframework.web.HttpMediaTypeNotSupportedException: Content type 'application/json;charset=UTF-8' not supported

Jika Anda menggunakan kelas ObjectMapper dari fastxml, secara default ObjectMapper tidak memahami kelas LocalDateTime, jadi, Anda perlu menambahkan dependensi lain di gradle / maven Anda:

compile 'com.fasterxml.jackson.datatype:jackson-datatype-jsr310:2.7.3'

Sekarang Anda perlu mendaftarkan dukungan tipe data yang ditawarkan oleh perpustakaan ini ke objek Anda objectmapper, ini dapat dilakukan dengan mengikuti:

ObjectMapper objectMapper = new ObjectMapper();
objectMapper.findAndRegisterModules();

Sekarang, di jsonString Anda, Anda dapat dengan mudah menempatkan bidang java.LocalDateTime Anda sebagai berikut:

{
    "user_id": 1,
    "score": 9,
    "date_time": "2016-05-28T17:39:44.937"
}

Dengan melakukan semua ini, konversi file Json ke Java Anda akan berfungsi dengan baik, Anda dapat membaca file dengan mengikuti:

objectMapper.readValue(jsonString, new TypeReference<List<User>>() {
            });

Ketergantungan pakar ini akan memecahkan masalah Anda:

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

Satu hal yang saya perjuangkan adalah zona waktu ZonedDateTime diubah menjadi GMT selama deserialisasi. Ternyata, bahwa secara default jackson menggantinya dengan satu dari konteks .. Untuk menjaga zona satu harus menonaktifkan 'fitur' ini

Jackson2ObjectMapperBuilder.json()
    .featuresToDisable(DeserializationFeature.ADJUST_DATES_TO_CONTEXT_TIME_ZONE)

Saya memiliki masalah yang sama saat menggunakan boot Spring . Dengan Spring boot 1.5.1.RELEASE yang harus saya lakukan adalah menambahkan ketergantungan:

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

Jika Anda menggunakan Jersey maka Anda perlu menambahkan dependensi Maven (jackson-datatype-jsr310) seperti yang disarankan orang lain dan mendaftarkan instance mapper objek Anda seperti:

@Provider
public class JacksonObjectMapper implements ContextResolver<ObjectMapper> {

  final ObjectMapper defaultObjectMapper;

  public JacksonObjectMapper() {
    defaultObjectMapper = createDefaultMapper();
  }

  @Override
  public ObjectMapper getContext(Class<?> type) {
    return defaultObjectMapper;
  }

  private static ObjectMapper createDefaultMapper() {
    final ObjectMapper mapper = new ObjectMapper();    
    mapper.registerModule(new JavaTimeModule());
    return mapper;
  }
}

Saat mendaftarkan Jackson di sumber daya Anda, Anda perlu menambahkan mapper ini seperti:

final ResourceConfig rc = new ResourceConfig().packages("<your package>");
rc
  .register(JacksonObjectMapper.class)
  .register(JacksonJaxbJsonProvider.class);

Jika Anda tidak dapat menggunakan jackson-modules-java8untuk alasan apa pun, Anda dapat (membatalkan) membuat serialisasi bidang instan longmenggunakan @JsonIgnoredan @JsonGetter& @JsonSetter:

public class MyBean {

    private Instant time = Instant.now();

    @JsonIgnore
    public Instant getTime() {
        return this.time;
    }

    public void setTime(Instant time) {
        this.time = time;
    }

    @JsonGetter
    private long getEpochTime() {
        return this.time.toEpochMilli();
    }

    @JsonSetter
    private void setEpochTime(long time) {
        this.time = Instant.ofEpochMilli(time);
    }
}

Contoh:

@Test
public void testJsonTime() throws Exception {
    String json = new ObjectMapper().writeValueAsString(new MyBean());
    System.out.println(json);
    MyBean myBean = new ObjectMapper().readValue(json, MyBean.class);
    System.out.println(myBean.getTime());
}

hasil panen

{"epochTime":1506432517242}
2017-09-26T13:28:37.242Z

Saya menggunakan format waktu ini: "{birthDate": "2018-05-24T13:56:13Z}"untuk deserialize dari json ke java.time.Instant (lihat screenshot)

Ini hanyalah contoh cara menggunakannya dalam unit test yang saya retas untuk men-debug masalah ini. Bahan utamanya adalah

• mapper.registerModule(new JavaTimeModule());
• ketergantungan maven <artifactId>jackson-datatype-jsr310</artifactId>

Kode:

import com.fasterxml.jackson.databind.ObjectMapper;
import com.fasterxml.jackson.datatype.jsr310.JavaTimeModule;
import org.testng.Assert;
import org.testng.annotations.Test;

import java.io.IOException;
import java.io.Serializable;
import java.time.Instant;

class Mumu implements Serializable {
    private Instant from;
    private String text;

    Mumu(Instant from, String text) {
        this.from = from;
        this.text = text;
    }

    public Mumu() {
    }

    public Instant getFrom() {
        return from;
    }

    public String getText() {
        return text;
    }

    @Override
    public String toString() {
        return "Mumu{" +
                "from=" + from +
                ", text='" + text + '\'' +
                '}';
    }
}
public class Scratch {


    @Test
    public void JacksonInstant() throws IOException {
        ObjectMapper mapper = new ObjectMapper();
        mapper.registerModule(new JavaTimeModule());

        Mumu before = new Mumu(Instant.now(), "before");
        String jsonInString = mapper.writeValueAsString(before);


        System.out.println("-- BEFORE --");
        System.out.println(before);
        System.out.println(jsonInString);

        Mumu after = mapper.readValue(jsonInString, Mumu.class);
        System.out.println("-- AFTER --");
        System.out.println(after);

        Assert.assertEquals(after.toString(), before.toString());
    }

}

Jika Anda menggunakan boot Spring dan memiliki masalah ini dengan OffsetDateTime maka perlu menggunakan registerModules seperti yang dijawab di atas oleh @greperror (dijawab 28 Mei 16 pada 13:04) tetapi perhatikan bahwa ada satu perbedaan. Ketergantungan yang disebutkan tidak perlu ditambahkan karena saya menduga boot spring sudah memilikinya. Saya mengalami masalah dengan boot Spring dan ini berhasil untuk saya tanpa menambahkan ketergantungan ini.

Anda dapat mengatur ini di application.ymlfile Anda untuk menyelesaikan waktu Instan, yang merupakan API Tanggal di java8:

spring.jackson.serialization.write-dates-as-timestamps=false

Bagi yang menggunakan Spring Boot 2.x

Tidak perlu melakukan hal di atas - Java 8 LocalDateTime adalah serial / de-serial keluar dari kotak. Saya harus melakukan semua hal di atas dalam 1.x, tetapi dengan Boot 2.x, ia berfungsi dengan mulus.

Lihat referensi ini juga format JSON Java 8 LocalDateTime di Spring Boot

Jika ada yang mengalami masalah saat menggunakan di SpringBootsini adalah bagaimana saya memperbaiki masalah tanpa menambahkan ketergantungan baru.

Dalam Spring 2.1.3Jackson mengharapkan string tanggal 2019-05-21T07:37:11.000dalam yyyy-MM-dd HH:mm:ss.SSSformat ini untuk de-serialisasi dalam LocalDateTime. Pastikan string tanggal memisahkan tanggal dan waktu dengan Ttidak dengan space. detik ( ss) dan milidetik ( SSS) dapat dinonaktifkan.

@JsonProperty("last_charge_date")
public LocalDateTime lastChargeDate;

Jika Anda mempertimbangkan untuk menggunakan fastjson, Anda dapat menyelesaikan masalah Anda, catat versinya

 <dependency>
        <groupId>com.alibaba</groupId>
        <artifactId>fastjson</artifactId>
        <version>1.2.56</version>
 </dependency>

Jika Anda mengalami masalah ini karena GraphQL Java Tools dan mencoba Instantmenyusun Java dari string tanggal, Anda perlu mengatur SchemaParser Anda untuk menggunakan ObjectMapper dengan konfigurasi tertentu:

Di kelas GraphQLSchemaBuilder Anda, suntikkan ObjectMapper dan tambahkan modul ini:

        ObjectMapper objectMapper = 
    new ObjectMapper().registerModule(new JavaTimeModule())
            .configure(SerializationFeature.WRITE_DATES_AS_TIMESTAMPS, false);

dan tambahkan ke opsi:

final SchemaParserOptions options = SchemaParserOptions.newOptions()
            .objectMapperProvider(fieldDefinition -> objectMapper)
            .typeDefinitionFactory(new YourTypeDefinitionFactory())
            .build();

Lihat https://github.com/graphql-java-kickstart/graphql-spring-boot/issues/32

Jika Anda menggunakan Jackson Serializer , berikut adalah cara menggunakan modul tanggal:

import com.fasterxml.jackson.core.JsonProcessingException;
import com.fasterxml.jackson.databind.ObjectMapper;
import com.fasterxml.jackson.datatype.jdk8.Jdk8Module;
import com.fasterxml.jackson.datatype.jsr310.JavaTimeModule;
import com.fasterxml.jackson.module.paramnames.ParameterNamesModule;
import org.apache.kafka.common.serialization.Serializer;

public class JacksonSerializer<T> implements Serializer<T> {

    private final ObjectMapper mapper = new ObjectMapper()
            .registerModule(new ParameterNamesModule())
            .registerModule(new Jdk8Module())
            .registerModule(new JavaTimeModule());

    @Override
    public byte[] serialize(String s, T object) {
        try {
            return mapper.writeValueAsBytes(object);
        } catch (JsonProcessingException e) {
            e.printStackTrace();
        }
        return null;
    }
}