================================
©Copyright 蕃薯耀 2021-04-27
https://blog.csdn.net/w995223851
一、SpringBoot Jackson类配置
SpringBoot 配置ObjectMapper的bean对象，通过增加@ResponseBody返回json对象
使用配置类返回ObjectMapper，而不是在配置文件，可以让ObjectMapper是同一个，不用在jsonUtils再声明一个，导致两处地方可能存在不一致的地方。在jsonUtils直接注入ObjectMapper，保持一致。
import java.text.SimpleDateFormat;
import java.util.TimeZone;
import org.springframework.boot.autoconfigure.condition.ConditionalOnMissingBean;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.context.annotation.Primary;
import org.springframework.http.converter.json.Jackson2ObjectMapperBuilder;
import com.fasterxml.jackson.annotation.JsonInclude.Include;
import com.fasterxml.jackson.core.JsonParser.Feature;
import com.fasterxml.jackson.core.json.JsonReadFeature;
import com.fasterxml.jackson.databind.DeserializationFeature;
import com.fasterxml.jackson.databind.ObjectMapper;
import com.fasterxml.jackson.databind.SerializationFeature;
@Configuration
public class JacksonConfig {
@Bean("objectMapper")
@Primary
@ConditionalOnMissingBean(ObjectMapper.class)
public ObjectMapper getObjectMapper(Jackson2ObjectMapperBuilder builder) {
ObjectMapper mapper = builder.build();
// 日期格式
mapper.setDateFormat(new SimpleDateFormat("yyyy-MM-dd HH:mm:ss"));
//GMT+8
//map.put("CTT", "Asia/Shanghai");
mapper.setTimeZone(TimeZone.getTimeZone("GMT+8"));
// Include.NON_NULL 属性为NULL 不序列化
//ALWAYS // 默认策略，任何情况都执行序列化
//NON_EMPTY // null、集合数组等没有内容、空字符串等，都不会被序列化
//NON_DEFAULT // 如果字段是默认值，就不会被序列化
//NON_ABSENT // null的不会序列化，但如果类型是AtomicReference，依然会被序列化
mapper.setSerializationInclusion(Include.NON_NULL);
//允许字段名没有引号（可以进一步减小json体积）：
mapper.configure(Feature.ALLOW_UNQUOTED_FIELD_NAMES, true);
//允许单引号：
mapper.configure(Feature.ALLOW_SINGLE_QUOTES, true);
// 允许出现特殊字符和转义符
//mapper.configure(Feature.ALLOW_UNQUOTED_CONTROL_CHARS, true);这个已经过时。
mapper.configure(JsonReadFeature.ALLOW_UNESCAPED_CONTROL_CHARS.mappedFeature(), true);
//允许C和C++样式注释：
mapper.configure(Feature.ALLOW_COMMENTS, true);
//序列化结果格式化，美化输出
mapper.enable(SerializationFeature.INDENT_OUTPUT);
//枚举输出成字符串
//WRITE_ENUMS_USING_INDEX：输出索引
mapper.enable(SerializationFeature.WRITE_ENUMS_USING_TO_STRING);
//空对象不要抛出异常：
mapper.disable(SerializationFeature.FAIL_ON_EMPTY_BEANS);
//Date、Calendar等序列化为时间格式的字符串(如果不执行以下设置，就会序列化成时间戳格式)：
mapper.disable(SerializationFeature.WRITE_DATES_AS_TIMESTAMPS);
//反序列化时，遇到未知属性不要抛出异常：
mapper.disable(DeserializationFeature.FAIL_ON_UNKNOWN_PROPERTIES);
//反序列化时，遇到忽略属性不要抛出异常：
mapper.disable(DeserializationFeature.FAIL_ON_IGNORED_PROPERTIES);
//反序列化时，空字符串对于的实例属性为null：
mapper.enable(DeserializationFeature.ACCEPT_EMPTY_STRING_AS_NULL_OBJECT);
return mapper;
}
}二、Java jackson工具类
ObjectMapper从JacksonConfig配置类注入，使用同一个ObjectMapper
import java.io.IOException;
import org.apache.commons.lang3.StringUtils;
import org.apache.log4j.Logger;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Component;
import com.fasterxml.jackson.core.type.TypeReference;
import com.fasterxml.jackson.databind.JavaType;
import com.fasterxml.jackson.databind.ObjectMapper;
/**
* Jackson工具类
**/
@Component
@ConditionalOnClass(JacksonConfig.class)
public class JsonUtil {
private static Logger log = Logger.getLogger(JsonUtil.class);
public static ObjectMapper objectMapper;
public static ObjectMapper getObjectMapper() {
return objectMapper;
}
//静态变量注入时，@Autowired注解只能在方法，不能在参数
@Autowired
public void setObjectMapper(ObjectMapper objectMapper) {
JsonUtil.objectMapper = objectMapper;
}
/**
* Object转json字符串
*/
public static <T> String toJson(T obj) {
try {
if (obj == null) {
return null;
}else if (obj instanceof String) {
return (String) obj;
}else {
return objectMapper.writeValueAsString(obj);
}
} catch (Exception e) {
log.error("Parse object to String error", e);
return null;
}
}
/**
* Object转json字符串并格式化美化
*/
public static <T> String toJsonPretty(T obj) {
try {
if (obj == null)
return null;
else if (obj instanceof String)
return (String) obj;
else
return objectMapper.writerWithDefaultPrettyPrinter().writeValueAsString(obj);
} catch (Exception e) {
log.error("Parse object to String Pretty error", e);
return null;
}
}
/**
* json转object
*/
@SuppressWarnings("unchecked")
public static <T> T toBean(String json, Class<T> clazz) {
try {
if (StringUtils.isEmpty(json) || clazz == null) {
return null;
}else if(clazz.equals(String.class)){
return (T)json;
}else{
return objectMapper.readValue(json, clazz);
}
} catch (IOException e) {
log.error("Parse String to bean error", e);
return null;
}
}
/**
* json转集合
* @param <T>
* @param json
* @param typeReference
* <li>new TypeReference<List<User>>() {}</li>
* @return
*/
@SuppressWarnings("unchecked")
public static <T> T toBean(String json, TypeReference<T> typeReference) {
try {
if (StringUtils.isEmpty(json) || typeReference == null) {
return null;
} else if (typeReference.getType().equals(String.class)) {
return (T) json;
} else {
return objectMapper.readValue(json, typeReference);
}
} catch (IOException e) {
log.error("Parse String to Bean error", e);
return null;
}
}
/**
* string转object 用于转为集合对象
* @param json Json字符串
* @param collectionClass 被转集合的类
* <p>List.class</p>
* @param elementClasses 被转集合中对象类型的类
* <p>User.class</p>
*/
public static <T> T toBean(String json, Class<?> collectionClass, Class<?>... elementClasses) {
try {
JavaType javaType = objectMapper.getTypeFactory().constructParametricType(collectionClass, elementClasses);
return objectMapper.readValue(json, javaType);
} catch (IOException e) {
log.error("Parse String to Bean error", e);
return null;
}
}
}三、application.properties文件配置jackson返回（使用类配置的方式，可以省略这个）
org.springframework.boot.autoconfigure.jackson.JacksonProperties
#jackson
#日期格式化
spring.jackson.date-format=yyyy-MM-dd HH:mm:ss
#时区
spring.jackson.time-zone=GMT+8
#格式化输出
spring.jackson.serialization.indent-output=true
#忽略无法转换的对象
spring.jackson.serialization.fail-on-empty-beans=false
#设置空如何序列化
spring.jackson.defaultPropertyInclusion=NON_NULL
#允许对象忽略json中不存在的属性
spring.jackson.deserialization.fail-on-unknown-properties=false
#允许出现特殊字符和转义符
spring.jackson.parser.allow-unquoted-control-chars=true
#允许出现单引号
spring.jackson.parser.allow-single-quotes=true
jackson自动装配类
org.springframework.boot.autoconfigure.jackson.JacksonAutoConfiguration
@Configuration(proxyBeanMethods = false)
@ConditionalOnClass(Jackson2ObjectMapperBuilder.class)
static class JacksonObjectMapperConfiguration {
@Bean
@Primary
@ConditionalOnMissingBean
ObjectMapper jacksonObjectMapper(Jackson2ObjectMapperBuilder builder) {
return builder.createXmlMapper(false).build();
}
}理论上，也可以在配置文件配置jackson，然后从spring容器获取ObjectMapper，在jackson工具类注入该对象，保证使用同一个ObjectMapper对象。
代码如下：
/**
* Jackson工具类
*
**/
@Component
@ConditionalOnBean(name = "jacksonObjectMapper")
public class JsonUtil {
//自定义的静态变量objectMapper
private static ObjectMapper objectMapper;
public static ObjectMapper getObjectMapper() {
return objectMapper;
}
/**
* 先在application.properties配置好jackson的，然后将jacksonObjectMapper注入到自定义的变量objectMapper
* @param jacksonObjectMapper
*/
@Autowired
public void setObjectMapper(ObjectMapper jacksonObjectMapper) {
JsonUtil.objectMapper = jacksonObjectMapper;
}
}
（时间宝贵，分享不易，捐赠回馈，^_^）
================================
©Copyright 蕃薯耀 2021-04-27