JackSon的自定义工具类

最新推荐文章于 2024-06-04 13:42:21 发布
最新推荐文章于 2024-06-04 13:42:21 发布
阅读量656 收藏 5
点赞数
文章标签： java spring boot
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_53025743/article/details/131258339
版权

JackSon的自定义工具类

import com.fasterxml.jackson.annotation.JsonInclude;
import com.fasterxml.jackson.core.JsonParser;
import com.fasterxml.jackson.core.JsonProcessingException;
import com.fasterxml.jackson.core.json.JsonReadFeature;
import com.fasterxml.jackson.core.type.TypeReference;
import com.fasterxml.jackson.databind.DeserializationFeature;
import com.fasterxml.jackson.databind.JavaType;
import com.fasterxml.jackson.databind.JsonNode;
import com.fasterxml.jackson.databind.ObjectMapper;
import com.fasterxml.jackson.databind.SerializationFeature;
import com.fasterxml.jackson.datatype.jsr310.JavaTimeModule;

import org.apache.commons.io.FileUtils;
import org.apache.commons.lang3.StringUtils;

import java.io.IOException;
import java.text.SimpleDateFormat;
import java.util.ArrayList;
import java.util.Collections;
import java.util.List;
import java.util.Map;
import java.util.TimeZone;

import lombok.extern.slf4j.Slf4j;

@Slf4j
public class JsonUtil {

    private static final ObjectMapper MAPPER = new ObjectMapper();

    static {
        // Include.NON_NULL 属性为NULL 不序列化
        //ALWAYS // 默认策略，任何情况都执行序列化
        //NON_EMPTY // null、集合数组等没有内容、空字符串等，都不会被序列化
        //NON_DEFAULT // 如果字段是默认值，就不会被序列化
        //NON_ABSENT // null的不会序列化，但如果类型是AtomicReference，依然会被序列化
        MAPPER.setSerializationInclusion(JsonInclude.Include.ALWAYS);

        //取消默认转换timestamps形式
        MAPPER.configure(SerializationFeature.WRITE_DATES_AS_TIMESTAMPS, false);
        //Date、Calendar等序列化为时间格式的字符串(如果不执行以下设置，就会序列化成时间戳格式)：
        MAPPER.disable(SerializationFeature.WRITE_DATES_AS_TIMESTAMPS);
        //所有的日期格式都统一为以下的样式，即yyyy-MM-dd HH:mm:ss.SSS z
        MAPPER.setDateFormat(new SimpleDateFormat("yyyy-MM-dd HH:mm:ss.SSS"));
        //GMT+8
        //map.put("CTT", "Asia/Shanghai");
        MAPPER.setTimeZone(TimeZone.getTimeZone("GMT+8"));
        // 注册java新时间类型模块
        MAPPER.registerModule(new JavaTimeModule());

        //忽略空Bean转json的错误
        MAPPER.configure(SerializationFeature.FAIL_ON_EMPTY_BEANS, false);
        //空对象不要抛出异常：
        MAPPER.disable(SerializationFeature.FAIL_ON_EMPTY_BEANS);

        //忽略 在json字符串中存在，但是在java对象中不存在对应属性的情况。防止错误
        MAPPER.configure(DeserializationFeature.FAIL_ON_UNKNOWN_PROPERTIES, false);
        //反序列化时，遇到未知属性不要抛出异常：
        MAPPER.disable(DeserializationFeature.FAIL_ON_UNKNOWN_PROPERTIES);

        //允许字段名没有引号（可以进一步减小json体积）：
        MAPPER.configure(JsonParser.Feature.ALLOW_UNQUOTED_FIELD_NAMES, true);
        //允许单引号：
        MAPPER.configure(JsonParser.Feature.ALLOW_SINGLE_QUOTES, true);
        // 允许出现特殊字符和转义符
        MAPPER.configure(JsonReadFeature.ALLOW_UNESCAPED_CONTROL_CHARS.mappedFeature(), true);

        //允许C和C++样式注释：
        MAPPER.configure(JsonParser.Feature.ALLOW_COMMENTS, true);

        //序列化结果格式化，美化输出
        MAPPER.enable(SerializationFeature.INDENT_OUTPUT);

        //枚举输出成字符串
        //WRITE_ENUMS_USING_INDEX：输出索引
        MAPPER.enable(SerializationFeature.WRITE_ENUMS_USING_TO_STRING);

        //反序列化时，遇到忽略属性不要抛出异常：
        MAPPER.disable(DeserializationFeature.FAIL_ON_IGNORED_PROPERTIES);

        //反序列化时，空字符串对于的实例属性为null：
        MAPPER.enable(DeserializationFeature.ACCEPT_EMPTY_STRING_AS_NULL_OBJECT);

    }

    public static String objectToJson(Object obj) {
        try {
            if (obj == null) {
                return null;
            }
            if (obj instanceof String) {
                return (String) obj;
            }
            return MAPPER.writeValueAsString(obj);
        } catch (Exception e) {
            log.error("Parse object to String error: {}", e.getMessage());
            throw new RuntimeException(e.getMessage());
        }
    }

    @SuppressWarnings("unchecked")
    public static <T> T jsonToObject(String json, Class<T> clazz) {
        if (null == clazz || StringUtils.isEmpty(json)) {
            return null;
        }
        if (String.class.equals(clazz)) {
            return (T) json;
        }
        try {
            return MAPPER.readValue(json, clazz);
        } catch (Exception e) {
            log.error("LogMessage.MSG_02");
            throw new RuntimeException(e.getMessage());
        }
    }

    public JsonNode readTree(String json) {
        try {
            return MAPPER.readTree(json);
        } catch (JsonProcessingException e) {
            log.error("LogMessage.MSG_03");
            throw new RuntimeException(e.getMessage());
        }
    }

    public JsonNode getChildrenFromJson(String json, String fieldName) {
        JsonNode parent = readTree(json);
        return null == parent ? null : parent.get(fieldName);
    }

    public JsonNode getChildrenFromNode(JsonNode jsonNode, String fieldName) {
        if (null == jsonNode || StringUtils.isBlank(fieldName)) {
            return null;
        }
        return jsonNode.get(fieldName);
    }

    public static <T> List<T> jsonToList(String json, Class<T> javaClazz) {
        if (null == json) {
            return new ArrayList<>();
        }
        try {
            JavaType javaType = MAPPER.getTypeFactory().constructParametricType(List.class, javaClazz);
            return MAPPER.readValue(json, javaType);
        } catch (JsonProcessingException e) {
            log.error("error", e);
            return null;
        }
    }

    /**
     * json转集合
     *
     * @param <T>
     * @param json
     * @param typeReference <li>new TypeReference<List<User>>() {}</li>
     * @return T
     */
    @SuppressWarnings("unchecked")
    public static <T> T toCollection(String json, TypeReference<T> typeReference) {
        try {
            if (StringUtils.isEmpty(json) || typeReference == null) {
                return null;
            }
            if (typeReference.getType().equals(String.class)) {
                return (T) json;
            }
            return MAPPER.readValue(json, typeReference);
        } catch (IOException e) {
            log.error("Parse String to Bean error", e);
            return null;
        }
    }

    public static <K, V> Map<K, V> jsonToMap(String json, Class<K> keyClass, Class<V> valueClass) {
        try {
            return MAPPER.readValue(json,
                MAPPER.getTypeFactory().constructParametricType(Map.class, keyClass, valueClass));
        } catch (JsonProcessingException e) {
            log.error("error", e);
        }
        return Collections.emptyMap();
    }

    /**
     * 读取磁盘的json文件，转换成json对象
     */
    public static JsonNode readJsonFile(String jsonPath) {
        if (StringUtils.isEmpty(jsonPath)) {
            log.error("JsonPath is empty.");
            return null;
        }
        try {
            return MAPPER.readTree(FileUtils.getFile(jsonPath));
        } catch (IOException e) {
            log.error("ReadJson from File[{}] failed, exception is {}", jsonPath, e.getLocalizedMessage());
        }
        return null;
    }
}

jackson常用注解

注解用法
@JsonProperty用于属性，把属性的名称序列化时转换为另外一个名称。示例：@JsonProperty("birth_date") private Date birthDate
@JsonIgnore可用于字段、getter/setter、构造函数参数上，作用相同，都会对相应的字段产生影响。使相应字段不参与序列化和反序列化。
@JsonIgnoreProperties该注解是类注解。该注解在Java类和JSON不完全匹配的时候使用。
@JsonFormat用于属性或者方法，把属性的格式序列化时转换成指定的格式。示例：@JsonFormat(timezone = "GMT+8", pattern = "yyyy-MM-dd HH:mm") public Date getBirthDate()
@JsonPropertyOrder用于类， 和 @JsonProperty 的index属性类似，指定属性在序列化时 json 中的顺序 ， 示例：@JsonPropertyOrder({ "birth_Date", "name"}) public class Person
@JsonCreator用于构造方法，和 @JsonProperty 配合使用，适用有参数的构造方法。示例：@JsonCreator public Person(@JsonProperty("name")String name) {…}
@JsonAnySetter用于属性或者方法，设置未反序列化的属性名和值作为键值存储到 map 中 @JsonAnySetter public void set(String key, Object value) { map.put(key, value); }
@JsonAnyGetter用于方法 ，获取所有未序列化的属性 @JsonAnyGetter public Map<String, Object> any() { return map; }
@JsonNaming类注解。序列化的时候该注解可将驼峰命名的字段名转换为下划线分隔的小写字母命名方式。反序列化的时候可以将下划线分隔的小写字母转换为驼峰命名的字段名。示例：@JsonNaming(PropertyNamingStrategy.SnakeCaseStrategy.class)
@JsonRootName类注解。需开启mapper.enable(SerializationFeature.WRAP_ROOT_VALUE)，用于序列化时输出带有根属性名称的 JSON 串，形式如 {"root_name":{"id":1,"name":"zhangsan"}}。但不支持该 JSON 串反序列化。

参考文章：

https://www.onblogs.net/2020/08/28/%E5%8F%B2%E4%B8%8A%E6%9C%80%E5%85%A8%E7%9A%84Jackson%E4%BD%BF%E7%94%A8%E6%95%99%E7%A8%8B/

https://www.cnblogs.com/fanshuyao/p/14707710.html

https://juejin.cn/post/6844904166809157639#heading-23

https://zhuanlan.zhihu.com/p/432521484

Java新客户
关注
  • 0
    点赞
  • 踩
  • 5
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
利用Jackson封装常用的JsonUtil工具类
yuhuofei的草屋
08-19 4029
jackson的使用，封装json工具类
JackSon工具类
m0_58680865的博客
10-22 464
Jackson 是当前用的比较广泛的，用来序列化和反序列化 json 的 Java 的开源框架。
Jackson工具类
最新发布
qq_51177455的博客
06-04 180
【代码】Jackson工具类。
Jackson 工具类
热门推荐
桃李不言下自成蹊
10-19 3万+
示例代码中包含 Date LocalDate LocalDateTime 类型处理方式JavaBean 与 json 相互转换 bean2json json2beanList 与 json 相互转换 list2json json2listMap 与 json 相互转换map2json json2map。
jackson工具类
04-27 2013
Jackson是一个流行的Java库，用于处理JSON数据。它提供了丰富的API来序列化和反序列化Java对象为JSON格式，以及将JSON数据解析回Java对象。
SpringBoot--封装JSON工具类（基于Jackson）
IT利刃出鞘的博客
09-28 1783
本文提供一个JSON工具类，本工具是对Jackson（也就是ObjectMapper）的封装。
Jackson：工具类
程序员无羡的博客
05-12 297
Jackson：工具类
json jackson 工具类
12-24
在这个“json jackson 工具类”中，我们看到对Jackson进行了封装，以便更方便地进行字符串与JSON对象之间的转换，包括对简单对象和复杂对象的支持。 Jackson库主要由以下组件组成： 1. `...
关于Jackson的JSON工具类封装 JsonUtils用法
10-14
【Jackson的JSON工具类封装JsonUtils】 在Java开发中，数据交换经常涉及到JSON格式的转换。Jackson库是一个高效且功能强大的处理JSON的工具，它提供了将Java对象转换为JSON字符串和将JSON字符串反序列化为Java对象...
springboot整合Jackson实例项目-附工具类
03-21
说明：本篇讲的是Jackson的详细用法，Jackson工具类在文章最后，直接复制粘贴即可使用。 Jackson是公司中必用的组件之一，常用的还用阿里的Fastjson，但是由于一些原因bug与漏洞是在是太多，在注重安全的公司直接被...
《SpringBoot篇》26.SpringBoot整合Jackson超详细教程（附Jackson工具类）
陈老老老板的博客
03-22 3万+
本篇讲的是Jackson的详细用法，Jackson工具类在文章最后，直接复制粘贴即可使用。Jackson是公司中必用的组件之一，常用的还用阿里的Fastjson，但是由于一些原因bug与漏洞是在是太多，在注重安全的公司直接被pass，还有就是谷歌的Gson（这个没用过不太了解）。Spring MVC 的默认 json 解析器便是 Jackson。Jackson 优点很多。Jackson 所依赖的 jar 包较少 ，简单易用。
Jackson 工具类使用及配置指南
攻城狮不是猫
04-08 1408
Json数据格式这两年发展的很快，其声称相对XML格式有很对好处:容易阅读；解析速度快；占用空间更少。不过,JSON 和 XML两者纠结谁优谁劣,这里不做讨论,可以参见知乎上为什么XML这么笨重的数据结构仍在广泛应用？最近在项目中，会有各种解析JSON文本的需求，使用第三方Jackson工具来解析时，又担心当增加会减少字段，会不会出现非预期的情况，因此，研究下jackson解析json数据格式的代码，很有需要。
封装单例Jackson工具类
呆萌小新@渊洁的博客
06-07 350
为什么不注入spring容器代理. 像这样的无状态的工具类,共享资源配置池,无状态配置类等.都可以不注入. 但是这个工具类不注入spring是因为.如下自定义单例写法/**// 日期格式化 private static final String STANDARD_FORMAT = "yyyy-MM-dd HH:mm:ss";} // 静态工厂方法获取单例 public static ObjectMapper getInstance() {
「Java工具类」Jackson工具类，json字符串转各种对象或者集合，工具类库是使用spring推荐使用的jackson库
Java Farmer
10-31 1586
介绍语 本博客主要是Java常用关键技术点，通用工具类的分享；以及springboot+springcloud+Mybatisplus+druid+mysql+redis+swagger+maven+docker等集成框架的技术分享；datax、kafka、flink等大数据处理框架的技术分享。文章会不断更新，欢迎码友关注点赞收藏转发！ 望各位码友点击关注，冲1000粉。后面会录制一些视频教程，图文和视频结合，比如：图书介绍网站系统、抢购系统、大数据中台系统等。技术才是程序猿的最爱，码友们冲啊 如果码
Jackson的使用与创建Jackson工具类
pan_junbiao的博客
05-30 3151
Jackson 是当前用的比较广泛的，用来序列化和反序列化 json 的 Java 的开源框架。Jackson 社 区相对比较活跃，更新速度也比较快， 从 Github 中的统计来看，Jackson 是最流行的 json 解析器之一 。 Spring MVC 的默认 json 解析器便是 Jackson。 Jackson 优点很多。 Jackson 所依赖的 jar 包较少 ，简单易用。与其他 Java 的 json 的框架 Gson 等相比， Jackson 解析大的 json 文件速度比较快；Jacks
spring jackson 工具类
04-30
Spring Jackson 工具类是一种用于将 JSON 数据序列化和反序列化为 Java 对象的工具类。该工具类是基于 Jackson 库开发的，可以在 Spring 应用程序中很方便地使用。 在 Spring 应用程序中使用 Spring Jackson 工具类，步骤如下： 1. 添加依赖：在 pom.xml 文件中添加以下依赖： ``` <dependency> <groupId>com.fasterxml.jackson.core</groupId> <artifactId>jackson-databind</artifactId> <version>2.10.3</version> </dependency> ``` 2. 创建配置类：创建一个配置类，用于配置 Jackson 的 ObjectMapper 对象。可以在配置类中添加自定义的序列化和反序列化器。 ``` @Configuration public class JacksonConfig { @Bean public ObjectMapper objectMapper() { ObjectMapper objectMapper = new ObjectMapper(); objectMapper.configure(DeserializationFeature.FAIL_ON_UNKNOWN_PROPERTIES,false); objectMapper.setSerializationInclusion(JsonInclude.Include.NON_NULL); return objectMapper; } } ``` 3. 使用工具类：在需要序列化或反序列化 JSON 数据的地方使用 Spring Jackson 工具类。 ``` @RestController public class UserController { @Autowired private UserService userService; @GetMapping("/users/{id}") public User getUserById(@PathVariable Long id) { return userService.getUserById(id); } @PostMapping("/users") public User addUser(@RequestBody User user) { return userService.addUser(user); } } ``` 在上面的例子中，使用了 @RequestBody 注解将 JSON 数据反序列化为 User 对象，在返回值中使用了 Spring Jackson 工具类将 User 对象序列化为 JSON 数据返回给客户端。 总之，Spring Jackson 工具类是一种方便易用的 JSON 序列化和反序列化工具类，对于需要对 JSON 数据和 Java 对象进行转换的 Spring 应用程序来说非常实用。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值