jackson 中各种 json 类型相互转换

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());
    }

}