使用Gson实现树型Json数据 非多重List，Map嵌套

最新推荐文章于 2023-04-04 17:59:35 发布
最新推荐文章于 2023-04-04 17:59:35 发布
阅读量1.4k 收藏 1
点赞数
分类专栏： 原创 gson实例 文章标签： Gson 前端
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/KH717586350/article/details/78812697
版权
使用Gson实现树型Json数据 非多重List，Map嵌套

这里写代码片最近前端需要json数据，格式比较复杂，里面数组和对象多重嵌套，最初是想构造一个list，map的多重集合，然后通过@ResponseBody直接写到页面的json格式，后来想想就觉得头疼，嵌套太多貌似很傻的写法，然后搜搜json工具，有Jackson,Gson啥的，觉得Gson高大上吧，然后看了看官方文档，喏，就是这个地址，您瞧瞧：http://tool.oschina.net/apidocs/apidoc?api=gson2.2.2 选择JsonWriter即可
Gson api
里面有个例子，照着写就好了，这里就几个注意点：

  1. 必须使用{ }开始，所以必须是writer.beginObject()开始
  2. 如果begin和end没有对应上，可能读取的数据就不全了
  3. 对于if else 这种互斥的，需要在每个分支里面end(建议每个分支里面都从begin开始，而不是begin写在分支外面)
下面是例子

需要生成这种类型的json格式
如果是生成这种根据是否有子节点的Json格式的话

{
    "conType":[
        {
            "code":1,
            "name":"个人",
            "hasChild":0
        },
        {
            "code":2,
            "name":"公司",
            "hasChild":0
        }
    ],
    "dcCity":[
        {
            "code":244,
            "name":"湖北",
            "hasChild":[
                {
                    "code":245,
                    "name":"武汉",
                    "hasChild":0
                },
                {
                    "code":246,
                    "name":"黄石",
                    "hasChild":0
                },
                {
                    "code":247,
                    "name":"十堰",
                    "hasChild":0
                },
                {
                    "code":248,
                    "name":"宜昌",
                    "hasChild":0
                },
                {
                    "code":249,
                    "name":"襄阳",
                    "hasChild":0
                },
                {
                    "code":250,
                    "name":"鄂州",
                    "hasChild":0
                },
                {
                    "code":251,
                    "name":"荆门",
                    "hasChild":0
                },
                {
                    "code":252,
                    "name":"孝感",
                    "hasChild":0
                },
                {
                    "code":253,
                    "name":"荆州",
                    "hasChild":0
                },
                {
                    "code":254,
                    "name":"黄冈",
                    "hasChild":0
                },
                {
                    "code":255,
                    "name":"咸宁",
                    "hasChild":0
                },
                {
                    "code":256,
                    "name":"随州",
                    "hasChild":0
                },
                {
                    "code":257,
                    "name":"恩施",
                    "hasChild":0
                }
            ]
        },
        {
            "code":426,
            "name":"台湾",
            "hasChild":0
        },
        {
            "code":427,
            "name":"香港",
            "hasChild":0
        },
        {
            "code":428,
            "name":"澳门",
            "hasChild":0
        }
    ]
}

Java代码如下

    @Test
    //将dic_type和dic_data两张表中的数据拼接成为树状目录的json字符串
    public void showDic6() {
        //数据库查询条件，循环初始时需要clear所有键值，也可以放下面循环中每次新建
        Map<String, Object> conditions = new HashMap<>();
        //初始化spring容器
        ApplicationContext ac = new ClassPathXmlApplicationContext("classpath:spring/applicationContext-dao.xml");
        //从容器中获得mapper代理对象
        DicTypeMapper typeMapper = ac.getBean(DicTypeMapper.class);
        DicDataMapper dataMapper = ac.getBean(DicDataMapper.class);
        try {
            //创建JsonWriter写入组合的json字符串到io流中
            OutputStream out = new ByteArrayOutputStream();
            JsonWriter writer = new JsonWriter(new OutputStreamWriter(out , "UTF-8"));
            //获的type列表和data列表
            List<DicType> dicTypeList = typeMapper.getAllDicType();
            List<DicData> dicDataList = dataMapper.getAllDicData();

            //开始写入对象，不同类别键名
            writer.beginObject();
            //遍历type列表，根据id在data列表中查找，在每个[]中存放该类型对应的多条数据
            for (DicType type : dicTypeList) {
                writer.name(type.getTypeCode());    //写入类别键名
                conditions.clear(); //循环初始时，对于多个键值对需要clear之前的值
                conditions.put("dtId", type.getId());
                List<DicData> dataList = dataMapper.getMultiConditionsDataList(conditions);
                //开始写入数组，该类别下的多条数据
                writer.beginArray();
                //查询数据库该类别的数据
                for (DicData dicData : dataList) {
                    //如果该条数据是子节点，那么就不能写入这个处于父节点的位置
                    if(dicData.getParentId() != 0) {
                        continue;
                    }
                    //如果该条数据是父节点，找到其下所有子节点写入数组
                    if(dicData.getHasChild() == 1) {
                        writer.beginObject();   //开始写入具体数据
                        writer.name("code").value(dicData.getCode());
                        writer.name("name").value(dicData.getName());
                        writer.name("hasChild");
                        conditions.put("parentId", dicData.getCode());
                        List<DicData> childList = dataMapper.getMultiConditionsDataList(conditions);
                        writer.beginArray();
                        for (DicData child : childList) {
                            writer.beginObject();
                            writer.name("code").value(child.getCode());
                            writer.name("name").value(child.getName());
                            writer.name("hasChild").value(child.getHasChild());
                            writer.endObject();
                        }
                        writer.endArray();
                        writer.endObject();
                    }else {
                        writer.beginObject();
                        writer.name("code").value(dicData.getCode());
                        writer.name("name").value(dicData.getName());
                        writer.name("hasChild").value(dicData.getHasChild());
                        writer.endObject();
                    }
                }
                writer.endArray();
            }
            writer.endObject();
            writer.flush(); //刷新缓冲到流
            System.out.println(out.toString());
        } catch (UnsupportedEncodingException e) {
            e.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace();
        } 
    }
总结：
  1. 首先需要分析目标Json数据的格式，对象和数组到底如何嵌套，先整个简单的样本数据分析清楚其结构组织
  2. 然后就简单了，在{ }地方调用beginObject，[ ]地方调用beginArray，建议和成对写括号一样，同时写出begin和end，避免漏掉end不对应情况
  3. 最后取出流里面的数据就可以看到生成的Json字符串了

下面这种废弃了，可以参考下如何写这种格式

如果是生成这种Json格式的话

{
    "conType":[
        {
            "name":"个人",
            "code":1
        },
        {
            "name":"公司",
            "code":2
        }
    ],
    "dcCity":[
        {
            "湖北":[
                {
                    "name":"武汉",
                    "code":245
                },
                {
                    "name":"黄石",
                    "code":246
                },
                {
                    "name":"十堰",
                    "code":247
                },
                {
                    "name":"宜昌",
                    "code":248
                },
                {
                    "name":"襄阳",
                    "code":249
                },
                {
                    "name":"鄂州",
                    "code":250
                },
                {
                    "name":"荆门",
                    "code":251
                },
                {
                    "name":"孝感",
                    "code":252
                },
                {
                    "name":"荆州",
                    "code":253
                },
                {
                    "name":"黄冈",
                    "code":254
                },
                {
                    "name":"咸宁",
                    "code":255
                },
                {
                    "name":"随州",
                    "code":256
                },
                {
                    "name":"恩施",
                    "code":257
                }
            ]
        },
        {
            "name":"台湾",
            "code":426
        },
        {
            "name":"香港",
            "code":427
        },
        {
            "name":"澳门",
            "code":428
        }
    ]
}
    @Test
    //将dic_type和dic_data两张表中的数据拼接成为树状目录的json字符串
    public void showDic5() {
        //数据库查询条件，循环初始时需要clear所有键值，也可以放下面循环中每次新建
        Map<String, Object> conditions = new HashMap<>();
        //初始化spring容器
        ApplicationContext ac = new ClassPathXmlApplicationContext("classpath:spring/applicationContext-dao.xml");
        //从容器中获得mapper代理对象
        DicTypeMapper typeMapper = ac.getBean(DicTypeMapper.class);
        DicDataMapper dataMapper = ac.getBean(DicDataMapper.class);
        try {
            //创建JsonWriter写入组合的json字符串到io流中
            OutputStream out = new ByteArrayOutputStream();
            JsonWriter writer = new JsonWriter(new OutputStreamWriter(out , "UTF-8"));
            //获的type列表和data列表
            List<DicType> dicTypeList = typeMapper.getAllDicType();
            List<DicData> dicDataList = dataMapper.getAllDicData();

            //开始写入对象，不同类别键名
            writer.beginObject();
            //遍历type列表，根据id在data列表中查找，在每个[]中存放该类型对应的多条数据
            for (DicType type : dicTypeList) {
                writer.name(type.getTypeCode());    //写入类别键名
                conditions.clear(); //循环初始时，对于多个键值对需要clear之前的值
                conditions.put("dtId", type.getId());
                List<DicData> dataList = dataMapper.getMultiConditionsDataList(conditions);
                //开始写入数组，该类别下的多条数据
                writer.beginArray();
                //查询数据库该类别的数据
                for (DicData dicData : dataList) {
                    //如果该条数据是子节点，那么就不能写入这个处于父节点的位置
                    if(dicData.getParentId() != 0) {
                        continue;
                    }
                    //如果该条数据是父节点，找到其下所有子节点写入数组
                    if(dicData.getHasChild() == 1) {
                        writer.beginObject();   //开始写入具体数据
                        writer.name(dicData.getName());
                        conditions.put("parentId", dicData.getCode());
                        List<DicData> childList = dataMapper.getMultiConditionsDataList(conditions);
                        writer.beginArray();
                        for (DicData child : childList) {
                            writer.beginObject();
                            writer.name("name").value(child.getName());
                            writer.name("code").value(child.getCode());
                            writer.endObject();
                        }
                        writer.endArray();
                        writer.endObject();
                    }else {
                        writer.beginObject();
                        writer.name("name").value(dicData.getName());
                        writer.name("code").value(dicData.getCode());
                        writer.endObject();
                    }
                }
                writer.endArray();
            }
            writer.endObject();
            writer.flush(); //刷新缓冲到流
            System.out.println(out.toString());
        } catch (UnsupportedEncodingException e) {
            e.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace();
        } 
    }
捏捏小脸蛋
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Java泛型（二）——使用Gson解析复杂的泛型嵌套泛型数据结构
David-Kuper的专栏
11-15 1万+
Gson是由Google自家出来的Json解析库，使用起来兼容性方面当然会有很多优势，而且解析Json数据也很方便，掌握了Gson的一些基本使用之后就可以使用它解析很多复杂的Json数据了。但当我们要解析一个复杂的数据结构时，比如说List<**CardBean<*E*>**>这种，泛型之中还有泛型的数组结构，就比较麻烦了。下面我会给出一种方案，在此之前我还是先简单的介绍一下Gson的一些东西，大神请直接第二节
Gson 对 Map 嵌套类型的序列化与反序列化
热门推荐
aliveTime的专栏
10-09 1万+
Gson 对 Map 嵌套类型的序列化与反序列化 样仅仅解决了gson对于嵌套的Map类型的序列化与反序列化，并且要求Map中的value为primative type or Map(代码42行，使用“{”作为判断是否为complex value type)
pg数据库中读取json
Master_Shifu_的博客
11-15 6774
pg数据库中读取json
Cinchoo ETL - JSON Writer
Dincat的专栏
08-03 561
下载源代码 下载编译文件 (.NET Framework) 下载编译文件 (.NET Standard / .NET Core) 内容 介绍2。要求3。“Hello World !”样本 3.1。快速写入-数据优先方法3.2。代码优先方法3.3。Configuration First 方法 4. 记录所有记录Write 记录手动6。自定义JSON记录8。自定义JSON字段 8.1。defaultvalue 8.2。chofallbackvalue 8.3。类型转换器 8.3.1。8.3.2声明性方法
fastjson2 输出null值字段
sayyy的专栏
03-07 563
略
Fastjson源码阅读（三）：JSON.toJSONString()
Baday的博客
12-10 1万+
前言 众所周知，我们在应用Fastjson时主要使用的是toJSONString(Object)和parseObject(String, Class)方法。因此接下来将会从这两个方法切入，逐层的分析其实现。 序列化入口 通常使用JSON.toJSONString()这个静态方法来实现序列化。 JSON抽象类实现了JSONAware(转为json串)和JSONStreamAware(将json串写入Appendable) 是JSONObject(内部实现就是个Map)和JSONArray(内部实现是个Lis
项目小知识
qq_45767346的博客
04-04 100
分隔的字符序列，并可选择性地从提供的前缀开始和以提供的后缀结尾。在mybatis中比较 java.util.Date 日期类型时，或者返回日期类型时，想要对日期格式化，可以使用。思想：先把excel文件生成到一个临时文件夹中，然后读取文件压缩，导出后删除文件夹。StringJoiner是Java8新出的一个类，用于构造由。1、可以使用union来合并两次的查询结果并过滤重复数据。一般使用group by对查询的结果进行去重。2、可以使用in来查询满足条件的所有数据。直接引入spring依赖即可。
map，对象，List转Json的方法---Gson处理Null的方法
fkfgq2008的博客
07-05 2924
踩过很多坑。试过好多方法，map，对象，转json往往会遇到很多问题，最常见的问题，莫过于出现了Object is null这个问题，查了好多资料。也试过很多方法。主流解决办法三种：第一种：循环遍历对象中的数据，if判断null就赋值“”，这种方法一般的对象还可以，可是我们的项目对象基本都是二十几个，这样弄起来很费劲，因此放弃。第二种：遇到null就不输出，只保留存在的。Gson进行转化Syste...
树形结构的json格式封装
歇息的专栏
06-10 6393
话不多说，直接show me the code ,no bb 数据库表结构如下： Organization表： Id 主键 Name 名称 ParentId 父Id 数据库的数据如下： 很明显，这是一个多层级的结构，我们需要把他组装成一个树形结构，返回给前端： 定义一个treeModel类： public class treemodel { pu...
前端传递list加map集合 或 list加对象
qq_54378364的博客
12-01 1737
前端传递list加map集合 或 list加对象
Android中使用Gson解析JSON数据的两种方法
09-05
Json是一种类似于XML的通用数据交换格式,具有比XML更高的传输效率;本文将介绍两种方法解析JSON数据，需要的朋友可以参考下
Gson解析（List和Map）格式json数据 - CSDN博客1
08-04
Gson解析（List和Map）格式json数据 - CSDN博客原创2013年11月23日 21:54:46Gson解析（List和Map）格式json数据天
JAVA使用Gson解析json数据实例解析
10-22
JSON(JavaScript Object Notation) 是一种轻量级的数据交换格式，易于阅读和编写，同时也易于机器解析和生成。接下来通过本文给大家介绍JAVA使用Gson解析json数据实例解析，需要的朋友参考下吧
使用Gson解析Json数据
10-21
1、生成Json数据 2、使用Gson解析Json数据（单个json对象、json数组和json对象内嵌json数组） // 这里有两篇好心人的博文，有详细的讲解 http://www.jb51.net/article/32547.htm ...
mybatis逆向工程 去除表字段前缀 匹配所有表名
焚心似火
11-30 6818
1.去除表字段前缀 使用table中的属性配置 searchString="^[^_]+",这个查找字符串就是使用正则表达式来匹配表的字段名 这个意思就是匹配，开头的任意个非下划线(_)的字符，也就是这种如：c_，abc_。。。等等 逆向工程生成数据库中所有表： 2.匹配数据库中所有的表（适合表太多） <table schema="" tableNa
windows本地使用Nginx反向代理解决前后端联调的跨域访问
焚心似火
12-14 4578
第一种使用Nginx 首先在服务端所在的电脑安装Windows版本的Nginx http://nginx.org/en/download.html （只能在本地搭建Nginx服务器，云服务器搭建不可以访问本地，本地没有外网地址，百度输入ip地址显示的本机我这里也不行  所以 像我这种本机启动项目，腾讯云服务器配置Nginx反向代理没卵用，没有外网地址，不过反向代理到百度还可
单独使用ueditor的图片上传功能，同时获得上传图片地址和缩略图
焚心似火
01-12 4410
单独使用ueditor图片上传功能参考我的这篇文章 http://blog.csdn.net/kh717586350/article/details/79041939 上篇文章讲述了如何获得上传到服务器后的图片信息列表，处理完这个功能后觉得需要显示一个已上传图片列表，但是使用图片原始地址页面加载很慢，W3C 特别说明img标签的width和height并不能使图片尺寸降低，需要使用工具改
UEditor上传图片到fastDFS 自定义请求地址
焚心似火
12-13 4073
首先是将ueditor导入项目 第一步：官网下载好后解压复制到项目里面就行，我将utf-8-jsp改为uedito 第二步：导入jar包，选择手动导入jar包或者使用maven导入，貌似ueditor中央仓库没有，需要手动安装到本地仓库，网上很多教程，一行命令就搞定了，然后pom.xml编写命令中配置的坐标 第三步：引入js文件，写一个页面测试下，可以照着官网例子http://fex
单独提取ueditor多图上传，解决无法获得上传后图片地址
焚心似火
01-12 3761
提取ueditor的多图上传功能整了好长时间，最后发现是官方文件错误了，感觉没爱了(╥╯^╰╥)，好了，还是先看怎么解决的吧 第一步 网上找了好多相关文章，最后发现只有两篇，大多是互相转载的。 我选的这篇，去掉了附件上传功能，保留需要的多图上传 https://www.cnblogs.com/woodyblog/p/6508524.html html lang="zh
使用 GSON 安卓 解析 JSON 数据
最新发布
06-01
Gson 是 Google 提供的一个用来在 Java 对象和 JSON 数据之间进行映射的 Java 类库，它可以将 JSON 字符串转换为 Java 对象，也可以将 Java 对象转换为 JSON 字符串。下面是使用 Gson 库解析 JSON 数据的示例代码： 1. 添加 GSON 依赖 在项目的 build.gradle 文件中添加以下依赖： ```groovy dependencies { // ... implementation 'com.google.code.gson:gson:2.8.6' // ... } ``` 2. 定义 Java 类 首先，我们需要定义一个 Java 类来表示 JSON 数据的结构。假设我们要解析的 JSON 数据格式如下： ```json { "name": "张三", "age": 20, "isMale": true } ``` 那么，我们可以定义一个对应的 Java 类： ```java public class Person { private String name; private int age; private boolean isMale; // 构造函数、getters 和 setters 略 // ... } ``` 3. 解析 JSON 数据 接下来，我们可以使用 Gson 类的`fromJson()`方法将 JSON 字符串转换为 Java 对象。示例代码如下： ```java String jsonData = "{\"name\":\"张三\",\"age\":20,\"isMale\":true}"; // 替换成你要解析的 JSON 数据 Gson gson = new Gson(); Person person = gson.fromJson(jsonData, Person.class); ``` 以上代码中，`fromJson()`方法的第一个参数是要解析的 JSON 字符串，第二个参数是要转换为的 Java 类的类型。Gson 会自动将 JSON 中的字段映射到 Java 对象的属性中。 现在，`person`对象中就包含了从 JSON 字符串中解析出来的数据。我们可以通过调用`person.getName()`、`person.getAge()`等方法获取属性的值。 注意：使用 Gson 解析 JSON 数据的前提是，JSON 字符串的字段名要与 Java 对象的属性名匹配。如果不匹配，需要通过`@SerializedName`注解或`FieldNamingStrategy`接口来指定对应关系。具体使用方法可以参考 Gson 的文档。

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值