[开发工具]Jackson

简介

通俗的来说，Jackson是一个 Java 用来处理 JSON 格式数据的类库，其性能非常好

Jackson具有比较高的序列化和反序列化效率，据测试，无论是哪种形式的转换，Jackson > Gson > Json-lib，而且Jackson的处理能力甚至高出Json-lib近10倍左右，且正确性也十分高。相比之下，Json-lib似乎已经停止更新，最新的版本也是基于JDK15，而Jackson的社区则较为活跃

Jackson提供了很多类和方法，而在序列化和反序列化中使用的最多的类则是ObjectMapper这个类，此类比较类似于Json-lib中JsonObject和ArrayObject。此类中提供了`readTree()，readValue(),writeValueAsString()等方法用于转换。具体关于此类的说明文档地址是：

com.fasterxml.jackson.databind.ObjectMapper

http://jackson.codehaus.org/1.7.9/javadoc/org/codehaus/jackson/map/ObjectMapper.html

使用

引入依赖

<!-- 根据自己需要引入相关版本依赖。 -->
<dependency>
  <groupId>com.fasterxml.jackson.core</groupId>
  <artifactId>jackson-core</artifactId>
  <version>2.9.10</version>
</dependency>
 
<dependency>
  <groupId>com.fasterxml.jackson.core</groupId>
  <artifactId>jackson-databind</artifactId>
  <version>2.9.10</version>
</dependency>
 
<dependency>
  <groupId>com.fasterxml.jackson.core</groupId>
  <artifactId>jackson-annotations</artifactId>
  <version>2.9.10</version>
</dependency>

ObjectMapper的常用配置

private static final ObjectMapper mapper;
 
public static ObjectMapper getObjectMapper(){
    return this.mapper;
}
 
static{
    //创建ObjectMapper对象
    mapper = new ObjectMapper();
 
    //configure方法 配置一些需要的参数
    // 转换为格式化的json 显示出来的格式美化
    mapper.enable(SerializationFeature.INDENT_OUTPUT);
 
   //序列化的时候序列对象的那些属性  
   //JsonInclude.Include.NON_DEFAULT 属性为默认值不序列化 
   //JsonInclude.Include.ALWAYS      所有属性
   //JsonInclude.Include.NON_EMPTY   属性为 空（“”） 或者为 NULL 都不序列化 
   //JsonInclude.Include.NON_NULL    属性为NULL 不序列化
   mapper.setSerializationInclusion(JsonInclude.Include.ALWAYS);  
 
   
    //反序列化时,遇到未知属性会不会报错 
    //true - 遇到没有的属性就报错 false - 没有的属性不会管，不会报错
    mapper.configure(DeserializationFeature.FAIL_ON_UNKNOWN_PROPERTIES, false);
 
    //如果是空对象的时候,不抛异常  
    mapper.configure(SerializationFeature.FAIL_ON_EMPTY_BEANS, false);  
 
    // 忽略 transient 修饰的属性
    mapper.configure(MapperFeature.PROPAGATE_TRANSIENT_MARKER, true);
 
    //修改序列化后日期格式
    mapper.configure(SerializationFeature.WRITE_DATES_AS_TIMESTAMPS, false);  
    mapper.setDateFormat(new SimpleDateFormat("yyyy-MM-dd HH:mm:ss"));
 
   //处理不同的时区偏移格式
   mapper.disable(SerializationFeature.WRITE_DATES_AS_TIMESTAMPS);
   mapper.registerModule(new JavaTimeModule());
 
}

ObjectMapper的常用方法

mapper.writeValueAsString(xxx.class)    序列化
mapper.readValue(jsonString, xxx.class)   反序列化

json字符串转对象

ObjectMapper mapper = new ObjectMapper();
String jsonString = "{\"name\":\"Hyl\", \"age\":20}";
 
//将字符串转换为对象
Student student = mapper.readValue(jsonString, Student.class);
System.out.println(student);
 
//将对象转换为json字符串
jsonString = mapper.writeValueAsString(student);
System.out.println(jsonString);
 
 
结果：
Student [ name: Hyl, age: 20 ]
 
{
  "name" : "Hyl",
  "age" : 20
}

getFactory() 序列化

JsonGenerator teststringstu = objectMapper.getFactory().createGenerator(System.out, JsonEncoding.UTF8);
teststringstu.writeObject(student);

System.out.println(teststringstu);

此方法同样可以得到上面方法的值。但是注意此方法中的这个函数：createGenerator（），它需要两个参数，一个是OutputStream类型参数，一个是JsonEncoding类型参数。通过这两个参数，我们可以了解到，此方法不仅可以将Json直接写入网络流，还可以将Json写入文件流或者内存流

渐次反序列化

此方法更灵活，可以只将用户感兴趣的Json串信息值提取出来。主要利用ObjectMapper提供的readTree和Jackson提供的JsonNode类来实现

String test="{"results":[{"objectID":357,"geoPoints":[{"x":504604.59802246094,"y":305569.9150390625}]},{"objectID":358,"geoPoints":[{"x":504602.2680053711,"y":305554.43603515625}]}]}";

JsonNode node = objectMapper.readTree(test);   //将Json串以树状结构读入内存
JsonNode contents = node.get("results");//得到results这个节点下的信息


//遍历results下的信息，size()函数可以得节点所包含的的信息的个数，类似于数组的长度
for (int i = 0; i < contents.size(); i++) {
    System.out.println(contents.get(i).get("objectID").getIntValue()); //读取节点下的某个子节点的值

    JsonNode geoNumber = contents.get(i).get("geoPoints");
     //循环遍历子节点下的信息
    for (int j = 0; j < geoNumber.size(); j++) {
        System.out.println(geoNumber.get(j).get("x").getDoubleValue() + " " + geoNumber.get(j).get("y").getDoubleValue());
    }
}
System.out.println(teststringstu);

输出

357

504604.59802246094 305569.9150390625

358

504602.2680053711 305554.43603515625

此方法类似于XML解析中的DOM方式解析，其好处是结构明细，便于提取想要的信息。当然，其缺点也和此方法一样：耗时费空间

数组和对象之间转换

//对象转为byte数组
byte[] byteArr = mapper.writeValueAsBytes(student);
System.out.println(byteArr);
 
 
//byte数组转为对象
Student student= mapper.readValue(byteArr, Student.class);
System.out.println(student);
 
结果：
[B@3327bd23
 
Student [ name: Hyl, age: 20 ]

集合和json字符串之间转换

List<Student> studentList= new ArrayList<>();
studentList.add(new Student("hyl1" ,20 , new Date()));
studentList.add(new Student("hyl2" ,21 , new Date()));
studentList.add(new Student("hyl3" ,22 , new Date()));
studentList.add(new Student("hyl4" ,23 , new Date()));
 
String jsonStr = mapper.writeValueAsString(studentList);
System.out.println(jsonStr);
        
List<Student> studentList2 = mapper.readValue(jsonStr, List.class);
System.out.println("字符串转集合：" + studentList2 );
 
结果：
[ {
  "name" : "hyl1",
  "age" : 20,
  "sendTime" : 1525164212803
}, {
  "name" : "hyl2",
  "age" : 21,
  "sendTime" : 1525164212803
}, {
  "name" : "hyl3",
  "age" : 22,
  "sendTime" : 1525164212803
}, {
  "name" : "hyl4",
  "age" : 23,
  "sendTime" : 1525164212803
} ]
[{name=hyl1, age=20, sendTime=1525164212803}, {name=hyl2, age=21, sendTime=1525164212803}, {name=hyl3, age=22, sendTime=1525164212803}, {name=hyl4, age=23, sendTime=1525164212803}]

map和json字符串之间转换

Map<String, Object> testMap = new HashMap<>();
testMap.put("name", "22");
testMap.put("age", 20);
testMap.put("date", new Date());
testMap.put("student", new Student("hyl", 20, new Date()));
 
 
String jsonStr = mapper.writeValueAsString(testMap);
System.out.println(jsonStr);
Map<String, Object> testMapDes = mapper.readValue(jsonStr, Map.class);
System.out.println(testMapDes);
 
结果：
{
  "date" : 1525164212803,
  "name" : "22",
  "student" : {
    "name" : "hyl",
    "age" : 20,
    "sendTime" : 1525164212803,
    "intList" : null
  },
  "age" : 20
}
{date=1525164212803, name=22, student={name=hyl, age=20, sendTime=1525164212803, intList=null}, age=20}

日期转json字符串

// 修改时间格式
mapper.setDateFormat(new SimpleDateFormat("yyyy-MM-dd HH:mm:ss"));

Student student = new Student ("hyl",21, new Date());
student.setIntList(Arrays.asList(1, 2, 3));
 
String jsonStr = mapper.writeValueAsString(student);
System.out.println(jsonStr);
 
结果：
{
  "name" : "hyl",
  "age" : 21,
  "sendTime" : "2020-07-23 13:14:36",
  "intList" : [ 1, 2, 3 ]
}

把一个对象集合转换为一个 Java里面的数组

public class Main2 {
	public static void main(String[] args) throws Exception{
		ObjectMapper objectMapper = new ObjectMapper();
		//序列化的时候序列对象的所有属性
		objectMapper.setSerializationInclusion(Include.NON_DEFAULT);
		
		List<Person> personList = Arrays.asList(
                Person.builder().age(10).name("张三").list(Arrays.asList("爱吃", "爱喝", "爱玩")).build(),
                Person.builder().age(11).name("李四").list(Arrays.asList("爱谁", "爱你", "爱我")).build()
        );
		
		//先转换为json字符串
		String personStr = objectMapper.writeValueAsString(persons);
		
		//反序列化为List<user> 集合,1需要通过 TypeReference 来具体传递值
		List<Person> persons2 = objectMapper.readValue(personStr, new TypeReference<List<Person>>() {});
		
		for(Person person : persons2) {
			System.out.println(person);
		}
		
		//2,通过 JavaType 来进行处理返回
		JavaType javaType = objectMapper.getTypeFactory().constructParametricType(List.class, Person.class);
		List<Person> persons3 = objectMapper.readValue(personStr, javaType);
		
		for(Person person : persons3) {
			System.out.println(person);
		}
	}
}

在 impl 实现类中使用 ObjectMapper

当做 bean 注入

@Resource
private ObjectMapper objectMapper;