《JSON筆記之二》----封裝JSONUtil

許多java開發人員對於fastjson再也熟悉不過了，這是alibaba開源的依賴，使用fastjson能夠使咱們很容易的把請求json串轉換成爲咱們所須要的對象、list、map等對象格式，對於開發帶來了不少的遍歷，具體的詳細操做就不詳細介紹了。

下面進入咱們的正題，最近開發項目和學習中封裝了一個JSONUtil類，使用也挺方便，因此就給你們分享一下吧！

package cn.itwx.mybatis.common;

import com.alibaba.fastjson.JSON;
import com.alibaba.fastjson.JSONArray;
import com.fasterxml.jackson.core.JsonProcessingException;
import com.fasterxml.jackson.core.type.TypeReference;
import com.fasterxml.jackson.databind.ObjectMapper;
//import com.sun.istack.internal.Nullable;
import lombok.AllArgsConstructor;
import lombok.Data;
import lombok.NoArgsConstructor;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.lang.Nullable;

import java.io.IOException;
import java.util.List;
import java.util.Map;

/**
 * @author: wx
 * @create: 2018-04-24 17:20
 **/
public class JsonUtils {

    public static final ObjectMapper mapper = new ObjectMapper();

    private static final Logger logger = LoggerFactory.getLogger(JsonUtils.class);

    /**
     * 將對象轉換成json格式
     * @param obj
     * @return
     */
    @Nullable
    public static String serialize(Object obj) {
        if (obj == null) {
            return null;
        }
        if (obj.getClass() == String.class) {
            return (String) obj;
        }
        try {
            return mapper.writeValueAsString(obj);
        } catch (JsonProcessingException e) {
            logger.error("json序列化出錯：" + obj, e);
            return null;
        }
    }

    /**
     * 將json轉換成對象的格式
     * @param json
     * @param tClass
     * @param <T>
     * @return
     */
    @Nullable
    public static <T> T parse(String json, Class<T> tClass) {
        try {
            return mapper.readValue(json, tClass);
        } catch (IOException e) {
            logger.error("json解析出錯：" + json, e);
            return null;
        }
    }

    /**
     * 將一個json轉換成list
     * @param json
     * @param eClass
     * @param <E>
     * @return
     */
    @Nullable
    public static <E> List<E> parseList(String json, Class<E> eClass) {
        try {
            return mapper.readValue(json, mapper.getTypeFactory().constructCollectionType(List.class, eClass));
        } catch (IOException e) {
            logger.error("json解析出錯：" + json, e);
            return null;
        }
    }

    /**
     * 將json解析成map
     * @param json
     * @param kClass
     * @param vClass
     * @param <K>
     * @param <V>
     * @return
     */
    @Nullable
    public static <K, V> Map<K, V> parseMap(String json, Class<K> kClass, Class<V> vClass) {
        try {
            return mapper.readValue(json, mapper.getTypeFactory().constructMapType(Map.class, kClass, vClass));
        } catch (IOException e) {
            logger.error("json解析出錯：" + json, e);
            return null;
        }
    }

    /**
     * 解析複雜類型的json串，適用以上全部的格式
     * @param json
     * @param type
     * @param <T>
     * @return
     */
    @Nullable
    public static <T> T nativeRead(String json, TypeReference<T> type) {
        try {
            return mapper.readValue(json, type);
        } catch (IOException e) {
            logger.error("json解析出錯：" + json, e);
            return null;
        }
    }
}

二、爲了驗證json解析格式是否正確，因此我專門在這個類裏面定義一個內部類和方法驗證，附上源代碼，有興趣的小夥伴們能夠親自操做一下。

對於這段代碼中可能會有小夥伴對於@Data、@Nullable\@NoArgsConstructor等註解會感到困惑，這些事lombok的註解方式，有興趣或者技術大佬能夠下面留言你們一些說下他的用法，這裏小編先不敘述了，等待詳解哦

public class JsonUtils {

  ......//省去上面的封裝方法

    //內部類
    @Data   //次註解能夠省去類中的set\get方法
    @NoArgsConstructor//註解無參構造
    @AllArgsConstructor//有參構造
    static class User{
        String name;
        int age;
    }
//定義的主方法
    public static void main(String[] args) {
        User user = new User("lisi",23);
        //json序列化：將對象轉換爲json串
        String json = serialize(user);
        System.out.println("json="+json);

        //json反序列化：將json串轉換成對象
        User parse = parse(json, User.class);
        System.out.println("user=" + parse);

        //將json轉換成對象list
        String json = "[12,23,63,64]";
        List<Integer> integers = parseList(json, Integer.class);
        System.out.println("list="+integers);
        String userJson = "[{\"name\":\"lisi\",\"age\":21},{\"name\":\"ahua\",\"age\":32},{\"name\":\"llk\",\"age\":23}]";
        //自定義JOSNUtil工具類
        List<User> users = parseList(userJson, User.class);
        System.out.println("users=" + users);
        //使用JSON類
        List<User> userList = JSON.parseArray(userJson, User.class);
        System.out.println("userList =" + userList);
        //使用JSON的子類，JSONArray
        List<User> list = JSONArray.parseArray(userJson, User.class);
        System.out.println("List = "+ list);

        //將json轉換成map
        //language=JSON
        String json = "{\"name\":\"Jack\",\"age\":\"23\"}";
        Map<String, String> map = parseMap(json, String.class, String.class);
        System.out.println("map:"+map);


        //json串爲map複雜類型
        //language=JSON
        String json = "[{\"name\":\"ROSE\",\"age\":\"32\"},{\"name\":\"jack\",\"sex\":\"m\"}]";
        List<Map<String, String>> maps = nativeRead(json, new TypeReference<List<Map<String, String>>>() {
        });//匿名內部類

        //循環List
        for (Map<String ,String> map : maps){
            System.out.println("map="+map);
        }
}

細心的小夥伴們可能會發現我同時用了fastjson去解析串，目的就是驗證這個工具類是否解析的格式有問題，因此有疑問或者有問題的夥伴們及時溝通哈！