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

}