使用 Jackson 序列化 Date

2025年3月17日 | 阅读11分钟

在 Java 中，Date 是最重要的数据类型之一。当我们使用 REST API 时，我们需要序列化 Date。在本节中，我们将了解如何使用 Jackson 序列化 Date。我们将了解如何序列化以下类型的日期

util.Date
Joda-Time
Java 8 DateTime

让我们一个一个地来理解它们

将 Date 序列化为时间戳

为了序列化 "java.util.Date"，我们借助 Event 类。我们首先使用 SimpleDateFormat 类创建一个日期。之后，我们使用 date 字段创建一个 Event 的实例。现在，我们使用 ObjectMapper 类序列化 Event 实例。

让我们实现上述理论的代码

SerializeDateToTimestamp.java

// import required classes and package if any
import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.util.Date;
import java.util.Scanner;
import java.util.TimeZone;
import com.fasterxml.jackson.core.JsonProcessingException;
import com.fasterxml.jackson.databind.ObjectMapper;

// create class SerializeDateToTimestamp to serialize Date to Timestamp
public class SerializeDateToTimestamp {	
	// main() method start
	public static void main(String args[]) throws ParseException, JsonProcessingException {
		String dateStr;
		// create an instance of Scanner class object
		Scanner sc = new Scanner(System.in);
		System.out.println("Enter Date in dd-MM-yyyy hh:mm:ss format:");
		dateStr = sc.nextLine();
		// create an instance of SimpleDateFormat class
		SimpleDateFormat sdf = new SimpleDateFormat("dd-MM-yyyy hh:mm:ss");
		// set time zone by using setTimeZone() method of SimpleDateFormat class
		sdf.setTimeZone(TimeZone.getTimeZone("UTC"));
		// parse dateStr by using parse() method of SimpleDateFormat
		Date date = sdf.parse(dateStr);
		// create an instance of Event by using data
		Event evt = new Event("New Date", date);
		// create an instance of ObjectMapper class
		ObjectMapper mapper = new ObjectMapper();
		// serialize evt by using writeValueAsString() method
	    	String jsonString = mapper.writeValueAsString(evt);
	    	//print jsonString
	    	System.out.println(jsonString);
	    	// close Scanner class object
	    	sc.close();
	}
}
 // create Event class
class Event{
	public String name;
	public Date data;
	
	// parameterized constructor
	Event(String name, Date data){
		this.name = name;
		this.data = data;
	}
}

输出

将 Date 序列化为 ISO-86o1

就像将 Date 序列化为时间戳一样，我们也可以使用 ObjectMapper 类将 Date 序列化为 ISO-86o1。我们使用 ObjectMapper 类的 setDateFormat() 方法将 Date 序列化为 ISO-86o1。

让我们看一个例子来了解如何使用 ObjectMapper 类进行序列化

SerializeDateToISO.java

//import required classes and package if any
import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.util.Date;
import java.util.Scanner;
import java.util.TimeZone;

import com.fasterxml.jackson.core.JsonProcessingException;
import com.fasterxml.jackson.databind.ObjectMapper;
import com.fasterxml.jackson.databind.SerializationFeature;
import com.fasterxml.jackson.databind.util.StdDateFormat;

//create class SerializeDateToISO to serialize Date to ISO
public class SerializeDateToISO {
	
	// main() method start
	public static void main(String args[]) throws ParseException, JsonProcessingException {
		String dateStr;
		// create an instance of Scanner class object
		Scanner sc = new Scanner(System.in);
		System.out.println("Enter Date in dd-MM-yyyy hh:mm:ss format:");
		dateStr = sc.nextLine();
		
		// create an instance of SimpleDateFormat class
		SimpleDateFormat sdf = new SimpleDateFormat("dd-MM-yyyy hh:mm:ss");
		// set time zone by using setTimeZone() method of SimpleDateFormat class
		sdf.setTimeZone(TimeZone.getTimeZone("UTC"));
		
		// parse dateStr by using parse() method of SimpleDateFormat
		Date date = sdf.parse(dateStr);
		
		// create an instance of Event by using data
		Event evt = new Event("New Date", date);
		
		// create an instance of ObjectMapper class
		ObjectMapper mapper = new ObjectMapper();
		
		//disable WRITE_DATES_AS_TIMESTAMPS feature
		mapper.disable(SerializationFeature.WRITE_DATES_AS_TIMESTAMPS);
	    
		// set StdDateFormat by using setDateFormat() method
	    mapper.setDateFormat(new StdDateFormat().withColonInTimeZone(true));
		
		// serialize evt by using writeValueAsString() method
	    String jsonString = mapper.writeValueAsString(evt);
	    
	    //print jsonString
	    System.out.println(jsonString);
	    
	    // close Scanner class object
	    sc.close();
		
	}
}
// create Event class
class Event{
	public String name;
	public Date data;
	
	// parameterized constructor
	Event(String name, Date data){
		this.name = name;
		this.data = data;
	}
}

输出

配置 ObjectMapper DateFormat

之前的所有 Date 序列化方法仍然缺乏选择表示 java.util.Date 实例的确切格式的完整灵活性。现在，我们执行一些配置，允许我们设置表示日期的格式。

让我们看一个例子来配置 ObjectMapper，允许我们设置 Date 格式。

SerializeDateWithConfiguration.java

//import required classes and package if any
import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.util.Date;
import java.util.Scanner;

import com.fasterxml.jackson.core.JsonProcessingException;
import com.fasterxml.jackson.databind.ObjectMapper;

//create class SerializeDateWithConfiguration to serialize Date with configuration
public class SerializeDateWithConfiguration {
	
	// main() method start
	public static void main(String args[]) throws ParseException, JsonProcessingException {
		
		String dateStr;
		
		// create an instance of Scanner class object
		Scanner sc = new Scanner(System.in);
		
		System.out.println("Enter Date in dd-MM-yyyy hh:mm:ss format:");
		dateStr = sc.nextLine();
		
		// create an instance of SimpleDateFormat class
		SimpleDateFormat sdf = new SimpleDateFormat("dd-MM-yyyy hh:mm:ss");
		
		// parse dateStr by using parse() method of SimpleDateFormat
		Date date = sdf.parse(dateStr);
		
		// create an instance of Event by using data
		Event evt = new Event("New Date", date);
		
		// create an instance of ObjectMapper class
		ObjectMapper mapper = new ObjectMapper();
		
		//configure ObjectMapper class by using setDateFormat() method
		mapper.setDateFormat(sdf);
		
		// serialize evt by using writeValueAsString() method
	    	String jsonString = mapper.writeValueAsString(evt);
	    
	    	//print jsonString
	    	System.out.println(jsonString);
	    
	    	// close Scanner class object
	    	sc.close();
		
	}
}
//create Event class
class Event{
	public String name;
	public Date data;
	
	// parameterized constructor
	Event(String name, Date data){
		this.name = name;
		this.data = data;
	}
}

输出

使用 @JsonFormat 序列化 Date

我们还可以使用 @JsonFormat 注解序列化 Date。我们使用注解来控制各个类上的 Date 格式。因此，当我们不想全局控制日期格式时，我们使用注解。

让我们看一个例子来了解如何使用注解来控制 Date 格式。

SerializeDateWithJsonFormat.java

//import required classes and package if any
import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.util.Date;
import java.util.Scanner;

import com.fasterxml.jackson.annotation.JsonFormat;
import com.fasterxml.jackson.core.JsonProcessingException;
import com.fasterxml.jackson.databind.ObjectMapper;

//create class SerializeDateWithJsonFormat to serialize Date with @JsonFormat annotation
public class SerializeDateWithJsonFormat {
	
	// main() method start
	public static void main(String args[]) throws ParseException, JsonProcessingException {
		
		String dateStr;
		
		// create an instance of Scanner class object
		Scanner sc = new Scanner(System.in);
		
		System.out.println("Enter Date in dd-MM-yyyy hh:mm:ss format:");
		dateStr = sc.nextLine();
		
		// create an instance of SimpleDateFormat class
		SimpleDateFormat sdf = new SimpleDateFormat("dd-MM-yyyy hh:mm:ss");
		
		// parse dateStr by using parse() method of SimpleDateFormat
		Date date = sdf.parse(dateStr);
		
		// create an instance of Event by using data
		Event evt = new Event("New Date", date);
		
		// create an instance of ObjectMapper class
		ObjectMapper mapper = new ObjectMapper();
		
		// serialize evt by using writeValueAsString() method
	    	String jsonString = mapper.writeValueAsString(evt);
	    
	    	//print jsonString
	    	System.out.println(jsonString);
	    
	    	// close Scanner class object
	    	sc.close();
		
	}
}
//create Event class
class Event{
	public String name;
	
	//declare date by using @JsonFormat
	@JsonFormat(shape = JsonFormat.Shape.STRING, pattern = "dd-MM-yyyy hh:mm:ss")
	public Date data;
	
	// parameterized constructor
	Event(String name, Date data){
		this.name = name;
		this.data = data;
	}
}

输出

使用自定义 Date 序列化器序列化 Date

这是序列化 Date 字段的另一种方式。我们定义自定义的 date 序列化器，然后将其与 @JsonSerialize 一起使用。

让我们首先定义 Date 序列化器，然后我们举一个例子，在其中使用我们的自定义 date 序列化器。

CustomDateSerializer.java

// import required classes and package, if any
import java.io.IOException;
import java.text.SimpleDateFormat;
import java.util.Date;

import com.fasterxml.jackson.core.JsonGenerator;
import com.fasterxml.jackson.core.JsonProcessingException;
import com.fasterxml.jackson.databind.SerializerProvider;
import com.fasterxml.jackson.databind.ser.std.StdSerializer;

// create class CustomDateSerializer by extending StdSerializer
public class CustomDateSerializer extends StdSerializer<Date> {
	
	// create an instance of SimpleDateFormat to form date in dd-MM-yyyy hh:mm:ss
	private SimpleDateFormat sdf = new SimpleDateFormat("dd-MM-yyyy");
	
	// default constructor
    	public CustomDateSerializer() {
        	this(null);
    	}
    
    	// parameterized constructor
    	public CustomDateSerializer(Class t) {
        	super(t);
    	}
    
    	// override serialize() method
    	@Override
    	public void serialize (Date value, JsonGenerator generator, SerializerProvider provider) throws IOException, JsonProcessingException {
    		generator.writeString(sdf.format(value));
    	}
}
SerializeDateWithCustomSerializer.java
//import required classes and package if any
import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.util.Date;
import java.util.Scanner;

import com.fasterxml.jackson.core.JsonProcessingException;
import com.fasterxml.jackson.databind.ObjectMapper;
import com.fasterxml.jackson.databind.annotation.JsonSerialize;

//create class SerializeDateWithCustomSerializer to serialize Date with Custom Date Serializer
public class SerializeDateWithCustomSerializer {
	
	// main() method start
	public static void main(String args[]) throws ParseException, JsonProcessingException {
		
		String dateStr;
		
		// create an instance of Scanner class object
		Scanner sc = new Scanner(System.in);
		
		System.out.println("Enter Date in dd-MM-yyyy hh:mm:ss format:");
		dateStr = sc.nextLine();
		
		// create an instance of SimpleDateFormat class
		SimpleDateFormat sdf = new SimpleDateFormat("dd-MM-yyyy hh:mm:ss");
		
		// parse dateStr by using parse() method of SimpleDateFormat
		Date date = sdf.parse(dateStr);
		
		// create an instance of Event by using data
		Event evt = new Event("New Date", date);
		
		// create an instance of ObjectMapper class
		ObjectMapper mapper = new ObjectMapper();
		
		// serialize evt by using writeValueAsString() method
	    	String jsonString = mapper.writeValueAsString(evt);
	    
	    	//print jsonString
	    	System.out.println(jsonString);
	    
	    	// close Scanner class object
	    	sc.close();
		
	}
}
//create Event class
class Event{
	public String name;
	
	//declare date by using @JsonFormat
	@JsonSerialize(using = CustomDateSerializer.class)
	public Date data;
	
	// parameterized constructor
	Event(String name, Date data){
		this.name = name;
		this.data = data;
	}
}

输出

使用 Jackson 序列化 Joda-Time

"java.util.Date" 不是唯一提供 Date 实例的类。日期也可以由其他类表示，例如 Joda-Time 等。DateTime 是 Joda-Time 库中最常见的实现之一。

为了使用 Joda-Time，我们在 POM.xml 文件中添加以下依赖项

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

要序列化 Joda-Time，我们只需将 JodaModule 注册到 ObjectMapper 类

SerializeJodaTimeExample.java

//import required classes and package, if any
import java.text.ParseException;
import java.util.Scanner;

import org.joda.time.DateTime;
import org.joda.time.DateTimeZone;

import com.fasterxml.jackson.core.JsonProcessingException;
import com.fasterxml.jackson.databind.ObjectMapper;
import com.fasterxml.jackson.databind.SerializationFeature;
import com.fasterxml.jackson.datatype.joda.JodaModule;

//create class SerializeJodaTimeExample to serialize Joda-Time
public class SerializeJodaTimeExample {
	
	// main() method start
	public static void main(String args[]) throws ParseException, JsonProcessingException {
		
		String day, month, year, hour, min, sec;
		
		// create an instance of Scanner class object
		Scanner sc = new Scanner(System.in);
		
		System.out.println("Enter Day:");
		day = sc.nextLine();
		
		System.out.println("Enter Month:");
		month = sc.nextLine();
		
		System.out.println("Enter Year:");
		year = sc.nextLine();
		
		System.out.println("Enter Hours:");
		hour = sc.nextLine();
		
		System.out.println("Enter Minutes:");
		min = sc.nextLine();
		
		System.out.println("Enter Seconds:");
		sec = sc.nextLine();
		
		// form Joda-DateTime
		DateTime data = new DateTime(Integer.valueOf(year), Integer.valueOf(month), Integer.valueOf(day), Integer.valueOf(hour), Integer.valueOf(min), Integer.valueOf(sec), DateTimeZone.forID("Europe/London"));
		
		// create an instance of Event by using data
		Event evt = new Event("New Date", data);
		
		// create an instance of ObjectMapper class
		ObjectMapper mapper = new ObjectMapper();
		
		// register JodaModule and disable SerializationFeature
		mapper.registerModule(new JodaModule()).disable(SerializationFeature.WRITE_DATES_AS_TIMESTAMPS);
		
		// serialize evt by using writeValueAsString() method
	    	String jsonString = mapper.writeValueAsString(evt);
	    
	    	//print jsonString
	    	System.out.println(jsonString);
	    
	    	// close Scanner class object
	    	sc.close();
	}
}
//create Event class
class Event{
	public String name;
	public DateTime data;
	
	// parameterized constructor
	Event(String name, DateTime data){
		this.name = name;
		this.data = data;
	}
}

输出

使用自定义序列化器序列化 Joda-Time

就像 "java.util.Date" 一样，我们也可以使用 DateTime 序列化器序列化 Joda-Time。让我们首先创建自定义 DateTime 序列化器，然后我们将使用它来序列化 Joda-DateTime。

CustomDateTimeSerializer.java

//import required classes and package, if any
package javaTpoint.Jackson;

import java.io.IOException;
import java.text.SimpleDateFormat;

import org.joda.time.DateTime;
import org.joda.time.format.DateTimeFormat;
import org.joda.time.format.DateTimeFormatter;

import com.fasterxml.jackson.core.JsonGenerator;
import com.fasterxml.jackson.core.JsonProcessingException;
import com.fasterxml.jackson.databind.SerializerProvider;
import com.fasterxml.jackson.databind.ser.std.StdSerializer;

//create class CustomDateTimeSerializer by extending StdSerializer
public class CustomDateTimeSerializer extends StdSerializer<DateTime> {
	
	// create an instance of DateTimeFormatter
	private static DateTimeFormatter dtf = DateTimeFormat.forPattern("yyyy-MM-dd HH:mm:ss");
	
	// default constructor
	public CustomDateTimeSerializer() {
		this(null);
	}
 
	// parameterized constructor
	public CustomDateTimeSerializer(Class<DateTime> t) {
		super(t);
	}
 
	// override serialize() method
	@Override
	public void serialize (DateTime value, JsonGenerator generator, SerializerProvider provider) throws IOException, JsonProcessingException {
		generator.writeString(dtf.print(value));
	}
}

SerializeJodaTimeWithSerializer.java

//import required classes and package if any
import java.text.ParseException;
import java.util.Scanner;

import org.joda.time.DateTime;
import org.joda.time.DateTimeZone;

import com.fasterxml.jackson.core.JsonProcessingException;
import com.fasterxml.jackson.databind.ObjectMapper;
import com.fasterxml.jackson.databind.SerializationFeature;
import com.fasterxml.jackson.databind.annotation.JsonSerialize;
import com.fasterxml.jackson.datatype.joda.JodaModule;

//create class SerializeJodaTimeWithSerializer to serialize Joda-Time with custom date serializer
public class SerializeJodaTimeWithSerializer {
	
	// main() method start
	public static void main(String args[]) throws ParseException, JsonProcessingException {
		
		String day, month, year, hour, min, sec;
		
		// create an instance of Scanner class object
		Scanner sc = new Scanner(System.in);
		
		System.out.println("Enter Day:");
		day = sc.nextLine();
		
		System.out.println("Enter Month:");
		month = sc.nextLine();
		
		System.out.println("Enter Year:");
		year = sc.nextLine();
		
		System.out.println("Enter Hours:");
		hour = sc.nextLine();
		
		System.out.println("Enter Minutes:");
		min = sc.nextLine();
		
		System.out.println("Enter Seconds:");
		sec = sc.nextLine();
		
		// form Joda-DateTime
		DateTime data = new DateTime(Integer.valueOf(year), Integer.valueOf(month), Integer.valueOf(day), Integer.valueOf(hour), Integer.valueOf(min), Integer.valueOf(sec), DateTimeZone.forID("Europe/London"));
		
		// create an instance of Event by using data
		Event evt = new Event("New Date", data);
		
		// create an instance of ObjectMapper class
		ObjectMapper mapper = new ObjectMapper();
		
		// serialize evt by using writeValueAsString() method
	    	String jsonString = mapper.writeValueAsString(evt);
	    
	    	//print jsonString
	    	System.out.println(jsonString);
	    
	    	// close Scanner class object
	    	sc.close();
		
	}
}
//create Event class
class Event{
	public String name;
	
	@JsonSerialize(using = CustomDateTimeSerializer.class)
	public DateTime data;
	
	// parameterized constructor
	Event(String name, DateTime data){
		this.name = name;
		this.data = data;
	}
}

输出

使用 Jackson 序列化 Java 8 Date

就像 java.util.Date 和 Joda-DateTime 一样，我们也可以使用 Jackson 序列化 Java 8 Date。我们将使用 LocalDateTime 进行序列化，为此，我们在 POM.xml 文件中添加以下依赖项。

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

为了序列化 Java 8 Date，我们将 JavaTimeModule 注册到 ObjectMapper 类。

让我们看一个例子来了解如何使用 Jackson 完成 Java 8 Date 的序列化。

SerializeJava8DateExample.java

//import required classes and package, if any
import java.text.ParseException;
import java.time.LocalDateTime;
import java.util.Scanner;

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;

//create class SerializeJava8DateExample to serialize Java 8 Date
public class SerializeJava8DateExample {
	
	// main() method start
	public static void main(String args[]) throws ParseException, JsonProcessingException {
		
		String day, month, year, hour, min, sec;
		
		// create an instance of Scanner class object
		Scanner sc = new Scanner(System.in);
		
		System.out.println("Enter Day:");
		day = sc.nextLine();
		
		System.out.println("Enter Month:");
		month = sc.nextLine();
		
		System.out.println("Enter Year:");
		year = sc.nextLine();
		
		System.out.println("Enter Hours:");
		hour = sc.nextLine();
		
		System.out.println("Enter Minutes:");
		min = sc.nextLine();
		
		System.out.println("Enter Seconds:");
		sec = sc.nextLine();
		
		// form LocalDateTime
		LocalDateTime data = LocalDateTime.of(Integer.valueOf(year), Integer.valueOf(month), Integer.valueOf(day), Integer.valueOf(hour), Integer.valueOf(min), Integer.valueOf(sec));
		
		// create an instance of Event by using data
		Event evt = new Event("New Date", data);
		
		// create an instance of ObjectMapper class
		ObjectMapper mapper = new ObjectMapper();
		
		// register JavaTimeModule and disable WRITE_DATES_AS_TIMESTAMPS
		mapper.registerModule(new JavaTimeModule()).disable(SerializationFeature.WRITE_DATES_AS_TIMESTAMPS);
		
		// serialize evt by using writeValueAsString() method
	    	String jsonString = mapper.writeValueAsString(evt);
	    
	    	//print jsonString
	    	System.out.println(jsonString);
	    
	    	// close Scanner class object
	    	sc.close();
		
	}
}
//create Event class
class Event{
	public String name;
	public LocalDateTime data;
	
	// parameterized constructor
	Event(String name, LocalDateTime data){
		this.name = name;
		this.data = data;
	}
}

输出

使用自定义序列化器序列化 Java 8 Date

我们还可以使用自定义 LocalDateTime 序列化器序列化 Java 8 Date。就像 java.util.Date 和 Joda-DateTime 一样，我们创建一个自定义序列化器，然后我们在我们的代码中使用它来序列化 Java 中的 LocalDateTime。

CustomLocalDateTimeSerializer.java

//import required classes and package if any
import java.io.IOException;
import java.time.LocalDateTime;
import java.time.format.DateTimeFormatter;

import com.fasterxml.jackson.core.JsonGenerator;
import com.fasterxml.jackson.core.JsonProcessingException;
import com.fasterxml.jackson.databind.SerializerProvider;
import com.fasterxml.jackson.databind.ser.std.StdSerializer;

//create class CustomLocalDateTimeSerializer by extending StdSerializer
public class CustomLocalDateTimeSerializer extends StdSerializer<LocalDateTime> {
	
	// create an instance of DateTimeFormatter
	private static DateTimeFormatter dtf = DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm:ss");
	
	// default constructor
	public CustomLocalDateTimeSerializer() {
		this(null);
	}
 
	// parameterized constructor
	public CustomLocalDateTimeSerializer(Class t) {
		super(t);
	}	
 
	// override serialize() method
	@Override
	public void serialize (LocalDateTime value, JsonGenerator generator, SerializerProvider provider) throws IOException, JsonProcessingException {
		generator.writeString(dtf.format(value));
	}
}

SerializeJava8DateWithCustomSerializer.java

//import required classes and package, if any
package javaTpoint.Jackson;

import java.text.ParseException;
import java.time.LocalDateTime;
import java.util.Scanner;

import com.fasterxml.jackson.core.JsonProcessingException;
import com.fasterxml.jackson.databind.ObjectMapper;
import com.fasterxml.jackson.databind.annotation.JsonSerialize;

//create class SerializeJava8DateWithCustomSerializer to serialize Java 8 Date with custom serializer
public class SerializeJava8DateWithCustomSerializer {
	
	// main() method start
	public static void main(String args[]) throws ParseException, JsonProcessingException {
		
		String day, month, year, hour, min, sec;
		
		// create an instance of Scanner class object
	
	Scanner sc = new Scanner(System.in);
		
		System.out.println("Enter Day:");
		day = sc.nextLine();
		
		System.out.println("Enter Month:");
		month = sc.nextLine();
		
		System.out.println("Enter Year:");
		year = sc.nextLine();
		
		System.out.println("Enter Hours:");
		hour = sc.nextLine();
		
		System.out.println("Enter Minutes:");
		min = sc.nextLine();
		
		System.out.println("Enter Seconds:");
		sec = sc.nextLine();
		
		// form LocalDateTime
		LocalDateTime data = LocalDateTime.of(Integer.valueOf(year), Integer.valueOf(month), Integer.valueOf(day), Integer.valueOf(hour), Integer.valueOf(min), Integer.valueOf(sec));
		
		// create an instance of Event by using data
		Event evt = new Event("New Date", data);
		
		// create an instance of ObjectMapper class
		ObjectMapper mapper = new ObjectMapper();
		
		// serialize evt by using writeValueAsString() method
	    	String jsonString = mapper.writeValueAsString(evt);
	    
	    	//print jsonString
	    	System.out.println(jsonString);
	    
	    	// close Scanner class object
	    	sc.close();
		
	}
}
//create Event class
class Event{
	public String name;
	
	@JsonSerialize(using = CustomLocalDateTimeSerializer.class)
	public LocalDateTime data;
	
	// parameterized constructor
	Event(String name, LocalDateTime data){
		this.name = name;
		this.data = data;
	}
}

输出

下一个主题Jackson JSON Views

使用 Jackson 序列化 Date

将 Date 序列化为时间戳

将 Date 序列化为 ISO-86o1

配置 ObjectMapper DateFormat

使用 @JsonFormat 序列化 Date

使用自定义 Date 序列化器序列化 Date

使用 Jackson 序列化 Joda-Time

使用自定义序列化器序列化 Joda-Time

使用 Jackson 序列化 Java 8 Date

使用自定义序列化器序列化 Java 8 Date

联系信息

关注我们

教程

面试题

在线编译器

Python

Java

.Net Framework

AI, ML and Data Science

Cloud Technology

B.Tech and MCA

Web Technology

PHP

Software Testing

Technical Interview

Java Interview

Python

Web Interview

Database Interview

B.Tech / MCA

Important Interview

Software Testing Interview

Company Interviews

Online Compilers

Multiple Choice Questions

Jackson 教程

Jackson 注解

序列化/反序列化

高级编组

使用 Jackson 序列化 Date

将 Date 序列化为时间戳

将 Date 序列化为 ISO-86o1

配置 ObjectMapper DateFormat

使用 @JsonFormat 序列化 Date

使用自定义 Date 序列化器序列化 Date

使用 Jackson 序列化 Joda-Time

使用自定义序列化器序列化 Joda-Time

使用 Jackson 序列化 Java 8 Date

使用自定义序列化器序列化 Java 8 Date

相关帖子

基于自定义标准序列化字段

使用 Jackson 比较 JSON 对象

Map 序列化和反序列化

序列化和反序列化枚举

将布尔值序列化和反序列化为整数

Jackson JSON 视图

反序列化为集合和数组

订阅 Tpoint Tech

联系信息

关注我们

教程

面试题

在线编译器