jackson 中各种 json 类型相互转换
spring web 中默认使用 jackson
jackson 中解析 json 所用到的类
- com.fasterxml.jackson.databind.ObjectMapper;
ObjectMapper 是类似一个工具的类,其中包含了一些 json 转换的方法,一般在 spring 中通过 @Autowired 注入bean
- com.fasterxml.jackson.databind.JsonNode;
JsonNode 是类似 fastjson 中的JsonObject类,底层都是通过 LinkedHashMap 实现,但是只能 get 属性,不能 set 属性
- com.fasterxml.jackson.databind.node.ObjectNode;
ObjectNode 是 JsonNode 的子类,实现的 JsonNode 不能 set 属性的缺陷, 可以通过 objectMapper.createObjectNode() 创建ObjectNode实例,或者直接对 JsonNode 强制转换
- com.fasterxml.jackson.databind.node.ArrayNode;
ArrayNode 与 ObjectNode 类似,但是其代表的是一个列表类型的JSON对象,可通过 add() 方法添加元素,或者通过 addAll() 添加集合
- com.fasterxml.jackson.core.type.TypeReference;
TypeReference 是 objectMapper.readValue(String content, TypeReference<T> valueTypeRef) 方法将字符串解析成复杂对象是所需要的参数。
复杂对象指的是如 List<Bean>,Bean[],Map<String,Object> 等一系列广义集合类型
class Person {
private String id;
private String name;
//todo 省略getter/setter
}
String jsonStr = "{"id":"123","name":"张三"}";
Person person = objectMapper.readValue(jsonStr, Person.class);
String jsonArrayStr = "[{"id":"123","name":"张三"},{"id":"456","name":"李四"}]";
List<Person> personList = objectMapper.readValue(jsonArrayStr, new TypeReference<List<Person>>() {});
另外附上自己封装的 util 工具
package com.example.myutil;
import com.fasterxml.jackson.core.JsonProcessingException;
import com.fasterxml.jackson.core.type.TypeReference;
import com.fasterxml.jackson.databind.DeserializationFeature;
import com.fasterxml.jackson.databind.JsonNode;
import com.fasterxml.jackson.databind.ObjectMapper;
import com.fasterxml.jackson.databind.node.ObjectNode;
import java.util.ArrayList;
import java.util.Collections;
import java.util.List;
import java.util.Map;
public class JsonUtil {
public static final ObjectMapper objectMapper = new ObjectMapper();
static {
//忽略字段不匹配错误
objectMapper.configure(DeserializationFeature.FAIL_ON_UNKNOWN_PROPERTIES, false);
}
/**
* 创建 ObjectNode
* @return
*/
public static ObjectNode createJson() {
return objectMapper.createObjectNode();
}
/**
* 字符串转 java bean
* @param json
* @param clazz
* @param <T>
* @return
*/
public static <T> T string2Bean(String json, Class<T> clazz){
T t = null;
try {
t = objectMapper.readValue(json,clazz);
} catch (JsonProcessingException e) {
e.printStackTrace();
}
return t;
}
/**
* 字符串转 Map
* @param json
* @param clazz
* @param <T>
* @return
*/
public static <T> Map<String,Object> string2Map(String json, Class<T> clazz){
Map<String,Object> map = null;
try {
map = objectMapper.readValue(json, new TypeReference<Map<String,Object>>() {});
} catch (JsonProcessingException e) {
map = Collections.emptyMap();
e.printStackTrace();
}
return map;
}
/**
* 字符串转 List<Bean>
* @param json
* @param clazz
* @param <T>
* @return
*/
public static <T> List<T> string2BeanList(String json, Class<T> clazz){
List<T> t = null;
try {
t = objectMapper.readValue(json, new TypeReference<List<T>>() {});
} catch (JsonProcessingException e) {
t = Collections.emptyList();
e.printStackTrace();
}
return t;
}
/**
* 字符串转 Bean[]
* @param json
* @param clazz
* @param <T>
* @return
*/
public static <T> T[] string2BeanArray(String json, Class<T> clazz){
T[] t = null;
try {
t = objectMapper.readValue(json, new TypeReference<T[]>() {});
} catch (JsonProcessingException e) {
t = (T[])new Object[0];
e.printStackTrace();
}
return t;
}
/**
* 字符串转 JsonNode
* @param json
* @return
*/
public static JsonNode string2Json(String json) {
JsonNode jsonNode = null;
try {
jsonNode = objectMapper.readTree(json);
} catch (JsonProcessingException e) {
e.printStackTrace();
}
return jsonNode;
}
/**
* java bean 或者 Map 或者 JsonNode 转字符串
* @param o
* @return
*/
public static String object2String(Object o) {
String json = null;
try {
json = objectMapper.writeValueAsString(o);
} catch (JsonProcessingException e) {
e.printStackTrace();
}
return json;
}
/**
* java bean 或者 Map 或者 JsonNode 转 JsonNode
* @param o
* @return
*/
public static JsonNode object2Json(Object o) {
JsonNode jsonNode = null;
try {
String jsonString = objectMapper.writeValueAsString(o);
jsonNode = objectMapper.readTree(jsonString);
} catch (JsonProcessingException e) {
e.printStackTrace();
}
return jsonNode;
}
/**
* jsonNode 转 JsonNode
* @param jsonNode
* @return
*/
public static <T> T json2Bean(JsonNode jsonNode, Class<T> clazz) {
String json = jsonNode.toString();
return string2Bean(json, clazz);
}
public static void main(String[] args) {
ObjectNode person = objectMapper.createObjectNode();
person.put("id","1101");
person.put("name","张三");
person.put("age",35);
person.put("sex","男");
List<ObjectNode> children = new ArrayList<>(1);
ObjectNode child = objectMapper.createObjectNode();
child.put("id","1102");
child.put("name","张小三");
child.put("age",12);
child.put("sex","男");
children.add(child);
person.putArray("children").addAll(children);
System.out.println(person.toPrettyString());
}
}