जावा 8 लोकलडेट जैक्सन प्रारूप


138

के लिए java.util.Date जब मैं करता हूँ

@JsonFormat(shape = JsonFormat.Shape.STRING, pattern = "dd/MM/yyyy")  
  private Date dateOfBirth;

जब मैं भेजता हूं तो JSON अनुरोध में

{ {"dateOfBirth":"01/01/2000"} }  

यह काम करता हैं।

मुझे जावा 8 के लोकलडेट क्षेत्र के लिए यह कैसे करना चाहिए ??

मैंने कोशिश की

@JsonDeserialize(using = LocalDateDeserializer.class)  
@JsonSerialize(using = LocalDateSerializer.class)  
private LocalDate dateOfBirth;  

यह काम नहीं किया।

क्या कोई मुझे बता सकता है कि ऐसा करने का सही तरीका क्या है ..

नीचे निर्भरताएं हैं

<dependency>
    <groupId>org.jboss.resteasy</groupId>
    <artifactId>jaxrs-api</artifactId>
     <version>3.0.9.Final</version>
</dependency>
<dependency>
    <groupId>com.fasterxml.jackson.jaxrs</groupId>
    <artifactId>jackson-jaxrs-json-provider</artifactId>
    <version>2.4.2</version>
</dependency>
<dependency>
    <groupId>com.wordnik</groupId>
    <artifactId>swagger-annotations</artifactId>
    <version>1.3.10</version>
</dependency>

जवाबों:


106

मैं एनोटेशन का उपयोग करके सरल काम करने में कभी सक्षम नहीं था। इसे काम करने के लिए, मैंने एक के ContextResolverलिए बनाया ObjectMapper, फिर मैंने एक और कैविएट के साथ JSR310Module( अपडेट: अब यह JavaTimeModuleइसके बजाय है ) जोड़ा , जो कि राइट करने के लिए राइट-डेट-ए-टाइमस्टैम्प सेट करने की आवश्यकता थी। JSR310 मॉड्यूल के प्रलेखन पर अधिक देखें । यहाँ एक उदाहरण है कि मैंने क्या प्रयोग किया।

निर्भरता

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

नोट: एक समस्या जिसका मुझे सामना करना पड़ा है वह यह है कि jackson-annotationएक और निर्भरता द्वारा खींचा गया संस्करण, 2.3.2 का उपयोग किया गया संस्करण, जिसे 2.4 आवश्यक द्वारा रद्द कर दिया गया था jsr310। क्या हुआ मुझे एक NoClassDefFound मिला ObjectIdResolver, जो कि एक 2.4 वर्ग है। इसलिए मुझे सिर्फ शामिल निर्भरता संस्करणों को लाइन करने की आवश्यकता थी

ContextResolver

import com.fasterxml.jackson.databind.ObjectMapper;
import com.fasterxml.jackson.databind.SerializationFeature;
import com.fasterxml.jackson.datatype.jsr310.JSR310Module;
import javax.ws.rs.ext.ContextResolver;
import javax.ws.rs.ext.Provider;

@Provider
public class ObjectMapperContextResolver implements ContextResolver<ObjectMapper> {  
    private final ObjectMapper MAPPER;

    public ObjectMapperContextResolver() {
        MAPPER = new ObjectMapper();
        // Now you should use JavaTimeModule instead
        MAPPER.registerModule(new JSR310Module());
        MAPPER.configure(SerializationFeature.WRITE_DATES_AS_TIMESTAMPS, false);
    }

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

संसाधन वर्ग

@Path("person")
public class LocalDateResource {

    @GET
    @Produces(MediaType.APPLICATION_JSON)
    public Response getPerson() {
        Person person = new Person();
        person.birthDate = LocalDate.now();
        return Response.ok(person).build();
    }

    @POST
    @Consumes(MediaType.APPLICATION_JSON)
    public Response createPerson(Person person) {
        return Response.ok(
                DateTimeFormatter.ISO_DATE.format(person.birthDate)).build();
    }

    public static class Person {
        public LocalDate birthDate;
    }
}

परीक्षा

curl -v http://localhost:8080/api/person
परिणाम: {"birthDate":"2015-03-01"}

curl -v -POST -H "Content-Type:application/json" -d "{\"birthDate\":\"2015-03-01\"}" http://localhost:8080/api/person
परिणाम: 2015-03-01


यहां भी देखेंJAXB समाधान के लिए ।

अपडेट करें

JSR310Moduleजैक्सन के संस्करण 2.7 के रूप में मान्य नहीं है। इसके बजाय, आपको मॉड्यूल को पंजीकृत करना चाहिए JavaTimeModule। यह अब भी वही निर्भरता है।


1
हाय पिसकिललेट, क्षेत्र जन्मतिथि, "जन्मतिथि": {"वर्ष": 0, "माह": "महीना", "दिनवार": 0, "दिनऑफ़वेक": "दिनोफ़ीक", "युग": {"" के रूप में उत्पन्न हो रही है। value ": 0}," dayOfYear ": 0," leapYear ": false," monthValue ": 0," कालक्रम ": {" id ":" "," CalendarType ":" "}} मैं इसे कैसे बना सकता हूं "जन्मतिथि" के रूप में ???
JAB

ContextResolver को कहा जाता है की जाँच करें। getContextविधि में एक प्रिंट स्टेटमेंट जोड़ें । यदि इस विधि को कहा जाता है, तो मुझे काम नहीं करने का एक कारण दिखाई नहीं देता है। यदि इसे नहीं बुलाया जाता है, तो यह कुछ ऐसा हो सकता है जिसे ऐप कॉन्फ़िगरेशन के साथ तय किया जाना चाहिए। इसके लिए मुझे आपके द्वारा प्रदान की गई चीजों से अधिक देखने की आवश्यकता होगी। रेस्टसी संस्करण की तरह, निर्भरता, ऐप कॉन्फ़िगर या तो web.xml या एप्लिकेशन उपवर्ग। मूल रूप से समस्या को पुन: पेश करने के लिए पर्याप्त है
पॉल समसोथा

ContextResolver को Peeskillet नहीं कहा जा रहा है। मैं इसे web.xml में <संदर्भ- param> <param-name> resteasy.resources </ param-name> <param-value> com.bac। निर्भरता के लिए अद्यतन प्रश्न मैं उपयोग कर रहा हूँ
JAB

स्वैगर मुद्दा लगता है। मैं इसे अक्षम करने के लिए कहूंगा लेकिन इस प्रश्न को देखते हुए एक मुद्दा है जो कि दायर किया गया है, स्वैगर के ऑब्जेक्टमैपर के बीच संघर्ष के साथ और अपना खुद का उपयोग करने की कोशिश कर रहा है। आप उनकी कोशिश कर सकते हैं और उन्हें निष्क्रिय कर सकते हैं, और ContextResolver में, सभी कॉन्फ़िगरेशन को उसी ObjectMapperतरह से सेट करता है जैसा कि स्वैगर करता है (आप प्रश्न में लिंक देख सकते हैं)। मुझे नहीं पता कि मैं बहुत स्वैगर के साथ काम नहीं करता। लेकिन मुझे लगता है कि स्वैगर मुख्य समस्या है, क्यों रेफ़रसोलर को नहीं बुलाया जा रहा है।
पॉल समसोथा

आगे के परीक्षण के बाद, एनोटेशन काम करता है । हम भले ही है स्वैगर ObjectMapper उपयोग करने के लिए है, तो पहले से ही हमारे लिए झूठे के रूप में समय टिकटों कॉन्फ़िगर करें। तो यह काम करना चाहिए। बेहतर सहायता के लिए, मैं दृढ़ता से सुझाव देता हूं कि आप एक MCVE प्रदान करें जो समस्या को प्रदर्शित करता है।
पॉल समसोथा

95

@JsonSerialize और @JsonDeserialize ने मेरे लिए ठीक काम किया। वे अतिरिक्त jsr310 मॉड्यूल आयात करने की आवश्यकता को समाप्त करते हैं:

@JsonDeserialize(using = LocalDateDeserializer.class)  
@JsonSerialize(using = LocalDateSerializer.class)  
private LocalDate dateOfBirth;

deserializer:

public class LocalDateDeserializer extends StdDeserializer<LocalDate> {

    private static final long serialVersionUID = 1L;

    protected LocalDateDeserializer() {
        super(LocalDate.class);
    }


    @Override
    public LocalDate deserialize(JsonParser jp, DeserializationContext ctxt)
            throws IOException, JsonProcessingException {
        return LocalDate.parse(jp.readValueAs(String.class));
    }

}

serializer:

public class LocalDateSerializer extends StdSerializer<LocalDate> {

    private static final long serialVersionUID = 1L;

    public LocalDateSerializer(){
        super(LocalDate.class);
    }

    @Override
    public void serialize(LocalDate value, JsonGenerator gen, SerializerProvider sp) throws IOException, JsonProcessingException {
        gen.writeString(value.format(DateTimeFormatter.ISO_LOCAL_DATE));
    }
}

2
यह मेरे लिए सबसे अच्छा जवाब है। धन्यवाद!
रोमियो जूनियर मारन

7
उन वर्गों में शामिल हैं jackson-datatype-jsr310। मैन्युअल रूप से उन्हें अपनी परियोजना में परिभाषित करने की आवश्यकता नहीं है।
न्यूरोएक्ससी

1
इस समाधान ने मेरे लिए काम किया, जिसमें धारावाहिकों का उपयोग किया गया jackson-datatype-jsr310
डेव

2
यह नया सबसे अच्छा उत्तर होना चाहिए।
चिकित्सक पैरामीटर

1
यदि आप jackson-datatype-jsr310 में सीरियलाइज़र और डिसेरिएलाइज़र का उपयोग करते हैं, तो अपने क्षेत्र में बेहतर @JsonFormat (आकृति = JsonFormat.Shape.STRING) जोड़ें। इस प्रारूप के बिना, मान को [वर्ष, माह, दिन] के रूप में क्रमबद्ध किया जाएगा, हालांकि डिसेरिएलाइज़ेशन काम करेगा।
जियान चेन

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

मेरे लिए ठीक काम करता है।


2
new com.fasterxml.jackson.datatype.jsr310.JSR310Module()संस्करण 2.5.4 के लिए जैक्सन। JavaTimeModule वर्ग इस संस्करण में मौजूद नहीं है।
user3774109

यह उत्तर भी काम करता है LocalDateTime(जैकसन 2.9.5)। 1 अतिरिक्त निर्भरता की आवश्यकता है, इसलिए मेरा build.sbt ऐसा दिखता है:"com.fasterxml.jackson.module" %% "jackson-module-scala" % "2.9.5", "com.fasterxml.jackson.datatype" % "jackson-datatype-jsr310" % "2.9.5"
ruhong

2
इस तरह से अधिक वोट होना चाहिए। सरल और प्रभावी।
mkasberg 5

पूरी तरह से काम किया! धन्यवाद।
MAD-HAX

इसने मुझे सही दिशा में इशारा किया, धन्यवाद! मैं जोड़ना होगा कि वसंत-बूट में तुम सब करने की जरूरत है application.properties के लिए निम्न जोड़ने है: spring.jackson.serialization.write-दिनांक के रूप में टाइम स्टांप = false
जूस्ट Lambregts

46

जैक्सन और JSR 310 संस्करण "2.8.5" के साथ स्प्रिंग बूट वेब ऐप में

compile "com.fasterxml.jackson.core:jackson-databind:2.8.5"
runtime "com.fasterxml.jackson.datatype:jackson-datatype-jsr310:2.8.5"

@JsonFormatकाम करता है:

import com.fasterxml.jackson.annotation.JsonFormat;

@JsonFormat(shape = JsonFormat.Shape.STRING, pattern = "yyyy-MM-dd")
private LocalDate birthDate;

2
क्या यह डिसेरिएलाइजेशन के लिए काम करता है? या केवल क्रमांकन?
डिसेरिएलाइज़ेशन के

7
मुझे स्पष्ट रूप से @JsonDeserialize(using= LocalDateDeserializer.class)
डिसिएरलाइज़र की

1
अब तक का सबसे सरल!
एंटोनियो

@JsonFormatसिर्फ आउटपुट डेटा प्रारूप बदलने के लिए। stackoverflow.com/a/53251526/816759 के साथ एकदम सही काम करता है @JsonFormat, @JsonDeserialize,@JsonSerialize
बहा

स्प्रिंग बूट में, एक बार जब आप JSR310 निर्भरता जोड़ते हैं, तो आपको बस इतना करना होगा कि आप spring.jackson.serialization.write-dates-as-timestamps=falseइसे अपने साथ जोड़ लें application.properties, और यह yyyy-MM-ddस्वचालित रूप से इसे प्रारूपित करता है । कोई ज़रूरत नहीं है@JsonFormat
esfandia

31

सबसे सरल समाधान (जो डिसरियलाइजेशन और क्रमबद्धता का भी समर्थन करता है) है

import com.fasterxml.jackson.annotation.JsonFormat;
import com.fasterxml.jackson.databind.annotation.JsonDeserialize;
import com.fasterxml.jackson.databind.annotation.JsonSerialize;
import com.fasterxml.jackson.datatype.jsr310.deser.LocalDateDeserializer;
import com.fasterxml.jackson.datatype.jsr310.ser.LocalDateSerializer;

@JsonFormat(shape = JsonFormat.Shape.STRING, pattern = "dd/MM/yyyy")
@JsonDeserialize(using = LocalDateDeserializer.class)
@JsonSerialize(using = LocalDateSerializer.class)
private LocalDate dateOfBirth;

अपनी परियोजना में निम्नलिखित निर्भरता का उपयोग करते समय।

Maven

<dependency>
   <groupId>com.fasterxml.jackson.core</groupId>
   <artifactId>jackson-databind</artifactId>
   <version>2.9.7</version>
</dependency>
<dependency>
   <groupId>com.fasterxml.jackson.datatype</groupId>
   <artifactId>jackson-datatype-jsr310</artifactId>
   <version>2.9.7</version>
</dependency>

Gradle

compile "com.fasterxml.jackson.core:jackson-databind:2.9.7"
compile "com.fasterxml.jackson.datatype:jackson-datatype-jsr310:2.9.7"

ContextResolver, Serializer या Deserializer का कोई अतिरिक्त कार्यान्वयन आवश्यक नहीं है।


शानदार, दूर और सबसे आसान। बहुत सी निर्भरता वाले किसी भी व्यक्ति के लिए FYI करें, मुझे कुछ अन्य पुस्तकालयों को अपडेट करना था जिसमें जैकसन एनोटेशन शामिल थे।
बर्ट

यह उत्तर मेरी समस्या को ठीक करने के लिए निकटतम निकटतम है। सीरियलाइज़ेशन काम कर रहा है, लेकिन @JsonFormat मुझे लगता है कि (@JsonFormat (आकार = JsonFormat.Shape.STRING, pattern = "dd-MM-yyy_HH: mm: SS")
fsakiyama

यदि आपके पास एक असफल deserialization है, तो सबसे अधिक संभावना है कि आपका पंजीकरण ObjectMapperनहीं हुआ है JavaTimeModule। यदि आपका ObjectMapper उदाहरण वसंत / MessageConverter ढांचे से प्रदान किया गया है। उन्होंने उन्हें तार-तार करने के लिए कुछ जादू किया। अन्य मामलों में, POJO में सभी "लोकलडेट" के लिए डिफ़ॉल्ट रूप registerModuleसे सक्षम होना चाहिएLocalDateDeserializer
डेनिस सी

19

चूंकि LocalDateSerializerयह डिफ़ॉल्ट रूप से "वर्ष-माह-दिन" (एक जौन स्ट्रिंग) के बजाय "[वर्ष, माह, दिन]" (एक json सरणी) में बदल जाता है, और चूंकि मुझे किसी विशेष ObjectMapperसेटअप की आवश्यकता नहीं है (आप कर सकते हैं) बनाने के LocalDateSerializerतार उत्पन्न करता है, तो आप को निष्क्रिय SerializationFeature.WRITE_DATES_AS_TIMESTAMPSलेकिन यह है कि करने के लिए अतिरिक्त सेटअप की आवश्यकता है अपनेObjectMapper ), मैं निम्नलिखित का उपयोग करें:

आयात:

import com.fasterxml.jackson.databind.ser.std.ToStringSerializer;
import com.fasterxml.jackson.datatype.jsr310.deser.LocalDateDeserializer;

कोड:

// generates "yyyy-MM-dd" output
@JsonSerialize(using = ToStringSerializer.class)
// handles "yyyy-MM-dd" input just fine (note: "yyyy-M-d" format will not work)
@JsonDeserialize(using = LocalDateDeserializer.class)
private LocalDate localDate;

और अब मैं बस new ObjectMapper()अपनी वस्तुओं को बिना किसी विशेष सेटअप के पढ़ने और लिखने के लिए उपयोग कर सकता हूं।


3
एक चीज जो मैं जोड़ना चाहूंगा, वह यह है कि तारीख के रूप में पास "2018-12-07"करने की बजाय "2018-12-7"आपको एक त्रुटि मिलेगी।
किड्स101

1
सही है, यह yyyy-MM-dd(2 अंक महीने और दिन) प्रारूप के साथ काम करता है , न कि yyyy-M-d(1 अंक महीने या दिन) प्रारूप में।
शैडो मैन

8

बस क्रिस्टोफर जवाब का एक अद्यतन।

संस्करण 2.6.0 के बाद से

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

JSR310Module (पदावनत) के बजाय JavaTimeModule का उपयोग करें ।

@Provider
public class ObjectMapperContextResolver implements ContextResolver<ObjectMapper> {  
    private final ObjectMapper MAPPER;

    public ObjectMapperContextResolver() {
        MAPPER = new ObjectMapper();
        MAPPER.registerModule(new JavaTimeModule());
        MAPPER.configure(SerializationFeature.WRITE_DATES_AS_TIMESTAMPS, false);
    }

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

प्रलेखन के अनुसार , नया JavaTimeModule समान मानक सेटिंग्स का उपयोग क्रमांकन के लिए डिफ़ॉल्ट रूप से करता है जो Timezone Ids का उपयोग नहीं करता है, और इसके बजाय केवल ISO-8601 अनुरूप टाइमज़ोन ऑफसेट का उपयोग करता है।

व्यवहार को SerializationFeature.WRITE_DATES_WITH_ZONE_ID का उपयोग करके बदला जा सकता है


इससे मुझे मदद मिली। मेरे मामले में, मुझे MAPPER.registerModule(new JavaTimeModule());लाइन जोड़ने की आवश्यकता थी। इसने मुझे LocalDate ऑब्जेक्ट्स को "2020-02-20" प्रारूप के रूप में प्रारूपित करने दिया। मैं जरूरत नहीं थी MAPPER.configure(SerializationFeature.WRITE_DATES_AS_TIMESTAMPS, false);लाइन, क्या मैं खोज रहा था के लिए
Cuga

6

निम्नलिखित एनोटेशन ने मेरे लिए ठीक काम किया।

कोई अतिरिक्त निर्भरता की जरूरत है।

    @JsonProperty("created_at")
    @JsonFormat(pattern = "yyyy-MM-dd'T'HH:mm:ss.SSSXXX")
    @JsonDeserialize(using = LocalDateTimeDeserializer.class)
    @JsonSerialize(using = LocalDateTimeSerializer.class)
    private LocalDateTime createdAt;

5
@JsonFormat(pattern = "yyyy-MM-dd HH:mm:ss")
@JsonSerialize(using = LocalDateTimeSerializer.class)
@JsonDeserialize(using = LocalDateTimeDeserializer.class)
private LocalDateTime createdDate;

4

https://stackoverflow.com/a/53251526/1282532 संपत्ति को क्रमबद्ध / निष्क्रिय करने का सबसे सरल तरीका है। मुझे इस दृष्टिकोण के बारे में दो चिंताएं हैं - कुछ बिंदु पर DRY सिद्धांत का उल्लंघन और पूजो और मैपर के बीच उच्च युग्मन।

public class Trade {
    @JsonFormat(pattern = "yyyyMMdd")
    @JsonDeserialize(using = LocalDateDeserializer.class)
    @JsonSerialize(using = LocalDateSerializer.class)
    private LocalDate tradeDate;
    @JsonFormat(pattern = "yyyyMMdd")
    @JsonDeserialize(using = LocalDateDeserializer.class)
    @JsonSerialize(using = LocalDateSerializer.class)
    private LocalDate maturityDate;
    @JsonFormat(pattern = "yyyyMMdd")
    @JsonDeserialize(using = LocalDateDeserializer.class)
    @JsonSerialize(using = LocalDateSerializer.class)
    private LocalDate entryDate;
}

यदि आपके पास कई लोकलडेट फ़ील्ड के साथ POJO है तो POJO के बजाय मैपर को कॉन्फ़िगर करना बेहतर है। यह https://stackoverflow.com/a/35062824/1282532 जितना सरल हो सकता हैयदि आप ISO-8601 मान ("2019-01-31") का उपयोग कर रहे हैं तो

यदि आपको कस्टम प्रारूप को संभालना है तो कोड इस तरह होगा:

ObjectMapper mapper = new ObjectMapper();
JavaTimeModule javaTimeModule = new JavaTimeModule();
javaTimeModule.addDeserializer(LocalDate.class, new LocalDateDeserializer(DateTimeFormatter.ofPattern("yyyyMMdd")));
javaTimeModule.addSerializer(LocalDate.class, new LocalDateSerializer(DateTimeFormatter.ofPattern("yyyyMMdd")));
mapper.registerModule(javaTimeModule);

तर्क सिर्फ एक बार लिखा गया है, इसे कई POJO के लिए पुन: उपयोग किया जा सकता है


3

अब तक का सबसे सरल और छोटा:

@JsonFormat(pattern = "yyyy-MM-dd")
private LocalDate localDate;

@JsonFormat(pattern = "yyyy-MM-dd HH:mm:ss")
private LocalDateTime localDateTime;

स्प्रिंग बूट> = 2.2+ के साथ कोई निर्भरता आवश्यक नहीं है


1

2020 और जैक्सन 2.10.1 के लिए किसी विशेष कोड की कोई आवश्यकता नहीं है, यह केवल जैक्सन को यह बताने की बात है कि आप क्या चाहते हैं:

ObjectMapper objectMapper = new ObjectMapper();

// Register module that knows how to serialize java.time objects
// Provided by jackson-datatype-jsr310
objectMapper.registerModule(new JavaTimeModule());

// Ask Jackson to serialize dates as String (ISO-8601 by default)
objectMapper.disable(SerializationFeature.WRITE_DATES_AS_TIMESTAMPS);

यह इस उत्तर में पहले ही उल्लेख किया गया है , मैं एक इकाई परीक्षण जोड़ रहा हूं जो कार्यक्षमता की पुष्टि करता है:

import com.fasterxml.jackson.annotation.JsonFormat;
import com.fasterxml.jackson.core.JsonProcessingException;
import com.fasterxml.jackson.databind.ObjectMapper;
import com.fasterxml.jackson.databind.SerializationFeature;
import com.fasterxml.jackson.datatype.jsr310.JavaTimeModule;
import lombok.Data;
import org.junit.jupiter.api.Test;

import java.time.LocalDate;

import static org.junit.jupiter.api.Assertions.assertEquals;

public class LocalDateSerializationTest {

    @Data
    static class TestBean {
        // Accept default ISO-8601 format
        LocalDate birthDate;
        // Use custom format
        @JsonFormat(shape = JsonFormat.Shape.STRING, pattern = "dd/MM/yyyy")
        LocalDate birthDateWithCustomFormat;
    }

    @Test
    void serializeDeserializeTest() throws JsonProcessingException {
        ObjectMapper objectMapper = new ObjectMapper();

        // Register module that knows how to serialize java.time objects
        objectMapper.registerModule(new JavaTimeModule());

        // Ask Jackson to serialize dates as String (ISO-8601 by default)
        objectMapper.disable(SerializationFeature.WRITE_DATES_AS_TIMESTAMPS);

        // The JSON string after serialization
        String json = "{\"birthDate\":\"2000-01-02\",\"birthDateWithCustomFormat\":\"03/02/2001\"}";

        // The object after deserialization
        TestBean object = new TestBean();
        object.setBirthDate(LocalDate.of(2000, 1, 2));
        object.setBirthDateWithCustomFormat(LocalDate.of(2001, 2, 3));

        // Assert serialization
        assertEquals(json, objectMapper.writeValueAsString(object));

        // Assert deserialization
        assertEquals(object, objectMapper.readValue(json, TestBean.class));
    }
}

TestBean सेम के लिए बॉयलरप्लेट उत्पन्न करने के लिए लोम्बोक का उपयोग करता है।


0

विन्यास कक्षा में परिभाषित LocalDateSerializer और LocalDateDeserializer वर्ग और करने के लिए उन्हें रजिस्टर ObjectMapper के माध्यम से JavaTimeModule नीचे की तरह:

@Configuration
public class AppConfig
{
@Bean
    public ObjectMapper objectMapper()
    {
        ObjectMapper mapper = new ObjectMapper();
        mapper.setSerializationInclusion(Include.NON_EMPTY);
        //other mapper configs
        // Customize de-serialization


        JavaTimeModule javaTimeModule = new JavaTimeModule();
        javaTimeModule.addSerializer(LocalDate.class, new LocalDateSerializer());
        javaTimeModule.addDeserializer(LocalDate.class, new LocalDateDeserializer());
        mapper.registerModule(javaTimeModule);

        return mapper;
    }

    public class LocalDateSerializer extends JsonSerializer<LocalDate> {
        @Override
        public void serialize(LocalDate value, JsonGenerator gen, SerializerProvider serializers) throws IOException {
            gen.writeString(value.format(Constant.DATE_TIME_FORMATTER));
        }
    }

    public class LocalDateDeserializer extends JsonDeserializer<LocalDate> {

        @Override
        public LocalDate deserialize(JsonParser p, DeserializationContext ctxt) throws IOException {
            return LocalDate.parse(p.getValueAsString(), Constant.DATE_TIME_FORMATTER);
        }
    }
}

0

यदि आपके अनुरोध में इस तरह की कोई वस्तु है:

{
    "year": 1900,
    "month": 1,
    "day": 20
}

तब आप उपयोग कर सकते हैं:

data class DateObject(
    val day: Int,
    val month: Int,
    val year: Int
)
class LocalDateConverter : StdConverter<DateObject, LocalDate>() {
    override fun convert(value: DateObject): LocalDate {
        return value.run { LocalDate.of(year, month, day) }
    }
}

मैदान के ऊपर:

@JsonDeserialize(converter = LocalDateConverter::class)
val dateOfBirth: LocalDate

कोड कोटलिन में है, लेकिन यह जावा के लिए भी काम करेगा।

हमारी साइट का प्रयोग करके, आप स्वीकार करते हैं कि आपने हमारी Cookie Policy और निजता नीति को पढ़ और समझा लिया है।
Licensed under cc by-sa 3.0 with attribution required.