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 工具

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 com.fasterxml.jackson.databind.type.TypeFactory;
import java.util.ArrayList;
import java.util.Iterator;
import java.util.List;
import java.util.Map;
import java.util.stream.Collectors;

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 stringToBean(String json, Class<T> clazz){
        T t = null;
        try {
            t = objectMapper.readValue(json,clazz);
        } catch (JsonProcessingException e) {
            e.printStackTrace();
        }
        return t;
    }

    /**
     * 字符串转 Map
     * @param json
     * @return
     */
    public static Map<String,Object> stringToMap(String json){
        Map<String,Object> map = null;
        try {
            map = objectMapper.readValue(json, new TypeReference<Map<String,Object>>() {});
        } catch (JsonProcessingException e) {
            e.printStackTrace();
        }
        return map;
    }

    /**
     * 字符串转 List<Bean>
     * @param json
     * @param <T>
     * @return
     */
    public static <T> List<T> stringToBeanList(String json,Class<T> clazz){
        List<T> t = null;
        try {
            t = objectMapper.readValue(json, TypeFactory.defaultInstance().constructCollectionType(List.class, clazz));
        } catch (JsonProcessingException e) {
            e.printStackTrace();
        }
        return t;
    }

    /**
     * 字符串转 Bean[]
     * @param json
     * @param <T>
     * @return
     */
    public static <T> T[] stringToBeanArray(String json){
        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 stringToJson(String json) {
        JsonNode jsonNode = null;
        try {
            jsonNode = objectMapper.readTree(json);
        } catch (JsonProcessingException e) {
            e.printStackTrace();
        }
        return jsonNode;
    }

    /**
     * java bean 转 JsonNode
     * @param obj
     * @return
     */
    public static JsonNode beanToJson(Object obj) {
        return objectMapper.valueToTree(obj);
    }

    /**
     * java bean 转 string
     * @param obj
     * @return
     */
    public static String beanToString(Object obj) {
        return objectToString(obj);
    }

    /**
     *  java bean 转 Map
     * @param obj
     * @return
     */
    public static Map<String,Object> beanToMap(Object obj) {
        return objectMapper.convertValue(obj, new TypeReference<Map<String, Object>>() {});
    }

    /**
     * jsonNode 转 java bean
     * @param jsonNode
     * @param clazz
     * @return
     */
    public static <T> T jsonToBean(JsonNode jsonNode, Class<T> clazz) {
        return objectMapper.convertValue(jsonNode,clazz);
    }

    /**
     * jsonNode 转 String
     * @param jsonNode
     * @return
     */
    public static String jsonToString(JsonNode jsonNode) {
        return objectToString(jsonNode);
    }

    /**
     * jsonNode 转 Map
     * @param jsonNode
     * @return
     */
    public static Map<String,Object> jsonToMap(JsonNode jsonNode) {
        return objectMapper.convertValue(jsonNode, new TypeReference<Map<String, Object>>() {});
    }

    /**
     * jsonNode 转 List<JsonNode>，若jsonNode不是数组，则返回null
     * @param jsonNode
     * @return
     */
    public static List<JsonNode> jsonToList(JsonNode jsonNode) {
        List<JsonNode> list = null;
        if (jsonNode.isArray()) {
            Iterator<JsonNode> iterator = jsonNode.elements();
            list = new ArrayList<>();
            iterator.forEachRemaining(list::add);
        }
        return list;
    }

    /**
     * Map 转 JsonNode
     * @param obj
     * @return
     */
    public static JsonNode mapToJson(Object obj) {
        return objectMapper.valueToTree(obj);
    }

    /**
     * Map 转 java bean
     * @param map
     * @param clazz
     * @param <T>
     * @return
     */
    public static <T> T mapToBean(Map map,Class<T> clazz) {
        return objectMapper.convertValue(map,clazz);
    }

    /**
     * Map 转 String
     * @param map
     * @return
     */
    public static String mapToString(Map map) {
        return objectToString(map);
    }

    /**
     * List<Bean> 转 List<JsonNode>
     * @param beanList
     * @param <T>
     * @return
     */
    public static <T> List<JsonNode> beanListToJsonList(List<T> beanList) {
        return beanList.stream().map(JsonUtil::beanToJson).collect(Collectors.toList());
    }

    /**
     * List<Bean> 转 List<Map>
     * @param beanList
     * @param <T>
     * @return
     */
    public static <T> List<Map<String,Object>> beanListToMapList(List<T> beanList) {
        return beanList.stream().map(JsonUtil::beanToMap).collect(Collectors.toList());
    }

    /**
     * List<JsonNode> 转 List<Bean>
     * @param jsonNodeList
     * @param clazz
     * @param <T>
     * @return
     */
    public static <T> List<T> jsonListToBeanList(List<JsonNode> jsonNodeList,Class<T> clazz) {
        return jsonNodeList.stream().map(jsonNode -> jsonToBean(jsonNode,clazz)).collect(Collectors.toList());
    }

    /**
     * List<JsonNode> 转 List<Map>
     * @param jsonNodeList
     * @return
     */
    public static List<Map<String,Object>> jsonListToMapList(List<JsonNode> jsonNodeList) {
        return jsonNodeList.stream().map(JsonUtil::jsonToMap).collect(Collectors.toList());
    }

    /**
     * List<Map> 转 List<JsonNode>
     * @param mapList
     * @return
     */
    public static List<JsonNode> mapListToJsonList(List<Map> mapList) {
        return mapList.stream().map(JsonUtil::mapToJson).collect(Collectors.toList());
    }

    /**
     * List<Map> 转 List<Bean>
     * @param mapList
     * @param clazz
     * @param <T>
     * @return
     */
    public static <T> List<T> mapListToBeanList(List<Map> mapList,Class<T> clazz) {
        return mapList.stream().map(map -> mapToBean(map,clazz)).collect(Collectors.toList());
    }

    /**
     * object 转 string
     * @param obj
     * @return
     */
    public static String objectToString(Object obj) {
        String json = null;
        try {
            json = objectMapper.writeValueAsString(obj);
        } catch (JsonProcessingException e) {
            e.printStackTrace();
        }
        return json;
    }
}