文章目录
一、 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的，具体案例如下：
publicstaticvoidmain(String[] args)throwsJsonGenerationException,JsonMappingException,IOException{AutoPartsSearchRequest request =newAutoPartsSearchRequest();
request.setKeywords("123");
request.setSortingField("234242");Gson g =newGsonBuilder().create();String str = g.toJson(request);System.out.println(str);//输出结果：{"sortingField":"234242","keywords":"123"}}
若是想序列化null值对应的key，只需要将以上创建代码改成以下代码就行：
Gson g =newGsonBuilder().serializeNulls().create();
若是想转行null为空字符串""，则需要手动处理了
（3）主要类介绍
Gson类：解析json的最基础的工具类
JsonParser类：解析器来解析JSON到JsonElements的解析树
JsonElement类：一个类代表的JSON元素
JsonObject类：JSON对象类型
JsonArray类：JsonObject数组
TypeToken类：用于创建type，比如泛型List<?>
（4）bean转换json
Gson gson =newGson();String json = gson.toJson(obj);//obj是对象
（5） json转换bean
Gson gson =newGson();String json ="{\"id\":\"2\",\"name\":\"Json技术\"}";Book book = gson.fromJson(json,Book.class);
（6） json转换复杂的bean，比如List，Set
将json转换成复杂类型的bean,需要使用TypeToken
Gson gson =newGson();String json ="[{\"id\":\"1\",\"name\":\"Json技术\"},{\"id\":\"2\",\"name\":\"java技术\"}]";//将json转换成ListList list = gson.fromJson(json,newTypeToken<LIST>(){}.getType());//将json转换成SetSet set = gson.fromJson(json,newTypeToken<SET>(){}.getType());
（7） 通过json对象直接操作json以及一些json的工具
a) 格式化Json
String json ="[{\"id\":\"1\",\"name\":\"Json技术\"},{\"id\":\"2\",\"name\":\"java技术\"}]";Gson gson =newGsonBuilder().setPrettyPrinting().create();JsonParser jp =newJsonParser();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{newJsonParser().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 =newJsonParser();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 =newJsonParser();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 =newJsonParser();JsonElement element = jsonParser.parse(json);JsonObject jsonObj = element.getAsJsonObject();
jsonObj.addProperty(propertyName,newGson().toJson(propertyValue));
json = jsonObj.toString();
f) 修改json中的属性
String json ="{\"id\":\"1\",\"name\":\"Json技术\"}";String propertyName ='name';Object propertyValue ="json各种技术的调研";JsonParser jsonParser =newJsonParser();JsonElement element = jsonParser.parse(json);JsonObject jsonObj = element.getAsJsonObject();
jsonObj.remove(propertyName);
jsonObj.addProperty(propertyName,newGson().toJson(propertyValue));
json = jsonObj.toString();
g) 判断json中是否有属性
String json ="{\"id\":\"1\",\"name\":\"Json技术\"}";String propertyName ='name';boolean isContains =false;JsonParser jsonParser =newJsonParser();JsonElement element = jsonParser.parse(json);JsonObject jsonObj = element.getAsJsonObject();
isContains = jsonObj.has(propertyName);
h) json中日期格式的处理
GsonBuilder builder =newGsonBuilder();
builder.setDateFormat("yyyy-MM-dd HH:mm:ss.SSS");Gson gson = builder.create();
然后使用gson对象进行json的处理，如果出现日期Date类的对象，就会按照设置的格式进行处理
i) json中对于Html的转义
Gson gson =newGson();
这种对象默认对Html进行转义，如果不想转义使用下面的方法
GsonBuilder builder =newGsonBuilder();
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 工具类
packagecom.dechnic.common.util;importcom.dechnic.common.anno.gson.Exclude;importcom.dechnic.common.po.ObjectTypeAdapter;importcom.google.gson.ExclusionStrategy;importcom.google.gson.FieldAttributes;importcom.google.gson.Gson;importcom.google.gson.GsonBuilder;importcom.google.gson.internal.LinkedTreeMap;importcom.google.gson.reflect.TypeToken;importjava.util.ArrayList;importjava.util.List;importjava.util.Map;/**
* @description:
* @author:houqd
* @time: 2022/6/27 17:31
*/publicclassGsonUtll{privatestaticGson gson;static{ExclusionStrategy strategy =newExclusionStrategy(){@OverridepublicbooleanshouldSkipField(FieldAttributes f){return f.getAnnotation(Exclude.class)!=null;}@OverridepublicbooleanshouldSkipClass(Class<?> clazz){returnfalse;}};
gson =newGsonBuilder().disableHtmlEscaping().setExclusionStrategies(strategy).registerTypeAdapter(newTypeToken<Map<String,Object>>(){}.getType(),newObjectTypeAdapter()).serializeNulls().create();}publicstaticMap<String,Object>jsonStr2Map(String jsonStr){return gson.fromJson(jsonStr,newTypeToken<Map<String,Object>>(){}.getType());}publicstaticList<Map<String,Object>>jsonStr2ListMap(String jsonStr){return gson.fromJson(jsonStr,newTypeToken<List<Map<String,Object>>>(){}.getType());}publicstaticStringtoJSON(Object object){return gson.toJson(object);}publicstatic<T>List<T>json2ListBean(String result,Class<T> t){List list = gson.fromJson(result,newTypeToken<List>(){}.getType());List list2 =newArrayList();for(Object o : list){
list2.add(json2Bean(toJSON(o),t));}return list2;}publicstatic<T>Tjson2Bean(String result,Class<T>t){return gson.fromJson(result, t);}}
3. 排除不要序列化的熟悉注解类 Exclude
packagecom.dechnic.common.anno.gson;importjava.lang.annotation.ElementType;importjava.lang.annotation.Retention;importjava.lang.annotation.RetentionPolicy;importjava.lang.annotation.Target;@Retention(RetentionPolicy.RUNTIME)@Target(ElementType.FIELD)public@interfaceExclude{}
三. 阿里巴巴的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时是否使用双引号,默认为trueWriteMapNullValue——–是否输出值为null的字段,默认为falseWriteNullNumberAsZero—-数值字段如果为null,输出为0,而非nullWriteNullListAsEmpty—–List字段如果为null,输出为[],而非nullWriteNullStringAsEmpty—字符类型字段如果为null,输出为”“,而非nullWriteNullBooleanAsFalse–Boolean字段如果为null,输出为false,而非null
结合上面，SerializerFeature… features是个数组，那么我们可以传入我们想要的参数，比如想序列化null，案例如下：
publicstaticvoidmain(String[] args){AutoPartsSearchRequest request =newAutoPartsSearchRequest();
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 =newStudent();Set books=newHashSet();Book book =newBook();
books.add(book);
stu.setBooks(books);List list =newArrayList();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转换成ListList list = JSON.parseObject(json,newTypeReference<ARRAYLIST>(){});//将json转换成SetSet set = JSON.parseObject(json,newTypeReference<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 =newDate();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
packagecom.example.demo2.config;/**
* @className: WebMvcConfig
* @author: houqd
* @date: 2022/11/4
**/importcom.alibaba.fastjson.serializer.SerializerFeature;importcom.alibaba.fastjson.support.config.FastJsonConfig;importcom.alibaba.fastjson.support.spring.FastJsonHttpMessageConverter;importorg.springframework.boot.autoconfigure.http.HttpMessageConverters;importorg.springframework.context.annotation.Bean;importorg.springframework.context.annotation.Configuration;importorg.springframework.http.MediaType;importjava.nio.charset.Charset;importjava.util.ArrayList;importjava.util.List;/**
* @description:
* @author:houqd
* @time: 2022/11/4 13:55
*/@ConfigurationpublicclassCustomFastjsonConfig{@BeanpublicFastJsonHttpMessageConverterfastjsonHttpMessageConverters(){FastJsonHttpMessageConverter converter =newFastJsonHttpMessageConverter();FastJsonConfig fastJsonConfig =newFastJsonConfig();
fastJsonConfig.setCharset(Charset.forName("UTF-8"));
fastJsonConfig.setDateFormat("yyyy-MM-dd HH:mm:ss");//设置序列化特征SerializerFeature[] serializerFeatures =newSerializerFeature[]{//WriteNullStringAsEmpty: 如果字符串等于 null，那么会被序列化成空字符串 ""SerializerFeature.WriteNonStringKeyAsString,// WriteNullNumberAsZero: 如果数字等于 null，那么会被序列化成 0SerializerFeature.WriteNullNumberAsZero,// WriteNullBooleanAsFalse: 如果布尔类型等于 null，那么会被序列化成 falseSerializerFeature.WriteNullBooleanAsFalse,// PrettyFormat: 美化JSONSerializerFeature.PrettyFormat};
fastJsonConfig.setSerializerFeatures(serializerFeatures);// 配置添加到消息转换器里面
converter.setFastJsonConfig(fastJsonConfig);
converter.setDefaultCharset(Charset.forName("UTF-8"));// 设置响应JSON格式数据List<MediaType> mediaTypeList =newArrayList<>();
mediaTypeList.add(MediaType.APPLICATION_JSON);// 设置消息转换器支持的格式
converter.setSupportedMediaTypes(mediaTypeList);return converter;}}
3. 测试
User.java
packagecom.example.demo2.entity;/**
* @className: User
* @author: houqd
* @date: 2022/11/4
**/importlombok.Data;importjava.io.Serializable;importjava.util.Date;/**
*@description:
*@author:houqd
*@time: 2022/11/4 14:12
*
*/@DatapublicclassUserimplementsSerializable{privateString username;privateDate createTime;privateBoolean enabled;privateInteger num;}
TestController.java
packagecom.example.demo2.controller;/**
* @className: TestController
* @author: houqd
* @date: 2022/11/4
**/importcom.example.demo2.entity.User;importorg.springframework.web.bind.annotation.GetMapping;importorg.springframework.web.bind.annotation.RequestMapping;importorg.springframework.web.bind.annotation.RestController;importjava.util.ArrayList;importjava.util.Date;importjava.util.List;/**
*@description:
*@author:houqd
*@time: 2022/11/4 14:13
*
*/@RestController@RequestMapping("/api")publicclassTestController{@GetMapping("/json")publicList<User>json(){List<User> list =this.getUserList();return list;}// 模拟数据privateList<User>getUserList(){List<User> list =newArrayList<>();for(int i =0; i <3; i++){User user =newUser();if(i !=1){
user.setUsername("test-00"+ i);
user.setCreateTime(newDate());
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的时候都会被序列化出来
publicstaticvoidmain(String[] args)throwsJsonGenerationException,JsonMappingException,IOException{AutoPartsSearchRequest request =newAutoPartsSearchRequest();
request.setKeywords("123");
request.setSortingField("234242");ObjectMapper mapper =newObjectMapper();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 =newObjectMapper();
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 进行代码配置实现
/**
* 全局序列化配置类
*/@ConfigurationpublicclassJsonConfig{/**
* 创建Jackson对象映射器
*
* @param builder Jackson对象映射器构建器
* @return ObjectMapper
*/@BeanpublicObjectMappergetJacksonObjectMapper(Jackson2ObjectMapperBuilder builder){ObjectMapper objectMapper = builder.createXmlMapper(false).build();//序列换成json时,将所有的long变成string.因为js中得数字类型不能包含所有的java long值，超过16位后会出现精度丢失SimpleModule simpleModule =newSimpleModule();
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(newSimpleDateFormat("yyyy-MM-dd HH:mm:ss"));return objectMapper;}}
方式二、重写configureMessageConverters方法
/**
* 全局序列化配置类
*/@Configuration@EnableWebMvcpublicclassJsonConfigimplementsWebMvcConfigurer{/**
* 全局序列化方式
*
* @param converters
*/@OverridepublicvoidconfigureMessageConverters(List<HttpMessageConverter<?>> converters){//Jackson的全局序列化方式configureJacksonHttpMessageConverter(converters);}/**
* Jackson的全局序列化方式
*
* @param converters
*/privatevoidconfigureJacksonHttpMessageConverter(List<HttpMessageConverter<?>> converters){MappingJackson2HttpMessageConverter converter =newMappingJackson2HttpMessageConverter();ObjectMapper objectMapper =newObjectMapper();//序列换成json时,将所有的long变成string.因为js中得数字类型不能包含所有的java long值，超过16位后会出现精度丢失SimpleModule simpleModule =newSimpleModule();
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(newSimpleDateFormat("yyyy-MM-dd HH:mm:ss"));
converter.setObjectMapper(objectMapper);
converters.add(converter);
converters.add(newStringHttpMessageConverter(StandardCharsets.UTF_8));}}
ObjectMapper 常用工具类
importcom.fasterxml.jackson.annotation.JsonInclude;importcom.fasterxml.jackson.core.type.TypeReference;importcom.fasterxml.jackson.databind.DeserializationFeature;importcom.fasterxml.jackson.databind.JavaType;importcom.fasterxml.jackson.databind.ObjectMapper;importjava.util.ArrayList;importjava.util.HashMap;importjava.util.List;importjava.util.Map;/**
* Jackson 工具类
* <p>Title: MapperUtils</p>
* <p>Description: </p>
*
*/publicclassMapperUtils{privatefinalstaticObjectMapper objectMapper =newObjectMapper();publicstaticObjectMappergetInstance(){return objectMapper;}/**
* 转换为 JSON 字符串
*
* @param obj
* @return
* @throws Exception
*/publicstaticStringobj2json(Object obj)throwsException{ObjectMapper mapper =newObjectMapper();
mapper.setSerializationInclusion(JsonInclude.Include.ALWAYS);return mapper.writeValueAsString(obj);}/**
* 转换为 JSON 字符串，忽略空值
*
* @param obj
* @return
* @throws Exception
*/publicstaticStringobj2jsonIgnoreNull(Object obj)throwsException{ObjectMapper mapper =newObjectMapper();
mapper.setSerializationInclusion(JsonInclude.Include.NON_NULL);return mapper.writeValueAsString(obj);}/**
* 转换为 JavaBean
*
* @param jsonString
* @param clazz
* @return
* @throws Exception
*/publicstatic<T>Tjson2pojo(String jsonString,Class<T> clazz)throwsException{
objectMapper.configure(DeserializationFeature.ACCEPT_SINGLE_VALUE_AS_ARRAY,true);return objectMapper.readValue(jsonString, clazz);}/**
* 字符串转换为 Map<String, Object>
*
* @param jsonString
* @return
* @throws Exception
*/publicstatic<T>Map<String,Object>json2map(String jsonString)throwsException{ObjectMapper mapper =newObjectMapper();
mapper.setSerializationInclusion(JsonInclude.Include.NON_NULL);return mapper.readValue(jsonString,Map.class);}/**
* 字符串转换为 Map<String, T>
*/publicstatic<T>Map<String,T>json2map(String jsonString,Class<T> clazz)throwsException{Map<String,Map<String,Object>> map = objectMapper.readValue(jsonString,newTypeReference<Map<String,T>>(){});Map<String,T> result =newHashMap<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
*/publicstaticMap<String,Object>json2mapDeeply(String json)throwsException{returnjson2MapRecursion(json, objectMapper);}/**
* 把 JSON 解析成 List，如果 List 内部的元素存在 jsonString，继续解析
*
* @param json
* @param mapper 解析工具
* @return
* @throws Exception
*/privatestaticList<Object>json2ListRecursion(String json,ObjectMapper mapper)throwsException{if(json ==null){returnnull;}List<Object> list = mapper.readValue(json,List.class);for(Object obj : list){if(obj !=null&& obj instanceofString){String str =(String) obj;if(str.startsWith("[")){
obj =json2ListRecursion(str, mapper);}elseif(obj.toString().startsWith("{")){
obj =json2MapRecursion(str, mapper);}}}return list;}/**
* 把 JSON 解析成 Map，如果 Map 内部的 Value 存在 jsonString，继续解析
*
* @param json
* @param mapper
* @return
* @throws Exception
*/privatestaticMap<String,Object>json2MapRecursion(String json,ObjectMapper mapper)throwsException{if(json ==null){returnnull;}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 instanceofString){String str =((String) obj);if(str.startsWith("[")){List<?> list =json2ListRecursion(str, mapper);
map.put(entry.getKey(), list);}elseif(str.startsWith("{")){Map<String,Object> mapRecursion =json2MapRecursion(str, mapper);
map.put(entry.getKey(), mapRecursion);}}}return map;}/**
* 将 JSON 数组转换为集合
*
* @param jsonArrayStr
* @param clazz
* @return
* @throws Exception
*/publicstatic<T>List<T>json2list(String jsonArrayStr,Class<T> clazz)throwsException{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
*/publicstaticJavaTypegetCollectionType(Class<?> collectionClass,Class<?>... elementClasses){return objectMapper.getTypeFactory().constructParametricType(collectionClass, elementClasses);}/**
* 将 Map 转换为 JavaBean
*
* @param map
* @param clazz
* @return
*/publicstatic<T>Tmap2pojo(Map map,Class<T> clazz){return objectMapper.convertValue(map, clazz);}/**
* 将 Map 转换为 JSON
*
* @param map
* @return
*/publicstaticStringmapToJson(Map map){try{return objectMapper.writeValueAsString(map);}catch(Exception e){
e.printStackTrace();}return"";}/**
* 将 JSON 对象转换为 JavaBean
*
* @param obj
* @param clazz
* @return
*/publicstatic<T>Tobj2pojo(Object obj,Class<T> clazz){return objectMapper.convertValue(obj, clazz);}}
本文转载自: https://blog.csdn.net/u014212540/article/details/127687138
版权归原作者 风随心飞飞 所有， 如有侵权，请联系我们删除。
版权归原作者 风随心飞飞 所有， 如有侵权，请联系我们删除。