Jackson工具类及其配置

  1 package com.ruoyi.common.core.utils.json;
  2
  3 import com.fasterxml.jackson.annotation.JsonAutoDetect;
  4 import com.fasterxml.jackson.annotation.JsonInclude;
  5 import com.fasterxml.jackson.annotation.JsonTypeInfo;
  6 import com.fasterxml.jackson.annotation.PropertyAccessor;
  7 import com.fasterxml.jackson.core.JsonParser;
  8 import com.fasterxml.jackson.core.JsonProcessingException;
  9 import com.fasterxml.jackson.core.json.JsonReadFeature;
 10 import com.fasterxml.jackson.core.type.TypeReference;
 11 import com.fasterxml.jackson.databind.DeserializationFeature;
 12 import com.fasterxml.jackson.databind.ObjectMapper;
 13 import com.fasterxml.jackson.databind.SerializationFeature;
 14 import com.fasterxml.jackson.databind.jsontype.impl.LaissezFaireSubTypeValidator;
 15 import com.fasterxml.jackson.databind.node.ObjectNode;
 16 import com.ruoyi.common.core.exception.BusinessException;
 17 import com.ruoyi.common.core.exception.param.UtilException;
 18 import lombok.extern.slf4j.Slf4j;
 19
 20 import java.text.SimpleDateFormat;
 21 import java.util.List;
 22 import java.util.Map;
 23
 24 /**
 25  * @Description : json工具类
 26  * @Author : wzkris
 27  * @Version : V1.0.0
 28  * @Date : 2023/1/2 8:37
 29  */
 30 @Slf4j
 31 public class JsonUtils {
 32
 33
 34     private static ObjectMapper MAPPER = new ObjectMapper();
 35
 36     static {
 37         //序列化的时候序列对象的所有属性
 38         MAPPER.setSerializationInclusion(JsonInclude.Include.ALWAYS);
 39         //取消默认转换timestamps形式
 40         MAPPER.configure(SerializationFeature.WRITE_DATES_AS_TIMESTAMPS, false);
 41         //忽略空Bean转json的错误
 42         MAPPER.configure(SerializationFeature.FAIL_ON_EMPTY_BEANS, false);
 43         //所有的日期格式都统一为以下的样式，即yyyy-MM-dd HH:mm:ss
 44         MAPPER.setDateFormat(new SimpleDateFormat("yyyy-MM-dd HH:mm:ss"));
 45         //忽略 在json字符串中存在，但是在java对象中不存在对应属性的情况。防止错误
 46         MAPPER.configure(DeserializationFeature.FAIL_ON_UNKNOWN_PROPERTIES, false);
 47         //是否允许使用注释
 48         MAPPER.configure(JsonParser.Feature.ALLOW_COMMENTS, true);
 49         //允许转义字符
 50         MAPPER.configure(JsonReadFeature.ALLOW_UNESCAPED_CONTROL_CHARS.mappedFeature(), true);
 51         //不输出空值字段
 52         MAPPER.setDefaultPropertyInclusion(JsonInclude.Include.NON_NULL);
 53         //定义识别码在反序列化时是否保留
 54         MAPPER.setVisibility(PropertyAccessor.FIELD, JsonAutoDetect.Visibility.ANY);
 55         //指定java序列化类型，否则会按默认LinkedHashMap序列化
 56         MAPPER.activateDefaultTyping(LaissezFaireSubTypeValidator.instance,
 57                 ObjectMapper.DefaultTyping.NON_FINAL, JsonTypeInfo.As.PROPERTY);
 58     }
 59
 60     private JsonUtils() {
 61     }
 62
 63
 64
 65     public static ObjectMapper getMapper() {
 66         return MAPPER;
 67     }
 68
 69     /**
 70      * 对象转Json格式字符串
 71      *
 72      * @param obj 对象
 73      * @return Json格式字符串
 74      */
 75     public static String toJsonString(Object obj) {
 76         try {
 77             return MAPPER.writeValueAsString(obj);
 78         } catch (Exception e) {
 79             log.error("convert error, errorMsg:{}", e.getMessage(), e);
 80             throw new BusinessException(e.getMessage());
 81         }
 82     }
 83
 84
 85     /**
 86      * 对象转字节
 87      *
 88      * @param obj 对象
 89      * @return 字节流
 90      */
 91     public static byte[] toBytes(Object obj) {
 92         try {
 93             return MAPPER.writeValueAsBytes(obj);
 94         } catch (JsonProcessingException e) {
 95             log.error("convert error, errorMsg:{}", e.getMessage(), e);
 96             throw new UtilException("JsonUtils工具类转换异常");
 97         }
 98     }
 99
100
101     /**
102      * Json 转为 Jave Bean
103      *
104      * @param text  json字符串
105      * @param clazz 对象类型class
106      * @param <T>   对象类型
107      * @return 对象类型
108      */
109     public static <T> T parse(String text, Class<T> clazz) {
110         try {
111             return MAPPER.readValue(text, clazz);
112         } catch (Exception e) {
113             log.error("convert error, errorMsg:{}", e.getMessage(), e);
114             throw new UtilException("JsonUtils工具类转换异常");
115         }
116     }
117
118
119     /**
120      * @param text json字符串
121      * @return 转为ObjectNode
122      */
123     public static ObjectNode parse(String text) {
124         try {
125             return MAPPER.readValue(text, ObjectNode.class);
126         } catch (JsonProcessingException e) {
127             log.error("convert error, errorMsg:{}", e.getMessage(), e);
128             throw new UtilException("JsonUtils工具类转换异常");
129         }
130     }
131
132     /**
133      * Json 转为 Map
134      *
135      * @param text json
136      * @param <K>  key
137      * @param <V>  value
138      * @return map
139      */
140     public static <K, V> Map<K, V> toMap(String text) {
141         try {
142             return MAPPER.convertValue(text, new TypeReference<Map<K, V>>() {
143             });
144         } catch (Exception e) {
145             log.error("convert error, errorMsg:{}", e.getMessage(), e);
146             throw new UtilException("JsonUtils工具类转换异常");
147         }
148     }
149
150
151     /**
152      * Json 转 List, Class 集合中泛型的类型，非集合本身
153      *
154      * @param text json
155      * @param <T>  对象类型
156      * @return List
157      */
158     public static <T> List<T> toList(String text) {
159         try {
160             return MAPPER.convertValue(text, new TypeReference<List<T>>() {
161             });
162         } catch (Exception e) {
163             log.error("convert error, errorMsg:{}", e.getMessage(), e);
164             throw new UtilException("JsonUtils工具类转换异常");
165         }
166     }
167
168 }