使用 Jackson 序列化和反序列化枚举

2025年03月17日 | 阅读 9 分钟

在本节中，我们将了解如何使用 Jackson 2 序列化和反序列化Java 枚举。在 Java 中，枚举是一组用于定义类类型的命名常量。就像 Java 类一样，Java 枚举也可以有方法、构造函数和实例变量。 Java 枚举是通过使用 enum 关键字创建的。

控制枚举表示

让我们使用 enum 关键字并了解我们如何定义枚举

Shape.Java

enum Shape {
	Circle,
    	Square,
    	Triangle;
 
    	// enum constructor for each constant
    	private Shape() {
        	System.out.println("Constructor called for shape : "+ this.toString());
    	}

	// enum method
	public void shapeInfo() {
        	System.out.println("Universal Shape");
    	}
}

Distance.Java

public enum Distance {
	KILOMETER("km", 1000), 
    	MILE("miles", 1609.34),
    	METER("meters", 1), 
    	INCH("inches", 0.0254),
    	CENTIMETER("cm", 0.01), 
    	MILLIMETER("mm", 0.001);
	
    	private String unit;
    	private final double meters;
	
    	private Distance(String unit, double meters) {
        		this.unit = unit;
        		this.meters = meters;
    	}
    	// standard getters and setters
}

将枚举序列化为 JSON

为了序列化 Enum，我们借助 ObjectMapper 类。我们使用 ObjectMapper 类的 writeValueAsString() 方法来序列化 Enum。如果我们使用 writeValueAsString() 方法序列化 Enum，它将 Java 枚举表示为简单的字符串。

SerializeEnumExample1.java

// import required classes and package if any
import java.util.Scanner;
import com.fasterxml.jackson.core.JsonProcessingException;
import com.fasterxml.jackson.databind.ObjectMapper;
// create class SerializeEnumExample1 to serialize Enum with jackson
public class SerializeEnumExample1 {
	// main() method start
	public static void main(String args[]) throws JsonProcessingException {
		// create instance variable
		String enumStr, jsonString;
		// Create scanner class object 
		Scanner sc = new Scanner(System.in);
		// create an instance of ObjectMapper class
		ObjectMapper mapper = new ObjectMapper();
		System.out.println("Enter Enum to serialize.");
		enumStr = sc.nextLine();
		if(enumStr.equals("KILOMETER")) {
			// serialize Enum KILOMETER
			jsonString = mapper.writeValueAsString(Distance.KILOMETER);
		} else if(enumStr.equals("MILE")) {
			// serialize Enum MILE
			jsonString = mapper.writeValueAsString(Distance.MILE);
		} else if(enumStr.equals("METER")) {
			// serialize Enum METER
			jsonString = mapper.writeValueAsString(Distance.METER);
		} else if(enumStr.equals("INCH")) {
			// serialize Enum INCH
			jsonString = mapper.writeValueAsString(Distance.INCH);
		} else if(enumStr.equals("CENTIMETER")) {
			// serialize Enum CENTIMETER
			jsonString = mapper.writeValueAsString(Distance.CENTIMETER);
		} else if(enumStr.equals("MILLIMETER")) {
			// serialize Enum MILLIMETER
			jsonString = mapper.writeValueAsString(Distance.MILLIMETER);
		} else {
			// serialize Enum UNKNOWN
			jsonString = mapper.writeValueAsString(Distance.UNKNOWN);
		}
		
		// close Scanner class object
		sc.close();
		
		System.out.println("Serialize Enum=====>"+jsonString);
		
	}
	
}

输出

Serialize and Deserialize Enums with Jackson

但是，如果我们将 Enum 编组为 JSON 对象，它将 Enum 表示为正确的 JSON 字符串。我们只需要通过使用 @JsonFormat 并以以下方式将字段设为 public 来更改 Distance.java

Distance.java

import com.fasterxml.jackson.annotation.JsonFormat;

@JsonFormat(shape = JsonFormat.Shape.OBJECT)
public enum Distance {
	KILOMETER("km", 1000), 
    	MILE("miles", 1609.34),
    	METER("meters", 1), 
    	INCH("inches", 0.0254),
    	CENTIMETER("cm", 0.01), 
    	MILLIMETER("mm", 0.001),
	UNKNOWN("unkown", 0);
	
    	public String unit;
    	public final double meters;
    
    	private Distance(String unit, double meters) {
    		this.unit = unit;
    		this.meters = meters;
    	}
    	// standard getters and setters
}

现在，如果我们运行 SerializeEnumExample1.java 类，它将结果表示为以下 JSON 字符串格式

输出

枚举和 @JsonValue

通过使用 @JsonValue 注解，我们还可以控制枚举的编组输出。我们只需在 getter 函数上添加 @JsonValue 注解。在我们的 Distance.java 类中，我们通过使用 @JsonValue 注解添加一个 getter 方法。让我们看看更新后的 Distance.java 类

Distance.java

import com.fasterxml.jackson.annotation.JsonValue;
public enum Distance {
	KILOMETER("km", 1000), 
    	MILE("miles", 1609.34),
    	METER("meters", 1), 
    	INCH("inches", 0.0254),
    	CENTIMETER("cm", 0.01), 
    	MILLIMETER("mm", 0.001),
	UNKNOWN("unkown", 0);
	
    public String unit;
    public final double meters;
    
    private Distance(String unit, double meters) {
    	this.unit = unit;
    	this.meters = meters;
    }
    // standard getters and setters
    
    @JsonValue
    public double getEnumValue() {
    	return meters;
    }
}

现在，如果我们运行 SerializeEnumExample1.java 类，它将结果表示为以下格式

输出

枚举的自定义序列化器

自定义序列化器 是控制枚举编组输出的另一种方式。当我们使用旧版本的 Jackson 或者我们需要对枚举进行更多自定义时，我们会使用自定义序列化器。

首先让我们为 Distance 枚举创建自定义序列化器

DistanceCustomSerializer.java

import java.io.IOException;
import com.fasterxml.jackson.core.JsonGenerator;
import com.fasterxml.jackson.databind.JsonSerializer;
import com.fasterxml.jackson.databind.SerializerProvider;

public class DistanceCustomSerializer extends JsonSerializer<Distance> {
@Override
	public void serialize(Distance obj, JsonGenerator gen, SerializerProvider provider) throws IOException {
    	
    		// form JSON using JsonGenerator
    		// writeFieldName() method is used to set the field name
    		// writeString() and writeNumber() methods are used to write String and Number values
		gen.writeStartObject();
		gen.writeFieldName("name");
		gen.writeString(obj.name());
		// check name of the field
		if(obj.name().equals("UNKOWN")) {
			gen.writeFieldName("unknown");
			gen.writeNumber(0);
		} else {
			gen.writeFieldName("unit");
			gen.writeString(obj.getUnitValue());
			gen.writeFieldName("meters");
			gen.writeNumber(obj.getMeterValue());
		}
		gen.writeEndObject();
	}
}

现在，我们通过使用 @JsonSerialize 注解，使用 DistanceCustomSerializer 修改 Distance.java 类。让我们看看更新后的 Distance.java 类。

Distance.java

// import required classes and package if any
import com.fasterxml.jackson.annotation.JsonValue;
import com.fasterxml.jackson.databind.annotation.JsonSerialize;

// use @JsonSerialize annotation to use DistanceCustomSerializer
@JsonSerialize(using = DistanceCustomSerializer.class)
public enum Distance {
	KILOMETER("km", 1000), 
	CENTIMETER("cm", 0.01), 
    	INCH("inches", 0.0254),
    	MILE("miles", 1609.34),
    	MILLIMETER("mm", 0.001),
    	METER("meters", 1), 
    	UNKNOWN("unkown", 0);
	
    	// instance variables
	public String unit;
    	public final double meters;
    
    	// parameterized constructors
    	private Distance(String unit, double meters) {
    		this.unit = unit;
    		this.meters = meters;
    	}
    
    	// standard getters and setters
    	@JsonValue
    	public double getMeterValue() {
    		return meters;
    	}
    	@JsonValue
    	public String getUnitValue() {
    		return unit;
    	}
}

现在，如果我们运行 SerializeEnumExample1.java 类，它将结果表示为以下格式

输出

将 JSON 反序列化为枚举

首先让我们了解 Jackson 的默认行为。默认情况下，Jackson 使用枚举名称从 JSON 反序列化。

我们有以下 JSON 字符串要反序列化

现在，我们将上面的字符串反序列化为 Distance.INCH 对象。

让我们通过一个例子来了解反序列化是如何完成的。

Distance.java

// import required classes and package if any
// create Enum Distance
public enum Distance {
	KILOMETER("km", 1000), 
	CENTIMETER("cm", 0.01), 
    	INCH("inches", 0.0254),
    	MILE("miles", 1609.34),
    	MILLIMETER("mm", 0.001),
    	METER("meters", 1), 
    	UNKNOWN("unkown", 0);
	
    	// instance variables
	public String unit;
    	public final double meters;
    
    	// parameterized constructors
    	private Distance(String unit, double meters) {
    		this.unit = unit;
    		this.meters = meters;
    	}
}

DeserializeEnumExample1.java

//import required classes and package, if any

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

// create class DeserializeEnumExample1 to deserialize JSON to Enum
public class DeserializeEnumExample1 {
	// main() method start
	public static void main(String args[]) throws JsonMappingException, JsonProcessingException {
		
		// jsons string to deserialize
		String jsonString = "{\"distance\":\"INCH\"}";
		
		// create an instance of the ObjectMapper class
		ObjectMapper mapper = new ObjectMapper();
	
		//  deserialize jsonString by using readValue() method of ObjectMapper class
		City obj = mapper.readValue(jsonString, City.class);
		
		// print distance of the City
		System.out.println("Distance of the City: "+ obj.getDistance());
	}	
}
// create class city having a member of type Distance
class City{
	//class variable
	Distance distance;
	// getter/ setters
	public Distance getDistance() {
		return distance;
	}
}

输出

使用 @JsonValue 注解将 JSON 字符串反序列化为枚举

@JsonValue 注解是我们可用于序列化和反序列化枚举的注解之一。枚举值是常量，因此，@JsonValue 注解可用于两者。

首先，我们通过使用 @JsonValue 注解将 getter 方法添加到我们的 Distance.java。

Distance.java

// import required classes and package if any
import com.fasterxml.jackson.annotation.JsonValue;
// create enum Distance by using enum keyword
public enum Distance {
	KILOMETER("km", 1000),
    	METER("meters", 1), 
    	MILLIMETER("mm", 0.001), 
    	INCH("inches", 0.0254),
    	CENTIMETER("cm", 0.01), 
    	MILE("miles", 1609.34),
	UNKNOWN("unkown", 0);
	// instance variable
    	public String unit;
   	public final double meters;
	//parameterized constructor
    	private Distance(String unit, double meters) {
    		this.unit = unit;
    		this.meters = meters;
    	}
    	// getter method annotated with @JsonValue
    	@JsonValue
   	public double getEnumValue() {
    		return meters;
    	}
}

我们有以下 JSON 字符串要反序列化

现在，我们将上面的字符串反序列化为 Distance.INCH 对象。

让我们通过一个例子来了解反序列化是如何完成的。

DeserializeEnumExample2.java

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

// create class DeserializeEnumExample2 to deserialize JSON to Enum
public class DeserializeEnumExample2 {	
	// main() method start
	public static void main(String args[]) throws JsonMappingException, JsonProcessingException {
		// jsons string to deserialize
		String jsonString = "{\"distance\":\"0.0254\"}";
		// create an instance of the ObjectMapper class
		ObjectMapper mapper = new ObjectMapper();
		//  deserialize jsonString by using readValue() method of ObjectMapper class
		City obj = mapper.readValue(jsonString, City.class);
		// print distance of the City
		System.out.println("Distance of the City: "+ obj.getDistance());
	}
}
// create class city having a member of type Distance
class City{
	
	//class variable
	Distance distance;
	
	// getter/ setters
	public Distance getDistance() {
		return distance;
	}
}

输出

使用 @JsonProperty 注解将 JSON 字符串反序列化为枚举

将 JSON 字符串反序列化为枚举的另一种方法是使用 @JsonProperty 注解。为了反序列化 JSON 字符串，我们以以下方式在枚举实例上使用 @JsonProperty 注解

Distance.java

// import required classes and package, if any
import com.fasterxml.jackson.annotation.JsonProperty;
import com.fasterxml.jackson.annotation.JsonValue;

//create enum Distance by using enum keyword
public enum Distance {
	@JsonProperty("KM-Distance")
	KILOMETER("km", 1000),
	@JsonProperty("Meter-Distance")
 	METER("meters", 1), 
 	@JsonProperty("Mili-Meter-Distance")
 	MILLIMETER("mm", 0.001), 
 	@JsonProperty("Inch-Distance")
 	INCH("inches", 0.0254),
 	@JsonProperty("CM-Distance")
 	CENTIMETER("cm", 0.01), 
 	@JsonProperty("Mile-Distance")
 	MILE("miles", 1609.34),
 	@JsonProperty("Unkown-Distance")
	UNKNOWN("unkown", 0);
	
	// instance variable
 	public String unit;
	public final double meters;

	//parameterized constructor
 	private Distance(String unit, double meters) {
 		this.unit = unit;
 		this.meters = meters;
 	}
 	// getter method annotated with @JsonValue
}

DeserializeEnumExample3.java

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

// create class DeserializeEnumExample3 to deserialize JSON to Enum
public class DeserializeEnumExample3 {
	
	// main() method start
	public static void main(String args[]) throws JsonMappingException, JsonProcessingException {
		
		// jsons string to deserialize
		String jsonString = "{\"distance\": \"Mili-Meter-Distance\"}";
		
		// create an instance of the ObjectMapper class
		ObjectMapper mapper = new ObjectMapper();
	
		//deserialize jsonString by using readValue() method of ObjectMapper class
		City obj = mapper.readValue(jsonString, City.class);
		
		// print distance of the City
		System.out.println("Distance of the City: "+ obj.getDistance());
	}
}

// create class city having a member of type Distance
class City{
	
	//class variable
	Distance distance;
	
	// getter/ setters
	public Distance getDistance() {
		return distance;
	}
}

输出

使用 @JsonCreator 注解将 JSON 字符串反序列化为枚举

@JsonCreator 是我们可用于反序列化枚举的另一个注解。所有由 @JsonCreator 注解的方法都由 Jackson 调用，以获取封闭类的实例。为了通过使用 @JsonCreator 将 JSON 字符串反序列化为枚举，我们将定义带有 @JsonCreator 注解的 forValues() 工厂方法。

Distance.java

// import required classes and package if any
import com.fasterxml.jackson.annotation.JsonCreator;
import com.fasterxml.jackson.annotation.JsonProperty;
//create enum Distance by using enum keyword
public enum Distance {
	KILOMETER("km", 1000),
 	METER("meters", 1), 
 	MILLIMETER("mm", 0.001), 
 	INCH("inches", 0.0254),
 	CENTIMETER("cm", 0.01), 
 	MILE("miles", 1609.34),
	UNKNOWN("unkown", 0);
	
	// instance variable
 	public String unit;
	public final double meters;
	
	//parameterized constructor
 	private Distance(String unit, double meters) {
 		this.unit = unit;
 		this.meters = meters;
 	}
 	// define the forValues() factory method with the @JsonCreator annotation
 	@JsonCreator
    	public static Distance forValues(@JsonProperty("unit") String unit, @JsonProperty("meters") double meters) {
        // iterate values of distance
 		for (Distance distance : Distance.values()) {
 			//condition to compare unit and meters
            		if (distance.unit.equals(unit) && Double.compare(distance.meters, meters) == 0) {
            			//return distance if condition match
               	 		return distance;
            		}
        	}
        	return null;
    	}
 	// getter method annotated with @JsonValue
}

我们有以下 JSON 字符串要反序列化

{
    "distance": {
        "unit":"miles", 
        "meters":1609.34
    }
}

现在，我们将上面的字符串反序列化为 Distance.INCH 对象。

让我们通过一个例子来了解反序列化是如何完成的。

DeserializeEnumExample4.java

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

// create class DeserializeEnumExample4 to deserialize JSON to Enum
public class DeserializeEnumExample4 {
	// main() method start
	public static void main(String args[]) throws JsonMappingException, JsonProcessingException {
		
		// jsons string to deserialize
		String jsonString = "{\"distance\": {\"unit\":\"inches\",\"meters\":0.0254}}";
		
		// create an instance of the ObjectMapper class
		ObjectMapper mapper = new ObjectMapper();
	
		//deserialize jsonString by using readValue() method of ObjectMapper class
		City obj = mapper.readValue(jsonString, City.class);
		
		// print distance of the City
		System.out.println("Distance of the City: "+ obj.getDistance());
	}
}

// create class city having a member of type Distance
class City{
	
	//class variable
	Distance distance;
	
	// getter/ setters
	public Distance getDistance() {
		return distance;
	}
}

输出

使用自定义反序列化器将 JSON 字符串反序列化为枚举

这是将 JSON 字符串反序列化为枚举的最后一种方法，当上述讨论的技术未能反序列化 JSON 字符串时，我们会使用这种方法。

当我们使用旧版本的 Jackson 或我们无法访问 Enum 时，我们会使用自定义反序列化器。

我们使用自定义反序列化器反序列化以下 JSON 字符串

{
    "distance": {
        "unit":"miles", 
        "meters":1609.34
    }
}

DistanceCustomDeserializer.java

import java.io.IOException;
import com.fasterxml.jackson.core.JsonParser;
import com.fasterxml.jackson.core.JsonProcessingException;
import com.fasterxml.jackson.databind.DeserializationContext;
import com.fasterxml.jackson.databind.JsonDeserializer;
import com.fasterxml.jackson.databind.JsonNode;

public class DistanceCustomDeserializer extends JsonDeserializer<Distance> {
    @Override
    public Distance deserialize(JsonParser jsonParser, DeserializationContext ctxt) throws IOException, JsonProcessingException {
        
    	// read data as JsonNode
    	JsonNode node = jsonParser.getCodec().readTree(jsonParser);

    	// get unit value as text and store in a variable
        String unit = node.get("unit").asText();
        
        // get unit value as text and store in a variable
        double meters = node.get("meters").asDouble();
        
        //iterate all the values of Distance 
        for (Distance distance : Distance.values()) {
           
        	// compare unit and meter values
            	if (distance.getUnitValue().equals(unit) && Double.compare(distance.getMeterValue(), meters) == 0) {
                	// return distance id comparison done successfully
            		return distance;
            	}
        }
        return null;
    }
}

现在，如果我们运行 DeserializeEnumExample4.java 类，它将结果表示为以下 JSON 字符串格式

输出

下一个主题使用 Jackson 序列化日期

← 上一个下一个 →

使用 Jackson 序列化和反序列化枚举

控制枚举表示

将枚举序列化为 JSON

枚举和 @JsonValue

枚举的自定义序列化器

将 JSON 反序列化为枚举

使用 @JsonValue 注解将 JSON 字符串反序列化为枚举

使用 @JsonProperty 注解将 JSON 字符串反序列化为枚举

使用 @JsonCreator 注解将 JSON 字符串反序列化为枚举

使用自定义反序列化器将 JSON 字符串反序列化为枚举

联系信息

关注我们

教程

面试题

在线编译器

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 序列化和反序列化枚举

控制枚举表示

将枚举序列化为 JSON

枚举和 @JsonValue

枚举的自定义序列化器

将 JSON 反序列化为枚举

使用 @JsonValue 注解将 JSON 字符串反序列化为枚举

使用 @JsonProperty 注解将 JSON 字符串反序列化为枚举

使用 @JsonCreator 注解将 JSON 字符串反序列化为枚举

使用自定义反序列化器将 JSON 字符串反序列化为枚举

相关帖子

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

使用 Jackson 比较 JSON 对象

Jackson 日期

反序列化为集合和数组

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

Map 序列化和反序列化

Jackson JSON 视图

订阅 Tpoint Tech

联系信息

关注我们

教程

面试题

在线编译器