脚本之家 服务器常用软件
快捷导航
您的位置：首页 → 软件编程 → java → SpringBoot Json工具类

SpringBoot中Json工具类的实现

 更新时间：2024年10月31日 09:00:46   作者：你家宝宝  
本文介绍在Java项目中实现一个JSON工具类,支持对象与JSON字符串之间的转换,并提供依赖和代码示例便于直接应用,感兴趣的可以了解一下

前言

在日常开发java项目的时候，总能遇到各种关于json的业务处理。
包括对象转json，json转对象，转map等情况。

本文就实现一个json工具类，来处理这些业务场景。开发项目时，可以直接粘贴依赖和代码到你的项目中使用。

正文

1、依赖引入

项目中需要先引入json对应的包。

<dependency>
  <groupId>com.fasterxml.jackson.core</groupId>
  <artifactId>jackson-databind</artifactId>
  <version>2.17.2</version>
</dependency>
<dependency>
  <groupId>com.fasterxml.jackson.datatype</groupId>
  <artifactId>jackson-datatype-jsr310</artifactId>
  <version>2.17.2</version>
</dependency>

2、JsonUtil.java

package com.pine.common.util.json;

import com.fasterxml.jackson.annotation.JsonInclude;
import com.fasterxml.jackson.core.JsonGenerator;
import com.fasterxml.jackson.core.JsonParser;
import com.fasterxml.jackson.databind.*;
import com.fasterxml.jackson.datatype.jsr310.JavaTimeModule;

import java.io.IOException;
import java.text.SimpleDateFormat;
import java.time.ZoneId;
import java.util.ArrayList;
import java.util.List;
import java.util.Map;
import java.util.TimeZone;
import java.util.regex.Pattern;

/**
 * json工具
 *
 * @author pine manage
 * @since 2024-10-30
 */
public class JsonUtil {
    private static final ObjectMapper OBJECT_MAPPER = new ObjectMapper();

    private static final String DEFAULT_DATE_TIME_PATTERN = "yyyy-MM-dd HH:mm:ss";

    /**
     * 正则表达式，用于判断是否是json串(只判断是否是{}, []的结构)
     */
    private static final Pattern PREPARE_JSON_PATTERN = Pattern.compile("^\\{.*\\}$|^\\[.*]$");

    public JsonUtil() {
    }

    /**
     * json转对象
     *
     * @param json        字符串
     * @param clazz       对象类型
     * @param ignoreError 是否忽略错误，true时返回null，false时抛出异常
     * @param <T>         对象泛型类型
     * @return 对象
     */
    public static <T> T json2Object(String json, Class<T> clazz, boolean ignoreError) {
        try {
            return OBJECT_MAPPER.readValue(json, clazz);
        } catch (IOException e) {
            if (ignoreError) {
                return null;
            }
            throw new RuntimeException("解析json错误");
        }
    }

    /**
     * json转对象
     *
     * @param json  字符串
     * @param clazz 对象类型
     * @param <T>   对象泛型类型
     * @return 对象
     */
    public static <T> T json2Object(String json, Class<T> clazz) {
        return json2Object(json, clazz, false);
    }


    /**
     * json转对象(忽略错误，出错时返回null)
     *
     * @param json  json字符串
     * @param clazz 类型
     * @param <T>   对象泛型类型
     * @return 对象
     */
    public static <T> T json2ObjectIgnoreError(String json, Class<T> clazz) {
        return json2Object(json, clazz, true);
    }

    /**
     * json转对象
     *
     * @param json 字符串
     * @param tr   类型封装
     * @param <T>  对象泛型类型
     * @return 对象
     */
    public static <T> T json2Object(String json, TypeRef<T> tr) {
        try {
            return OBJECT_MAPPER.readValue(json, tr.getType());
        } catch (IOException e) {
            throw new RuntimeException("解析json错误");
        }
    }

    /**
     * json转json树
     *
     * @param json json字符串
     * @return json树
     */
    public static JsonNode json2Tree(String json) {
        try {
            return OBJECT_MAPPER.readTree(json);
        } catch (Exception e) {
            throw new RuntimeException("解析json错误");
        }
    }

    /**
     * json转map
     *
     * @param json  json字符串
     * @param clazz 类型
     * @param <T>   对象泛型类型
     * @return map
     */
    public static <T> Map<String, T> toObjectMap(String json, Class<T> clazz) {
        try {
            JavaType javaType = OBJECT_MAPPER.getTypeFactory().constructParametricType(Map.class, String.class, clazz);
            return OBJECT_MAPPER.readValue(json, javaType);
        } catch (IOException e) {
            throw new RuntimeException("解析json错误");
        }
    }

    /**
     * json转list
     *
     * @param json  json字符串
     * @param clazz 类型
     * @param <T>   对象泛型类型
     * @return list
     */
    public static <T> List<T> toObjectList(String json, Class<T> clazz) {
        JavaType javaType = OBJECT_MAPPER.getTypeFactory().constructParametricType(ArrayList.class, clazz);
        try {
            return OBJECT_MAPPER.readValue(json, javaType);
        } catch (IOException e) {
            throw new RuntimeException("解析json错误");
        }
    }


    /**
     * 对象转json
     *
     * @param entity 实体对象
     * @param <T>    对象泛型类型
     * @return json字符串
     */
    public static <T> String object2Json(T entity) {
        try {
            return OBJECT_MAPPER.writeValueAsString(entity);
        } catch (IOException e) {
            throw new RuntimeException("转换json错误");
        }
    }

    /**
     * 对象转json树
     *
     * @param obj 对象
     * @return json树
     */
    public static JsonNode object2TreeJson(Object obj) {
        try {
            return OBJECT_MAPPER.valueToTree(obj);
        } catch (Exception e) {
            throw new RuntimeException("转换json错误");
        }
    }

    /**
     * 判断一个字符串是否是json串
     *
     * @param content 内容
     * @return true 是，false 否
     */
    public static boolean isJson(String content) {
        if (content == null || content.isEmpty()) {
            return false;
        }

        // 预判是否是json串
        if (PREPARE_JSON_PATTERN.matcher(content).matches()) {
            try {
                OBJECT_MAPPER.readTree(content);
                return true;
            } catch (Exception e) {
                return false;
            }
        }
        return false;
    }


    /**
     * 获取objectMapper对象
     *
     * @return objectMapper对象
     */
    public static ObjectMapper getObjectMapper() {
        return OBJECT_MAPPER;
    }


    static {
        // 禁止日期/时间默认序列化为时间戳
        OBJECT_MAPPER.configure(SerializationFeature.WRITE_DATES_AS_TIMESTAMPS, false);
        // 设置时区为gmt+8
        OBJECT_MAPPER.setTimeZone(TimeZone.getTimeZone(ZoneId.systemDefault()));
        // 设置日期格式
        OBJECT_MAPPER.setDateFormat(new SimpleDateFormat(DEFAULT_DATE_TIME_PATTERN));
        // 允许单引号
        OBJECT_MAPPER.configure(JsonParser.Feature.ALLOW_SINGLE_QUOTES, true);
        // 将 BigDecimal 序列化为 bigDecimal.toPlainString(), 防止生成科学计数法
        OBJECT_MAPPER.configure(JsonGenerator.Feature.WRITE_BIGDECIMAL_AS_PLAIN, Boolean.TRUE);
        // 允许序列化空的POJO类（否则会抛出异常）
        OBJECT_MAPPER.disable(SerializationFeature.FAIL_ON_EMPTY_BEANS);
        // 在遇到未知属性的时候不抛出异常
        OBJECT_MAPPER.disable(DeserializationFeature.FAIL_ON_UNKNOWN_PROPERTIES);
        // 忽略值为默认值的属性
        OBJECT_MAPPER.setSerializationInclusion(JsonInclude.Include.NON_NULL);
        // java8时间类型支持
        OBJECT_MAPPER.registerModule(new JavaTimeModule());
    }
}

3、TypeRef.java

package com.pine.common.util.json;

import com.fasterxml.jackson.databind.JavaType;
import com.fasterxml.jackson.databind.type.TypeFactory;

import java.lang.reflect.ParameterizedType;

/**
 * type引用封装,javaType取自范型T
 *
 * @author pine manage
 * @since 2024-10-30
 */
public abstract class TypeRef<T> {
    /**
     * javaType: 获取范型T
     */
    private final JavaType jt = TypeFactory.defaultInstance()
            .constructType(((ParameterizedType) this.getClass().getGenericSuperclass()).getActualTypeArguments()[0]);

    public TypeRef() {
    }

    public JavaType getType() {
        return this.jt;
    }
}

测试

package com.pine.common.util.json;

import com.fasterxml.jackson.annotation.JsonFormat;
import com.pine.common.util.time.TimeUtil;
import lombok.Data;

import java.math.BigDecimal;
import java.time.LocalDateTime;
import java.util.Date;
import java.util.Map;


public class TestJson {

    public static void main(String[] args) {
        Demo demo = new Demo();
        demo.createTime = LocalDateTime.now();
        demo.date = new Date();
        demo.map = Map.of("key", "value");
        String json = JsonUtil.object2Json(demo);
        System.out.println(json);

        Demo demo1 = JsonUtil.json2Object(json, new TypeRef<>() {
        });
        System.out.println(demo1);
    }

    @Data
    private static class Demo {
        /**
         * 状态:0=启用,1=禁用
         */
        Integer status;
        /**
         * 描述、备注
         */
        String remark;
        /**
         * 创建时间
         */
        @JsonFormat(pattern = TimeUtil.DEFAULT_DATE_TIME_PATTERN, timezone = TimeUtil.GMT_8)
        LocalDateTime createTime;

        @JsonFormat(pattern = TimeUtil.DEFAULT_DATE_TIME_PATTERN, timezone = TimeUtil.GMT_8)
        Date date;

        Map<String, String> map;

        BigDecimal volume;
    }
}

控制台输出结果：

{"createTime":"2024-10-30 14:21:03","date":"2024-10-30 14:21:03","map":{"key":"value"}}
TestJson.Demo(status=null, remark=null, createTime=2024-10-30T14:21:03, date=Wed Oct 30 14:21:03 CST 2024, map={key=value}, volume=null)

到此这篇关于SpringBoot中Json工具类的实现的文章就介绍到这了,更多相关SpringBoot Json工具类内容请搜索脚本之家以前的文章或继续浏览下面的相关文章希望大家以后多多支持脚本之家！ 

您可能感兴趣的文章:

相关文章

  • spring的jdbctemplate的crud的基类dao

    spring的jdbctemplate的crud的基类dao

    本文主要介绍了使用spring的jdbctemplate进行增删改查的基类Dao的简单写法,需要的朋友可以参考下
    2014-02-02
  • 解决IDEA maven 项目修改代码不生效,mvn clean、install后才生效

    解决IDEA maven 项目修改代码不生效,mvn clean、install后才生效

    这篇文章主要介绍了解决IDEA maven 项目修改代码不生效,mvn clean、install后才生效的问题，具有很好的参考价值，希望对大家有所帮助。一起跟随小编过来看看吧
    2020-09-09
  • SpringBoot项目打成War包部署的方法步骤

    SpringBoot项目打成War包部署的方法步骤

    这篇文章主要介绍了springboot项目如何打war包流程的方法,文中通过示例代码介绍的非常详细,对大家的学习或者工作具有一定的参考学习价值,需要的朋友们下面随着小编来一起学习学习吧
    2020-12-12
  • springboot使用hibernate validation对参数校验的实现方法

    springboot使用hibernate validation对参数校验的实现方法

    这篇文章主要介绍了spring-boot 使用hibernate validation对参数进行优雅的校验,本文通过实例代码给大家介绍的非常详细，对大家的学习或工作具有一定的参考借鉴价值，需要的朋友可以参考下
    2020-12-12
  • Springboot整合Flowable6.x导出bpmn20的步骤详解

    Springboot整合Flowable6.x导出bpmn20的步骤详解

    这篇文章主要介绍了Springboot整合Flowable6.x导出bpmn20,Flowable流程引擎可用于部署BPMN 2.0流程定义，可以十分灵活地加入你的应用/服务/构架，本文给出两种从flowable导出流程定义bpmn20.xml的方式，需要的朋友可以参考下
    2023-04-04
  • 简单的用java实现读/写文本文件的示例

    简单的用java实现读/写文本文件的示例

    同时也展示了如果从输入流中读出来内容写入输出流中（仅限文本流） 三个例子可以独立存在，所以根据需要只看其中一个就行了。
    2008-07-07
  • Java持久化XML文件配置解析

    Java持久化XML文件配置解析

    这篇文章主要为大家介绍了Java持久化XML文件配置解析，当你在使用 Java 编程语言 来编写软件时，实现持久化配置的方式。有需要的朋友可以借鉴参考下，希望能够有所帮助<BR>
    2022-03-03
  • java 实现通过 post 方式提交json参数操作

    java 实现通过 post 方式提交json参数操作

    这篇文章主要介绍了java 实现通过 post 方式提交json参数操作，具有很好的参考价值，希望对大家有所帮助。一起跟随小编过来看看吧
    2020-09-09
  • SpringBoot项目热部署的实现

    SpringBoot项目热部署的实现

    SpringBoot项目热部署是一种让开发人员在修改代码后无需重启应用即可看到更改效果的技术,通过使用SpringBoot的DevTools等工具,文中通过示例代码介绍的非常详细,对大家的学习或者工作具有一定的参考学习价值,需要的朋友们下面随着小编来一起学习学习吧
    2024-09-09
  • springboot接收JSON实现示例解析

    springboot接收JSON实现示例解析

    这篇文章主要为大家介绍了springboot如何接收JSON的实现示例解析，有需要的朋友可以借鉴参考下，希望能够有所帮助，祝大家多多进步，早日升职加薪
    2023-07-07

最新评论