SpringMVC和Jackson解决Long 精度丢失（多方案）

最新推荐文章于 2024-03-29 09:49:10 发布
最新推荐文章于 2024-03-29 09:49:10 发布
阅读量3k 收藏 8
点赞数
分类专栏： Web前端 文章标签： Jackson js Long 精度丢失
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/liubinwyzbt/article/details/103036347
版权

概述

问题描述
Java输出至前端的整数长度超过16位时，前端js在解析整数时，超过16位的整数时，后面的数字会损失精度。

问题原因
JS内置的number类型是基于32位整数，Number类型的最大安全整数为9007199254740991，当Java Long型的值大小超过JS Number的最大安全整数时，超出此范围的整数值可能会被破坏，丢失精度。

解决办法
在后台将整数转换成字符串，围绕这个目标，共探索出5种解决方案，能满足大部分的个性化需求。

解决方案

  1. 过滤器统一拦截
  2. 自定义Serializer序列化类
  3. POJO属性增加注解
  4. 修改Serializers源码
  5. 代码转化

项目环境：

Spring 3.X and Jackson 2.X

1）过滤器统一拦截

配置Spring消息转换器的ObjectMapper类，引用创建的自定义类型转换器类。

  • 创建CustomObjectMapperForJackson类
package com.xiaodajia.framework.util.web.databind;

import java.math.BigDecimal;
import java.math.BigInteger;
import java.text.SimpleDateFormat;

import com.fasterxml.jackson.databind.ObjectMapper;
import com.fasterxml.jackson.databind.module.SimpleModule;
import com.fasterxml.jackson.databind.ser.std.ToStringSerializer;

public class CustomObjectMapperForJackson extends ObjectMapper {

	public CustomObjectMapperForJackson() {
		super();
		// 设置日期转换yyyy-MM-dd HH:mm:ss
		setDateFormat(new SimpleDateFormat("yyyy-MM-dd HH:mm:ss"));
		SimpleModule simpleModule = new SimpleModule();
		simpleModule.addSerializer(BigDecimal.class,
				ToStringSerializer.instance);
		simpleModule.addSerializer(BigInteger.class,
				ToStringSerializer.instance);
		simpleModule.addSerializer(Long.class,
				ToStringSerializer.instance);
		simpleModule.addSerializer(Long.TYPE,
				ToStringSerializer.instance);
		registerModule(simpleModule);
	}
}
  • spring-mvc.xml配置objectMapper
<mvc:annotation-driven validator="validator" conversion-service="conversion-service">
    	<mvc:message-converters register-defaults="true">
			<!-- 将StringHttpMessageConverter的默认编码设为UTF-8 -->
			<bean class="org.springframework.http.converter.StringHttpMessageConverter">
		    	<constructor-arg value="UTF-8" />
			</bean>
			<!-- 将Jackson2HttpMessageConverter的默认格式化输出设为true -->
			<bean class="org.springframework.http.converter.json.MappingJackson2HttpMessageConverter">
                <property name="prettyPrint" value="true"/>
                <property name="objectMapper">
                    <bean class="com.xiaodajia.framework.util.web.databind.CustomObjectMapperForJackson"/>
                </property>
            </bean>			
  		</mvc:message-converters>
	</mvc:annotation-driven>

关键代码
当项目中使用Mybatis持久层框架，如果结果类型设置为resultType="map"，将集合数据输出至前端时，Jackson会默认将数组、对象中的数值以BigDecimal类型序列化，如果我们只配置了Long的序列化类，对map中数据是不会生效，还需要在自定义ObjectMapper中配置BigDecimal、BigInteger类的序列化

simpleModule.addSerializer(BigDecimal.class,ToStringSerializerForJackson.instance);
simpleModule.addSerializer(BigInteger.class,ToStringSerializerForJackson.instance);
2）自定义Serializer序列化类

在“过滤器统一拦截”方案中，会将所有数值全部转化为String，如果我们只需要将数值长度超过16位的整数才转化为String，那该如何处理呢？

面对这类需求，我们可以参考ToStringSerializer类，自定义序列化类ToStringSerializerForJackson，重写serialize方法中BigDecimal、BigInteger、Long类型数值，将长度超过16位数值转化为String。

package com.xiaodajia.framework.util.web.databind;

import java.io.IOException;
import java.lang.reflect.Type;
import java.math.BigDecimal;
import java.math.BigInteger;

import com.fasterxml.jackson.core.*;
import com.fasterxml.jackson.databind.JavaType;
import com.fasterxml.jackson.databind.JsonMappingException;
import com.fasterxml.jackson.databind.JsonNode;
import com.fasterxml.jackson.databind.SerializationFeature;
import com.fasterxml.jackson.databind.SerializerProvider;
import com.fasterxml.jackson.databind.annotation.JacksonStdImpl;
import com.fasterxml.jackson.databind.jsonFormatVisitors.JsonFormatVisitorWrapper;
import com.fasterxml.jackson.databind.jsontype.TypeSerializer;
import com.fasterxml.jackson.databind.ser.std.StdSerializer;
import com.fasterxml.jackson.databind.util.TokenBuffer;

/**
 * Simple general purpose serializer, useful for any type for which
 * {@link Object#toString} returns the desired JSON value.
 */
@JacksonStdImpl
public class ToStringSerializerForJackson extends StdSerializer<Object> {
	/**
	 * Singleton instance to use.
	 */
	public final static ToStringSerializerForJackson instance = new ToStringSerializerForJackson();

	/**
	 * <p>
	 * Note: usually you should NOT create new instances, but instead use
	 * {@link #instance} which is stateless and fully thread-safe. However,
	 * there are cases where constructor is needed; for example, when using
	 * explicit serializer annotations like
	 * {@link com.fasterxml.jackson.databind.annotation.JsonSerialize#using}.
	 */
	public ToStringSerializerForJackson() {
		super(Object.class);
	}

	@Override
	public boolean isEmpty(Object value) {
		if (value == null) {
			return true;
		}
		String str = value.toString();
		// would use String.isEmpty(), but that's JDK 1.6
		return (str == null) || (str.length() == 0);
	}

	@Override
	public void serialize(Object value, JsonGenerator jgen,
			SerializerProvider provider) throws IOException,
			JsonGenerationException {
//		System.out.println("ToStringSerializerForJackson序列化------" + value);
		if (null != value) {
			if (value instanceof BigDecimal) {
				if (provider
						.isEnabled(SerializationFeature.WRITE_BIGDECIMAL_AS_PLAIN)) {
					// [Issue#232]: Ok, rather clumsy, but let's try to work
					// around the problem with:
					if (!(jgen instanceof TokenBuffer)) {
						jgen.writeNumber(((BigDecimal) value).toPlainString());
						return;
					}
				}
				if (((BigDecimal) value).compareTo(new BigDecimal(
						1000000000000000L)) == 1) {
//					System.out.println("ToStringSerializerForJackson BigDecimal序列化------"+ value);
					jgen.writeString(value + "");
				} else {
//					System.out.println("ToStringSerializerForJackson BigDecimal  To String序列化------"+ value);
					jgen.writeNumber((BigDecimal) value);
				}
			} else if (value instanceof BigInteger) {
				if (((BigInteger) value).compareTo(new BigInteger(
						"1000000000000000")) > 0) {
//					System.out.println("ToStringSerializerForJackson BigInteger序列化------"+ value);
					jgen.writeString(value + "");
				} else {
//					System.out.println("ToStringSerializerForJackson BigInteger  To String序列化------"+ value);
					jgen.writeNumber((BigInteger) value);
				}
			} else if (value instanceof Long) {
				if (((Long) value).longValue() >= 1000000000000000L) {
//					System.out.println("ToStringSerializerForJackson Long序列化------"
//							+ value);
					jgen.writeString(value + "");
				} else {
//					System.out.println("ToStringSerializerForJackson Long To String序列化------"+ value);
					jgen.writeNumber(((Long) value).longValue());
				}
			} else {
//				System.out.println("StringSerializer else序列化------" + value);
				jgen.writeString(value.toString());
			}
		} else {
			jgen.writeString("");
		}
	}

	/*
	 * 01-Mar-2011, tatu: We were serializing as "raw" String; but generally
	 * that is not what we want, since lack of type information would imply real
	 * String type.
	 */
	/**
	 * Default implementation will write type prefix, call regular serialization
	 * method (since assumption is that value itself does not need JSON Array or
	 * Object start/end markers), and then write type suffix. This should work
	 * for most cases; some sub-classes may want to change this behavior.
	 */
	@Override
	public void serializeWithType(Object value, JsonGenerator jgen,
			SerializerProvider provider, TypeSerializer typeSer)
			throws IOException, JsonGenerationException {
		System.out.println("ToStringSerializerForJackson -serializeWithType序列化------"
				+ value);
		typeSer.writeTypePrefixForScalar(value, jgen);
		serialize(value, jgen, provider);
		typeSer.writeTypeSuffixForScalar(value, jgen);
	}

	@Override
	public JsonNode getSchema(SerializerProvider provider, Type typeHint)
			throws JsonMappingException {
		return createSchemaNode("string", true);
	}

	@Override
	public void acceptJsonFormatVisitor(JsonFormatVisitorWrapper visitor,
			JavaType typeHint) throws JsonMappingException {
		if (visitor != null) {
			visitor.expectStringFormat(typeHint);
		}
	}
}
3）POJO属性增加注解

在POJO类需要转换的属性上增加@JsonSerialize注解，如果需要转换的字段多，则需要逐一增加注解，管理很麻烦

public class YNotice implements Serializable {
	private static final long serialVersionUID = 1L;

	@JsonSerialize(using=ToStringSerializer.class)
	private long noticeId;

	private String content;

	private Date createTime;
4）修改Serializers源码

修改Jackson源码，在NumberSerializers类的子类NumberSerializer中，将Long转换为String

@JacksonStdImpl
    public final static class NumberSerializer
        extends StdScalarSerializer<Number>
    {
        public final static NumberSerializer instance = new NumberSerializer();
    
        public NumberSerializer() { super(Number.class); }
    
        @Override
        public void serialize(Number value, JsonGenerator jgen, SerializerProvider provider)
            throws IOException, JsonGenerationException
        {
        	/**
        	 * 强制转化类，判断数字长度超过16位时，将数字转化为字符串
        	 */
            if (value instanceof BigDecimal) {
                if (provider.isEnabled(SerializationFeature.WRITE_BIGDECIMAL_AS_PLAIN)) {
                    // [Issue#232]: Ok, rather clumsy, but let's try to work around the problem with:
                    if (!(jgen instanceof TokenBuffer)) {
                        jgen.writeNumber(((BigDecimal) value).toPlainString());
                        return;
                    }
                }
                if(((BigDecimal) value).compareTo(new BigDecimal(10000000000000000L)) == 1){
                	System.out.println("NumberSerializer BigDecimal 转化为String------" + value);
                	jgen.writeString(value+"");
                }else{
                	System.out.println("NumberSerializer BigDecimal ------" + value);
                	jgen.writeNumber((BigDecimal) value);
                }
            } else if (value instanceof BigInteger) {
                jgen.writeNumber((BigInteger) value);
            } else if (value instanceof Integer) {
            	jgen.writeNumber(value.intValue());
            } else if (value instanceof Long) {
            	if(value.longValue()>=10000000000000000L) {
            		System.out.println("NumberSerializer Long 转化为String------" + value);
            		jgen.writeString(value+"");
            	}else{
            		System.out.println("NumberSerializer Long ------" + value);
            		jgen.writeNumber(value.longValue());
            	}
            } else if (value instanceof Double) {
            	jgen.writeNumber(value.doubleValue());
            } else if (value instanceof Float) {
            	jgen.writeNumber(value.floatValue());
            } else if ((value instanceof Byte) || (value instanceof Short)) {
                jgen.writeNumber(value.intValue()); // doesn't need to be cast to smaller numbers
            } else {
                jgen.writeNumber(value.toString());
            }
        }
    
        @Override
        public JsonNode getSchema(SerializerProvider provider, Type typeHint)
        {
            return createSchemaNode("number", true);
        }
        
        @Override
        public void acceptJsonFormatVisitor(JsonFormatVisitorWrapper visitor, JavaType typeHint)
            throws JsonMappingException
        {
            // Hmmh. What should it be? Ideally should probably indicate BIG_DECIMAL
            // to ensure no information is lost? But probably won't work that well...
            JsonNumberFormatVisitor v2 = visitor.expectNumberFormat(typeHint);
            if (v2 != null) {
                v2.numberType(JsonParser.NumberType.BIG_DECIMAL);
            }
        }
    }

关键代码是NumberSerializer类的serialize方法，在方法中判断数值是否BigDecimal、Long类型，如果数字长度超过16位时，则将数字转化为字符串。

代码转化

直接在java代码中，将Map对象和集合的Long数值强转化为String类型

参考资料

  1. https://my.oschina.net/u/1787735/blog/1833697
  2. https://stackoverflow.com/questions/7854030/configuring-objectmapper-in-spring
  3. https://www.jianshu.com/p/92ce8c52d468
liubinwyzbt
关注
  • 0
    点赞
  • 踩
  • 8
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
专栏目录
详解SpringMVC解决跨域的两种方案
08-29
本篇文章主要介绍了详解SpringMVC解决跨域的两种方案，小编觉得挺不错的，现在分享给大家，也给大家做个参考。一起跟随小编过来看看吧
spring Boot处理返回给前端Long类型精度丢失
xiaoliu_alone的博客
04-13 2396
项目中采用springcloud Alibaba技术开发分布式系统，开发过程中采用雪花算法生成分布式Id，为Long类型，而Long类型返回给前端，会出现精度丢失问题。接下来我们主要了解下，如何快速的处理精度丢失的问题。
彻底解决JS处理Long类型精度丢失问题（一）
热门推荐
陌上花开，可缓缓归矣
01-20 6万+
对于Long类型的数据，如果我们在Controller层将结果序列化为json，直接传给前端的话，在Long长度大于17位时会出现精度丢失的问题。如何避免精度丢失呢？最常用的办法就是将Long类型字段统一转成String类型。 JS 数字丢失精度的原因 计算机的二进制实现和位数限制有些数无法有限表示。就像一些无理数不能有限表示，如 圆周率 3.1415926…，1.3333… 等。JS 遵循 IE...
Jackson 2.x 系列【8】注解大全篇四
最新发布
记录知识、锤炼自我
03-29 1112
🙈🙈🙈紧接上篇，接下来我们介绍`jackson-databind`模块提供的所有注解，到这里注解大全篇就结束了。🙈🙈🙈
雪花算法ID在前端丢失精度解决方案
罗翔
08-14 929
首先说一下背景，目前笔者的工作是物联网方面的，设备有对应的智慧运营平台，平台开发中建表的主键用的是Mybatis plus默认的雪花算法来生成的，也就是分布式系统比较常用的雪花ID，技术栈就是常用的Spring boot+Spring could Alibaba，json工具用的是FastJson。 在开发的过程中遇到了一个问题：前端接收到的数据在回传给后端的时候ID总是不对，仔细排查发现，前端接...
SpringMVC返回json数据时，Long字段丢失精度
qq_43664324的博客
11-05 779
实体类的id，java为Long，数据库为Bigint,从数据库查询返回时是正确的，但是将实体响应的时候19位的Long类型id精度丢失。 解决方案一： 字段加注解，返回时将此字段序列化为string类型 @Data public class User { @TableId(value = "id",type = IdType.ASSIGN_ID) @JsonSerialize(using = ToStringSerializer.class) private Long id;
springboot中，long类型数据，js丢失精度问题
bai259257的博客
04-13 2463
项目中，数据库用bigint类型存储主键，java实体类中用long类型来存储对应的属性。这个时候前台通过ajax请求获取json数据时，使用了jackson来转换。但是javascript中number类型存储的长度小于long，精度为17位，超过17位的部分就会自动补0，而long类型数据是19或者20位，所以会出现丢失精度的问题。 解决手段：将long类型转换为string类型，前端接收string类型是正常的，不会丢失精度。 解决办法1：在long类型的字段上加上注解，把字段解析成字符串
springboot 解决Jackson导致Long型数据精度丢失问题
weixin_46020146的博客
06-13 101
springboot 解决Jackson导致Long型数据精度丢失问题
Spring Boot 2.0版本 Jackson全局转化long类型为String，解决jackson序列化时long类型缺失精度问题
Cx的博客
12-31 1万+
说明 在传递long类型到前台时，如果long类型的数值比较长，会出现精度丢失的问题。以下是解决办法。 前提 版本：Spring Boot 2.0及以上 序列化工具Jackson 解决办法 import org.springframework.boot.autoconfigure.jackson.Jackson2ObjectMapperBuilderCustomizer; import...
Long类型转换精度丢失问题解决
qq_45936359的博客
06-22 1840
在后台返回给前端的时候 默认的情况下是由JACKSON进行转换成JSON的，但是数据还是Long类型所以给前端变成了丢失精度
Jackson-Long精度丢失问题
菜鸡在路上找食吃
02-26 1189
文章目录说明而我的问题是处理 说明 由于Javascript中数字的精度是有限，通过控制台获取最大值Number.MAX_SAFE_INTEGER会发现是9007199254740991，任何大于 9007199254740992 的就可能会丢失精度 而我的问题是 由于我们的ID 是分布式ID 数据类型是Long类型的远远大于了最大值，所以在返给前端的时候，处理掉就好了 处理 通过定制j...
SpringBoot中使用Jackson导致Long型等数据精度丢失问题
zhou_fan_xi的博客
10-10 3226
数据库中有一个bigint类型数据，对应java后台类型为Long型，在某个查询页面中碰到了问题：页面上显示的数据和数据库中的数据不一致。例如数据库中存储的是：1475797674679549851，显示出来却成了1475797674679550000，后面几位全变成了0，精度丢失了。 1. 原因 这是因为Javascript中数字的精度是有限的，bigint类型的的数字超出了Javascript的处理范围。JS 遵循 IEEE 754 规范，采用双精度存储（double precision），占用 6
SPRINGMVC 406问题解决方案
08-25
主要介绍了SPRINGMVC 406问题解决方案,文中通过示例代码介绍的非常详细，对大家的学习或者工作具有一定的参考学习价值,需要的朋友可以参考下
springmvc-jackson-jar包集合
12-23
用户Spring mvc Jackson自动转化的支持
SpringMVC简介与多线程解决方案
01-11
SpringMVC简介与多线程解决方案SpringMVC简介与多线程解决方案SpringMVC简介与多线程解决方案
SpringMVC的跨域解决方案.docx
10-26
SpringMVC的跨域解决方案.docx
前端js精度丢失 出现小数
weixin_42039715的博客
06-15 240
第一种如果是固定前端控制精度可以在表达式内用toFixed()方法； {{item.price.toFixed(2)}} 第二种有后台传输精度的参数变量进行控制，可以用vue的过滤器filter来控制； {{item.price | priceFloat}} js Vue.filter('priceFloat', function (value) { //if (!value) return '' value = value.toString(); var result = Number(va
SpringBoot返回前端Long类型字段丢失精度问题及解决方案
c739816555的博客
10-25 1398
本文针对Java服务端返回Long整型数据给前端时精度丢失问题，提出了两种解决方案，大家根据自己的需求选择食用，欢迎大家批评指正。
Long类型转换丢失精度问题解决Jackson2
Liaryank的博客
11-24 782
Jackson2全局转化long类型为String，解决jackson序列化时long类型缺失精度问题 注意哦！是Jackson2 import com.fasterxml.jackson.databind.ser.std.ToStringSerializer; import org.springframework.boot.autoconfigure.jackson.Jackson2ObjectMapperBuilderCustomizer; import org.springframewor..
springmvc jackson-databind
05-09
Spring MVC是一个基于Java的Web框架，它提供了很多简化Web开发的功能。其中一个常用的功能是处理HTTP请求和响应。而Jackson-databind是一个Java库，用于将Java对象与JSON（JavaScript Object Notation）之间进行相互转换。 在Spring MVC中，我们可以使用Jackson-databind来处理请求和响应中的JSON数据。具体来说，我们可以使用Jackson-databind的ObjectMapper类来将JSON数据转换为Java对象，或将Java对象转换为JSON数据。 例如，我们可以在Spring MVC中定义一个Controller，用于处理来自客户端的HTTP请求，并返回一个Java对象，然后使用Jackson-databind将该Java对象转换为JSON数据，以便客户端可以使用该数据进行相应的操作。 示例代码如下： ```java @Controller public class MyController { @GetMapping("/myendpoint") @ResponseBody public MyObject handleRequest() { // 处理请求，返回一个 MyObject 对象 MyObject obj = new MyObject(); obj.setProperty1("value1"); obj.setProperty2("value2"); return obj; } // 使用 Jackson-databind 将 MyObject 对象转换为 JSON 数据 @GetMapping(value = "/myendpoint", produces = MediaType.APPLICATION_JSON_VALUE) @ResponseBody public ResponseEntity<String> handleRequest() throws JsonProcessingException { MyObject obj = new MyObject(); obj.setProperty1("value1"); obj.setProperty2("value2"); ObjectMapper mapper = new ObjectMapper(); String json = mapper.writeValueAsString(obj); HttpHeaders headers = new HttpHeaders(); headers.setContentType(MediaType.APPLICATION_JSON); return new ResponseEntity<String>(json, headers, HttpStatus.OK); } } ``` 在上面的示例中，我们定义了一个Spring MVC的Controller，该Controller处理来自客户端的HTTP请求，并返回一个MyObject对象。随后，我们使用Jackson-databind将该对象转换为JSON数据，并将其返回给客户端。

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值