Java常用JSON库FastJson,Gson,Jackson,Json-lib性能及特点比较，常用工具方法

迷南。 2021-12-11 08:47 313阅读 0赞

### Java常用JSON库性能及特点比较，常用工具方法 ###

*  四种库序列化，反序列化性能对比
 *  四种库对空值属性的处理
 *   *  测试
     *  结果
     *  结论
 *  四种库的工具类
 *   *  FastJsonUtil
     *  GsonUtil
     *  JacksonUtil
     *  JsonLibUtil

# 四种库序列化，反序列化性能对比 #

*  [JMH做的序列化,反序列化的性能测试][JMH]
 *  10W次测试结果如下  
    序列化性能：FastJson>Jackson>Gson>Jsonlib  
    反序列化性能：Gson>Jackson>FastJson>Jsonlib  
    ![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2RoYmZqaA_size_16_color_FFFFFF_t_70]

# 四种库对空值属性的处理 #

## 测试 ##

import lombok.AllArgsConstructor;
    import lombok.Getter;
    import lombok.Setter;
    
    /** * json测试对象 * * @author fan */
    @Setter
    @Getter
    @AllArgsConstructor
    public class Student { 
        private String name;
        private String password;
        private Integer age;
        private String[] hobbies;
        private Student deskMate;
    }

import com.ultra.util.FastJsonUtil;
    import com.ultra.util.GsonUtil;
    import com.ultra.util.JacksonUtil;
    import com.ultra.util.JsonLibUtil;
    import org.junit.Test;
    
    /** * json测试工具 * * @author fan */
    public class JsonUtilTest { 
        @Test
        public void testJson() { 
            Student student = new Student("AA", null, null, null, null);
            System.out.println("FastJson: " + FastJsonUtil.getJson(student));
            System.out.println("Gson: " + GsonUtil.bean2Json(student));
            System.out.println("Jackson: " + JacksonUtil.bean2Json(student));
            System.out.println("JsonLib: " + JsonLibUtil.bean2Json(student));
    
        }
    }

## 结果 ##

FastJson: { "name":"AA"}
    Gson: { "name":"AA"}
    Jackson: { "name":"AA","password":null,"age":null,"hobbies":null,"deskMate":null}
    JsonLib: { "age":0,"deskMate":null,"hobbies":[],"name":"AA","password":""}

## 结论 ##

*  FastJson：忽略空值的属性，空集合的属性
 *  Gson：忽略空值的属性，空集合的属性
 *  Jackson：空值的属性和空集合的属性值是null
 *  JsonLib：基本数据类型包装类会初始化值，String属性会初始化""；其他空值属性的值是null,空集合的属性值是\[\]

# 四种库的工具类 #

## FastJsonUtil ##

import com.alibaba.fastjson.JSON;
    import com.alibaba.fastjson.JSONObject;
    
    import java.util.List;
    
    /** * @author admin */
    public class FastJsonUtil { 
    
        /** * json转对象 * * @param jsonString json * @param requestType <T>类型的class对象 * @param <T> 对象类型 * @return 对象 */
        public static <T> T json2Bean(String jsonString, Class<T> requestType) { 
            return JSON.parseObject(jsonString, requestType);
        }
    
        /** * json转对象集合 * * @param jsonString json * @return 对象集合 */
        public static <T> List<T> json2Beans(String jsonString, Class<T> requestType) { 
            return JSON.parseArray(jsonString, requestType);
        }
    
        /** * 对象转json * * @param javaObject 对象 * @return json */
        public static String bean2Json(Object javaObject) { 
            return JSONObject.toJSONString(javaObject);
        }
    
        /** * 集合转json * * @param list 集合或者数组 * @return json串 */
        public static String beans2Json(Object list) { 
            return JSONObject.toJSONString(list);
        }
    }

## GsonUtil ##

import com.google.gson.Gson;
    import com.google.gson.GsonBuilder;
    import com.google.gson.reflect.TypeToken;
    
    import java.util.List;
    
    public class GsonUtil { 
        private static final Gson GSON = new GsonBuilder().create();
    
        /** * 对象、集合转json * * @param obj 对象 * @return json */
        public static String bean2Json(Object obj) { 
            return GSON.toJson(obj);
        }
    
        /** * json转对象 * * @param jsonString json * @param objClass 对象类型 * @param <T> 对象类型 * @return 对象 */
        public static <T> T json2Bean(String jsonString, Class<T> objClass) { 
            return GSON.fromJson(jsonString, objClass);
        }
    
        /** * json转集合 * TODO 返回的对象不是List<T>，而是List<com.google.gson.internal.LinkedTreeMap>，强转是会报错；待优化 * * @param jsonString json * @param <T> 对象类型 * @return 对象集合 */
        public static <T> List<T> json2Beans(String jsonString) { 
            return GSON.fromJson(jsonString, new TypeToken<List<T>>() { 
            }.getType());
        }
    
    }

## JacksonUtil ##

import com.fasterxml.jackson.core.JsonProcessingException;
    import com.fasterxml.jackson.databind.JavaType;
    import com.fasterxml.jackson.databind.ObjectMapper;
    import org.slf4j.Logger;
    import org.slf4j.LoggerFactory;
    
    import java.io.IOException;
    import java.util.ArrayList;
    import java.util.List;
    
    /** * @author admin */
    public class JacksonUtil { 
    
        private static final Logger logger = LoggerFactory.getLogger(JacksonUtil.class);
    
        private static final ObjectMapper MAPPER = new ObjectMapper();
    
        /** * 对象、集合转json * * @param obj 对象 * @return json */
        public static String bean2Json(Object obj) { 
            try { 
                return MAPPER.writeValueAsString(obj);
            } catch (JsonProcessingException e) { 
                logger.error("", e);
                return null;
            }
        }
    
        /** * json转对象 * * @param jsonString json * @param objClass 对象的Class * @param <T> 对象类型 * @return 对象 */
        public static <T> T json2Bean(String jsonString, Class<T> objClass) { 
            try { 
                return MAPPER.readValue(jsonString, objClass);
            } catch (IOException e) { 
                logger.error("", e);
                return null;
            }
        }
    
        /** * json转集合 * * @param jsonString json * @param objClass 对象的Class * @param <T> 对象类型 * @return 对象集合 */
        public static <T> List<T> json2Beans(String jsonString, Class<T> objClass) { 
            try { 
                JavaType javaType = getCollectionType(objClass);
                return MAPPER.readValue(jsonString, javaType);
            } catch (IOException e) { 
                logger.error("", e);
                return null;
            }
        }
    
        /** * 获取泛型的Collection Type * * @param elementClass 元素类 * @return JavaType Java类型 */
        private static JavaType getCollectionType(Class<?> elementClass) { 
            return MAPPER.getTypeFactory().constructParametricType(ArrayList.class, elementClass);
        }
    }

## JsonLibUtil ##

import net.sf.json.JSONArray;
    import net.sf.json.JSONObject;
    
    import java.util.ArrayList;
    import java.util.List;
    
    /** * 注意：bean2Json需要无参构造器 * * @author admin */
    public class JsonLibUtil { 
    
        /** * 对象转json * * @param obj 对象 * @return json */
        public static String bean2Json(Object obj) { 
            JSONObject jsonObject = JSONObject.fromObject(obj);
            return jsonObject.toString();
        }
    
        /** * 集合转json * * @param list 集合 * @return json */
        public static String beans2Json(Object list) { 
            JSONArray jsonArray = JSONArray.fromObject(list);
            return jsonArray.toString();
        }
    
        /** * json转对象 * * @param jsonString json * @param objClass 对象类型 * @param <T> 对象类型 * @return 对象 */
        public static <T> T json2Bean(String jsonString, Class<T> objClass) { 
            return (T) JSONObject.toBean(JSONObject.fromObject(jsonString), objClass);
        }
    
        /** * json转集合 * * @param jsonString json * @param objClass 对象类型 * @param <T> 对象类型 * @return 集合 */
        public static <T> List<T> json2Beans(String jsonString, Class<T> objClass) { 
            JSONArray jsonArray = JSONArray.fromObject(jsonString);
            return new ArrayList<T>(JSONArray.toCollection(jsonArray, objClass));
        }
    }

[JMH]: https://www.xncoding.com/2018/01/09/java/jsons.html
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2RoYmZqaA_size_16_color_FFFFFF_t_70]: /images/20211211/df7dea0af2474c78be0d55745f583b1a.png