Jackson 中的 ObjectMapper 类

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

ObjectMapper 是 Jackson 库中最重要的类之一。它用于读写 JSON 数据。它负责从 POJO 文件读取数据或向 POJO 文件写入数据，以及与 JSON 树模型进行交互。

ObjectMapper 类具有以下特点：

它支持 **多态** 和 **对象识别** 等高级概念。
它高度可定制，可以处理不同风格的 JSON 内容。
它充当高级 ObjectReader 和 ObjectWriter 类的工厂。

ObjectMapper 类声明如下：

public class ObjectMapper extends ObjectCodec implements Versioned, Serializable

嵌套类

下表定义了扩展 ObjectMapper 类或可以称之为 ObjectMapper 类嵌套的类。

Class	描述
DefaultTypeResolverBuilder	这是一个自定义的 TypeResolverBuilder 类，用于获取我们可以与 “默认类型” 一起使用的类型解析器构建器。
DefaultTyping	为了指定类型种类，枚举与 enableDefaultTyping() 方法一起使用。

现在，让我们来理解 ObjectMapper 类的字段、构造函数和方法。

ObjectMapper 类的字段

protected DefaultDeserializationContext _deserializationContext

这是一个蓝图上下文对象，用于允许自定义子类。

protected DeserializationConfig _deserializationConfig

这是一个配置对象，用于定义反序列化过程的基本全局设置。

protected JsonFactory jsonFactory

JsonFactory 用于创建 JsonParser 和 JsonGenerator 的实例。

protected InjectableValues _injectableValues

这是一个提供程序，用于将值注入到反序列化的 POJO 中。

protected ConfigOverrides _propertyOverrides

用于访问当前活动的每种配置覆盖。

protected SimpleMixInResolver _mixIns

这是一个映射，用于定义应用 mix-in 注解的方式。映射如下：

键：接收附加注解的类型。

值：包含要“混合”的注解的类型。

protected Set<Object> _registeredModuleTypes

这是一个 Set，用于定义已注册的模块类型的集合。

protected SerializationConfig _serializationConfig

这也是一个配置对象，用于定义序列化过程的基本全局设置。

protected ConcurrentHashMap<JavaType,JsonDeserializer<Object>> _rootDeserializers

这是一个 Map，用于跟踪根级反序列化器。它是一个主级 Map。

protected SerializerFactory _serializerFactory

这是一个用于构造序列化器的工厂。

protected SubtypeResolver _subtypeResolver

用于根据需要注册子类型并为父/子类型解决它们。

protected TypeFactory _typeFactory

这是一个用于创建 JavaType 实例的工厂。它们是允许模块添加更多自定义类型处理所必需的。

protected DefaultSerializerProvider _serializerProvider

这是一个负责管理用于序列化的序列化器访问的对象。

protected static BaseSettings DEFAULT_BASE

这是基础设置，包含所有 ObjectMapper 实例的默认值。

ObjectMapper 类的构造函数

ObjectMapper 类有以下构造函数：

构造函数	描述
ObjectMapper()	这是一个默认构造函数，用于构造一个使用默认 JsonFactory、SerializerProvider 和 BeanSerializerFactory 的实例。
ObjectMapper(JsonFactory factory )	用于构造一个使用给定 JsonFactory 的实例。给定的 JsonFactory 用于构造 JsonParsers 和/或 JsonGenerators。
ObjectMapper(JsonFactory factory, SerializerProvider provider1, DeserializerProvider provider2)	用于构造一个使用给定的 JsonFactory、SerializerProvider 和 DeserializerProvider 的实例。给定的 JsonFactory 用于构造 JsonParsers 和/或 JsonGenerators。
protected ObjectMapper(ObjectMapper mapper)	这是一个拷贝构造函数，用于支持 copy() 方法。

ObjectMapper 类的方法

ObjectMapper 类定义了以下方法：

方法	返回值	描述
_checkInvalidCopy(Class<?> exp)	void	用于检查无效的拷贝。
_configAndWriteValue(JsonGenerator g, Object value)	void	用于在必要时配置生成器，然后执行写入功能。
_convert(Object fromValue, JavaType toValueType)	Object	用于获取实际的转换实现。此处，不使用读写方法。
_initForReading(JsonParser p)	JsonToken	用于确保给定的解析器是否已准备好读取数据绑定内容。
_findRootDeserializer(DeserializationContext ctxt, JavaType valueType)	JsonDeserializer<Object>	如果我们要查找传递的根级别值的反序列化器，则使用此方法。
_newReader(DeserializationConfig config) 类似的方法 _newReader(DeserializationConfig config, JavaType valueType, Object valueToUpdate, FormatSchema schema, InjectableValues injectableValues)	ObjectReader	这是一个工厂方法，即用于获取 ObjectReader 实例的适当子类型。为了使用此方法，子类必须覆盖它。
_newWriter(SerializationConfig config) 类似的方法 _newWriter(SerializationConfig config, FormatSchema schema) _newWriter(SerializationConfig config, JavaType rootType, PrettyPrinter pp)	ObjectWriter	这是一个工厂方法，即用于获取 ObjectWriter 实例的适当子类型。为了使用此方法，子类必须覆盖它。
_readValue(DeserializationConfig cfg, JsonParser p, JavaType valueType)	Object	用于获取定义值读取和绑定操作的对象。
_serializerProvider(SerializationConfig config)	DefaultSerializerProvider	这是一个可覆盖的辅助方法，用于构造 SerializerProvider。
acceptJsonFormatVisitor(Class<?> type, JsonFormatVisitorWrapper visitor) 类似的方法 acceptJsonFormatVisitor(JavaType type, JsonFormatVisitorWrapper visitor)	void void	如果我们想使用指定的访问器访问特定类型的类型层次结构，则使用此方法。
addHandler(DeserializationProblemHandler h)	ObjectMapper	为了处理反序列化过程中发生的特定问题，我们使用指定的 DeserializationProblemHandler，并使用此方法添加处理程序。
addMixIn(Class<?> target, Class<?> mixinSource)	ObjectMapper	为了使用 mix-in 注解来指定增强类或接口，我们使用此方法来添加它。
canDeserialize(JavaType type)	Boolean	用于检查映射器是否可以反序列化指定类型的对象。
canDeserialize(JavaType type, AtomicReference<Throwable> cause)	Boolean	与前一个方法类似。唯一的区别是它可以返回在构造序列化器时抛出的可抛出对象。可抛出对象可用于确定实际问题。
canSerialize(Class<?> type)	Boolean	用于检查映射器是否可以序列化指定类型的对象。
canSerialize(Class<?> type, AtomicReference<Throwable> cause)	Boolean	与前一个方法类似。唯一的区别是它可以返回在构造序列化器时抛出的可抛出对象。可抛出对象可用于确定实际问题。
clearProblemHandlers()	ObjectMapper	这是用于从映射器中删除所有已注册的 DeserializationProblemHandlers 实例的方法之一。
configure(DeserializationFeature f, boolean state) 类似的方法 configure(JsonGenerator.Feature f, boolean state) configure(JsonParser.Feature f, boolean state) configure(MapperFeature f, boolean state) configure(SerializationFeature f, boolean state)	ObjectMapper	用于更改 ObjectMapper、生成器实例、解析器实例、映射器实例或 ObjectMapper 的反序列化、Json Generator、JsonParser、Mapper 或 Serialization 功能的开启/关闭状态。
constructType(Type t)	JavaType	如果我们想在没有显式上下文的情况下从给定类型构造 JavaType，则使用此方法。
convertValue(Object fromValue, ClasstoValueType) 类似的方法 convertValue(Object fromValue, JavaType toValueType)	T	如果我们想执行两步转换，将给定值转换为给定值类型的实例，则使用 converValue() 方法。
createArrayNode()	ArrayNode	用于创建 ArrayNode。
defaultClassIntrospector()	ClassIntrospector	如果我们想使用默认的 ClassIntrospector，则使用此可覆盖的辅助方法来构造它。
disable(DeserializationFeature feature) 类似的方法 disable(DeserializationFeature first, DeserializationFeature... f) disable(JsonGenerator.Feature... features) disable(JsonParser.Feature... features) disable(MapperFeature... f) disable(SerializationFeature f) disable(SerializationFeature first, SerializationFeature... f)	ObjectMapper	用于禁用给定反序列化配置、解析器实例的 JsonGenerator 特性、对象映射器的解析器实例的 JsonParser 特性。
disableDefaultTyping()	ObjectMapper	很多时候，我们需要禁用类型信息的自动包含，为此，我们使用此方法。
enable(DeserializationFeature feature) enable(DeserializationFeature first, DeserializationFeature... f) enable(JsonGenerator.Feature... features) enable(JsonParser.Feature... features) enable(MapperFeature... f) enable(SerializationFeature f) enable(SerializationFeature first, SerializationFeature... f)	ObjectMapper	用于启用给定反序列化配置、解析器实例的 JsonGenerator 特性、对象映射器的解析器实例的 JsonParser 特性。
enableDefaultTyping() 类似的方法 enableDefaultTyping(ObjectMapper.DefaultTyping dti) enableDefaultTyping(ObjectMapper.DefaultTyping applicability, JsonTypeInfo.As includeAs) enableDefaultTypingAsProperty(ObjectMapper.DefaultTyping applicability, String propertyName)	ObjectMapper	为了反序列化多态类型时使用类型信息的自动包含，我们使用此方法来启用它。
findAndRegisterModules()	ObjectMapper	这类似于 mapper.registerModules(mapper.findModules()) 方法。
findModules() 类似的方法 findModules(ClassLoader classLoader)	List<Module>	用于定位可用的模块。该方法使用模块提供的 SPI 来使用 JDK ServiceLoader 机制。
getDateFormat()	DateFormat	用于获取日期的格式。
getDeserializationConfig()	DeserializationConfig	用于获取共享的默认 DeserializationConfig 对象。返回的对象定义了反序列化的配置设置。
getDeserializationContext()	DeserializationContext	用于获取当前的 DeserializationContext。
getFactory()	JsonFactory	如果映射器需要构造 Json 解析器和生成器，它需要 json 工厂，并且为了获取它，我们使用 getFactory() 方法。
getInjectableValues()	InjectableValues	用于获取可注入的值。
getJsonFactory()	JsonFactory	这是一个已弃用的获取 Json 工厂的方法。
getNodeFactory()	JsonNodeFactory	用于获取映射器在直接构造树的根 JsonNode 实例时使用的 JsonNodeFactory。
getPropertyNamingStrategy()	PropertyNamingStrategy	顾名思义，它用于属性的命名策略。
getSerializationConfig()	SerializationConfig	用于获取共享的默认 SerializationConfig 对象。返回的对象定义了序列化的配置设置。
getSerializerFactory()	SerializerFactory	用于获取当前的 SerializerFactory。
getSerializerProvider()	SerializerProvider	这是一个工厂的访问器，用于通过调用 DefaultSerializerProvider.createInstance(SerializationConfig, SerializerFactory) 来创建实例。
getSerializerProviderInstance()	SerializerProvider	这是一个访问器，用于构造并返回一个 SerializerProvider 实例，我们可以使用它来访问序列化器。
getSubtypeResolver()	SubtypeResolver	用于访问正在使用的子类型解析器。
getTypeFactory()	TypeFactory	这是一个访问器，用于获取当前配置的 TypeFactory 实例。
getVisibilityChecker()	VisibilityChecker<?>	用于访问当前配置的可视性检查器。
isEnabled(DeserializationFeature f) 类似的方法 isEnabled(JsonFactory.Feature f) isEnabled(JsonGenerator.Feature f) isEnabled(JsonParser.Feature f) isEnabled(MapperFeature f) isEnabled(SerializationFeature f)	Boolean	isEnabled() 方法及其变体用于检查给定的反序列化特定、JsonFactory、JsonGenerator、JsonParser、Mapper 或 Serialization 功能是否已启用。
mixInCount()	int	用于获取 mixIn 的计数。
reader() 类似的方法 reader(Base64Variant defaultBase64) reader(Class<?> type) reader(ContextAttributes attrs) reader(DeserializationFeature feature) reader(DeserializationFeature first, DeserializationFeature... other) reader(FormatSchema schema) reader(InjectableValues injectableValues) reader(JavaType type) reader(JsonNodeFactory f) reader(TypeReference<?> type)	ObjectReader	reader() 方法及其变体是用于构造 ObjectReader 实例的工厂方法。根据需要，我们可以传递 Base64 编码变体用于 Base64 编码的二进制数据、默认属性、启用的功能、可注入的值、用于构造 JSON 树的 JsonNodeFactory。
readerFor(Class<?> type)	ObjectReader	这是一个工厂方法，用于构造 ObjectReader，允许对指定类型的实例进行读写操作。
readerFor(JavaType type)	ObjectReader	这是一个工厂方法，用于构造 ObjectReader，允许对指定 JavaType 的实例进行读写操作。
readerFor(TypeReference<?> type)	ObjectReader	这是一个工厂方法，用于构造 ObjectReader，允许对给定的 TypeReference 实例进行读写操作。
readerForUpdating(Object valueToUpdate)	ObjectReader	这是一个工厂方法，用于构造 ObjectReader，允许对给定对象进行更新操作。
readerWithView(Class<?> view)	ObjectReader	这是一个工厂方法，用于构造 ObjectReader，允许对具有给定 JSON 视图的对象进行反序列化。
readTree(byte[] content) readTree(File file) readTree(InputStream in) readTree(JsonParser p) readTree(Reader r) readTree(String content) readTree(URL source)	JsonNode 或 <T extends TreeNode> T	readTree() 方法及其变体用于将 JSON 内容反序列化为由一系列 JsonNode 实例表示的树。
readValue(byte[] src, Class<T> valueType) 类似的方法 readValue(byte[] src, int offset, int len, JavaType valueType) readValue(byte[] src, int offset, int len, Class<T> valueType) readValue(byte[] src, JavaType valueType) readValue(DataInput src, Class<T> valueType) readValue(File src, Class<T> valueType) readValue(DataInput src, JavaType valueType) readValue(File src, JavaType valueType) readValue(File src, TypeReference valueTypeRef) readValue(InputStream src, JavaType valueType) readValue(byte[] src, TypeReference valueTypeRef) readValue(InputStream src, Class<T> valueType) readValue(InputStream src, TypeReference valueTypeRef) readValue(JsonParser p, JavaType valueType) readValue(JsonParser p, Class<T> valueType) readValue(JsonParser p, ResolvedType valueType) readValue(byte[] src, int offset, int len, TypeReference valueTypeRef) readValue(Reader src, TypeReference valueTypeRef) readValue(JsonParser p, TypeReference<?> valueTypeRef) readValue(Reader src, JavaType valueType) readValue(String content, TypeReference valueTypeRef) readValue(Reader src, Class<T> valueType) readValue(String content, Class<T> valueType) readValue(String content, JavaType valueType) readValue(URL src, TypeReference valueTypeRef)readValue(URL src, Class<T> valueType) readValue(URL src, JavaType valueType)	<T> T 或 <T> MappingIterator<T>	readValue() 方法及其变体用于将 JSON 内容反序列化从给定文件到给定的 Java 类型，到非容器类型，或到作为参数传递给它的 Java 类型引用。将给定的 JSON 内容转换为 String。将给定资源转换为给定的 Java 类型。变体根据不同的需求使用。
readValues(JsonParser p, Class<T> valueType) 类似的方法 readValues(JsonParser p, JavaType valueType) readValues(JsonParser p, ResolvedType valueType) readValues(JsonParser p, TypeReference<?>valueTypeRef)	<T> MappingIterator<T>	readValues() 方法及其变体用于从解析器流中读取对象序列。
registerModule(Module module) 类似的方法 registerModules(Iterable<Module> modules) registerModules(Module... modules)	ObjectMapper	registerModule() 方法及其变体用于注册一个模块，该模块能够扩展映射器提供的功能。
registerSubtypes(NamedType... types)	void	用于将给定类注册为子类型。通过这样做，基于类型名称的解析可以将父类型链接到子类型。
setAnnotationIntrospector(AnnotationIntrospector ai)	ObjectMapper	用于设置 AnnotationIntrospector，映射器实例同时用于序列化和反序列化。
setAnnotationIntrospectors(AnnotationIntrospector serializerAI, AnnotationIntrospector deserializerAI)	ObjectMapper	用于更改当前映射器实例用于序列化和反序列化的 AnnotationIntrospector 实例。
setBase64Variant(Base64Variant v)	ObjectMapper	用于配置将在 byte[] 序列化器和反序列化器使用的默认 Base64Variant。
setConfig(DeserializationConfig config)	ObjectMapper	为了覆盖底层 DeserializationConfig 对象，我们使用此方法。
setConfig(SerializationConfig config)	ObjectMapper	为了覆盖具有序列化特定配置设置的底层 SerializationConfig 对象，我们使用此方法。
setDateFormat(DateFormat dateFormat)	ObjectMapper	用于配置默认 DateFormat，以便在将时间值序列化为字符串或从 JSON 字符串反序列化时使用。
setDefaultPrettyPrinter(PrettyPrinter pp)	ObjectMapper	用于指定 PrettyPrinter，以便在启用“默认美化打印”时使用。
setDefaultTyping(TypeResolverBuilder<?> typer)	ObjectMapper	用于启用类型信息的自动包含。
setHandlerInstantiator(HandlerInstantiator hi)	Object	用于配置 HandlerInstantiator 以创建处理程序实例。
setFilterProvider(FilterProvider filterProvider)	ObjectMapper	用于配置当前映射器使用指定的 FilterProvider 将 Filter ID 映射到实际的 Filter 实例。
setInjectableValues(InjectableValues injectableValues)	ObjectMapper	用于配置 InjectableValues，用于查找要注入的值。
setLocale(Locale l)	ObjectMapper	用于覆盖格式化时使用的默认区域设置。
setMixInResolver(ClassIntrospector.MixInResolver resolver)	ObjectMapper	我们使用此方法指定给定的解析器来查找要使用的 mix-in 类，从而覆盖直接添加的映射。
setMixInAnnotations(Map<Class<?>,Class<?>> sourceMixins)	void	这是一个已弃用的用于定义 mix-in 注解的方法。
setNodeFactory(JsonNodeFactory f)	ObjectMapper	用于指定要使用的 JsonNodeFactory，用于构造树的根级别节点。
setMixIns(Map<Class<?>,Class<?>> sourceMixins)	ObjectMapper	用于定义要使用的 mix-in 注解，以增强可处理类已有的注解。
setPropertyInclusion(JsonInclude.Value incl)	ObjectMapper	用于设置序列化的默认 POJO 属性包含策略。
setPropertyNamingStrategy(PropertyNamingStrategy s)	ObjectMapper	用于设置要使用的自定义属性命名策略。
setSerializerFactory(SerializerFactory f)	ObjectMapper	用于设置要使用的特定 SerializerFactory 来构造（bean）序列化器。
setSerializerProvider(DefaultSerializerProvider p)	ObjectMapper	用于设置“蓝图” SerializerProvider 实例，作为实际提供程序实例的基础，用于处理 JsonSerializer 实例的缓存。
setSubtypeResolver(SubtypeResolver str)	ObjectMapper	用于设置要使用的自定义子类型解析器。
setTimeZone(TimeZone tz)	ObjectMapper	用于覆盖格式化时使用的默认时区。
setTypeFactory(TypeFactory f)	ObjectMapper	用于覆盖当前映射器使用的 TypeFactory 实例。
setVisibility(PropertyAccessor forMethod, JsonAutoDetect.Visibility visibility) setVisibility(VisibilityChecker<?> vc) setVisibilityChecker(VisibilityChecker<?> vc)	ObjectMapper	setVisibility() 方法及其变体用于设置当前配置的 VisibilityChecker。返回的 ObjectMapper 实例用于检查给定的属性元素是否可以自动检测。
treeAsTokens(TreeNode n)	JsonParser	用于从 JSON 树表示构造 JsonParser。
treeToValue(TreeNode n, Class<T> valueType)	<T> T	用于将给定的 JSON 树包含的数据绑定到特定值类型。
version()	版本	用于获取存储在此类所含 jar 中的版本信息并从中读取。
writer() writer(Base64Variant defaultBase64) writer(CharacterEscapes escapes) writer(ContextAttributes attrs) writer(DateFormat df) writer(FilterProvider filterProvider) writer(FormatSchema schema) writer(PrettyPrinter pp) writer(SerializationFeature feature) writer(SerializationFeature first, SerializationFeature... other)	ObjectWriter	write() 方法及其变体用于使用默认设置、Base64 编码变体（用于 Base64 编码的二进制数据）、输出的字符转义详细信息、默认属性、DateFormat、Filter Provider、用于写入内容的 JsonGenerator 的 Schema 对象、用于缩进的 pretty printer 或启用的功能来构造 ObjectWriter。
writerFor(Class<?> rootType) -	ObjectWriter	用于构造 ObjectWriter，以便使用指定的根类型而不是值的实际运行时类型来序列化对象。
writerFor(JavaType rootType)	ObjectWriter	用于构造 ObjectWriter，以便使用指定的根类型而不是值的实际运行时类型来序列化对象。
writerFor(TypeReference<?> rootType)	ObjectWriter	用于构造 ObjectWriter，以便使用指定的根类型而不是值的实际运行时类型来序列化对象。
writerWithDefaultPrettyPrinter()	ObjectWriter	这是一个工厂方法，用于构造 ObjectWriter，以便使用默认的 pretty printer 进行缩进以序列化对象。
writerWithType(Class<?> rootType) writerWithType(Class<?> rootType) writerWithType(TypeReference<?> rootType)	ObjectWriter	这些方法已弃用，应改用 writerFor(TypeReference) 方法。
writerWithView(Class<?> serializationView)	ObjectWriter	这是一个工厂方法，用于构造 ObjectWriter，以便使用指定的 JSON 视图来序列化对象。
writeTree(JsonGenerator jgen, JsonNode rootNode)	void	用于使用给定的 JsonGenerator 序列化提供的 JSON 树。
writeValue(File resultFile, Object value)	void	用于将 Java 值序列化为 JSON 输出，并将其写入给定的文件。
writeValue(JsonGenerator g, Object value).	void	用于使用给定的 JsonGenerator 将 Java 值序列化为 JSON 输出。
writeValue(OutputStream out, Object value)	void	用于使用给定的 OutputStream 将 Java 值序列化为 JSON 输出。
writeValue(Writer w, Object value)	void	用于使用给定的 Writer 将 Java 值序列化为 JSON 输出。
writeValueAsBytes(Object value)	byte[]	用于将 Java 值序列化为字节数组。
writeValueAsString(Object value)	String	用于将 Java 值序列化为 String。

JacksonExample.java

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

import java.io.IOException;
import java.util.List;

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

//create class JacksonExample to understand implementation of Jackson
public class JacksonExample {	
	// main() method start
	public static void main(String args[]){
		// create an instance of ObjectMapper class
		ObjectMapper mapper = new ObjectMapper();
		// create a JSON string of employee details to deserilized object
		String stdString = "{\n\"students\" : [\n{\n\"stdId\":\"001\",\n\"course\":\"MCA\","+"\n\"firstName\":\"Nicholas\",\n\"lastName\":\"Clemens\",\n\"preferredFullName\":\"Nicholas Clemens\","+"\n\"enrol\":\"S010\",\n\"region\":\"indian\",\n\"phoneNumber\":\"408-1234567\",\n\"emailAddress\""+":\"nicholas.clemens@gmail.com\"\n},\n{\n\"stdId\":\"002\",\n\"course\":\"BCA\","+"\n\"firstName\":\"Sharon\",\n\"lastName\":\"Lorenz\",\n\"preferredFullName\":\"Sharon Lorenz\","+"\n\"enrol\":\"S011\",\n\"region\":\"indian\",\n\"phoneNumber\":\"408-1111111\",\n\"emailAddress\""+":\"sharon.lorenz@gmail.com\"\n},\n{\n\"stdId\":\"003\",\n\"course\":\"Btech\","+"\n\"firstName\":\"Brittany\",\n\"lastName\":\"Hart\",\n\"preferredFullName\":\"Brittany Hart\",\n\""+"enrol\":\"S012\",\n\"region\":\"indian\",\n\"phoneNumber\":\"408-2222222\",\n\"emailAddress\":\"brittany.hart@gmail.com\"\n}\n]\n}";
   
		try{
			// use ObjectMapper for mapping JSON to Student
			Students students = mapper.readValue(stdString, Students.class);
			
			// print students
			System.out.println(students);
			
			// serialize students into json string
			stdString = mapper.writerWithDefaultPrettyPrinter().writeValueAsString(students);
      
			System.out.println(stdString);
		
		}catch (JsonParseException e) {
			e.printStackTrace();
		}catch (JsonMappingException e) {
			e.printStackTrace(); 
		}catch (IOException e) {
			e.printStackTrace(); 
		}
	}
}

//create Students class 
class Students {
	
	public List<Student> students;
	// getter and setter
	public List<Student> getStudent() {
		return students;
	}
	public void setStudent(List<Student> students) {
		this.students = students;
	}
}


class Student {
	
	// declare variables
private String stdId;
private String course;
private String firstName;
private String lastName;
private String preferredFullName;
private String enrol;
private String region;
private String phoneNumber;
private String emailAddress;

public Student(){
	   
}

// getter/setters for all variables
public String getStdId() {
   		return stdId;
}
public void setStdId(String stdId) {
   		this.stdId = stdId;
}

public String getCourse() {
   		return course;
}
public void getCourse(String course) {
   		this.course = course;
}

public String getFirstName() {
   		return firstName;
}
public void setFirstName(String firstName) {
   		this.firstName = firstName;
}

public String getLastName() {
   	return lastName;
}
public void setLastName(String lastName) {
   		this.lastName = lastName;
}

public String getPreferredFullName() {
   		return preferredFullName;
}
public void setPreferredFullName(String preferredFullName) {
   		this.preferredFullName = preferredFullName;
}

public String getEnrol() {
   		return enrol;
}
public void setEnrol(String enrol) {
   		this.enrol = enrol;
}

public String getRegion() {
   		return region;
}
public void setRegion(String region) {
   		this.region = region;
}

public String getPhoneNumber() {
   		return phoneNumber;
}
public void setPhoneNumber(String phoneNumber) {
   		this.phoneNumber = phoneNumber;
}

public String getEmailAddress() {
   		return emailAddress;
}
public void setEmailAddress(String emailAddress) {
   		this.emailAddress = emailAddress;
}

public String toString(){
   		return "Employee [ Student Id: "+stdId+", Course: "+course+ ""
   		+ ", First Name: \"+firstName+ \", Last Name: \"+lastName+ \""
   		+ ", Name: \"+preferredFullName+ \", Enrol No: \"+enrol+ \""
   		+ ", Region: \"+region+ \", Phone Number: \"+phoneNumber+ \""
   		+ ", Email Address: \"+emailAddress+ \" ]";
}
}

输出

下一个主题使用 Jackson 进行对象序列化

Jackson 中的 ObjectMapper 类