对象和 json 互转四种方式 json-lib、Gson、FastJson、Jackson[通俗易懂]

文章目录

一、 json-lib

json-lib最开始的也是应用最广泛的json解析工具，json-lib 不好的地方确实是依赖于很多第三方包，
包括commons-beanutils.jar，commons-collections-3.2.jar，commons-lang-2.6.jar，commons-logging-1.1.1.jar，ezmorph-1.0.6.jar，
对于复杂类型的转换，json-lib对于json转换成bean还有缺陷，比如一个类里面会出现另一个类的list或者map集合，json-lib从json到bean的转换就会出现问题。
json-lib在功能和性能上面都不能满足现在互联网化的需求。

二、 Google的Gson

1.简介

（1）Gson是目前功能最全的Json解析神器，Gson当初是为因应Google公司内部需求而由Google自行研发而来但自从在2008年五月公开发布第一版后已被许多公司或用户应用。
Gson的应用主要为toJson与fromJson两个转换函数，无依赖，不需要例外额外的jar，能够直接跑在JDK上。
而在使用这种对象转换之前需先创建好对象的类型以及其成员才能成功的将JSON字符串成功转换成相对应的对象。
类里面只要有get和set方法，Gson完全可以将复杂类型的json到bean或bean到json的转换，是JSON解析的神器。
Gson在功能上面无可挑剔，但是性能上面比FastJson有所差距。
（2）默认是不序列化null值对应的key的，具体案例如下：

public static void main(String[] args) throws JsonGenerationException, JsonMappingException, IOException { 
   
		AutoPartsSearchRequest request = new AutoPartsSearchRequest();
		request.setKeywords("123");
		request.setSortingField("234242");
		Gson g = new GsonBuilder().create();
		String str = g.toJson(request);
		System.out.println(str);
		//输出结果：{"sortingField":"234242","keywords":"123"}
	}

若是想序列化null值对应的key，只需要将以上创建代码改成以下代码就行：

Gson g = new GsonBuilder().serializeNulls().create();

若是想转行null为空字符串””，则需要手动处理了

（3）主要类介绍
Gson类：解析json的最基础的工具类
JsonParser类：解析器来解析JSON到JsonElements的解析树
JsonElement类：一个类代表的JSON元素
JsonObject类：JSON对象类型
JsonArray类：JsonObject数组
TypeToken类：用于创建type，比如泛型List<?>

（4）bean转换json

Gson gson = new Gson();
String json = gson.toJson(obj);
//obj是对象

（5） json转换bean

Gson gson = new Gson();
String json = "{\"id\":\"2\",\"name\":\"Json技术\"}";
Book book = gson.fromJson(json, Book.class);

（6） json转换复杂的bean，比如List，Set
将json转换成复杂类型的bean,需要使用TypeToken

Gson gson = new Gson();
String json = "[{\"id\":\"1\",\"name\":\"Json技术\"},{\"id\":\"2\",\"name\":\"java技术\"}]";
//将json转换成List
List list = gson.fromJson(json,new TypeToken<LIST>() { 
   }.getType());
//将json转换成Set
Set set = gson.fromJson(json,new TypeToken<SET>() { 
   }.getType());

（7）通过json对象直接操作json以及一些json的工具
a) 格式化Json

String json = "[{\"id\":\"1\",\"name\":\"Json技术\"},{\"id\":\"2\",\"name\":\"java技术\"}]";
Gson gson = new GsonBuilder().setPrettyPrinting().create();
JsonParser jp = new JsonParser();
JsonElement je = jp.parse(json);
json = gson.toJson(je);

b) 判断字符串是否是json,通过捕捉的异常来判断是否是json

String json = "[{\"id\":\"1\",\"name\":\"Json技术\"},{\"id\":\"2\",\"name\":\"java技术\"}]";
boolean jsonFlag;
try { 
   
new JsonParser().parse(str).getAsJsonObject();
jsonFlag = true;
} catch (Exception e) { 
   
jsonFlag = false;
}

c) 从json串中获取属性

String json = "{\"id\":\"1\",\"name\":\"Json技术\"}";
String propertyName = 'id';
String propertyValue = "";
try { 
   
JsonParser jsonParser = new JsonParser();
JsonElement element = jsonParser.parse(json);
JsonObject jsonObj = element.getAsJsonObject();
propertyValue = jsonObj.get(propertyName).toString();
} catch (Exception e) { 
   
propertyValue = null;
}

d) 除去json中的某个属性

String json = "{\"id\":\"1\",\"name\":\"Json技术\"}";
String propertyName = 'id';
JsonParser jsonParser = new JsonParser();
JsonElement element = jsonParser.parse(json);
JsonObject jsonObj = element.getAsJsonObject();
jsonObj.remove(propertyName);
json = jsonObj.toString();

e) 向json中添加属性

String json = "{\"id\":\"1\",\"name\":\"Json技术\"}";
String propertyName = 'desc';
Object propertyValue = "json各种技术的调研";
JsonParser jsonParser = new JsonParser();
JsonElement element = jsonParser.parse(json);
JsonObject jsonObj = element.getAsJsonObject();
jsonObj.addProperty(propertyName, new Gson().toJson(propertyValue));
json = jsonObj.toString();

f) 修改json中的属性

String json = "{\"id\":\"1\",\"name\":\"Json技术\"}";
String propertyName = 'name';
Object propertyValue = "json各种技术的调研";
JsonParser jsonParser = new JsonParser();
JsonElement element = jsonParser.parse(json);
JsonObject jsonObj = element.getAsJsonObject();
jsonObj.remove(propertyName);
jsonObj.addProperty(propertyName, new Gson().toJson(propertyValue));
json = jsonObj.toString();

g) 判断json中是否有属性

String json = "{\"id\":\"1\",\"name\":\"Json技术\"}";
String propertyName = 'name';
boolean isContains = false ;
JsonParser jsonParser = new JsonParser();
JsonElement element = jsonParser.parse(json);
JsonObject jsonObj = element.getAsJsonObject();
isContains = jsonObj.has(propertyName);

h) json中日期格式的处理

GsonBuilder builder = new GsonBuilder();
builder.setDateFormat("yyyy-MM-dd HH:mm:ss.SSS");
Gson gson = builder.create();

然后使用gson对象进行json的处理，如果出现日期Date类的对象，就会按照设置的格式进行处理

i) json中对于Html的转义

Gson gson = new Gson();

这种对象默认对Html进行转义，如果不想转义使用下面的方法

GsonBuilder builder = new GsonBuilder();
builder.disableHtmlEscaping();
Gson gson = builder.create();

2. 配置步骤

1. MAVEN 依赖引入

 <!--gson-->
 <dependency>
     <groupId>com.google.code.gson</groupId>
     <artifactId>gson</artifactId>
     <version>2.8.0</version>
 </dependency>

2. gsonUtil 工具类

package com.dechnic.common.util;

import com.dechnic.common.anno.gson.Exclude;
import com.dechnic.common.po.ObjectTypeAdapter;
import com.google.gson.ExclusionStrategy;
import com.google.gson.FieldAttributes;
import com.google.gson.Gson;
import com.google.gson.GsonBuilder;
import com.google.gson.internal.LinkedTreeMap;
import com.google.gson.reflect.TypeToken;

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

/** * @description: * @author:houqd * @time: 2022/6/27 17:31 */

public class GsonUtll { 
   
    private static Gson gson;
    static { 
   
        ExclusionStrategy strategy = new ExclusionStrategy() { 
   
            @Override
            public boolean shouldSkipField(FieldAttributes f) { 
   
                return f.getAnnotation(Exclude.class) !=null;
            }

            @Override
            public boolean shouldSkipClass(Class<?> clazz) { 
   
                return false;
            }
        };
        gson = new GsonBuilder().disableHtmlEscaping().setExclusionStrategies(strategy).registerTypeAdapter(new TypeToken<Map<String,Object>>(){ 
   }.getType(),new ObjectTypeAdapter()).serializeNulls().create();
    }
    public static Map<String,Object> jsonStr2Map(String jsonStr){ 
   
        return gson.fromJson(jsonStr, new TypeToken<Map<String, Object>>() { 
   
        }.getType());
    }
    public static List<Map<String,Object>> jsonStr2ListMap(String jsonStr){ 
   
        return gson.fromJson(jsonStr, new TypeToken<List<Map<String, Object>>>() { 
   
        }.getType());
    }
    public static String toJSON(Object object){ 
   
        return gson.toJson(object);
    }
    public static <T> List<T> json2ListBean(String result, Class<T> t){ 
   
        List list = gson.fromJson(result, new TypeToken<List>() { 
   
        }.getType());
        List list2 = new ArrayList();
        for (Object o : list) { 
   
            list2.add(json2Bean(toJSON(o),t));
        }
        return list2;
    }
    public static <T> T json2Bean(String result,Class<T>t){ 
   
        return gson.fromJson(result, t);
    }

}

3. 排除不要序列化的熟悉注解类 Exclude

package com.dechnic.common.anno.gson;

import java.lang.annotation.ElementType;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;

@Retention(RetentionPolicy.RUNTIME)
@Target(ElementType.FIELD)
public @interface Exclude { 
   
}

三. 阿里巴巴的FastJson

1.简介

（1）Fastjson是一个Java语言编写的高性能的JSON处理器,由阿里巴巴公司开发。
无依赖，不需要例外额外的jar，能够直接跑在JDK上。
FastJson在复杂类型的Bean转换Json上会出现一些问题，可能会出现引用的类型，导致Json转换出错，需要制定引用。
FastJson采用独创的算法，将parse的速度提升到极致，超过所有json库。
（2）fastJson在转换java对象为json的时候，默认是不序列化null值对应的key的，也就是说当对象里面的属性为空的时候，在转换成json时，不序列化那些为null值的属性
但是如果想把null对应的key序列化出来呢？
那就要仔细看看fastjson转换java对象为json的时候的入参了：也就是这个方法：

JSONObject.toJSONString(Object object, SerializerFeature… features)

Fastjson的SerializerFeature序列化属性：

QuoteFieldNames———-输出key时是否使用双引号,默认为true 
WriteMapNullValue——–是否输出值为null的字段,默认为false 
WriteNullNumberAsZero—-数值字段如果为null,输出为0,而非null 
WriteNullListAsEmpty—–List字段如果为null,输出为[],而非null 
WriteNullStringAsEmpty—字符类型字段如果为null,输出为”“,而非null 
WriteNullBooleanAsFalse–Boolean字段如果为null,输出为false,而非null

结合上面，SerializerFeature… features是个数组，那么我们可以传入我们想要的参数，比如想序列化null，案例如下：

public static void main(String[] args) { 
   
		AutoPartsSearchRequest request = new AutoPartsSearchRequest();
		request.setKeywords("123");
		request.setSortingField("234242");
		String str = JSONObject.toJSONString(request, SerializerFeature.WriteMapNullValue);
		System.out.println(str);
	}

（3） bean转换json将对象转换成格式化的json

JSON.toJSONString(obj,true);

（4）将对象转换成非格式化的json

JSON.toJSONString(obj,false);

obj设计对象
对于复杂类型的转换,对于重复的引用在转成json串后在json串中出现引用的字符,比如 ref”:”[0].books[1]

Student stu = new Student();
Set books= new HashSet();
Book book = new Book();
books.add(book);
stu.setBooks(books);
List list = new ArrayList();
for(int i=0;i<5;i++)
list.add(stu);
String json = JSON.toJSONString(list,true);

（5） json转换bean

String json = "{\"id\":\"2\",\"name\":\"Json技术\"}";
Book book = JSON.parseObject(json, Book.class);

（6） json转换复杂的bean，比如List，Map

String json = "[{\"id\":\"1\",\"name\":\"Json技术\"},{\"id\":\"2\",\"name\":\"java技术\"}]";
//将json转换成List
List list = JSON.parseObject(json,new TypeReference<ARRAYLIST>(){ 
   });
//将json转换成Set
Set set = JSON.parseObject(json,new TypeReference<HASHSET>(){ 
   });

（7）通过json对象直接操作json
a) 从json串中获取属性

String propertyName = 'id';
String propertyValue = "";
String json = "{\"id\":\"1\",\"name\":\"Json技术\"}";
JSONObject obj = JSON.parseObject(json);
propertyValue = obj.get(propertyName));

b) 除去json中的某个属性

String propertyName = 'id';
String propertyValue = "";
String json = "{\"id\":\"1\",\"name\":\"Json技术\"}";
JSONObject obj = JSON.parseObject(json);
Set set = obj.keySet();
propertyValue = set.remove(propertyName);
json = obj.toString();

c) 向json中添加属性

String propertyName = 'desc';
Object propertyValue = "json的玩意儿";
String json = "{\"id\":\"1\",\"name\":\"Json技术\"}";
JSONObject obj = JSON.parseObject(json);
obj.put(propertyName, JSON.toJSONString(propertyValue));
json = obj.toString();

d) 修改json中的属性

String propertyName = 'name';
Object propertyValue = "json的玩意儿";
String json = "{\"id\":\"1\",\"name\":\"Json技术\"}";
JSONObject obj = JSON.parseObject(json);
Set set = obj.keySet();
if(set.contains(propertyName))
obj.put(propertyName, JSON.toJSONString(propertyValue));
json = obj.toString();

e) 判断json中是否有属性

String propertyName = 'name';
boolean isContain = false;
String json = "{\"id\":\"1\",\"name\":\"Json技术\"}";
JSONObject obj = JSON.parseObject(json);
Set set = obj.keySet();
isContain = set.contains(propertyName);

f) json中日期格式的处理

Object obj = new Date();
String json = JSON.toJSONStringWithDateFormat(obj, "yyyy-MM-dd HH:mm:ss.SSS");

简单的使用场景:

2.配置步骤

1.引入maven

<dependency>
     <groupId>com.alibaba</groupId>
     <artifactId>fastjson</artifactId>
     <version>1.2.83</version>
 </dependency>

2. 配置 CustomFastjsonConfig

package com.example.demo2.config;/** * @className: WebMvcConfig * @author: houqd * @date: 2022/11/4 **/

import com.alibaba.fastjson.serializer.SerializerFeature;
import com.alibaba.fastjson.support.config.FastJsonConfig;
import com.alibaba.fastjson.support.spring.FastJsonHttpMessageConverter;
import org.springframework.boot.autoconfigure.http.HttpMessageConverters;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.http.MediaType;

import java.nio.charset.Charset;
import java.util.ArrayList;
import java.util.List;

/** * @description: * @author:houqd * @time: 2022/11/4 13:55 */
@Configuration
public class CustomFastjsonConfig { 
   
    @Bean
    public FastJsonHttpMessageConverter fastjsonHttpMessageConverters() { 
   
        FastJsonHttpMessageConverter converter = new FastJsonHttpMessageConverter();
        FastJsonConfig fastJsonConfig = new FastJsonConfig();
        fastJsonConfig.setCharset(Charset.forName("UTF-8"));
        fastJsonConfig.setDateFormat("yyyy-MM-dd HH:mm:ss");
        //设置序列化特征
        SerializerFeature[] serializerFeatures = new SerializerFeature[]{ 
   
                //WriteNullStringAsEmpty: 如果字符串等于 null，那么会被序列化成空字符串 ""
                SerializerFeature.WriteNonStringKeyAsString,
                // WriteNullNumberAsZero: 如果数字等于 null，那么会被序列化成 0
                SerializerFeature.WriteNullNumberAsZero,
                // WriteNullBooleanAsFalse: 如果布尔类型等于 null，那么会被序列化成 false
                SerializerFeature.WriteNullBooleanAsFalse,
                // PrettyFormat: 美化JSON
                SerializerFeature.PrettyFormat
        };
        fastJsonConfig.setSerializerFeatures(serializerFeatures);

        // 配置添加到消息转换器里面
        converter.setFastJsonConfig(fastJsonConfig);
        converter.setDefaultCharset(Charset.forName("UTF-8"));
        // 设置响应JSON格式数据
        List<MediaType> mediaTypeList = new ArrayList<>();
        mediaTypeList.add(MediaType.APPLICATION_JSON);
        // 设置消息转换器支持的格式
        converter.setSupportedMediaTypes(mediaTypeList);
        return converter;
    }

}

3. 测试

User.java

package com.example.demo2.entity;/** * @className: User * @author: houqd * @date: 2022/11/4 **/

import lombok.Data;

import java.io.Serializable;
import java.util.Date;

/** *@description: *@author:houqd *@time: 2022/11/4 14:12 * */
@Data
public class User implements Serializable { 
   
    private String username;
    private Date createTime;
    private Boolean enabled;
    private Integer num;

}

TestController.java

package com.example.demo2.controller;/** * @className: TestController * @author: houqd * @date: 2022/11/4 **/

import com.example.demo2.entity.User;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;

import java.util.ArrayList;
import java.util.Date;
import java.util.List;

/** *@description: *@author:houqd *@time: 2022/11/4 14:13 * */
@RestController
@RequestMapping("/api")
public class TestController { 
   
    @GetMapping("/json")
    public List<User> json() { 
   
        List<User> list = this.getUserList();
        return list;
    }
    // 模拟数据
    private List<User> getUserList() { 
   
        List<User> list = new ArrayList<>();
        for (int i = 0; i < 3; i++) { 
   
            User user = new User();
            if (i != 1) { 
   
                user.setUsername("test-00" + i);
                user.setCreateTime(new Date());
                user.setEnabled(true);
                user.setNum(520);
            }
            list.add(user);
        }
        return list;
    }

}

测试结果：

注意： fastJson 引用2.0.17 版本后日期格式话失败，退回到1.2.83 版本后正常。

4. 开源的Jackson

简介：

(1)相比json-lib框架，Jackson所依赖的jar包较少，简单易用并且性能也要相对高些。
而且Jackson社区相对比较活跃，更新速度也比较快。
Jackson对于复杂类型的json转换bean会出现问题，一些集合Map，List的转换出现问题。
Jackson对于复杂类型的bean转换Json，转换的json格式不是标准的Json格式

(2)jackson默认是序列化null对应的key的，也就是说不管你对象属性有没有值，在转换json的时候都会被序列化出来

public static void main(String[] args) throws JsonGenerationException, JsonMappingException, IOException { 
   
		AutoPartsSearchRequest request = new AutoPartsSearchRequest();
		request.setKeywords("123");
		request.setSortingField("234242");
		ObjectMapper mapper = new ObjectMapper();
		String str = mapper.writeValueAsString(request); 
		System.out.println(str);
		//输出结果(此处就不格式化了)：{"sortingField":"234242","partsClassifyId":null,"partsSubClassifyId":null,"sortingDirection":null:......
	}

2、同理，想要不序列化null也是可以的，具体如下：

1.实体上
 
@JsonInclude(Include.NON_NULL) 
 
//将该标记放在属性上，如果该属性为NULL则不参与序列化 
//如果放在类上边,那对这个类的全部属性起作用 
//Include.Include.ALWAYS 默认 
//Include.NON_DEFAULT 属性为默认值不序列化 
//Include.NON_EMPTY 属性为 空（“”） 或者为 NULL 都不序列化 
//Include.NON_NULL 属性为NULL 不序列化 
 
 
2.代码上
ObjectMapper mapper = new ObjectMapper();
 
mapper.setSerializationInclusion(Include.NON_NULL);  
 
//通过该方法对mapper对象进行设置，所有序列化的对象都将按改规则进行系列化 
//Include.Include.ALWAYS 默认 
//Include.NON_DEFAULT 属性为默认值不序列化 
//Include.NON_EMPTY 属性为 空（“”） 或者为 NULL 都不序列化 
//Include.NON_NULL 属性为NULL 不序列化

注意：只对VO起作用，Map List不起作用，另外jackson还能过滤掉你设置的属性，具体的就各位自己去研究源码了

(3)pringboot默认使用Jackson ,@RestController注解，会采用HttpMessageConverter将数据进行转换后写入Response的body数据区

Jackson配置

引入maven

        <dependency>
            <groupId>com.fasterxml.jackson.core</groupId>
            <artifactId>jackson-core</artifactId>
            <version>2.10.0</version>
        </dependency>

        <dependency>
            <groupId>com.fasterxml.jackson.core</groupId>
            <artifactId>jackson-databind</artifactId>
            <version>2.10.0</version>
        </dependency>
        <dependency>
            <groupId>com.fasterxml.jackson.core</groupId>
            <artifactId>jackson-annotations</artifactId>
            <version>2.10.0</version>
        </dependency>

1. 通过在application.yml中进行jackson的对应配置去实现

    spring:
    jackson:
      # 设置属性命名策略,对应jackson下PropertyNamingStrategy中的常量值，SNAKE_CASE-返回的json驼峰式转下划线，json body下划线传到后端自动转驼峰式
      property-naming-strategy: SNAKE_CASE
      # 全局设置@JsonFormat的格式pattern
      date-format: yyyy-MM-dd HH:mm:ss
      # 当地时区
      locale: zh
      # 设置全局时区
      time-zone: GMT+8
      # 常用，全局设置pojo或被@JsonInclude注解的属性的序列化方式
      default-property-inclusion: NON_NULL #不为空的属性才会序列化,具体属性可看JsonInclude.Include
      # 常规默认,枚举类SerializationFeature中的枚举属性为key，值为boolean设置jackson序列化特性,具体key请看SerializationFeature源码
      serialization:
        WRITE_DATES_AS_TIMESTAMPS: true # 返回的java.util.date转换成timestamp
        FAIL_ON_EMPTY_BEANS: true # 对象为空时是否报错，默认true
      # 枚举类DeserializationFeature中的枚举属性为key，值为boolean设置jackson反序列化特性,具体key请看DeserializationFeature源码
      deserialization:
        # 常用,json中含pojo不存在属性时是否失败报错,默认true
        FAIL_ON_UNKNOWN_PROPERTIES: false
      # 枚举类MapperFeature中的枚举属性为key，值为boolean设置jackson ObjectMapper特性
      # ObjectMapper在jackson中负责json的读写、json与pojo的互转、json tree的互转,具体特性请看MapperFeature,常规默认即可
      mapper:
        # 使用getter取代setter探测属性，如类中含getName()但不包含name属性与setName()，传输的vo json格式模板中依旧含name属性
        USE_GETTERS_AS_SETTERS: true #默认false
      # 枚举类JsonParser.Feature枚举类中的枚举属性为key，值为boolean设置jackson JsonParser特性
      # JsonParser在jackson中负责json内容的读取,具体特性请看JsonParser.Feature，一般无需设置默认即可
      parser:
        ALLOW_SINGLE_QUOTES: true # 是否允许出现单引号,默认false
      # 枚举类JsonGenerator.Feature枚举类中的枚举属性为key，值为boolean设置jackson JsonGenerator特性，一般无需设置默认即可
      # JsonGenerator在jackson中负责编写json内容,具体特性请看JsonGenerator.Feature

2.通过ObjectMapper 进行代码配置实现

/** * 全局序列化配置类 */
@Configuration
public class JsonConfig { 
   
 
    /** * 创建Jackson对象映射器 * * @param builder Jackson对象映射器构建器 * @return ObjectMapper */
    @Bean
    public ObjectMapper getJacksonObjectMapper(Jackson2ObjectMapperBuilder builder) { 
   
        ObjectMapper objectMapper = builder.createXmlMapper(false).build();
        //序列换成json时,将所有的long变成string.因为js中得数字类型不能包含所有的java long值，超过16位后会出现精度丢失
        SimpleModule simpleModule = new SimpleModule();
        simpleModule.addSerializer(Long.class, com.fasterxml.jackson.databind.ser.std.ToStringSerializer.instance);
        simpleModule.addSerializer(Long.TYPE, com.fasterxml.jackson.databind.ser.std.ToStringSerializer.instance);
        objectMapper.registerModule(simpleModule);
        //反序列化的时候如果多了其他属性,不抛出异常
        objectMapper.configure(DeserializationFeature.FAIL_ON_UNKNOWN_PROPERTIES, false);
        //日期格式处理
        objectMapper.setDateFormat(new SimpleDateFormat("yyyy-MM-dd HH:mm:ss"));
        return objectMapper;
    }
}

方式二、重写configureMessageConverters方法

/** * 全局序列化配置类 */
@Configuration
@EnableWebMvc
public class JsonConfig implements WebMvcConfigurer { 
   
 
    /** * 全局序列化方式 * * @param converters */
    @Override
    public void configureMessageConverters(List<HttpMessageConverter<?>> converters) { 
   
        //Jackson的全局序列化方式
        configureJacksonHttpMessageConverter(converters);
    }
 
    /** * Jackson的全局序列化方式 * * @param converters */
    private void configureJacksonHttpMessageConverter(List<HttpMessageConverter<?>> converters) { 
   
        MappingJackson2HttpMessageConverter converter = new MappingJackson2HttpMessageConverter();
        ObjectMapper objectMapper = new ObjectMapper();
        //序列换成json时,将所有的long变成string.因为js中得数字类型不能包含所有的java long值，超过16位后会出现精度丢失
        SimpleModule simpleModule = new SimpleModule();
        simpleModule.addSerializer(Long.class, com.fasterxml.jackson.databind.ser.std.ToStringSerializer.instance);
        simpleModule.addSerializer(Long.TYPE, com.fasterxml.jackson.databind.ser.std.ToStringSerializer.instance);
        objectMapper.registerModule(simpleModule);
        //反序列化的时候如果多了其他属性,不抛出异常
        objectMapper.configure(DeserializationFeature.FAIL_ON_UNKNOWN_PROPERTIES, false);
        //日期格式处理
        objectMapper.setDateFormat(new SimpleDateFormat("yyyy-MM-dd HH:mm:ss"));
        converter.setObjectMapper(objectMapper);
        converters.add(converter);
        converters.add(new StringHttpMessageConverter(StandardCharsets.UTF_8));
    }
}

ObjectMapper 常用工具类

import com.fasterxml.jackson.annotation.JsonInclude;
import com.fasterxml.jackson.core.type.TypeReference;
import com.fasterxml.jackson.databind.DeserializationFeature;
import com.fasterxml.jackson.databind.JavaType;
import com.fasterxml.jackson.databind.ObjectMapper;

import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;

/** * Jackson 工具类 * <p>Title: MapperUtils</p> * <p>Description: </p> * */
public class MapperUtils { 
   
    private final static ObjectMapper objectMapper = new ObjectMapper();

    public static ObjectMapper getInstance() { 
   
        return objectMapper;
    }

    /** * 转换为 JSON 字符串 * * @param obj * @return * @throws Exception */
    public static String obj2json(Object obj) throws Exception { 
   
        ObjectMapper mapper = new ObjectMapper();
        mapper.setSerializationInclusion(JsonInclude.Include.ALWAYS);
        return mapper.writeValueAsString(obj);
    }

    /** * 转换为 JSON 字符串，忽略空值 * * @param obj * @return * @throws Exception */
    public static String obj2jsonIgnoreNull(Object obj) throws Exception { 
   
        ObjectMapper mapper = new ObjectMapper();
        mapper.setSerializationInclusion(JsonInclude.Include.NON_NULL);
        return mapper.writeValueAsString(obj);
    }

    /** * 转换为 JavaBean * * @param jsonString * @param clazz * @return * @throws Exception */
    public static <T> T json2pojo(String jsonString, Class<T> clazz) throws Exception { 
   
        objectMapper.configure(DeserializationFeature.ACCEPT_SINGLE_VALUE_AS_ARRAY, true);
        return objectMapper.readValue(jsonString, clazz);
    }

    /** * 字符串转换为 Map<String, Object> * * @param jsonString * @return * @throws Exception */
    public static <T> Map<String, Object> json2map(String jsonString) throws Exception { 
   
        ObjectMapper mapper = new ObjectMapper();
        mapper.setSerializationInclusion(JsonInclude.Include.NON_NULL);
        return mapper.readValue(jsonString, Map.class);
    }

    /** * 字符串转换为 Map<String, T> */
    public static <T> Map<String, T> json2map(String jsonString, Class<T> clazz) throws Exception { 
   
        Map<String, Map<String, Object>> map = objectMapper.readValue(jsonString, new TypeReference<Map<String, T>>() { 
   
        });
        Map<String, T> result = new HashMap<String, T>();
        for (Map.Entry<String, Map<String, Object>> entry : map.entrySet()) { 
   
            result.put(entry.getKey(), map2pojo(entry.getValue(), clazz));
        }
        return result;
    }

    /** * 深度转换 JSON 成 Map * * @param json * @return */
    public static Map<String, Object> json2mapDeeply(String json) throws Exception { 
   
        return json2MapRecursion(json, objectMapper);
    }

    /** * 把 JSON 解析成 List，如果 List 内部的元素存在 jsonString，继续解析 * * @param json * @param mapper 解析工具 * @return * @throws Exception */
    private static List<Object> json2ListRecursion(String json, ObjectMapper mapper) throws Exception { 
   
        if (json == null) { 
   
            return null;
        }

        List<Object> list = mapper.readValue(json, List.class);

        for (Object obj : list) { 
   
            if (obj != null && obj instanceof String) { 
   
                String str = (String) obj;
                if (str.startsWith("[")) { 
   
                    obj = json2ListRecursion(str, mapper);
                } else if (obj.toString().startsWith("{")) { 
   
                    obj = json2MapRecursion(str, mapper);
                }
            }
        }

        return list;
    }

    /** * 把 JSON 解析成 Map，如果 Map 内部的 Value 存在 jsonString，继续解析 * * @param json * @param mapper * @return * @throws Exception */
    private static Map<String, Object> json2MapRecursion(String json, ObjectMapper mapper) throws Exception { 
   
        if (json == null) { 
   
            return null;
        }

        Map<String, Object> map = mapper.readValue(json, Map.class);

        for (Map.Entry<String, Object> entry : map.entrySet()) { 
   
            Object obj = entry.getValue();
            if (obj != null && obj instanceof String) { 
   
                String str = ((String) obj);

                if (str.startsWith("[")) { 
   
                    List<?> list = json2ListRecursion(str, mapper);
                    map.put(entry.getKey(), list);
                } else if (str.startsWith("{")) { 
   
                    Map<String, Object> mapRecursion = json2MapRecursion(str, mapper);
                    map.put(entry.getKey(), mapRecursion);
                }
            }
        }

        return map;
    }

    /** * 将 JSON 数组转换为集合 * * @param jsonArrayStr * @param clazz * @return * @throws Exception */
    public static <T> List<T> json2list(String jsonArrayStr, Class<T> clazz) throws Exception { 
   
        JavaType javaType = getCollectionType(ArrayList.class, clazz);
        List<T> list = (List<T>) objectMapper.readValue(jsonArrayStr, javaType);
        return list;
    }


    /** * 获取泛型的 Collection Type * * @param collectionClass 泛型的Collection * @param elementClasses 元素类 * @return JavaType Java类型 * @since 1.0 */
    public static JavaType getCollectionType(Class<?> collectionClass, Class<?>... elementClasses) { 
   
        return objectMapper.getTypeFactory().constructParametricType(collectionClass, elementClasses);
    }

    /** * 将 Map 转换为 JavaBean * * @param map * @param clazz * @return */
    public static <T> T map2pojo(Map map, Class<T> clazz) { 
   
        return objectMapper.convertValue(map, clazz);
    }

    /** * 将 Map 转换为 JSON * * @param map * @return */
    public static String mapToJson(Map map) { 
   
        try { 
   
            return objectMapper.writeValueAsString(map);
        } catch (Exception e) { 
   
            e.printStackTrace();
        }
        return "";
    }

    /** * 将 JSON 对象转换为 JavaBean * * @param obj * @param clazz * @return */
    public static <T> T obj2pojo(Object obj, Class<T> clazz) { 
   
        return objectMapper.convertValue(obj, clazz);
    }
}

今天的文章对象和 json 互转四种方式 json-lib、Gson、FastJson、Jackson[通俗易懂]分享到此就结束了，感谢您的阅读。

版权声明：本文内容由互联网用户自发贡献，该文观点仅代表作者本人。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如发现本站有涉嫌侵权/违法违规的内容，请发送邮件至举报，一经查实，本站将立刻删除。
如需转载请保留出处：https://bianchenghao.cn/79393.html

对象 和 json 互转 四种方式 json-lib、Gson、FastJson、Jackson[通俗易懂]

文章目录

一、 json-lib

二、 Google的Gson

1.简介

2. 配置步骤

1. MAVEN 依赖引入

2. gsonUtil 工具类

3. 排除不要序列化的熟悉注解类 Exclude

三. 阿里巴巴的FastJson

1.简介

2.配置步骤

1.引入maven

2. 配置 CustomFastjsonConfig

3. 测试

4. 开源的Jackson

简介：

Jackson配置

ObjectMapper 常用工具类

相关推荐

发表回复

对象和 json 互转四种方式 json-lib、Gson、FastJson、Jackson[通俗易懂]