操作json的工具

操作json的工具

1.常用工具的了解

性能对比

参考网址

• 序列化时，在少量数据时，jackson性能比fastson要好，当数据量越来越大时，fastson的性能要好于jackson；序列化时选取何种json库，可根据数据多少进行选择。

json字符串转换成java对象（反序列化）性能对比：

• 反序列化时，除在map转化有些不同，在少量数据时，jackson性能比fastson要好，当数据量越来越大时，fastson的性能要好于jackson

说明:

springboot初始集成了jackson

fastjson阿里的工具

Gson时谷歌的工具

json-lib 我没接触过,用的也少

2.三个依赖依次封装成工具类,操作json

2.1jackson

ackage com.shaoming.常用工具类的封装;

import java.io.IOException;

import com.fasterxml.jackson.core.JsonProcessingException;
import com.fasterxml.jackson.core.type.TypeReference;
import com.fasterxml.jackson.databind.JavaType;
import com.fasterxml.jackson.databind.ObjectMapper;
import com.fasterxml.jackson.databind.annotation.JsonSerialize.Inclusion;

import cn.hutool.core.util.StrUtil;

/**
 * jsonUtil工具类
 *
 * @author ryz
 * @since 2020-05-11
 */
public class JacksonUtil {


    private static ObjectMapper mapper = new ObjectMapper();

    /**
     * 对象转Json格式字符串
     * @param obj 对象
     * @return Json格式字符串
     */
    public static <T> String obj2String(T obj) {
        if (obj == null) {
            return null;
        }
        try {
            return obj instanceof String ? (String) obj : mapper.writeValueAsString(obj);
        } catch (JsonProcessingException e) {
            e.printStackTrace();
            return null;
        }
    }

    /**
     * 对象转Json格式字符串(格式化的Json字符串)
     * @param obj 对象
     * @return 美化的Json格式字符串
     */
    public static <T> String obj2StringPretty(T obj) {
        if (obj == null) {
            return null;
        }
        try {
            return obj instanceof String ? (String) obj : mapper.writerWithDefaultPrettyPrinter().writeValueAsString(obj);
        } catch (JsonProcessingException e) {
        	e.printStackTrace();
            return null;
        }
    }

    /**
     * 字符串转换为自定义对象
     * @param str 要转换的字符串
     * @param clazz 自定义对象的class对象
     * @return 自定义对象
     */
    public static <T> T jsonToObj(String str, Class<T> clazz){
        if(StrUtil.isEmpty(str) || clazz == null){
            return null;
        }
        try {
            return clazz.equals(String.class) ? (T) str : mapper.readValue(str, clazz);
        } catch (Exception e) {
        	e.printStackTrace();
            return null;
        }
    }


    /**
     * 集合对象与Json字符串之间的转换
     * @param str 要转换的字符串
     * @param typeReference 集合类型如List<Object>
     * @param <T> 
     * @return
     */
    public static <T> T jsonToObj(String str, TypeReference<T> typeReference) {
        if (StrUtil.isEmpty(str) || typeReference == null) {
            return null;
        }
        try {
            return (T) (typeReference.getType().equals(String.class) ? str : mapper.readValue(str, typeReference));
        } catch (IOException e) {
        	e.printStackTrace();
            return null;
        }
    }

    /**
     * 集合对象与Json字符串之间的转换
     * @param str 要转换的字符串
     * @param collectionClazz 集合类型
     * @param elementClazzes 自定义对象的class对象
     * @param <T>
     * @return
     */
    public static <T> T string2Obj(String str, Class<?> collectionClazz, Class<?>... elementClazzes) {
        JavaType javaType = mapper.getTypeFactory().constructParametricType(collectionClazz, elementClazzes);
        try {
            return mapper.readValue(str, javaType);
        } catch (IOException e) {
        	e.printStackTrace();
            return null;
        }
    }
}

2.2FastJson

package com.shaoming.常用工具类的封装;

import java.util.List;
import java.util.Map;

import com.alibaba.fastjson.JSON;
import com.alibaba.fastjson.TypeReference;

/**
 * 
 * @Description: 基于fastjson封装的json转换工具类
 * @author hbb
 * @date 2019年1月1日
 *
 */
public class FastJsonUtil {

	/**
	 * 功能描述：把JSON数据转换成指定的java对象
	 * 
	 * @param jsonData JSON数据
	 * @param clazz    指定的java对象
	 * @return 指定的java对象
	 */
	public static <T> T getJsonToBean(String jsonData, Class<T> clazz) {
		return JSON.parseObject(jsonData, clazz);
	}

	/**
	 * 功能描述：把java对象转换成JSON数据
	 * 
	 * @param object java对象
	 * @return JSON数据
	 */
	public static String getBeanToJson(Object object) {
		return JSON.toJSONString(object);
	}

	/**
	 * 功能描述：把JSON数据转换成指定的java对象列表
	 * 
	 * @param jsonData JSON数据
	 * @param clazz    指定的java对象
	 * @return List<T>
	 */
	public static <T> List<T> getJsonToList(String jsonData, Class<T> clazz) {
		return JSON.parseArray(jsonData, clazz);
	}

	/**
	 * 功能描述：把JSON数据转换成较为复杂的List<Map<String, Object>>
	 * 
	 * @param jsonData JSON数据
	 * @return List<Map<String, Object>>
	 */
	public static List<Map<String, Object>> getJsonToListMap(String jsonData) {
		return JSON.parseObject(jsonData, new TypeReference<List<Map<String, Object>>>() {
		});
	}

}

2.3Gson

package com.shaoming.常用工具类的封装;

import java.util.List;
import java.util.Map;

import com.google.gson.Gson;
import com.google.gson.reflect.TypeToken;

/**
* 
* @Description: 基于Gson封装的jsonUtil
* @author hbb
* @date 2019年1月1日
*
*/
public class GsonUtil {
   private static Gson gson = null;
   static {
       if (gson == null) {
           gson = new Gson();
       }
   }

   private GsonUtil() {
   }

   /**
    * 对象转成json
    *
    * @param object
    * @return json
    */
   public static String objectToJson(Object object) {
       String json = null;
       if (gson != null) {
          json = gson.toJson(object);
       }
       return json;
   }

   /**
    * Json转成对象
    *
    * @param json
    * @param cls
    * @return 对象
    */
   public static <T> T gsonToBean(String json, Class<T> cls) {
       T t = null;
       if (gson != null) {
           t = gson.fromJson(json, cls);
       }
       return t;
   }

   /**
    * json转成list<T>
    *
    * @param json
    * @param cls
    * @return list<T>
    */
   public static <T> List<T> gsonToList(String json, Class<T> cls) {
       List<T> list = null;
       if (gson != null) {
           list = gson.fromJson(json, new TypeToken<List<T>>() {
           }.getType());
       }
       return list;
   }

   /**
    * json转成list中有map的
    *
    * @param json
    * @return List<Map<String, T>>
    */
   public static <T> List<Map<String, T>> gsonToListMaps(String json) {
       List<Map<String, T>> list = null;
       if (gson != null) {
           list = gson.fromJson(json, new TypeToken<List<Map<String, T>>>() {
           }.getType());
       }
       return list;
   }

   /**
    * json转成map的
    *
    * @param json
    * @return Map<String, T>
    */
   public static <T> Map<String, T> gsonToMaps(String json) {
       Map<String, T> map = null;
       if (gson != null) {
           map = gson.fromJson(json, new TypeToken<Map<String, T>>() {
           }.getType());
       }
       return map;
   }
}