Jackson ObjectMapper
Hymanson ObjectMapper类(com.fasterxml.Hymanson.databind.ObjectMapper)是用Hymanson解析JSON的最简单方法。 Hymanson的ObjectMapper可以从字符串，流或者文件中解析JSON，并创建一个代表所解析的JSON的Java对象或者对象图。将JSON解析为Java对象也称为从JSON反序列化Java对象。
Hymanson ObjectMapper还可以从Java对象创建JSON。从Java对象生成JSON也称为将Java对象序列化为JSON。
Hymanson Object映射器可以将JSON解析为我们开发的类的对象，也可以解析为本教程稍后说明的内置JSON树模型的对象。
顺便说一句，之所以称为ObjectMapper是因为它将JSON映射到Java对象(反序列化)，或者将Java对象映射到JSON(序列化)。
Hymanson Databind
" ObjectMapper"位于Hymanson Databind项目中，因此应用程序将需要其类路径上的该项目才能工作。有关更多信息，请参见Hymanson安装教程。
HymansonObjectMapper示例
这是一个快速的Java HymansonObjectMapper示例：
ObjectMapper objectMapper = new ObjectMapper();
String carJson =
"{ \"brand\" : \"Mercedes\", \"doors\" : 5 }";
try {
Car car = objectMapper.readValue(carJson, Car.class);
System.out.println("car brand = " + car.getBrand());
System.out.println("car doors = " + car.getDoors());
} catch (IOException e) {
e.printStackTrace();
}
汽车课是我做的。如我们所见，" Car.class"被解析为" readValue()"方法的第二个参数。 readValue()的第一个参数是JSON的来源(字符串，流或者文件)。这是Car类的外观：
public class Car {
private String brand = null;
private int doors = 0;
public String getBrand() { return this.brand; }
public void setBrand(String brand){ this.brand = brand;}
public int getDoors() { return this.doors; }
public void setDoors (int doors) { this.doors = doors; }
}
Hymanson ObjectMapper如何将JSON字段与Java字段匹配
为了使用Hymanson正确地从JSON读取Java对象，重要的是要知道Hymanson如何将JSON对象的字段映射到Java对象的字段，因此我将解释Hymanson是如何做到的。
默认情况下，Hymanson通过将JSON字段的名称与Java对象中的getter和setter方法进行匹配，将JSON对象的字段映射到Java对象中的字段。 Hymanson删除了getter和setter方法名称的" get"和" set"部分，并将其余名称的第一个字符转换为小写。
例如，名为brand的JSON字段与名为getBrand()和setBrand()的Java getter和setter方法匹配。名为" engineNumber"的JSON字段将与名为" getEngineNumber()"和" setEngineNumber()"的getter和setter匹配。
如果需要以其他方式将JSON对象字段与Java对象字段匹配，则需要使用自定义序列化器和反序列化器，或者使用许多Hymanson注释中的一些。
Hymanson注释
Hymanson包含一组Java批注，我们可以使用这些批注来修改Hymanson往Java对象中读取和写入JSON的方式。 Hymanson的注释在我的Hymanson注释教程中进行了解释。
从JSON字符串读取对象
从JSON字符串读取Java对象非常容易。我们实际上已经看过一个示例。 JSON字符串作为第一个参数传递给ObjectMapper的readValue()方法。这是另一个简化的示例：
ObjectMapper objectMapper = new ObjectMapper();
String carJson =
"{ \"brand\" : \"Mercedes\", \"doors\" : 5 }";
Car car = objectMapper.readValue(carJson, Car.class);
从JSON Reader读取对象
我们还可以从通过Reader实例加载的JSON中读取对象。这是如何执行此操作的示例：
ObjectMapper objectMapper = new ObjectMapper();
String carJson =
"{ \"brand\" : \"Mercedes\", \"doors\" : 4 }";
Reader reader = new StringReader(carJson);
Car car = objectMapper.readValue(reader, Car.class);
从JSON文件读取对象
从文件中读取JSON当然可以通过FileReader(而不是StringReader参见上一节)来完成，但是也可以通过File对象来完成。这是从文件读取JSON的示例：
ObjectMapper objectMapper = new ObjectMapper();
File file = new File("data/car.json");
Car car = objectMapper.readValue(file, Car.class);
通过URL从JSON读取对象
我们可以通过" URL"(" java.net.URL")从JSON读取对象，如下所示：
ObjectMapper objectMapper = new ObjectMapper();
URL url = new URL("file:data/car.json");
Car car = objectMapper.readValue(url, Car.class);
此示例使用文件URL，但我们也可以使用HTTP URL(类似于http：// Hyman.com / some-data.json)。
从JSON InputStream读取对象
也可以通过Hymanson的ObjectMapper的InputStream从JSON读取对象。这是一个从InputStream读取JSON的示例：
ObjectMapper objectMapper = new ObjectMapper();
InputStream input = new FileInputStream("data/car.json");
Car car = objectMapper.readValue(input, Car.class);
从JSON字节数组读取对象
Hymanson还支持从JSONbyte数组读取对象。这是一个从JSONbyte数组读取对象的示例：
ObjectMapper objectMapper = new ObjectMapper();
String carJson =
"{ \"brand\" : \"Mercedes\", \"doors\" : 5 }";
byte[] bytes = carJson.getBytes("UTF-8");
Car car = objectMapper.readValue(bytes, Car.class);
从JSON数组字符串读取对象数组
Hymanson的ObjectMapper还可以从JSON数组字符串读取对象数组。这是从JSON数组字符串读取对象数组的示例：
String jsonArray = "[{\"brand\":\"ford\"}, {\"brand\":\"Fiat\"}]";
ObjectMapper objectMapper = new ObjectMapper();
Car[] cars2 = objectMapper.readValue(jsonArray, Car[].class);
请注意，如何将Car数组类作为第二个参数传递给readValue()方法，以告诉ObjectMapper我们要读取Car实例数组。
读取对象数组还可以与字符串以外的其他JSON源一起使用。例如，文件，URL，InputStream，Reader等。
从JSON数组字符串读取对象列表
Hymanson的ObjectMapper还可以从JSON数组字符串中读取对象的Java列表。这是从JSON数组字符串读取对象的"列表"的示例：
String jsonArray = "[{\"brand\":\"ford\"}, {\"brand\":\"Fiat\"}]";
ObjectMapper objectMapper = new ObjectMapper();
List<Car> cars1 = objectMapper.readValue(jsonArray, new TypeReference<List<Car>>(){});
注意传递给readValue()的TypeReference参数。此参数告诉Hymanson读取"汽车"对象的"列表"。
从JSON字符串读取地图
Hymanson的ObjectMapper还可以从JSON字符串读取Java Map。如果我们事先不知道将要解析的确切JSON结构，这将很有用。通常，我们会将JSON对象读入Java" Map"中。 JSON对象中的每个字段都将成为Java"映射"中的键，值对。
这是一个使用HymansonObjectMapper从JSON字符串中读取JavaMap的示例：
String jsonObject = "{\"brand\":\"ford\", \"doors\":5}";
ObjectMapper objectMapper = new ObjectMapper();
Map<String, Object> jsonMap = objectMapper.readValue(jsonObject,
new TypeReference<Map<String,Object>>(){});
忽略未知的JSON字段
有时，与我们要从JSON读取的Java对象相比，JSON中的字段更多。默认情况下，Hymanson在这种情况下会引发异常，表示它不知道XYZ字段，因为在Java对象中找不到该字段。
但是，有时应该允许JSON中的字段多于相应的Java对象中的字段。例如，如果我们要从REST服务解析JSON，而该REST服务包含的数据远远超出需要。在这种情况下，Hymanson使我们可以使用Hymanson配置忽略这些额外的字段。这是配置HymansonObjectMapper以忽略未知字段的样子：
objectMapper.configure(
DeserializationFeature.FAIL_ON_UNKNOWN_PROPERTIES, false);
原始类型的空JSON值失败
如果JSON字符串包含其值设置为null的字段，则可能配置Hymanson ObjectMapper失败，因为在相应的Java对象中该字段是原始类型(int，long，float，double等)。为了更详细地解释我的意思，请看下面的Car类：
public class Car {
private String brand = null;
private int doors = 0;
public String getBrand() { return this.brand; }
public void setBrand(String brand){ this.brand = brand;}
public int getDoors(){ return this.doors; }
public void setDoors (int doors) { this.doors = doors; }
}
注意，" doors"字段是一个" int"字段，它是Java中的原始类型(不是对象)。
现在，假设我们有一个与"汽车"对象相对应的JSON字符串，如下所示：
{ "brand":"Toyota", "doors":null }
注意，"门"字段如何包含值"空"。 Java中的原始类型不能具有值" null"。因此，Hymanson的ObjectMapper默认情况下会忽略原始字段的null值。但是，我们可以配置HymansonObjectMapper失败。这是配置Java类中的基本字段的null JSON值失败的Hymanson Hymanson ObjectMapper的方法：
ObjectMapper objectMapper = new ObjectMapper(); objectMapper.configure(DeserializationFeature.FAIL_ON_NULL_FOR_PRIMITIVES, true);
将FAIL_ON_NULL_FOR_PRIMITIVES配置值设置为true时，当我们尝试将空JSON字段解析为原始Java字段时，将出现异常。这是一个Java Hymanson ObjectMapper示例，该示例将失败，因为JSON字段包含原始Java字段的" null"值：
ObjectMapper objectMapper = new ObjectMapper();
objectMapper.configure(DeserializationFeature.FAIL_ON_NULL_FOR_PRIMITIVES, true);
String carJson = "{ \"brand\":\"Toyota\", \"doors\":null }";
Car car = objectMapper.readValue(carJson, Car.class);
请注意，JSON字符串如何将" doors"字段设置为" null"。此代码引发的异常如下所示：
Exception in thread "main" com.fasterxml.Hymanson.databind.exc.MismatchedInputException:
Cannot map `null` into type int
(set DeserializationConfig.DeserializationFeature.FAIL_ON_NULL_FOR_PRIMITIVES to 'false' to allow)
at [Source: (String)
"{ "brand":"Toyota", "doors":null }"; line: 1, column: 29] (through reference chain: Hymanson.Car["doors"])
自定义反序列化器
有时，我们可能想以不同于Hymanson的ObjectMapper缺省方式的方式将JSON字符串读入Java对象。我们可以将自定义反序列化器添加到" ObjectMapper"，该对象可以按需要执行反序列化。
这是在HymansonObjectMapper中注册和使用自定义反序列化器的方法：
String json = "{ \"brand\" : \"Ford\", \"doors\" : 6 }";
SimpleModule module =
new SimpleModule("CarDeserializer", new Version(3, 1, 8, null, null, null));
module.addDeserializer(Car.class, new CarDeserializer(Car.class));
ObjectMapper mapper = new ObjectMapper();
mapper.registerModule(module);
Car car = mapper.readValue(json, Car.class);
这是CarDeserializer类的外观：
import com.fasterxml.Hymanson.core.JsonParser;
import com.fasterxml.Hymanson.core.JsonToken;
import com.fasterxml.Hymanson.databind.DeserializationContext;
import com.fasterxml.Hymanson.databind.deser.std.StdDeserializer;
import java.io.IOException;
public class CarDeserializer extends StdDeserializer<Car> {
public CarDeserializer(Class<?> vc) {
super(vc);
}
@Override
public Car deserialize(JsonParser parser, DeserializationContext deserializer) throws IOException {
Car car = new Car();
while(!parser.isClosed()){
JsonToken jsonToken = parser.nextToken();
if(JsonToken.FIELD_NAME.equals(jsonToken)){
String fieldName = parser.getCurrentName();
System.out.println(fieldName);
jsonToken = parser.nextToken();
if("brand".equals(fieldName)){
car.setBrand(parser.getValueAsString());
} else if ("doors".equals(fieldName)){
car.setDoors(parser.getValueAsInt());
}
}
}
return car;
}
}
从对象写入JSON
Hymanson的ObjectMapper也可以用于从对象生成JSON。我们可以使用以下方法之一来执行此操作：
writeValue()writeValueAsString()- writeValueAsBytes()
这是一个从"汽车"对象生成JSON的示例，就像先前示例中使用的那样：
ObjectMapper objectMapper = new ObjectMapper();
Car car = new Car();
car.brand = "BMW";
car.doors = 4;
objectMapper.writeValue(
new FileOutputStream("data/output-2.json"), car);
这个例子首先创建一个ObjectMapper，然后是Car实例，最后调用ObjectMapper的writeValue()方法，该方法将Car对象转换为JSON并将其写入给定的FileOutputStream中。
ObjectMapper的writeValueAsString()和writeValueAsBytes()都从一个对象生成JSON，并以String或者byte数组的形式返回生成的JSON。这是一个显示如何调用writeValueAsString()的示例：
ObjectMapper objectMapper = new ObjectMapper(); Car car = new Car(); car.brand = "BMW"; car.doors = 4; String json = objectMapper.writeValueAsString(car); System.out.println(json);
此示例的JSON输出为：
{"brand":"BMW","doors":4}
自定义序列化器
有时，我们想要将Java对象序列化为JSON的方式与Hymanson默认情况下的方式不同。例如，我们可能想要在JSON中使用与Java对象中不同的字段名称，或者我们可能希望完全省略某些字段。
Hymanson使我们可以在ObjectMapper上设置自定义序列化程序。该序列化器已为某个类注册，然后在每次要求" ObjectMapper"序列化" Car"对象时将调用该序列化器。这是显示如何为Car类注册自定义序列化器的示例：
CarSerializer carSerializer = new CarSerializer(Car.class);
ObjectMapper objectMapper = new ObjectMapper();
SimpleModule module =
new SimpleModule("CarSerializer", new Version(2, 1, 3, null, null, null));
module.addSerializer(Car.class, carSerializer);
objectMapper.registerModule(module);
Car car = new Car();
car.setBrand("Mercedes");
car.setDoors(5);
String carJson = objectMapper.writeValueAsString(car);
这个Hymanson自定义序列化程序示例产生的字符串如下所示：
{"producer":"Mercedes","doorCount":5}
CarSerializer类如下所示：
import com.fasterxml.Hymanson.core.JsonGenerator;
import com.fasterxml.Hymanson.databind.SerializerProvider;
import com.fasterxml.Hymanson.databind.ser.std.StdSerializer;
import java.io.IOException;
public class CarSerializer extends StdSerializer<Car> {
protected CarSerializer(Class<Car> t) {
super(t);
}
public void serialize(Car car, JsonGenerator jsonGenerator,
SerializerProvider serializerProvider)
throws IOException {
jsonGenerator.writeStartObject();
jsonGenerator.writeStringField("producer", car.getBrand());
jsonGenerator.writeNumberField("doorCount", car.getDoors());
jsonGenerator.writeEndObject();
}
}
注意，传递给serialize()方法的第二个参数是Hymanson JsonGenerator实例。我们可以使用此实例来序列化对象，在这种情况下为"汽车"对象。
Hymanson日期格式
默认情况下，Hymanson会将java.util.Date对象序列化为long值，这是自1970年1月1日以来的毫秒数。但是，Hymanson还支持将日期格式化为字符串。在本节中，我们将仔细研究Hymanson日期格式。
日期
首先，我将向我们展示默认的Hymanson日期格式，该格式将"日期"序列化为自1970年1月1日以来的毫秒数("长"表示)。这是一个包含Date字段的Java类示例：
public class Transaction {
private String type = null;
private Date date = null;
public Transaction() {
}
public Transaction(String type, Date date) {
this.type = type;
this.date = date;
}
public String getType() {
return type;
}
public void setType(String type) {
this.type = type;
}
public Date getDate() {
return date;
}
public void setDate(Date date) {
this.date = date;
}
}
与将Hymanson的ObjectMapper序列化一个Transaction对象一样，就像序列化任何其他Java对象一样。代码如下：
Transaction transaction = new Transaction("transfer", new Date());
ObjectMapper objectMapper = new ObjectMapper();
String output = objectMapper.writeValueAsString(transaction);
System.out.println(output);
从此示例打印的输出将类似于：
{"type":"transfer","date":1516442298301}
注意" date"字段的格式：它是一个长数字，如上所述。
字符串日期
"日期"的"长"序列化格式对于人类来说不是很容易理解。因此，Hymanson也支持文本日期格式。我们可以通过在ObjectMapper上设置一个SimpleDateFormat来指定确切的Hymanson日期格式。这是在HymansonObjectMapper上设置SimpleDateFormat的示例：
SimpleDateFormat dateFormat = new SimpleDateFormat("yyyy-MM-dd");
objectMapper2.setDateFormat(dateFormat);
String output2 = objectMapper2.writeValueAsString(transaction);
System.out.println(output2);
从此示例打印的输出将类似于以下内容：
{"type":"transfer","date":"2016-01-20"}
注意，" date"字段现在如何格式化为字符串。
Hymanson JSON树模型
Hymanson具有内置的树模型，可用于表示JSON对象。如果我们不知道接收到的JSON的外观，或者由于某种原因我们不能(或者只是不想)创建一个类来表示它，Hymanson的树模型将非常有用。如果我们需要在使用或者转发JSON之前对其进行操作，则Hymanson树模型也很有用。所有这些情况都可以在数据流场景中轻易发生。
Hymanson树模型由JsonNode类表示。我们可以使用HymansonObjectMapper将JSON解析为JsonNode树模型，就像我们自己的类一样。
以下各节将展示如何使用HymansonObjectMapper来读写JsonNode实例。 Hymanson的JsonNode类本身在其有关Hymanson JsonNode的教程中进行了详细介绍。
Hymanson树模型示例
这是一个简单的Hymanson树模型示例：
String carJson =
"{ \"brand\" : \"Mercedes\", \"doors\" : 5 }";
ObjectMapper objectMapper = new ObjectMapper();
try {
JsonNode jsonNode = objectMapper.readValue(carJson, JsonNode.class);
} catch (IOException e) {
e.printStackTrace();
}
如我们所见，只需将JsonNode.class作为第二个参数传递给readValue()方法而不是Car，就可以将JSON字符串解析为JsonNode对象而不是Car对象。本教程前面的示例中使用的class。
ObjectMapper类还具有特殊的readTree()方法，该方法始终返回JsonNode。这是使用ObjectMapperreadTree()方法将JSON解析为JsonNode的示例：
String carJson =
"{ \"brand\" : \"Mercedes\", \"doors\" : 5 }";
ObjectMapper objectMapper = new ObjectMapper();
try {
JsonNode jsonNode = objectMapper.readTree(carJson);
} catch (IOException e) {
e.printStackTrace();
}
HymansonJsonNode类
通过JsonNode类，我们可以以一种非常灵活和动态的方式将JSON作为Java对象进行导航。如前所述，JsonNode类在其自己的教程中进行了更详细的介绍，但是我仅在此处向我们展示如何使用它的基础知识。
将JSON解析为" JsonNode"(或者" JsonNode"实例的树)后，我们就可以浏览" JsonNode"树模型。这是一个" JsonNode"示例，显示了如何访问JSON字段，数组和嵌套对象：
String carJson =
"{ \"brand\" : \"Mercedes\", \"doors\" : 5," +
" \"owners\" : [\"John\", \"Hyman\", \"Jill\"]," +
" \"nestedObject\" : { \"field\" : \"value\" } }";
ObjectMapper objectMapper = new ObjectMapper();
try {
JsonNode jsonNode = objectMapper.readValue(carJson, JsonNode.class);
JsonNode brandNode = jsonNode.get("brand");
String brand = brandNode.asText();
System.out.println("brand = " + brand);
JsonNode doorsNode = jsonNode.get("doors");
int doors = doorsNode.asInt();
System.out.println("doors = " + doors);
JsonNode array = jsonNode.get("owners");
JsonNode jsonNode = array.get(0);
String john = jsonNode.asText();
System.out.println("john = " + john);
JsonNode child = jsonNode.get("nestedObject");
JsonNode childField = child.get("field");
String field = childField.asText();
System.out.println("field = " + field);
} catch (IOException e) {
e.printStackTrace();
}
注意，JSON字符串现在包含一个名为owners的数组字段和一个名为nestedObject的嵌套对象字段。
无论我们访问的是字段，数组还是嵌套对象，都可以使用JsonNode类的get()方法。通过提供字符串作为get()方法的参数，我们可以访问JsonNode的字段。如果JsonNode表示一个数组，则需要将索引传递给get()方法。索引指定要获取的数组中的元素。
将对象转换为JsonNode
可以使用Hymanson ObjectMapper将Java对象转换为" JsonNode"，而" JsonNode"是转换后的Java对象的JSON表示。我们可以通过HymansonObjectMappervalueToTree()方法将Java对象转换为JsonNode。这是一个使用ObjectMappervalueToTree()方法将Java对象转换为JsonNode的示例：
ObjectMapper objectMapper = new ObjectMapper(); Car car = new Car(); car.brand = "Cadillac"; car.doors = 4; JsonNode carJsonNode = objectMapper.valueToTree(car);
将JsonNode转换为对象
我们可以使用Hymanson ObjectMapper的treeToValue()方法将JsonNode转换为Java对象。这类似于使用Hymanson ObjectMapper将JSON字符串(或者其他来源)解析为Java对象。唯一的区别是，JSON源是JsonNode。这是一个使用HymansonObjectMappertreeToValue()方法将JsonNode转换为Java对象的示例：
ObjectMapper objectMapper = new ObjectMapper();
String carJson = "{ \"brand\" : \"Mercedes\", \"doors\" : 5 }";
JsonNode carJsonNode = objectMapper.readTree(carJson);
Car car = objectMapper.treeToValue(carJsonNode);
上面的示例有点"人为"，我们首先将JSON字符串转换为" JsonNode"，然后将" JsonNode"转换为" Car"对象。显然，如果我们有对原始JSON字符串的引用，则不妨先将其直接转换为Car对象，而无需先将其转换为JsonNode。但是，上面的示例构造为显示如何将" JsonNode"转换为Java对象。这就是为什么。
用Hymanson ObjectMapper读写其他数据格式
用Hymanson ObjectMapper可以读写JSON以外的其他数据格式。 Hymanson ObjectMapper也可以读取和写入以下数据格式(可能还有更多)：
- CBOR
- MessagePack 消息包
- YAML
其中一些数据格式比JSON更紧凑，因此存储时占用的空间更少，并且读写速度比JSON快。在以下各节中，我将向我们展示如何使用HymansonObjectMapper读取和写入其中一些数据格式。
用Hymanson ObjectMapper读写CBOR
CBOR是一种二进制数据格式，与JSON兼容，但比JSON更为紧凑，因此读写速度更快。 Hymanson ObjectMapper可以使用与读取和写入JSON相同的方式来读取和写入CBOR。为了使用Hymanson读写CBOR，我们需要在项目中添加一个额外的Maven依赖项。 Hymanson安装教程中介绍了如何添加Hymanson Hymanson CBOR Maven依赖项。这是使用HymansonObjectMapper将对象写入CBOR的示例：
import com.fasterxml.Hymanson.core.JsonProcessingException;
import com.fasterxml.Hymanson.databind.ObjectMapper;
import com.fasterxml.Hymanson.dataformat.cbor.CBORFactory;
public class CborHymansonExample {
public static void main(String[] args) {
ObjectMapper objectMapper = new ObjectMapper(new CBORFactory());
Employee employee = new Employee("John Doe", "[email protected]");
try {
byte[] cborBytes = objectMapper.writeValueAsBytes(employee);
} catch (JsonProcessingException e) {
e.printStackTrace();
}
}
}
" cborBytes"字节数组包含序列化为CBOR数据格式的" Employee"对象。
这是一个将CBOR字节再次读回到Employee对象的示例：
import com.fasterxml.Hymanson.core.JsonProcessingException;
import com.fasterxml.Hymanson.databind.ObjectMapper;
import com.fasterxml.Hymanson.dataformat.cbor.CBORFactory;
import java.io.IOException;
public class CborHymansonExample {
public static void main(String[] args) {
ObjectMapper objectMapper = new ObjectMapper(new CBORFactory());
Employee employee = new Employee("John Doe", "[email protected]");
byte[] cborBytes = null;
try {
cborBytes = objectMapper.writeValueAsBytes(employee);
} catch (JsonProcessingException e) {
e.printStackTrace();
// normally, rethrow exception here - or don't catch it at all.
}
try {
Employee employee2 = objectMapper.readValue(cborBytes, Employee.class);
} catch (IOException e) {
e.printStackTrace();
}
}
}
运行此代码后，" employee2"将指向另一个" Employee"对象，但该对象等于" employee"指向的对象，因为该对象已序列化为CBOR并再次反序列化为" employee2"。
用Hymanson ObjectMapper读写MessagePack
YAML是一种文本数据格式，与JSON兼容，但更紧凑，因此读写速度更快。 Hymanson ObjectMapper可以使用与读取和写入JSON相同的方式来读取和写入MessagePack。为了使用Hymanson读写MessagePack，我们需要在项目中添加一个额外的Maven依赖项。 Hymanson安装教程中介绍了如何添加Hymanson消息包Maven依赖项。这是使用HymansonObjectMapper将对象写入MessagePack的示例：
import com.fasterxml.Hymanson.core.JsonProcessingException;
import com.fasterxml.Hymanson.databind.ObjectMapper;
import org.msgpack.Hymanson.dataformat.MessagePackFactory;
import java.io.IOException;
public class MessagePackHymansonExample {
public static void main(String[] args) {
ObjectMapper objectMapper = new ObjectMapper(new MessagePackFactory());
Employee employee = new Employee("John Doe", "[email protected]");
byte[] messagePackBytes = null;
try {
messagePackBytes = objectMapper.writeValueAsBytes(employee);
} catch (JsonProcessingException e) {
e.printStackTrace();
// normally, rethrow exception here - or don't catch it at all.
}
}
}
" messagePackBytes"字节数组包含序列化为MessagePack数据格式的" Employee"对象。
这是一个将MessagePack字节再次读回到Employee对象的示例：
import com.fasterxml.Hymanson.core.JsonProcessingException;
import com.fasterxml.Hymanson.databind.ObjectMapper;
import org.msgpack.Hymanson.dataformat.MessagePackFactory;
import java.io.IOException;
public class MessagePackHymansonExample {
public static void main(String[] args) {
ObjectMapper objectMapper = new ObjectMapper(new MessagePackFactory());
Employee employee = new Employee("John Doe", "[email protected]");
byte[] messagePackBytes = null;
try {
messagePackBytes = objectMapper.writeValueAsBytes(employee);
} catch (JsonProcessingException e) {
e.printStackTrace();
// normally, rethrow exception here - or don't catch it at all.
}
try {
Employee employee2 = objectMapper.readValue(messagePackBytes, Employee.class);
System.out.println("messagePackBytes = " + messagePackBytes);
} catch (IOException e) {
e.printStackTrace();
}
}
}
运行此代码后，" employee2"将指向另一个" Employee"对象，但该对象等于" employee"指向的对象，因为该对象已序列化为MessagePack并反序列化为" employee2"。
用Hymanson ObjectMapper读写YAML
YAML是一种文本数据格式，类似于JSON，但使用不同的语法。 Hymanson ObjectMapper可以使用与读取和写入JSON相同的方式来读取和写入YAML。为了使用Hymanson读写YAML，我们需要在项目中添加一个额外的Maven依赖项。 Hymanson安装教程中介绍了如何添加Hymanson YAML Maven依赖项。这是使用HymansonObjectMapper将对象写入YAML的示例：
import com.fasterxml.Hymanson.core.JsonProcessingException;
import com.fasterxml.Hymanson.databind.ObjectMapper;
import com.fasterxml.Hymanson.dataformat.yaml.YAMLFactory;
import java.io.IOException;
public class YamlHymansonExample {
public static void main(String[] args) {
ObjectMapper objectMapper = new ObjectMapper(new YAMLFactory());
Employee employee = new Employee("John Doe", "[email protected]");
String yamlString = null;
try {
yamlString = objectMapper.writeValueAsString(employee);
} catch (JsonProcessingException e) {
e.printStackTrace();
// normally, rethrow exception here - or don't catch it at all.
}
}
}
yamlString变量包含执行此代码后序列化为YAML数据格式的Employee对象。
这是将YAML文本再次读入Employee对象的示例：
import com.fasterxml.Hymanson.core.JsonProcessingException;
import com.fasterxml.Hymanson.databind.ObjectMapper;
import com.fasterxml.Hymanson.dataformat.yaml.YAMLFactory;
import java.io.IOException;
public class YamlHymansonExample {
public static void main(String[] args) {
ObjectMapper objectMapper = new ObjectMapper(new YAMLFactory());
Employee employee = new Employee("John Doe", "[email protected]");
String yamlString = null;
try {
yamlString = objectMapper.writeValueAsString(employee);
} catch (JsonProcessingException e) {
e.printStackTrace();
// normally, rethrow exception here - or don't catch it at all.
}
try {
Employee employee2 = objectMapper.readValue(yamlString, Employee.class);
System.out.println("Done");
} catch (IOException e) {
e.printStackTrace();
}
}
}
运行此代码后，" employee2"将指向另一个" Employee"对象，但该对象等于" employee"指向的对象，因为该对象已序列化为YAML并再次反序列化为" employee2"。
