JSON格式化与结构对比

已于 2025-07-27 18:18:00 修改
阅读量54 收藏
点赞数
CC 4.0 BY-SA版权
分类专栏： JAVA 实用功能 文章标签： json fastjson
于 2025-07-27 18:17:02 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.youkuaiyun.com/java_t_t/article/details/149693729

说明

功能

  1. 格式化json字符串为最简格式，并标识值类型；

  2. 比对json字符串结构。

第三方依赖

  1. fastjson: 用于解析json、判断json值类型；

  2. springframework自带的字符串判断，可以不依赖该方法，改为自行实现；

  3. slf4j: 用于打印日志，可以不依赖该方法，改为其它方法。

json结构对比规则

  1. null与任何类型相等；

  2. 空对象{}与任何对象{}相等；

  3. 空数组[]与任何数组[]相等。

代码

JSON工具类

import com.alibaba.fastjson.JSON;
import com.alibaba.fastjson.JSONArray;
import com.alibaba.fastjson.JSONException;
import com.alibaba.fastjson.JSONObject;
import lombok.extern.slf4j.Slf4j;
import org.springframework.util.StringUtils;

import java.util.Map;
import java.util.Set;

@Slf4j
public class JSONUtil {
    private static final String NULL = "Null";
    private static final String OBJECT = "Object";
    private static final String ARRAY = "Array";
    private static final String EQUAL = "=";
    private static final String ADD = "+";
    private static final String DELETE = "-";
    private static final String MODIFY = "%s -> %s";
    private static final String CAN_NOT_COMPARE = "not json, can't compare!";
    private static final String CAN_NOT_FORMAT = "not json, can't format!";

    /**
     * 格式化json字符串为最简格式，并标识值类型
     *
     * @param json json字符串
     * @return json结构
     */
    public static String format(String json) {
        if (!StringUtils.hasText(json)) {
            return CAN_NOT_FORMAT;
        }
        try {
            Object formatJson = null;
            if (json.trim().startsWith("{")) {
                formatJson = JSON.parseObject(json);
                formatJSONObject((JSONObject) formatJson);
            } else if (json.trim().startsWith("[")) {
                formatJson = JSON.parseArray(json);
                formatJSONArray((JSONArray) formatJson);
            }
            return JSON.toJSONString(formatJson);
        } catch (JSONException exception) {
            log.warn("compareStruct error", exception);
        }
        return CAN_NOT_FORMAT;
    }

    private static Object formatJSONObject(JSONObject json) {
        if (json == null) {
            return null;
        }
        if (json.isEmpty()) {
            return OBJECT;
        }
        for (Map.Entry<String, Object> entry : json.entrySet()) {
            Object value = entry.getValue();
            if (value instanceof JSONObject) {
                entry.setValue(formatJSONObject((JSONObject) value));
            } else if (value instanceof JSONArray) {
                entry.setValue(formatJSONArray((JSONArray) value));
            } else {
                entry.setValue(getTypeName(value));
            }
        }
        return json;
    }

    private static Object formatJSONArray(JSONArray json) {
        if (json == null) {
            return null;
        }
        if (json.isEmpty()) {
            return ARRAY;
        }
        Object typical = json.get(0);
        if (typical instanceof JSONObject) {
            typical = formatJSONObject((JSONObject) typical);
        } else if (typical instanceof JSONArray) {
            typical = formatJSONArray((JSONArray) typical);
        } else {
            typical = getTypeName(typical);
        }
        json.clear();
        json.add(typical);
        return json;
    }

    /**
     * 比对json字符串
     * <p>
     * 说明：
     * 1、null与任何类型相等；
     * 2、{}与任何{}相等；
     * 3、[]与任何[]相等；
     *
     * @param oldJson 旧json字符串
     * @param newJson 新json字符串
     * @return 新旧json字符串差异
     */
    public static Object compareStruct(String oldJson, String newJson) {
        if (!StringUtils.hasText(oldJson) || !StringUtils.hasText(newJson)) {
            return CAN_NOT_COMPARE;
        }
        try {
            if (oldJson.trim().startsWith("{")) {
                if (newJson.trim().startsWith("{")) {
                    JSONObject oldJsonObject = JSON.parseObject(oldJson);
                    JSONObject newJsonObject = JSON.parseObject(newJson);
                    if (oldJsonObject == null || newJsonObject == null || oldJsonObject.isEmpty() || newJsonObject.isEmpty()) {
                        // null与任何类型相等；{}与任何{}相等
                        return EQUAL;
                    }
                    JSONObject result = new JSONObject();
                    compareJSONObject(oldJsonObject, newJsonObject, result);
                    return result;
                } else {
                    return String.format(MODIFY, OBJECT, ARRAY);
                }
            } else if (oldJson.trim().startsWith("[")) {
                if (newJson.trim().startsWith("[")) {
                    JSONArray oldJsonArray = JSON.parseArray(oldJson);
                    JSONArray newJsonArray = JSON.parseArray(newJson);
                    if (oldJsonArray == null || newJsonArray == null || oldJsonArray.isEmpty() || newJsonArray.isEmpty()) {
                        // null与任何类型相等；[]与任何[]相等
                        return EQUAL;
                    }
                    JSONArray result = new JSONArray();
                    compareJSONArray(oldJsonArray, newJsonArray, result);
                    if (result.size() == 1 && EQUAL.equals(result.get(0))) {
                        return EQUAL;
                    } else {
                        return result;
                    }
                } else {
                    return String.format(MODIFY, ARRAY, OBJECT);
                }
            }
        } catch (JSONException exception) {
            log.warn("compareStruct error", exception);
        }
        return CAN_NOT_COMPARE;
    }

    private static void compareJSONObject(JSONObject oldJson, JSONObject newJson, JSONObject result) {
        if (oldJson == null || newJson == null) {
            // 该空校验可以去掉，调用的地方已经校验过了
            return;
        }
        Set<String> oldKeySet = oldJson.keySet();
        Set<String> newKeySet = newJson.keySet();
        for (Map.Entry<String, Object> entry : newJson.entrySet()) {
            if (!oldKeySet.contains(entry.getKey())) {
                result.put(entry.getKey(), ADD);
                continue;
            }

            Object newValue = entry.getValue();
            Object oldValue = oldJson.get(entry.getKey());
            if (oldValue == null || newValue == null) {
                result.put(entry.getKey(), EQUAL);
                continue;
            }

            if (!newValue.getClass().equals(oldValue.getClass())) {
                result.put(entry.getKey(), String.format(MODIFY, getTypeName(oldValue), getTypeName(newValue)));
                continue;
            }

            if (newValue instanceof JSONObject) {
                JSONObject oldValueJson = (JSONObject) oldValue;
                JSONObject newValueJson = (JSONObject) newValue;
                if (oldValueJson.isEmpty() || newValueJson.isEmpty()) {
                    result.put(entry.getKey(), EQUAL);
                    continue;
                }
                JSONObject subResult = new JSONObject();
                result.put(entry.getKey(), subResult);
                compareJSONObject(oldValueJson, newValueJson, subResult);
            } else if (newValue instanceof JSONArray) {
                JSONArray subResult = new JSONArray();
                compareJSONArray((JSONArray) oldValue, (JSONArray) newValue, subResult);
                if (subResult.size() == 1 && EQUAL.equals(subResult.get(0))) {
                    // 嵌套数组，如果内层结构相同，那么本层结构也相同
                    result.put(entry.getKey(), EQUAL);
                } else {
                    result.put(entry.getKey(), subResult);
                }
            } else {
                result.put(entry.getKey(), EQUAL);
            }
        }

        for (Map.Entry<String, Object> entry : oldJson.entrySet()) {
            if (!newKeySet.contains(entry.getKey())) {
                result.put(entry.getKey(), DELETE);
            }
        }
    }


    private static void compareJSONArray(JSONArray oldJson, JSONArray newJson, JSONArray result) {
        if (oldJson == null || newJson == null || oldJson.isEmpty() || newJson.isEmpty()) {
            result.add(EQUAL);
            return;
        }

        // 取第一个元素对比
        Object oldTypical = oldJson.get(0);
        Object newTypical = newJson.get(0);
        if (oldTypical == null || newTypical == null) {
            result.add(EQUAL);
            return;
        }
        if (!newTypical.getClass().equals(oldTypical.getClass())) {
            result.add(String.format(MODIFY, getTypeName(oldTypical), getTypeName(newTypical)));
            return;
        }

        if (newTypical instanceof JSONObject) {
            JSONObject subResult = new JSONObject();
            result.add(subResult);
            compareJSONObject((JSONObject) oldTypical, (JSONObject) newTypical, subResult);
        } else if (newTypical instanceof JSONArray) {
            JSONArray subResult = new JSONArray();
            compareJSONArray((JSONArray) oldTypical, (JSONArray) newTypical, subResult);
            if (subResult.size() == 1 && EQUAL.equals(subResult.get(0))) {
                // 嵌套数组，如果内层结构相同，那么本层结构也相同
                result.add(EQUAL);
            } else {
                result.add(subResult);
            }
        } else {
            result.add(EQUAL);
        }
    }

    private static Object getTypeName(Object obj) {
        if (obj == null) {
            return NULL;
        }
        if (obj instanceof JSONObject) {
            return OBJECT;
        }
        if (obj instanceof JSONArray) {
            return ARRAY;
        }
        return obj.getClass().getSimpleName();
    }
}

测试

测试代码

import com.alibaba.fastjson.JSON;
import com.example.study.util.JSONUtil;

public class Test {
    public static void main(String[] args) {
        System.out.println(JSON.toJSONString(JSONUtil.compareStruct("{}", "{}")));
        System.out.println(JSON.toJSONString(JSONUtil.compareStruct("[]", "[]")));
        System.out.println(JSON.toJSONString(JSONUtil.compareStruct("{}", "[]")));
        System.out.println(JSON.toJSONString(JSONUtil.compareStruct("[]", "{}")));
        System.out.println(JSON.toJSONString(JSONUtil.compareStruct("[]", null)));
        System.out.println(JSON.toJSONString(JSONUtil.compareStruct(null, "{}")));
        System.out.println(JSON.toJSONString(JSONUtil.compareStruct("[]", "")));
        System.out.println(JSON.toJSONString(JSONUtil.compareStruct("", "{}")));
        System.out.println(JSON.toJSONString(JSONUtil.compareStruct("[[]]", "[[]]")));
        System.out.println(JSON.toJSONString(JSONUtil.compareStruct("[[2]]", "[[1]]")));
        System.out.println(JSON.toJSONString(JSONUtil.compareStruct("[[]]", "[[[]]]")));
        System.out.println(JSON.toJSONString(JSONUtil.compareStruct("[[]]", "[[[1]]]")));
        System.out.println(JSON.toJSONString(JSONUtil.compareStruct("[[1]]", "[[[1]]]")));
        System.out.println(JSON.toJSONString(JSONUtil.compareStruct("[", "[[[1]]]")));
        String oldJsonObj = "{\"id\":1,\"isMan\":true,\"name\":\"testName\",\"testNull\":null,\"testEmptyObject\":{}," +
                "\"testObject\":{\"id\":1,\"arr\":[]},\"testEmptyArr\":[],\"testIntegerArr\":[1,2,3],\"testObjectArr\":[{\"id\":1,\"arr\":[\"a\"]},{\"id\":2,\"arr\":[\"b\"]}],\"testNestingArr\":[[[1,2,3]]],\"testNestingArrEqual\":[[[\"1\"]]]}";
        String newJsonObj = "{\"id\":\"1\",\"isMan\":true,\"name\":\"testName\",\"testNull\":{}," +
                "\"testEmptyObject\":{},\"testObject\":{\"id\":1,\"testAdd\":\"add\",\"arr\":[]},\"testEmptyArr\":[],\"testIntegerArr\":[1,2,3],\"testObjectArr\":[{\"arr\":[\"a\",\"b\",\"c\",\"d\"]},{\"arr\":[\"b\",\"b\",\"c\",\"d\"]}],\"testNestingArr\":[[[\"a\",\"b\",\"c\",\"d\"]]],\"testNestingArrEqual\":[[[\"a\",\"b\",\"c\",\"d\"]]]}";
        System.out.println(JSON.toJSONString(JSONUtil.compareStruct(oldJsonObj, newJsonObj)));
        System.out.println(JSON.toJSONString(JSONUtil.compareStruct("[" + oldJsonObj + "]", "[" + newJsonObj + "]")));

        oldJsonObj = "{\"id\":1,\"isMan\":true,\"name\":\"testName\",\"testNull\":null,\"testEmptyObject\":{}," +
                "\"testObject\":{\"id\":1,\"arr\":[]},\"testEmptyArr\":[],\"testIntegerArr\":[1,2,3],\"testObjectArr\":[{\"id\":1,\"arr\":[\"a\"]},{\"id\":2,\"arr\":[\"b\"]}],\"testNestingArr\":[[[1,2,3]]],\"testNestingArrEqual\":[[[\"1\"]]],\"nullArr0\":[null],\"nullArr1\":[[[null]]],\"emptyArr0\":[],\"emptyArr1\":[[[]]],\"nestingArr0\":[[[1,2,3]]],\"nestingArr1\":[[[\"a\"]]],\"nestingArr2\":[[[{\"id\":2,\"arr\":[\"b\"],\"arr2\":[[]]}]]]}";
        System.out.println(JSON.toJSONString(JSONUtil.compareStruct(oldJsonObj, newJsonObj)));
        System.out.println(JSONUtil.format(oldJsonObj));
    }
}

输出

"="
"="
"Object -> Array"
"Array -> Object"
"not json, can't compare!"
"not json, can't compare!"
"not json, can't compare!"
"not json, can't compare!"
"="
"="
"="
"="
[["Integer -> Array"]]
18:08:25.205 [main] WARN com.example.study.util.JSONUtil -- compareStruct error
com.alibaba.fastjson.JSONException: unclosed jsonArray
	at com.alibaba.fastjson.parser.DefaultJSONParser.parseArray(DefaultJSONParser.java:1266)
	at com.alibaba.fastjson.parser.DefaultJSONParser.parseArray(DefaultJSONParser.java:1169)
	at com.alibaba.fastjson.JSON.parseArray(JSON.java:612)
	at com.alibaba.fastjson.JSON.parseArray(JSON.java:592)
	at com.example.study.util.JSONUtil.compareStruct(JSONUtil.java:124)
	at com.example.study.controller.Test.main(Test.java:21)
"not json, can't compare!"
{"testObjectArr":[{"arr":"=","id":"-"}],"testObject":{"arr":"=","testAdd":"+","id":"="},"name":"=","testIntegerArr":"=","id":"Integer -> String","testNull":"=","testEmptyObject":"=","testNestingArrEqual":"=","isMan":"=","testEmptyArr":"=","testNestingArr":[[["Integer -> String"]]]}
[{"testObjectArr":[{"arr":"=","id":"-"}],"testObject":{"arr":"=","testAdd":"+","id":"="},"name":"=","testIntegerArr":"=","id":"Integer -> String","testNull":"=","testEmptyObject":"=","testNestingArrEqual":"=","isMan":"=","testEmptyArr":"=","testNestingArr":[[["Integer -> String"]]]}]
{"nullArr0":"-","nullArr1":"-","testIntegerArr":"=","emptyArr0":"-","nestingArr1":"-","emptyArr1":"-","nestingArr2":"-","testNestingArrEqual":"=","nestingArr0":"-","isMan":"=","testEmptyArr":"=","testNestingArr":[[["Integer -> String"]]],"testObjectArr":[{"arr":"=","id":"-"}],"testObject":{"arr":"=","testAdd":"+","id":"="},"name":"=","id":"Integer -> String","testNull":"=","testEmptyObject":"="}
{"nullArr0":["Null"],"nullArr1":[[["Null"]]],"testIntegerArr":["Integer"],"emptyArr0":"Array","nestingArr1":[[["String"]]],"emptyArr1":[["Array"]],"nestingArr2":[[[{"arr":["String"],"id":"Integer","arr2":["Array"]}]]],"testNestingArrEqual":[[["String"]]],"nestingArr0":[[["Integer"]]],"isMan":"Boolean","testEmptyArr":"Array","testNestingArr":[[["Integer"]]],"testObjectArr":[{"arr":["String"],"id":"Integer"}],"testObject":{"arr":"Array","id":"Integer"},"name":"String","id":"Integer","testNull":"Null","testEmptyObject":"Object"}
JSON 数据格式化方法
小发菜
06-04 3万+
JSON 数据格式化是处理 JSON 数据的重要步骤，有助于提高数据的可读性和可维护性。您可以使用 IDE 或脚本语言提供的内置功能进行格式化，也可以使用在线工具进行格式化。非常推荐 [JSONS](https://www.sojson.com) 不仅支持格式化，而且还支持代码文本对比和替换等功能。
JSON格式化工具：优化数据交换的利器
lsx202406的博客
08-11 537
JSON格式化工具是一种软件应用程序，它能够将JSON数据转换为更易于阅读的格式。这些工具通常提供诸如缩进、着色和高亮等功能，以增强JSON数据的可读性。格式化后的JSON数据不仅便于人类阅读，还有助于开发者更快速地识别和解决问题。
python读写json、格式化写入json文件
热门推荐
ESSE的博客
12-25 9万+
JSON(JavaScript Object Notation) 是一种轻量级的数据交换格式。它基于ECMAScript的一个子集。 JSON采用完全独立于语言的文本格式，但是也使用了类似于C语言家族的习惯(包括C、C++、Java、JavaScript、Perl、Python等)。这些特性使JSON成为理想的数据交换语言。易于人阅读和编写，同时也易于机器解析和生成(一般用于提升网络传输速率)。 JSON在python中分别由list和dict组成。 这是用于序列化的两个模块： json: 用于字符串和p
cJson——序列化格式json和protobuf对比
qq_39642740的博客
01-10 1318
特性ProtobufJSON消息大小更小（二进制格式）较大（文本格式）序列化/反序列化速度更快较慢数据类型强类型（需要.proto文件定义）弱类型（只存储文本）兼容性良好的向前向后兼容性无内建的版本控制机制带宽消耗更低更高跨语言支持提供自动化代码生成，支持多种语言支持多种语言，但没有标准生成机制复杂数据结构支持强大的数据类型和结构支持支持嵌套结构，但缺乏类型验证机制适用场景高效、大数据、跨平台系统简单的配置文件、日志文件、Web API总结。
JSON 格式详解
Huazzi的博客
09-03 2万+
JSON 是一种基于文本的数据交换格式，源于 JavaScript 语言，但其设计目的是独立于语言的。目前，几乎所有主流编程语言都支持 JSON，常用于数据存储和网络传输。以下是B站尚硅谷javaweb课程老师的图解：尚硅谷Javaweb教程JSON 的结构由两种基本数据结构组成：对象（object）和数组（array）。对象是键值对的集合，而数组是有序的值集合。JSON 作为一种轻量级的数据交换格式，凭借其简洁、易于解析等特点，已经成为了 Web 开发中的事实标准。
JSON解析格式化
a100488的专栏
11-29 791
json.asia 搭建了一个在线解析json的网站 目前可以做这些功能 json美化工具 json对比 编码/解码 代码美化工具 代码压缩工具 时间(戳)转换 二维码生成 图片转Base64 跨域请求 在开发 Web 应用程序时，向存在于其他域上的 API（应用程序可编程接口）发送和接收数据是司空见惯的。这种跨域通信通常直接在浏览器中执行，在客户端使用 JavaScript。跨域通信可以使用 Python、Nodejs、PHP 等服务器端语言来完成，但是对于跨域请求响应在浏览器中使用的情况，JavaSc
Nodepad++ JSON格式化插件：NPPJSONViewer
weixin_36231030的博客
05-17 1800
在Notepad++中安装JSON插件后，界面会增加一系列与JSON处理相关的工具按钮。这些按钮通常会集成在编辑器顶部的工具栏中。图标通常为类似书本的页面、一个类似树形的图标和一个校验图标，分别对应着JSON的格式化、折叠和验证功能。用户可以根据自身习惯，使用快捷键或是菜单选项来进行对应的操作。插件除了提供标准的JSON格式化之外，用户还可以根据自己的需求，自定义一些格式化规则。这通常在“格式化选项”中设置，用户可以定义缩进的字符（如空格或制表符）、层级缩进的空格数等。
JSON格式化工具：JSONView插件使用详解
weixin_28931507的博客
04-28 1419
JSON（JavaScript Object Notation）是一种轻量级的数据交换格式，易于人阅读和编写，同时也易于机器解析和生成。它是基于文本的、语言无关的标准，其设计目的是为了便于在不同系统之间进行数据交换，尤其是在网络传输中。在JSON格式中，数据被组织成键值对的结构。其中，键（key）总是字符串类型，而值（value）可以是字符串、数字、布尔值、null、数组或对象。这种结构的嵌套使用可以构建复杂的数据结构，使其适用于表示具有层次关系的数据集。
Json结构解析&比较
FBB360JAVA的博客
07-22 3865
本次练习，主要是针对于两个Json的结构差异。多用于测试场景，比如一个很大的Json报文，需要和现有的Json报文对比，看看哪些字段没传递。亦或是新旧应用交替，使用Java应用代替其他应用，对比原先和现在的报文结构等。实现了通过javaBean的Class，解析获取一个包含所有字段的完整Json结构。实现了两个Json的比较，并记录差异节点路径；输出比较的日志。
好用的在线JSON编辑与格式化工具
fix_bugs的专栏
09-09 1218
首页我们要搞明白"好用的"到底包含哪些因素，我这里基于多年的使用经验将一些要点因素列出来。 本人9年来一直从事互联网行业开发者工作，实际工作中需要经常更json打交道，所以自我觉得本人经验有一定代表性。 下面是要点因素： 支持单行跟折叠换行相互转换 支持语法自动检查 支持关键字过滤，这个对于大json非常有用，不然用眼睛一个个找要累死 支持逐级展开与折叠 支持编辑时自动缩进 最好支持多json对比 打开要快，部分站点虽然做的不错，但打开要等5秒以上，这个受不了 市场上能进行json编辑的在
大文件JSON数据格式化工具与修改前后对比方法 迅速找出不同改动点
06-09
标签“软件/插件”表明可能存在特定的JSON格式化工具或编辑器插件，这些工具可能集成在常见的代码编辑器（如Visual Studio Code、Sublime Text或Atom）中，也可以是独立的应用程序。 根据提供的压缩包子文件名，...
json数据在Html页面格式化显示
11-01
在描述中提到的“采用光标事件格式化展示”，意味着在页面上，当用户通过鼠标光标选中或点击某部分JSON数据时，会以某种方式（如高亮、折叠展开等）进行格式化显示，以便于查看和对比接口文档。 要实现这样的功能，...
Json格式化树形显示.zip
08-15
为了解决这个问题，出现了各种JSON格式化工具，其中"Json格式化树形显示"就是一个很好的示例。 "Json格式化树形显示"是一款基于Java开发的应用程序，它利用了Fastjson这个高性能的JSON库来解析和格式化JSON数据。...
大型语言模型JSON响应格式化的基准测试与优化
10-25
内容概要：本文介绍了StructuredRAG，这是一个针对大型语言模型（LLMs）生成JSON响应格式能力的基准测试。研究对比了Gemini 1.5 Pro和Llama 3 8B-instruct两种模型的表现，通过24次实验评估它们对不同类型JSON输出的...
forest远程调用注意事项
xiyafei122的博客
07-24 214
5.36，且pom中引用了fastjson2，那么@JSONField（com.alibaba.fastjson2.annotation包下）将不起作用，因为版本<1.5.36不支持Fastjson2，按照1的说法，forest此时会以Jackson作为json转换器，此时要用@JsonProperty注解。1、如果在项目中，同时依赖了其中多个框架，那么按 Fastjson2 > Fastjson > Jackson > Gson 这样的优先级来判断，Forest 会以。的框架作为 JSON 转换器。
【C++】C++ 和python 夸语言包通信，使用Json数据格式传输。
weixin_47564581的博客
07-24 309
这些是Qt网络模块的通用函数，与JSON格式本身无关，它们负责处理底层数据传输。使用JSON时需要这些函数，是因为网络传输只能处理字节流，而JSON需要先转换为字节流才能传输。这种编码/解码过程是所有文本格式（包括JSON）在网络传输中的通用处理方式，并非JSON特有，但JSON作为文本型数据交换格式，必须遵循这一流程。
Kibana报错[security_exception] current license is non-compliant for [security]
黄黄黄黄黄的博客
07-22 420
点击右边5.x版本下载到本地，会生成一个json文件，命名为：First name-Last name-编号-版本号.json。并将该文件上传到服务器。)申请license，所有条目都需要填写，邮箱正确即可。（2）点开邮箱，打开链接下载license。，提示执行下面的代码。
智能小e-集成配置
撸其修远兮的博客
07-23 689
生成规则，生成方式：Md5(appKey + secretKey + params + timestamp).toUpperCase()关于md5加密参数使用的是第三方jar包：commons-codec-1.13.jar，自己实现时，参考上述依赖包标准即可。生成规则，需要使用params ，这里使用HashMap实现,无法保证顺序，所有json序列化时，为了保证一致，请使用。本文主要讲解，第三方如何集成智能小e，集成常见问题和解决方案；单点登录时，关于参数。
WEB安全--Java安全--Fastjson反序列化原理初探
最新发布
m0_74800552的博客
07-26 643
这里的fastjson包版本为1.2.24，通过pom的方式即可导入可以看到在运行主类后，发现字符串被处理为json对象打印出来了当然也可以提取出json对象中的具体值。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值