以上就是给各位分享fastjson生成JSON字符串的时候出现$ref，其中也会对fastjsonjsonfield进行解释，同时本文还将给你拓展Fastjsonjson字符串怎样直接反序列化为对象、
以上就是给各位分享fastjson生成JSON字符串的时候出现$ref，其中也会对fastjson jsonfield进行解释，同时本文还将给你拓展Fastjson json字符串怎样直接反序列化为对象、Fastjson 从JSON字符串中取值 操作示例、fastjson 处理json字符串嵌套结构、FastJson 处理json数据中对象相互引用,最后转为json字符串出现占位符("$ref"标识循环引用)"的问题等相关知识，如果能碰巧解决你现在面临的问题，别忘了关注本站，现在开始吧！
本文目录一览：- fastjson生成JSON字符串的时候出现$ref（fastjson jsonfield）
- Fastjson json字符串怎样直接反序列化为对象
- Fastjson 从JSON字符串中取值 操作示例
- fastjson 处理json字符串嵌套结构
- FastJson 处理json数据中对象相互引用,最后转为json字符串出现占位符("$ref"标识循环引用)"的问题
fastjson生成JSON字符串的时候出现$ref（fastjson jsonfield）
转载自：http://wuzhuti.cn/201426!826!05!130202.html
可以通过选项disableCircularReferenceDetect来禁止循环引用检测：
JSON.toJSONString( yourObject,SerializerFeature.disableCircularReferenceDetect);
循环引用很多场景中，我们需要序列化的对象中存在循环引用，在许多的json库中，这会导致stackoverflow。在功能强大的fastjson中，你不需要担心这个问题。例如：
A a = new A();
B b = new B(a);
a.setB(b);
String text = JSON.toJSONString(a); // {"b":{"a":{"$ref":".."}}}
A a1 = JSON.parSEObject(text,A.class);
Assert.assertTrue(a1 == a1.getB().getA());
引用是通过"$ref"来表示的
引用 描述
"$ref":".." 上一级
"$ref":"@" 当前对象，也就是自引用
"$ref":"$" 根对象
"$ref":"$.children.0" 基于路径的引用，相当于 root.getChildren().get(0)
Fastjson json字符串怎样直接反序列化为对象
该文章为原创（转载请注明出处）：Fastjson json字符串怎样直接反序列化为对象？ - 简书 (jianshu.com)
真实业务场景
因为某种原因（可能是前端定义、可能是远程调用外部已经定义），json接收过来是json字符串
希望在接受的时候直接能够反序列化为对象
@Data
public static class TestOuter {
private Stirng bizJson;
}
@Data
public static class BizJson {
private String name;
}{
"bizJson": "{\"name\":\"testName\"}"
}上述案例，返回 我想要得到 BizJsonDTO对象只能手动处理
public class Test {
public static void main(String[] args) {
TestOuter testOuter = JSON.parse("", TestOuter.class);
String bizJsonString = testOuter.getBizJson();
BizJson bizJson = JSON.parse(bizJsonString, BizJson.class);
//...
}
}需要达成的目的
我希望第一次反序列化的时候就能够 得到BizJsonDTO，同时还能兼容 json 的场景
方案思路
实现一个 字符串的反序列化器
代码实现
@Data
public static class TestOuter {
@JSONField(deserializeUsing = JsonStringDeserializer.class)
private BizJson bizJson;
}
@Data
public static class BizJson {
private String name;
}
public static void main(String[] args) {
// 字符串场景 bizJson = "{\"name\": \"123\"}"
JSON.parseObject("{\"bizJson\": \"{\\\"name\\\": \\\"123\\\"}\"}", TestOuter.class);
// 对象场景 bizJson = {"name": "123"}
JSON.parseObject("{\"bizJson\": {\"name\": \"123\"}}", TestOuter.class);
}import java.lang.reflect.Type;
import com.alibaba.fastjson.JSON;
import com.alibaba.fastjson.parser.DefaultJSONParser;
import com.alibaba.fastjson.parser.deserializer.ObjectDeserializer;
/**
* 适用于：对应字段的值 非json对象 而是 json的字符串
*
* @author fuhangbo.hanger.uhfun
**/
public class JsonStringDeserializer implements ObjectDeserializer {
@Override
public <T> T deserialze(DefaultJSONParser parser, Type type, Object fieldName) {
// json字符串场景
if (parser.lexer.token() == LITERAL_STRING) {
String jsonString = (String)parser.parse(fieldName);
return JSON.parseObject(jsonString, type);
}
// json对象场景
if (parser.lexer.token() == LBRACE) {
return parser.parseObject(type, fieldName);
}
throw new UnsupportedOperationException();
}
@Override
public int getFastMatchToken() {
return 0;
}
}该文章为原创（转载请注明出处）：Fastjson json字符串怎样直接反序列化为对象？ - 简书 (jianshu.com)
Fastjson 从JSON字符串中取值 操作示例
package jsonDemo;
import com.alibaba.fastjson.JSON;
import com.alibaba.fastjson.JSONArray;
import com.alibaba.fastjson.JSONObject;
import com.alibaba.fastjson.TypeReference;
import java.util.HashMap;
public class JSONDemo {
public static void main(String[] args) {
//自定义JSON字符串
String json = "{\"name\":\"卢本伟\",\"age\":24,\"语录\":[{\"骚话1\":\"可以，不跟你多bb\",\"骚话2\":\"表面兄弟\"},{\"骚话3\":\"卢本伟牛逼\",\"骚话4\":\"给阿姨倒一杯卡布奇诺\"}]}";
//JSON字符串转换成JSONObject对象
JSONObject jo = JSON.parseObject(json);
System.out.println("初始JSONObject:\n" + jo + "\n");
//JSONObject对象取得some对应的JSONArray数组
JSONArray jsarr = jo.getJSONArray("语录");
System.out.println("JSONObject里面的JSONArray:\n" + jsarr + "\n");
//JSONArray对象通过getJSONObject(index)方法取得数组里面的JSONObject对象
JSONObject ao = jsarr.getJSONObject(0);
System.out.println("JSONObject里面的JSONArray里面的第一个JSONObject：\n" + ao + "\n");
//JSONobject对象通过key直接取得String的值
String str = ao.getString("骚话1");
System.out.println("JSONObject里面的JSONArray里面的第一个JSONObject里的键值对对Key取值：\n" + str + "\n");
System.out.println("=====================JSON字符串转换成map=========================");
//Json字符串转换成map
HashMap<String, Object> map = JSON.parseObject(String.valueOf(jo), new TypeReference<HashMap<String, Object>>() {});
System.out.println(map.get("语录"));
System.out.println(map.get("name"));
}
}
输出结果如下：
初始JSONObject:
{"name":"卢本伟","语录":[{"骚话2":"表面兄弟","骚话1":"可以，不跟你多bb"},{"骚话4":"给阿姨倒一杯卡布奇诺","骚话3":"卢本伟牛逼"}],"age":24}
JSONObject里面的JSONArray:
[{"骚话2":"表面兄弟","骚话1":"可以，不跟你多bb"},{"骚话4":"给阿姨倒一杯卡布奇诺","骚话3":"卢本伟牛逼"}]
JSONObject里面的JSONArray里面的第一个JSONObject：
{"骚话2":"表面兄弟","骚话1":"可以，不跟你多bb"}
JSONObject里面的JSONArray里面的第一个JSONObject里的键值对对Key取值：
可以，不跟你多bb
=====================JSON字符串转换成map=========================
[{"骚话2":"表面兄弟","骚话1":"可以，不跟你多bb"},{"骚话4":"给阿姨倒一杯卡布奇诺","骚话3":"卢本伟牛逼"}]
卢本伟
要遍历JSONArray对象，可以通过size( )方法取得JSONArray的长度，JSONArray.getJSONObject(index)取得里面JSONObject对象；如：
JSONArray jsarr = jo.getJSONArray("语录");
for (int i = 0; i < jsarr.size();i++) {
//...
}
fastjson 处理json字符串嵌套结构
String res = "{\"status\": \"success\",\"content\": {\"token\": \"xxxxxxxxxxxxxxxxxxxxxx\",\"user_id\": \"13612345678\"},\"code\": 200,\"msg\": \"\"}";
String str = (String)json.get("status");
//使用toString的方法避免了构建对象解析或者是map的办法
String content = json.get("content").toString(); JSONObject json2 = JSONObject.parSEObject(content); String userId = (String)json2.get("user_id");
FastJson 处理json数据中对象相互引用,最后转为json字符串出现占位符("$ref"标识循环引用)"的问题
FastJson 值相互引用,最后转为json字符串出现占位符的问题环境
fastjson 1.2.41
问题说明
FastJson 问题
在json对象中有多个地方引用了相同的对象,在经过几次转换转为json字符串的时候会出现占位符,
然后使用fastjson 解析字符串也能正确解析,但使用其他json类库解析,无法正常还原数据,还是占位符
测试代码
/** * FastJson 问题 * 测试 JSONArray(几个元素有关联,引用了相同得对象) -> 转为List -> 加入到 JSONObject 中 -> 最后转为 json 字符串 打印的时候(最后一步得时候会出现占位符) * -> 然后再转为 JSONObject 的时候,非FastJson解析会出现问题(fastJson 解析正常,但是其他json类库处理时,不会对占位符处理,最后直接就原样的将值解析成占位符) * 测试 * testTransfer1 仅仅数据一样,但是实际上是几个不同的对象(数据相同,对象不同),经过上述变化,未出现占位符 * testTransfer2 是从某一元素上取得数据(同一个对象,在json对象中,多个地方都有引用)在添加到该jsonArray 上,经过上述变化,会出现占位符 */ @Test public void name() {// testTransfer1(); testTransfer2(); } private void testTransfer1() {// [{"one":1,"two":2,"tickets":[{"one":2,"two":3},{"one":3,"two":4}]},{"one":2,"two":3},{"one":3,"two":4}] String str = "[{\"one\":1,\"two\":2,\"tickets\":[{\"one\":2,\"two\":3},{\"one\":3,\"two\":4}]},{\"one\":2,\"two\":3},{\"one\":3,\"two\":4}]"; JSONArray array = JSON.parseArray(str); List<Object> objects = array.toJavaList(Object.class); JSONObject object = new JSONObject(); object.put("list", objects); System.out.println(object); // 经过测试发现如果,不直接用从某个元素中取数据,在添加到该jsonArray 本身,即使他们数据有重合的(数据相同,但不是同一个对象),也不会出现 占位符的现象 } private void testTransfer2() {// [{"one":1,"two":2,"tickets":[{"one":2,"two":3},{"one":3,"two":4}]] String str = "[{\"one\":1,\"two\":2,\"tickets\":[{\"one\":2,\"two\":3},{\"one\":3,\"two\":4}]}]"; JSONArray array = JSON.parseArray(str); // 这里添加 JSONArray tickets = array.getJSONObject(0).getJSONArray("tickets"); for (int i = 0; i < tickets.size(); i++) { array.add(tickets.get(i)); } List<Object> list = array.toJavaList(Object.class);// 以下代码说明 FastJson 在之后 转为 json 字符串 ,然后再解析为 json 对象时处理正常(能正常解析) JSONObject object = new JSONObject(); object.put("list",list); String jsonS.........关于fastjson生成JSON字符串的时候出现$ref和fastjson jsonfield的介绍已经告一段落，感谢您的耐心阅读，如果想了解更多关于Fastjson json字符串怎样直接反序列化为对象、Fastjson 从JSON字符串中取值 操作示例、fastjson 处理json字符串嵌套结构、FastJson 处理json数据中对象相互引用,最后转为json字符串出现占位符("$ref"标识循环引用)"的问题的相关信息，请在本站寻找。
本文标签：
![[转帖]Ubuntu 安装 Wine方法（ubuntu如何安装wine）](https://www.gvkun.com/zb_users/cache/thumbs/4c83df0e2303284d68480d1b1378581d-180-120-1.jpg)
