Jackson 高性能的JSON处理 ObjectMapper（jackson jsonproperty）

25-02-04 22

这篇文章主要围绕Jackson高性能的JSON处理ObjectMapper和jacksonjsonproperty展开，旨在为您提供一份详细的参考资料。我们将全面介绍Jackson高性能的JSON处理

这篇文章主要围绕Jackson 高性能的JSON处理 ObjectMapper和jackson jsonproperty展开，旨在为您提供一份详细的参考资料。我们将全面介绍Jackson 高性能的JSON处理 ObjectMapper的优缺点，解答jackson jsonproperty的相关问题，同时也会为您带来Jackson Object mapper将java地图转换为json维护键的顺序、Jackson ObjectMapper、jackson ObjectMapper 之 Timezone 問題、Jackson ObjectMapper 反序列化一个包含对象数组的对象的实用方法。

本文目录一览：

Jackson 高性能的JSON处理 ObjectMapper（jackson jsonproperty）
Jackson Object mapper将java地图转换为json维护键的顺序
Jackson ObjectMapper
jackson ObjectMapper 之 Timezone 問題
Jackson ObjectMapper 反序列化一个包含对象数组的对象

Jackson 高性能的JSON处理 ObjectMapper（jackson jsonproperty）

今天自行研究了下json ，感觉非常好用，经过测试比google的GSON快多了

同时Jackson可以轻松的将Java对象转换成json对象和xml文档，同样也可以将json、xml转换成Java对象。功能非常的强悍！

大家也知道，json 在如今互联网时代应用的非常广，因为大家如此的关注，所以对json的解析性能要求也是非常高的。

一、准备工作

1、下载依赖库jar包

Jackson的jar all下载地址：http://jackson.codehaus.org/1.7.6/jackson-all-1.7.6.jar

然后在工程中导入这个jar包即可开始工作

官方示例：http://wiki.fasterxml.com/JacksonInFiveMinutes

因为下面的程序是用junit测试用例运行的，所以还得添加junit的jar包。版本是junit-4.2.8

如果你需要转换xml，那么还需要stax2-api.jar

2、测试类基本代码如下

[java] view plaincopy

/*
* @project java
* @package
* @file Jackson.java
* @version 1.0
* @author 廖益平
* @time 2011-11-8 上午02:59:37
*/
public class Jackson {
/*
*
* Class Descripton goes here.
*
* @class Jackson
* @version 1.0
* @author 廖益平
* @time 2011-11-8 上午02:59:37
*/
public static JsonGenerator jsonGenerator = null;
private static ObjectMapper mapper = new ObjectMapper();
public static void main(String[] args) {
Student student = new Student();
student.setIsstudent(true);
student.setUid(1000);
student.setUname("xiao liao");
student.setUpwd("123");
student.setNumber(12);
Map<String, Student> stuMap = new HashMap<String, Student>();
stuMap.put("1", student);
stuMap.put("2", student);
List<Object> stuList = new ArrayList<Object>();
List<Student> stuList1 = new ArrayList<Student>();
stuList1.add(student);
student= new Student();
student.setIsstudent(false);
student.setUid(200);
student.setUname("xiao mi");
stuList1.add(student);
stuList.add(student);
stuList.add("xiao xin");
stuList.add("xiao er");
stuList.add(stuMap);
//readJson2List();
try {
//readJson2Array();
//writeArray2Json(array);
//writeJson2List();
//writeEntity2Json(student);
writeJson2Entity();
//writeMap2Json(stuMap);
//writeList2Json(stuList1);
} catch (IOException e) {
e.printStackTrace();
}
}
/**
*
* <code>writeEntity2Json</code>
* @description: TODO(实体类转换成json)
* @param object
* @throws IOException
* @since 2011-11-8 廖益平
*/
public static void writeEntity2Json(Object object) throws IOException {
mapper.writeValue( new File("D:\\developSoft\\aaadowload\\testjson1\\lib\\aa.txt"),object );
mapper.writeValue( System.out,object );
}
/**
*
* <code>writeArray2Json</code>
* @description: TODO(数组转换成json数组)
* @param object
* @throws IOException
* @since 2011-11-8 廖益平
*/
public static void writeArray2Json(Object object) throws IOException {
// writeValue具有和writeObject相同的功能
mapper.writeValue( new File("D:\\developSoft\\aaadowload\\testjson1\\lib\\aa.txt"),object );
mapper.writeValue(System.out,object );
}
/**
*
* <code>writeMap2Json</code>
* @description: TODO(map对象转换成json对象)
* @param object
* @throws IOException
* @since 2011-11-8 廖益平
*/
public static void writeMap2Json(Object object) throws IOException {
System.out.println("使用ObjectMapper-----------");
// writeValue具有和writeObject相同的功能
System.out.println("==>"+mapper.writeValueAsString(object));
mapper.writeValue( new File("D:\\developSoft\\aaadowload\\testjson1\\lib\\aamap.txt"),object );
mapper.writeValue( System.out , object );
}
/**
*
* <code>writeList2Json</code>
* @description: TODO(list转换成json)
* @param object
* @throws IOException
* @since 2011-11-8 廖益平
*/
public static void writeList2Json(Object object) throws IOException {
System.out.println("==>"+mapper.writeValueAsString(object));
mapper.writeValue( new File("D:\\developSoft\\aaadowload\\testjson1\\lib\\aamap.txt"),object );
mapper.writeValue( System.out , object );
}
/**
*
* <code>writeJson2Entity</code>
* @description: TODO(json转换成实体)
* @throws IOException
* @since 2011-11-8 廖益平
*/
public static void writeJson2Entity() throws IOException {
System.out.println("json串转换成entity-------------");
// File file = new File("D:\\developSoft\\aaadowload\\testjson1\\lib\\aa.txt");
// FileInputStream inputStream = new FileInputStream(file);
// Student student = mapper.readValue(inputStream,Student.class);
// System.out.println(student.toString());
//漂亮输出
//mapper.defaultPrettyPrintingWriter().writeValueAsString(value);
String json = "{\"uid\":1000,\"uname\":\"xiao liao\",\"upwd\":\"123\",\"number\":12.0,\"isstudent\":true}";
Student student1 = mapper.readValue(json,Student.class);
System.out.println("json2:"+student1.toString());
}
/**
*
* <code>writeJson2List</code>
* @description: TODO(json专程list对象)
* @throws IOException
* @since 2011-11-8 廖益平
*/
public static void writeJson2List() throws IOException {
System.out.println("json串转换成entity-------------");
File file = new File("D:\\developSoft\\aaadowload\\testjson1\\lib\\aa.txt");
FileInputStream inputStream = new FileInputStream(file);
Student student = mapper.readValue(inputStream,Student.class);
System.out.println(student.toString());
String json = "[{\"uid\":1000,\"uname\":\"xiao liao\",\"upwd\":\"123\",\"number\":12.0,\"isstudent\":true},{\"uid\":200,\"uname\":\"xiao mi\",\"upwd\":null,\"number\":0.0,\"isstudent\":false}]";
List<LinkedHashMap<String, Object>> s= mapper.readValue(json,List.class);
for (int i = 0; i < s.size(); i++) {
LinkedHashMap<String, Object> link = s.get(i);
Set<String> key = link.keySet();
for (Iterator iterator = key.iterator(); iterator.hasNext();) {
String string = (String) iterator.next();
System.out.println(string+"==>"+link.get(string));
}
System.out.println("json:"+i+""+s.get(i).toString());
}
}
/**
* JSON转换为List对象
*/
public static void readJson2List() {
String json = "[{\"uid\":1,\"uname\":\"www\",\"number\":234,\"upwd\":\"456\"},"
+ "{\"uid\":5,\"uname\":\"tom\",\"number\":3.44,\"upwd\":\"123\"}]";
try {
List<LinkedHashMap<String, Object>> list = mapper.readValue(
json, List.class);
System.out.println(list.size());
for (int i = 0; i < list.size(); i++) {
Map<String, Object> map = list.get(i);
Set<String> set = map.keySet();
for (Iterator<String> it = set.iterator(); it.hasNext();) {
String key = it.next();
System.out.println(key + ":" + map.get(key));
}
}
} catch (JsonParseException e) {
e.printStackTrace();
} catch (JsonMappingException e) {
e.printStackTrace();
} catch (IOException e) {
e.printStackTrace();
}
}
/**
* JSON转换为List对象
*/
public static void readJson2Array() {
String json = "[{\"uid\":1,\"uname\":\"www\",\"number\":234,\"upwd\":\"456\"},"
+ "{\"uid\":5,\"uname\":\"tom\",\"number\":3.44,\"upwd\":\"123\"}]";
try {
Student[] students = mapper.readValue(json, Student[].class);
for (Student student : students) {
System.out.println(">"+student.toString());
}
} catch (JsonParseException e) {
e.printStackTrace();
} catch (JsonMappingException e) {
e.printStackTrace();
} catch (IOException e) {
e.printStackTrace();
}
}
}

打印结果：

串转换成entity-------------
json2:uid=1000,name=xiao liao,upwd=123,number=12.0,isStudent=true

writeMap2Json -----------
{"2":{"uid":1000,"uname":"xiao liao","upwd":"123","number":12.0,"isstudent":true},"1":{"uid":1000,"uname":"xiao liao","upwd":"123","number":12.0,"isstudent":true}}

readJson2Array------------------
>uid=1,name=www,upwd=456,number=234.0,isStudent=false
>uid=5,name=tom,upwd=123,number=3.44,isStudent=false
writeMap2Json -----------
{"2":{"uid":1000,"uname":"xiao liao","upwd":"123","number":12.0,"isstudent":true},"1":{"uid":1000,"uname":"xiao liao","upwd":"123","number":12.0,"isstudent":true}}

大家逐个自己试试吧，上面也是我的测试代码

[java] view plaincopy

实体类：
/*
* @project java
* @package
* @file Student.java
* @version 1.0
* @author 廖益平
* @time 2011-11-8 上午03:01:08
*/
public class Student {
/*
*
* Class Descripton goes here.
*
* @class Student
* @version 1.0
* @author 廖益平
* @time 2011-11-8 上午03:01:08
*/
private int uid;
private String uname;
private String upwd;
private double number;
private boolean isstudent;
public int getUid() {
return uid;
}
public void setUid(int uid) {
this.uid = uid;
}
public String getUname() {
return uname;
}
public void setUname(String uname) {
this.uname = uname;
}
public String getUpwd() {
return upwd;
}
public void setUpwd(String upwd) {
this.upwd = upwd;
}
public double getNumber() {
return number;
}
public void setNumber(double number) {
this.number = number;
}
public boolean isIsstudent() {
return isstudent;
}
public void setIsstudent(boolean isstudent) {
this.isstudent = isstudent;
}
@Override
public String toString() {
return "uid="+uid+",name="+uname+",upwd="+upwd+",number="+number+",isStudent="+isstudent;
}
}

Jackson Object mapper将java地图转换为json维护键的顺序

我使用jackson.map.ObjectMapper API将map转换为json字符串.我使用writeValueAsstring方法来实现这一点.

我传递了一个基于值排序的map到writeValueAsstring方法.我得到的JSON字符串是基于键的.

有没有办法使用jackson将地图转换为JSON字符串,而不会干扰地图中项目的顺序.

我尝试将Feature.soRT_PROPERTIES_ALPHABETICALLY设置为false,但根据文档,它仅适用于POJO类型.

任何想法实现上述行为.

解决方法

使用Jackson 2.3.1(不知道以前的版本)你可以序列化一个SortedMap,例如一个TreeMap,该命令将得到尊重.

以下是junit 4的示例：

@Test
public void testSerialize() throws JsonProcessingException{
    ObjectMapper om = new ObjectMapper();
    om.configure(SerializationFeature.WRITE_NULL_MAP_VALUES,false);
    om.configure(SerializationFeature.INDENT_OUTPUT,true);
    om.setSerializationInclusion(Include.NON_NULL);

    SortedMap<String,String> sortedMap = new TreeMap<String,String>();
    Map<String,String> map = new HashMap<String,String>();
    map.put("aaa","AAA");

    map.put("bbb","BBB");
    map.put("ccc","CCC");
    map.put("ddd","DDD");

    sortedMap.putAll(map);

    System.out.println(om.writeValueAsstring(map));

    System.out.println(om.writeValueAsstring(sortedMap));


}

这是结果：`

用地图

{
  "aaa" : "AAA","ddd" : "DDD","ccc" : "CCC","bbb" : "BBB"
}

使用SortedMap

{
  "aaa" : "AAA","bbb" : "BBB","ddd" : "DDD"
}

带有Map的第一个序列化将不会被订购,
带有TreeMap的第二个将使用键按字母顺序排序.您可以将比较器传递给treeMap以获取不同的顺序.

编辑：即使这不是SortedMap,它也可以在Jackson上使用LinkedHashMap().这是Map的一个实现,它保存了键插入到地图中的顺序.这可能是你正在寻找的.

Jackson ObjectMapper

背景

在最近写邓白氏项目的时候遇到一个需求，就是JSON字符串和Java对象之间相互转换，这就是涉及到数据反序列化。

概述

Jackson ObjectMapper是Java中处理JSON数据的强大工具，具有以下主要功能：
JSON与Java对象的相互转换：ObjectMapper可以将JSON数据转换为Java对象，以及将Java对象转换为JSON格式。这种转换过程称为序列化和反序列化。通过ObjectMapper，我们可以轻松地在Java应用程序中实现JSON和Java对象之间的转换。

支持不同数据格式：ObjectMapper支持多种JSON数据格式，包括JSON对象、数组、字符串等。它能够处理各种JSON数据结构，并将其转换为相应的Java对象。

快速开始

Maven 依赖

<dependency>
    <groupId>com.fasterxml.jackson.core</groupId>
    <artifactId>jackson-databind</artifactId>
    <version>2.11.1</version>
</dependency>

ObjectMapper读写操作

定义一个Person对象

@Data
@NoArgsConstructor
@AllArgsConstructor
public class Person {
    private String name;
    
    private Integer age;
}

Java 对象转 JSON

  Person person = new Person("yunzhi", 23);
  ObjectMapper objectMapper = new ObjectMapper();
  String s = objectMapper.writeValueAsString(person);
  logger.info(s);
 // {"name":"yunzhi","age":23}

JSON 对象转 Java

  ObjectMapper objectMapper = new ObjectMapper();
  String json = "{ \"name\" : \"yunzhi\", \"age\" : \"23\" }";
  Person person = objectMapper.readValue(json, Person.class);
  logger.info(people.toString());
// Person(name=yunzhi, age=23)

JSON数组转Java List

 ObjectMapper objectMapper = new ObjectMapper();
 String json = "[{ \"name\" : \"yunzhi\", \"age\" : \"23\" },{ \"name\" : \"kxb\", \"age\" : \"21\" }]";
 List<Person> peoples = objectMapper.readValue(json, new TypeReference<List<Person>>() {});
 logger.info(peoples.toString());
// [Person(name=yunzhi, age=23), Person(name=kxb, age=21)]

TypeReference的使用场景，假设我们有一个包含了许多人信息的JSON字符串，我们想要将它反序列化为一个列表（List）类型的对象，其中每个人信息是一个独立的对象。Java编译器无法确定这个列表中具体存放的是什么类型的对象。

JSON数组转Java Map

  ObjectMapper objectMapper = new ObjectMapper();
  String json = "{ \"name\" : \"yunzhi\", \"age\" : 23 }";
  Map<String, Object> map
                = objectMapper.readValue(json, new TypeReference<Map<String,Object>>(){});
logger.info(map.toString());
// {name=yunzhi, age=23}

特殊情况转换

Json转Java对象

重新定义Person类

public class Person {
    private String fullName;

    private Integer age;
}

下划线转驼峰性字段

 ObjectMapper objectMapper = new ObjectMapper();
 String json = "{ \"full_name\" : \"yunzhi\", \"age\" : 23 }";
 objectMapper.setPropertyNamingStrategy(PropertyNamingStrategies.SNAKE_CASE);
 Person person = objectMapper.readValue(json, Person.class);
 logger.info(person.toString());

// Person(fullName=yunzhi, age=23)

Json字段转换为对象字段不对应的情况

// 当json比对象实体多一个的情况，如何进行转换就会进行出错
ObjectMapper objectMapper = new ObjectMapper();
String json = "{\"full_name\":\"yunzhi\",\"age\":23, \"sex\":\"男\"}";

objectMapper.setPropertyNamingStrategy(PropertyNamingStrategies.SNAKE_CASE);
Person person = objectMapper.readValue(json,Person.class);

logger.info(person.toString());

//Unrecognized field "sex" (class club.yunzhi.dengbai.entity.Person)

解决方法：ObjectMapper配置

ObjectMapper objectMapper = new ObjectMapper();
String json = "{\"full_name\":\"yunzhi\",\"age\":23, \"sex\":\"男\"}";

objectMapper.configure(DeserializationFeature.FAIL_ON_UNKNOWN_PROPERTIES, false);
objectMapper.setPropertyNamingStrategy(PropertyNamingStrategies.SNAKE_CASE);

Person person = objectMapper.readValue(json,Person.class);
logger.info(person.toString());

// Person(fullName=yunzhi, age=23)

设置DeserializationFeatureFAIL_ON_UNKNOWN_PROPERTIES设置为false，这意味着在反序列化时，如果JSON中有未知的属性，如果有未知的属性，会进行忽略。

更多配置可以参考DeserializationFeature这个enum

Json字段为_开头的情况

ObjectMapper objectMapper = new ObjectMapper();
String json = "{ \"full_name\" : \"yunzhi\", \"_age\" : 23 }";
objectMapper.setPropertyNamingStrategy(PropertyNamingStrategies.SNAKE_CASE);
Person person = objectMapper.readValue(json, Person.class);
logger.info(person.toString());
//  Unrecognized field "_age" (class club.yunzhi.dengbai.entity.Person), not marked as ignorable (2 known properties: "full_name", "age"])

解决方式

// 重写Person
 @JsonProperty(value = "_age")
 private Integer age;

再次重新打印的值
Person(fullName=yunzhi, age=23)

@JsonProperty注解可以将 Java 对象的属性与 JSON 数据中的字段名称进行关联。这样，即使属性名称与字段名称不一致，Jackson 也能正确地进行序列化和反序列化。

总结

使用ObjectMapper API方式来解析和序列化JSON。方便进行序列化和反序列化

参考资料

https://www.baeldung.com/jackson-object-mapper-tutorial

jackson ObjectMapper 之 Timezone 問題

在json 轉換java對象的時候，遇到時間類型會自動偏移8小時，看起來是默認加上了時區的值，怎麼去掉？

com.fasterxml.jackson.databind.ObjectMapper mapper = new ObjectMapper().configure(DeserializationFeature.FAIL_ON_UNKNOWN_PROPERTIES, false);

xxxJSONObject = mapper.readValue(json, XXXJSONResponse.class);

Jackson ObjectMapper 反序列化一个包含对象数组的对象

如何解决Jackson ObjectMapper 反序列化一个包含对象数组的对象？

我序列化了这种对象：

public class MyObject implements Serializable {

private String type;
...
private String[] target;

//getters and setters
}

但是当我尝试反序列化 MyObject 时，由于 target 数组而出现错误。

java.lang.RuntimeException: com.fasterxml.jackson.databind.exc.MismatchedInputException: Cannot deserialize instance of `java.lang.String` out of START_ARRAY token
at [Source: UNKNowN; line: -1,column: -1] (through reference chain: java.util.ArrayList[0]->MyObject["target"])
...

如何反序列化数组？

解决方法

我终于找到了问题所在。我没有看到我班上有 2 个二传手。杰克逊可能用错了。

我只需将注释 @JsonSetter("target") 放在接受数组的 setter 上方，以告诉 Jackson 使用好的数组。

public void setTarget(String target) {
    this.target = new String[]{target};
}

@JsonSetter("target")
public void setTarget(String[] target) {
    this.target = target;
}

关于Jackson 高性能的JSON处理 ObjectMapper和jackson jsonproperty的问题就给大家分享到这里，感谢你花时间阅读本站内容，更多关于Jackson Object mapper将java地图转换为json维护键的顺序、Jackson ObjectMapper、jackson ObjectMapper 之 Timezone 問題、Jackson ObjectMapper 反序列化一个包含对象数组的对象等相关知识的信息别忘了在本站进行查找喔。

本文标签：