Jackson自动将null对象转为默认值，将Js处理不了大数字转为字符串

最新推荐文章于 2023-11-08 22:40:00 发布
最新推荐文章于 2023-11-08 22:40:00 发布
阅读量710 收藏 3
点赞数
文章标签： java spring boot json
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/wushuiliushang/article/details/131131539
版权

Jackson自动将null对象转为默认值，将Js处理不了大数字转为字符串

前言

SpringBoot开发中，接口返回值中将null对象转成对应的默认值。例如String转为空字符串，Integer转为0
SpringBoot项目中，默认使用的是Jackson来进行json序列化，本文对json进行属性配置来完成该功能。另外会讲两个主要功能封装成配置类，可以在yml文件中进行开启或关闭。

一、开发环境准备

准备一个SpringBoot项目
pom.xml文件

<dependencies>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
        </dependency>

        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-configuration-processor</artifactId>
            <optional>true</optional>
        </dependency>

        <dependency>
            <groupId>org.projectlombok</groupId>
            <artifactId>lombok</artifactId>
            <version>1.18.24</version>
            <scope>provided</scope>
        </dependency>
    </dependencies>

二、操作步骤

创建自定义的各种类型空对象时的处理器。例如：String的null对象处理器，在处理器中将空null的String对象转为空字符串串

package com.xue.demos.config.jackson;

import com.fasterxml.jackson.core.JsonGenerator;
import com.fasterxml.jackson.databind.JsonSerializer;
import com.fasterxml.jackson.databind.SerializerProvider;

import java.io.IOException;


public class CustomizeNullJsonSerializer {
    /**
     * 处理数组集合类型的null值
     */
    public static class NullArrayJsonSerializer extends JsonSerializer<Object> {
        @Override
        public void serialize(Object value, JsonGenerator jsonGenerator,
                              SerializerProvider serializerProvider) throws IOException {
            jsonGenerator.writeStartArray();
            jsonGenerator.writeEndArray();
        }
    }

    /**
     * 处理字符串类型的null值
     */
    public static class NullStringJsonSerializer extends JsonSerializer<Object> {
        @Override
        public void serialize(Object value, JsonGenerator jsonGenerator,
                              SerializerProvider serializerProvider) throws IOException {
            jsonGenerator.writeString("");
        }
    }

    /**
     * 处理数值类型的null值
     */
    public static class NullNumberJsonSerializer extends JsonSerializer<Object> {
        @Override
        public void serialize(Object value, JsonGenerator jsonGenerator,
                              SerializerProvider serializerProvider) throws IOException {
            jsonGenerator.writeNumber(0);
        }
    }

    /**
     * 处理boolean类型的null值
     */
    public static class NullBooleanJsonSerializer extends JsonSerializer<Object> {
        @Override
        public void serialize(Object value, JsonGenerator jsonGenerator,
                              SerializerProvider serializerProvider) throws IOException {
            jsonGenerator.writeBoolean(false);
        }
    }
    /**
     * 处理date类型的null值
     */
    public static class NullDateJsonSerializer extends JsonSerializer<Object> {
        @Override
        public void serialize(Object value, JsonGenerator jsonGenerator,
                              SerializerProvider serializerProvider) throws IOException {
            jsonGenerator.writeString("");
        }
    }


    /**
     * 处理实体对象类型的null值
     */
    public static class NullObjectJsonSerializer extends JsonSerializer<Object> {
        @Override
        public void serialize(Object value, JsonGenerator jsonGenerator,
                              SerializerProvider serializerProvider) throws IOException {
            jsonGenerator.writeStartObject();
            jsonGenerator.writeEndObject();
        }
    }

}

在Js中可处理的数据范围是-9007199254740992 ~ 9007199254740992 。但在Java中数字长度或是超过这个限制，Js会将超出的部分填充为0。故需要自定义一个大数字处理器，来解决这个问题。

package com.xue.demos.config.jackson;

import com.fasterxml.jackson.core.JsonGenerator;
import com.fasterxml.jackson.databind.SerializerProvider;
import com.fasterxml.jackson.databind.ser.std.NumberSerializer;

import java.io.IOException;


public class BigNumberSerializer extends NumberSerializer {
    private static final long JS_NUM_MAX = 9007199254740992L;
    private static final long JS_NUM_MIN = -9007199254740992L;
    public static final BigNumberSerializer instance = new BigNumberSerializer(Number.class);

    public BigNumberSerializer(Class<? extends Number> rawType) {
        super(rawType);
    }

    public void serialize(Number value, JsonGenerator gen, SerializerProvider provider) throws IOException {
        long longValue = value.longValue();
        if (longValue >= JS_NUM_MIN && longValue <= JS_NUM_MAX) {
            super.serialize(value, gen, provider);
        } else {
            gen.writeString(value.toString());
        }

    }
}

自定义修改器，将对应的数据类型和对应的null对象处理器绑定上

package com.xue.demos.config.jackson;

import com.fasterxml.jackson.databind.BeanDescription;
import com.fasterxml.jackson.databind.SerializationConfig;
import com.fasterxml.jackson.databind.ser.BeanPropertyWriter;
import com.fasterxml.jackson.databind.ser.BeanSerializerModifier;

import java.time.temporal.Temporal;
import java.util.Collection;
import java.util.Date;
import java.util.List;


public class CustomizeBeanSerializerModifier extends BeanSerializerModifier {

    @Override
    public List<BeanPropertyWriter> changeProperties(SerializationConfig config,
                                                     BeanDescription beanDesc,
                                                     List<BeanPropertyWriter> beanProperties) {
        // 循环所有的beanPropertyWriter
        for (BeanPropertyWriter writer : beanProperties) {
            // 判断字段的类型，如果是数组或集合则注册nullSerializer
            if (isArrayType(writer)) {
                // 给writer注册一个自己的nullSerializer
                writer.assignNullSerializer(new CustomizeNullJsonSerializer.NullArrayJsonSerializer());
                continue;
            }
            if (isStringType(writer)) {
                writer.assignNullSerializer(new CustomizeNullJsonSerializer.NullStringJsonSerializer());
                continue;
            }
            if (isNumberType(writer)){
                writer.assignNullSerializer(new CustomizeNullJsonSerializer.NullNumberJsonSerializer());
                continue;
            }
            if (isDateType(writer)){
                writer.assignNullSerializer(new CustomizeNullJsonSerializer.NullDateJsonSerializer());
                continue;
            }
            if (isBooleanType(writer)){
                writer.assignNullSerializer(new CustomizeNullJsonSerializer.NullBooleanJsonSerializer());
            }
        }
        return beanProperties;
    }

    /**
     * 是否是数组
     */
    private boolean isArrayType(BeanPropertyWriter writer) {
        Class<?> clazz = writer.getType().getRawClass();
        return clazz.isArray() || Collection.class.isAssignableFrom(clazz);
    }

    /**
     * 是否是String
     */
    private boolean isStringType(BeanPropertyWriter writer) {
        Class<?> clazz = writer.getType().getRawClass();
        return CharSequence.class.isAssignableFrom(clazz) || Character.class.isAssignableFrom(clazz);
    }

    /**
     * 是否是数值类型
     */
    private boolean isNumberType(BeanPropertyWriter writer) {
        Class<?> clazz = writer.getType().getRawClass();
        return Number.class.isAssignableFrom(clazz);
    }

    /**
     * 是否是boolean
     */
    private boolean isBooleanType(BeanPropertyWriter writer) {
        Class<?> clazz = writer.getType().getRawClass();
        return clazz.equals(Boolean.class);
    }
    /**
     * 是否是date
     */
    private boolean isDateType(BeanPropertyWriter writer) {
        Class<?> clazz = writer.getType().getRawClass();
        return clazz.equals(Date.class) || Temporal.class.isAssignableFrom(clazz);
    }

}

为了方便使用，配置config类，并通过ConditionalOnProperty实现通过ymal里面的配置去动态开启或关闭空对象处理功能以及大数字转字符串功能。额外扩充个知识点：在Java中Integer.class来表示Integer类，用Integer.Type来表示int
第一个是配置类：

package com.xue.demos.config.jackson;

import com.fasterxml.jackson.databind.ObjectMapper;
import com.fasterxml.jackson.databind.SerializerProvider;
import com.fasterxml.jackson.databind.ser.std.ToStringSerializer;
import org.springframework.boot.autoconfigure.condition.ConditionalOnMissingBean;
import org.springframework.boot.autoconfigure.condition.ConditionalOnProperty;
import org.springframework.boot.autoconfigure.jackson.Jackson2ObjectMapperBuilderCustomizer;
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 java.math.BigDecimal;
import java.math.BigInteger;


@Configuration
public class JacksonConfig {
    @Bean
    @Primary
    @ConditionalOnMissingBean(ObjectMapper.class)
    @ConditionalOnProperty(name = "nullToEmpty",prefix = "jackson.config", havingValue = "true")
    public ObjectMapper jacksonObjectMapper(Jackson2ObjectMapperBuilder builder) {
        ObjectMapper objectMapper = builder.createXmlMapper(false).build();
        /** 为objectMapper注册一个带有SerializerModifier的Factory */
        objectMapper.setSerializerFactory(objectMapper.getSerializerFactory()
                .withSerializerModifier(new CustomizeBeanSerializerModifier()));

        SerializerProvider serializerProvider = objectMapper.getSerializerProvider();
        serializerProvider.setNullValueSerializer(new CustomizeNullJsonSerializer
                .NullObjectJsonSerializer());
        return objectMapper;
    }

    @Bean
    @ConditionalOnMissingBean(Jackson2ObjectMapperBuilderCustomizer.class)
    @ConditionalOnProperty(name = "bigNumToString",prefix = "jackson.config", havingValue = "true")
    public Jackson2ObjectMapperBuilderCustomizer jackson2ObjectMapperBuilderCustomizer() {
        return builder -> {
            //将Long类型转换成string类型返回，避免大整数导致前端精度丢失的问题
            builder.serializerByType(Long.TYPE, BigNumberSerializer.instance);
            builder.serializerByType(Long.class, BigNumberSerializer.instance);
            builder.serializerByType(BigInteger.class, BigNumberSerializer.instance);
            builder.serializerByType(BigDecimal.class, ToStringSerializer.instance);
        };
    }
}

第二个是用于yaml中的控制类，通过nullToEmpty和bigNumToString两个属性来控制功能是否开户。两个值的默认是true，也就是说默认开启

package com.xue.demos.config.jackson;

import org.springframework.boot.context.properties.ConfigurationProperties;
import org.springframework.stereotype.Component;


@Component
@ConfigurationProperties(prefix = "jackson.config")
public class JacksonProperties {
    private Boolean nullToEmpty;
    private Boolean bigNumToString;

    public JacksonProperties() {
        nullToEmpty = Boolean.TRUE;
        bigNumToString = Boolean.TRUE;
    }

    public Boolean getNullToEmpty() {
        return nullToEmpty;
    }

    public void setNullToEmpty(Boolean nullToEmpty) {
        this.nullToEmpty = nullToEmpty;
    }

    public Boolean getBigNumToString() {
        return bigNumToString;
    }

    public void setBigNumToString(Boolean bigNumToString) {
        this.bigNumToString = bigNumToString;
    }
}

下面是yaml配置

# 应用服务 WEB 访问端口
server:
  port: 8080
spring:
  application:
    name: jackson-demo
jackson:
  config:
    nullToEmpty: true # 空对象转换
    bigNumToString: true # 大数字转换字符串

测试阶段

我们建议一个实体类，以及一个接口，通过接口的返回值来查看功能是否生效。
对应实体类，在实体类使用lombok注解来简化代码：

package com.xue.demos.entity;

import lombok.AllArgsConstructor;
import lombok.Data;
import lombok.NoArgsConstructor;

import java.time.LocalDate;
import java.util.Date;
import java.util.List;
import java.util.Map;

@Data
@AllArgsConstructor
@NoArgsConstructor
public class TestJson {
    private Integer userId;
    private String userName;
    // 大数字的long对象
    private Long bigNumLong = 9007199254740999L;
    private Long smallNumLong = 1000L;
    private Double userIdDouble;
    private Date date;
    private LocalDate date1;
    private List list;
    private Map map;
}

controller层的接口，不做其他过多的操作，只是new 一个实体类，然后返回，看下接口的返回值

package com.xue.demos.controller;

import com.xue.demos.entity.TestJson;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RestController;

@RestController
public class TestJsonController {

    @GetMapping("/testJackson")
    public TestJson testJackson() {
        return new TestJson();
    }
}

接口返回值
通过截图可以发现，空对象已经转换为对应的默认值。例如：Integer的userId转为了0。
而大数字的bigNumLong 也已经转为了字符串，而小数字smallNumLong则没变。

总结

以上就是今天要讲的内容，本文仅仅简单介绍了Jackson在SpringBoot中的一个使用，而这个使用也可以方便前端对象的一个处理和使用。

wushuiliushang
关注
  • 0
    点赞
  • 踩
  • 3
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
java对象映射器(基于jackson将Java对象转为json，或者将json转为Java对象)
04-26
用来干啥？ 答：将JSON解析为Java对象的过程称为 [从JSON反序列化Java对象] 从Java对象生成JSON的过程称为 [序列化Java对象到JSON] 为什么用它？ 答：我数据库中的主键是使用雪花算法生成的，就是因为用id的位数太多，导致在前台我点击删除/修改按钮后传入到后端的id会缺少精度。（比如本应该是18234736282736、传过去就是18234736282700），可以看到后三位就省略变成了0.就是缺精度。导致的原因就是js的精度没有java中Long的精度高。这就需要传到后端时通过json转成string，然后在进行解析json拿到id。 不光是这一个场景，就像有些时间的格式到后端变成能接受的值等。
Jackson自定义序列化null值处理
qq_2321620071的博客
03-11 4615
1. 私人定制jackson的自定义序列化(null值的处理) 1.1 处理的原因 在对List类型的值进行处理时，有一部分服务是有做一些逻辑判断的，在逻辑判断不通过的时候会返回一个null值，而有一些值是直接通过jpa查询到的List类型的值则会进行实例化，即同样是List类型，一个是null，一个"[]"。 最简单的办法是在null值的地方全部实例化一个new ArrayList<?>(0);但是这样会修改很多地方，而且对于这些情况都要进行实例化分配内存不是那么的理想。 所以就在spring
Jackson将json string转为Object,org.json读取json数组的实例
10-18
下面小编就为大家带来一篇Jackson将json string转为Object,org.json读取json数组的实例，具有很好的参考价值，希望对大家有所帮助
jackson解析json字符串,首字母大写会自动转为小写的方法
01-19
问题 楼主碰到的问题是，在实体类和表中定义的某个字段为RMBPrice，首字母大写，sql查询出来的列名也是大写的RMBPrice，但是使用jquery的datatables初始化列时，却出错。 那一行的代码如下： {name: RMBPrice, data: RMBPrice, className: text-center, render: formatRMBPrice}, 打开页面却会显示这个。查看浏览器调用接口返回的值： 是小写的rmbprice 分析 接口返回的是一个@ResponseBody对象，在代码中打断点，一直到接口的返回值都是大写的，所以只可
jackson 对象json字符串数组集合互转
06-20
jackson 对象json字符串数组集合互转 各jar包 希望能用到。
springBoot jackson 统一 null 值的默认值
m0_49606223的博客
05-02 3089
在实际的项目开发中，后端返回的json数据没有的时候一般直接返回的null,但是有的时候由于增加了前端的处理或者业务的需要,需要把值为null的设置成""或者[]亦或者{} 此时我们可以使用返回值统一处理，配置如下 ...
springboot的自带序列化jackson的使用 对不同类型的null字段进行设置指定值
Rallos的博客
05-07 3040
JackSon是解析JSON和XML的一个框架，优点是简单易用，性能较高。 SpringBoot使用Jackson序列化时将null转成空字符串 简介 大家知道很多情况下，我们的API中数据交换都用JSON数据，这种数据格式简单、易读写、且轻量。在SpringBoot中默认使用jackson帮助我们进行序列化与反序列化的操作。 在控制层将我们的对象序列化返回给前端时，有些字段为null，序列化后的值也是null，如果前端直接展示的话，对用户不够友好，这里我们可以对jackson稍加修改，将值为null
jackson注解
yan_wenliang的专栏
06-18 970
@JsonIgnoreProperties 在类上标注哪些属性不参与序列化和反序列化 @JsonIgnoreProperties(value = { "age" }) public class Person { private String name; private String age; } @JsonIgnore 在属性上标注哪些属性不参与序列化和反序列化 public class Person { private String hello; @JsonIgnore pr
springboot 如何将返回前端的null值 变为固定值
qq_43028226的博客
07-24 347
今天做了个项目 当我给前端返回null值时需求要把 null值都返回成 “–” 记录一下子 在springboot上配置一下就好 import com.fasterxml.jackson.core.JsonGenerator; import com.fasterxml.jackson.databind.JsonSerializer; import com.fasterxml.jackson.databind.ObjectMapper; import com.fasterxml.jackson.datab
springboot返回给前端数据将null值转化为对应的空字符串、空数组、时间统一格式化等等
小林子的博客
03-05 1621
实现WebMvcConfigurer 即：implements WebMvcConfigurer 自己重写消息转换器代码如下： import com.alibaba.fastjson.serializer.SerializerFeature; import com.alibaba.fastjson.support.config.FastJsonConfig; import com.alibaba.fastjson.support.spring.FastJsonHttpMessageConverter;
Jackson注解学习参考
04-15
NULL 博文链接：https://wong-john.iteye.com/blog/1753402
自定义jackson反序列null和空字符串的默认值
baidu_33470149的博客
11-09 4031
将json反序列化，但是不希望对象的属性中有null或者空字符串，那么就可以采用以下方案。 首先是实体类 package com.example.demo.dto; import com.example.demo.config.StringDeserializer; import com.fasterxml.jackson.annotation.JsonProperty; import com.fasterxml.jackson.databind.annotation.JsonDeserialize; i
spring boot 返回json字符串 null值转空字符串
sidan8的专栏
03-17 9580
@Configuration public class JacksonConfig { @Bean @Primary @ConditionalOnMissingBean(ObjectMapper.class) public ObjectMapper jacksonObjectMapper(Jackson2ObjectMapperBuilder builder) {
java 自定义序列化 @JsonSerialize null值赋默认值
dc_young的博客
09-26 1020
定义序列化 需要继承 JsonSerializer类， 重写serialize方法。利用反射获取要序列化的对象的所有属性名和属性值判断：如果属性值为null，为不同类型的属性分别赋一个默认值，如：string类型赋""，Integer类型赋0，List集合赋空集等判读：如果属性值不为null，定义其他处理规则，如：保留指定小数位、添加/删除list中的元素等。
SpringBoot中Jackson返回null处理,字符串类型转空串,数组集合转[],对象转{}
Life is for sharing的博客
09-27 8070
文章目录1.自定义null值序列化处理器2.序列化程序修改器3.配置Jackson实体 SpringBoot框架返回Json数据中null值处理，将字符串类型null值转换为""，将集合数组类型null值转换为[]，将原始数据类型null值转换为0，将布尔类型null值转换为false，将实体对象null值转换为{}。 1.自定义null值序列化处理器 import com.fasterxml.j...
java 字段为空设置默认值_使用Jackson进行映射时，将默认值设置为空字段
weixin_39991935的博客
02-27 2533
另一种选择是使用InjectableValues和@JacksonInject。如果您不总是需要使用相同的值，而是需要从DB或其他地方获取一个特定情况的值，这将非常有用。这是使用JacksonInject的示例：protected static class Some {private final String field1;private final String field2;public So...
@JacksonInject 指定反序列化时的默认值
赵丙双的博客
04-22 2512
@JacksonInject 指定反序列化时的默认值通过 key 注入通过类型注入原文链接 在反序列化期间，被注解属性的值会被注入，而不是从 JSON 中反序列化。如果源 JSON 中没有我们需要的信息时，这时将很有用，我们可以用它设置默认值。 通过 key 注入 public class CurrencyRate { private String pair; private double rate; @JacksonInject("lastUpdated") private
源码分析SpringBoot自定义Jackson序列化，默认null值个性化处理返回值
最新发布
qq_43842093的博客
11-08 971
剩下的解释一下为什么单独配置并设置实例化@bean的MappingJackson2HttpMessageConverter也是好使的呢，大家可以看一下JacksonHttpMessageConvertersConfiguration类的源码，里面明确写了@ConditionalOnMissingBean注解，如果我们自己进行配置了，这个注入后就是一个备胎，以我们的为准，这个不多说。讲到这里，不知道大家理解了多少，这些都是博主遇到需求后，自己问自己的问题，自己通过源码回答问题的，也希望大家能理解源码。
java-使用Jackson进行反序列化时,将标量转换为字符串
weixin_44109689的博客
01-01 2895
我想识别通过POST请求的请求正文发送的JSON中插入的不带引号(作为字符串)的数值： 例如,这将是错误的JSON格式,因为age字段不包含引号： { "Student":{ "Name": "John", "Age": 12 } } 正确的JSON格式为： { "Student":{ "Name": "John", "...
java中map再转json时null也被转为字符串
09-26
当使用Java进行Map转JSON时，如果Map中有一个值为null，则它会被转换为字符串"null"。这是因为JSON格式要求所有值都必须是字符串，所以null值也会被转换为字符串。 如果你想要避免这种情况，你可以使用Jackson库来转换Map到JSON。Jackson允许你配置序列化器，使null值在序列化时被忽略。例如，你可以使用下面的代码来配置Jackson库： ``` ObjectMapper mapper = new ObjectMapper(); mapper.setSerializationInclusion(JsonInclude.Include.NON_NULL); ``` 这样，Jackson就会忽略null值，并在序列化时不包含它们。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值