精华内容
下载资源
问答
  • 使用Gson(https://github.com/google/gson)去解析json应该是很常见的,大部分的情况下我们只要创建一个Gson对象,然后根据json和对应的Java类去解析就可以了。但是对于比较复杂的json,比如下面这种,attributes...
  • 下面小编就为大家带来一篇Android利用Gson解析嵌套多层的Json的简单方法。小编觉得挺不错的,现在就分享给大家,也给大家做个参考。一起跟随小编过来看看吧
  • Gson解析容错框架 云地址: Gradle集成 dependencies { // Gson 解析容错:https://github.com/getActivity/GsonFactory implementation ' com.hjq.gson:factory:5.0 ' // Json 解析框架:...
  • JSON、GSON解析json

    2019-02-01 17:05:34
    JSON、GSON解析json数据,详细介绍了json和gson的使用,解析复杂json数据
  • gson解析工具类封装

    2017-03-03 09:21:51
    gson解析工具类封装,避免解析时String为null时报错。
  • Gson解析json数据

    2016-04-07 14:38:59
    这里进行介绍Gson解析复杂Json和简单Json的数据方式
  • 使用Gson解析Json数据

    2014-10-21 16:30:40
    1、生成Json数据 2、使用Gson解析Json数据(单个json对象、json数组和json对象内嵌json数组) // 这里有两篇好心人的博文,有详细的讲解 http://www.jb51.net/article/32547.htm ...
  • 通过Gson解析Json文件

    2015-01-24 19:59:05
    通过Gson解析Json文件,相关博文:http://www.cnblogs.com/tianzhijiexian/p/4246497.html
  • 使用Gson解析json数据

    2017-07-06 20:16:12
    包含json.jar以及服务端代码和客户端代码
  • JSON(JavaScript Object Notation) 是一种轻量级的数据交换格式,易于阅读和编写,同时也易于机器解析和生成。接下来通过本文给大家介绍JAVA使用Gson解析json数据实例解析,需要的朋友参考下吧
  • Json是一种类似于XML的通用数据交换格式,具有比XML更高的传输效率;本文将介绍两种方法解析JSON数据,需要的朋友可以参考下
  • 全国省市区数据,json数组表示,kotlin使用GSON一句即可解析, val chinaLocations: MutableList<ChinaLocation> = Gson().fromJson(InputStreamReader(inputStream), object : TypeToken<List<ChinaLocation>>() {}...
  • gson解析json jar

    2019-03-19 10:18:27
    gson解析json 1gson-2.0.jar 2log4j-1.2.17.jar 3slf4j-api-1.7.10.jar 4slf4j-log4j12-1.7.10.jar
  • Eclipse下使用Google Gson解析Json数据示例,挺好用的,亲测
  • Gson解析JSON中动态未知key的例程源码

    热门讨论 2015-10-11 17:35:24
    我的博客中介绍的Gson解析JSON中动态未知key的例程源码,eclipse工程。
  • Gson解析之自定义序列化和反序列化的代码例子,但后端对同一个字段给的数据类型与文档不一致时的处理
  • gson 解析泛型和将泛型转为json字符串
  • Android Studio下使用Google Gson解析Json数据示例
  • 使用gson解析json

    2018-11-28 10:35:57
    json解析,使用gson解析,FastJson的简单介绍(alibaba),9、原生的Json的解析
  • gson解析json

    2018-03-12 17:22:39
    gson解析json(1.6),162K,gson主要用到的方法有两个,gson.toJson()是将对象,属性等转化成 json 串,gson.fromJson(,)是将json串转化成对象
  • Gson解析复杂json数据

    热门讨论 2011-06-21 18:07:18
    Gson解析复杂json数据,复杂的json数据用gson工具解析
  • Gson 解析数组、集合

    2021-04-24 17:35:25
    首先用Gson解析实体类好办,直接用 new Gson().fromJson(jsonString,object.class); 但是如果我们想要解析,一个 String[] 类型的数组能显然用如下代码,是解析不出来的。 new Gson().fromJson(jsonString,...

    首先用Gson解析实体类好办,直接用

    new Gson().fromJson(jsonString,object.class);

     但是如果我们想要解析,一个 String[] 类型的数组能显然用如下代码,是解析不出来的。

    new Gson().fromJson(jsonString,String.class);

     自然它肯定有解决的办法,我们用如下代码,此时String[]当成一个实体类。

    new Gson().fromJson(jsonString,String[].class);

     这时我们可能会想那我们的集合可不可以也用这种方法啊呢!来看看这段代码 

    new Gson().fromJson(jsonString,List<Object>.class)

    看起来没毛病但是写代码是就报错如下图

    对于Java来说List<String>和List<User>这俩个的字节码文件只一个那就是List.class,这是Java泛型使用时要注意的问题 泛型擦除。
    当然有解决办法:

    new Gson().fromJson(jsonArray, new TypeToken<List<Object>>(){}.getType());

    或者

    // List
    Type type = new TypeToken<List<Object>>() {}.getType();
    List<Object> list = gson.fromJson(record, type);
    
    // Map
    Type type = new TypeToken<Map<String, NetVO>>() {}.getType();
    Map<String, NetVO> map = gson.fromJson(record, type);

    Gson为我们提供了TypeToken来实现对泛型的支持,

    展开全文
  • Gson解析JSON数组

    2020-08-26 09:54:54
    五种方法解析各种情况下的JSON数组 "muser": [ { "name": "zhangsan", "age": "10", "phone": "11111", "email": "11111@11.com" }, ... ] 这里的 "muser" ,就是数组的名称,称它为数据头,防止跟里面的...

     

    五种方法解析各种情况下的JSON数组

    "muser": [
        {
          "name": "zhangsan",
          "age": "10",
          "phone": "11111",
          "email": "11111@11.com"
        },
        ...
    ]
    • 这里的 "muser" ,就是数组的名称,称它为数据头,防止跟里面的字段有歧义
    • 如果没有数据头,那就叫它纯数据,或者纯数组数据
    • 代码中用到的JsonArray/JsonObject等都来自GSON

    没有数据头的纯数组JSON如何解析?

    解析的JSON数组(JsonArray):

    [
      {
        "name": "zhangsan",
        "age": "10",
        "phone": "11111",
        "email": "11111@11.com"
      },
      {
        "name": "lisi",
        "age": "20",
        "phone": "22222",
        "email": "22222@22.com"
      },
      ...
    ]

    这种JSON数组格式,强大的GSON会直接解析成一个List。但是这里我们先用原始的方法去解析。

    1. 首先我们需要建立一个Bean对象,注意变量名和字段名称一致(不一致时,可以使用序列化):
    public class UserBean {
        //变量名跟JSON数据的字段名需要一致
        private String name ;
        private String age;
        private String phone;
        private String email;
        ...
    }
    1. 解析过程:
    /**
     * 解析没有数据头的纯数组
     */
    private void parseNoHeaderJArray() {
        //拿到本地JSON 并转成String
        String strByJson = JsonToStringUtil.getStringByJson(this, R.raw.juser_1);
    
        //Json的解析类对象
        JsonParser parser = new JsonParser();
        //将JSON的String 转成一个JsonArray对象
        JsonArray jsonArray = parser.parse(strByJson).getAsJsonArray();
    
        Gson gson = new Gson();
        ArrayList<UserBean> userBeanList = new ArrayList<>();
    
        //加强for循环遍历JsonArray
        for (JsonElement user : jsonArray) {
            //使用GSON,直接转成Bean对象
            UserBean userBean = gson.fromJson(user, UserBean.class);
            userBeanList.add(userBean);
        }
        mainLView.setAdapter(new UserAdapter(this, userBeanList));
    }

    步骤如下:

    • 无论JSON来自本地还是网络获取,都要先将JSON转化成String;
    • 需要一个JSON解析类对象将JSON字符串转换成JsonArray,前提是我们知道JSON 中只有纯数组;
    • 循环遍历JsonArray,并用Gson解析成相应的对象

    注意:

    1. JsonParse,这是一个解析类它可以把json数据分别通过getAsJsonObject和getAsJsonArray解析成JsonObject和JsonArray.
    2. JsonElement,一个抽象类,代表JSON串中的某一个元素,

    有数据头的纯数组数据改如何解析?

    内容和上面的JSON一样,只不过是加了一个名称“muser”,也就是约定好的数据头:

    {
      "muser": [
        {
          "name": "zhangsan",
          "age": "10",
          "phone": "11111",
          "email": "11111@11.com"
        },
        {
          "name": "lisi",
          "age": "20",
          "phone": "22222",
          "email": "22222@22.com"
        },
        ...
      ]
    }

    解析过程:

    /**
     * 解析有数据头的纯数组
     */
    private void parseHaveHeaderJArray() {
        //拿到本地JSON 并转成String
        String strByJson = JsonToStringUtil.getStringByJson(this, R.raw.juser_2);
    
        //先转JsonObject
        JsonObject jsonObject = new JsonParser().parse(strByJson).getAsJsonObject();
        //再转JsonArray 加上数据头
        JsonArray jsonArray = jsonObject.getAsJsonArray("muser");
    
        Gson gson = new Gson();
        ArrayList<UserBean> userBeanList = new ArrayList<>();
    
        //循环遍历
        for (JsonElement user : jsonArray) {
            //通过反射 得到UserBean.class
            UserBean userBean = gson.fromJson(user, new TypeToken<UserBean>() {}.getType());
            userBeanList.add(userBean);
        }
        mainLView.setAdapter(new UserAdapter(this, userBeanList));
    }
    1. TypeToken

    它其实是一个匿名内部类,官方解释:Gson提供了TypeToken这个类来帮助我们捕获像list这样的泛型信息。java编译器就会把捕获到的泛型信息编译到这个匿名内部类中,然后再运行时就会被getType()方法用反射的API提取到。其实就是将T转成.class。

    有数据头的复杂数据该如何解析?

    {
      "code": 200,
      "msg": "OK",
      "muser": [
        {
          "name": "zhangsan",
          "age": "10",
          "phone": "11111",
          "email": "11111@11.com"
        },
        {
          "name": "lisi",
          "age": "20",
          "phone": "22222",
          "email": "22222@22.com"
        },
        ...
      ]
    }
    • 根据json建立Bean,注意这里的Bean是返回所有的字段,因为GSON能直接解析成list,所以Bean是下面这样的,
    /**
     * Created by xiarui on 2016/8/30.
     * 返回所有结果的Bean
     */
    public class ResultBean {
        //注意变量名与字段名一致
        private int code;
        private String msg;
        private List<UserBean> muser;
    
        public class UserBean{
            private String name ;
            private String age;
            private String phone;
            private String email;
            ...
        }
        ...
    }

    注意,这里ResultBean里面有一个UserBean,虽然和上面两种的内容一样,但是作用不一样,这里作为JsonArray解析后存入List中的对象。

    /**
     * 有消息头 复杂数据 常规方式
     */
    private void parseComplexJArrayByCommon() {
        //拿到Json字符串
        String strByJson = JsonToStringUtil.getStringByJson(this, R.raw.juser_3);
        //GSON直接解析成对象
        ResultBean resultBean = new Gson().fromJson(strByJson,ResultBean.class);
        //对象中拿到集合
        List<ResultBean.UserBean> userBeanList = resultBean.getMuser();
        //展示到UI中
        mainLView.setAdapter(new ResultAdapter(this, userBeanList));
    }

     

    直接解析复杂JSON中的数组或数组中的某部分内容

    {
      "code": 200,
      "msg": "OK",
      "muser": [
        {
          "name": "zhangsan",
          "age": "10",
          "phone": "11111",
          "email": "11111@11.com"
        },
        {
          "name": "lisi",
          "age": "20",
          "phone": "22222",
          "email": "22222@22.com"
        },
        ...
      ]
    }

    假如只想取“muser”这个数组中的年龄大于30岁该怎么做?

    • 第一点肯定就是刚才提到的遍历,这个很好理解,所以我们先要取这一个数组(JsonArray),那么如何取呢?还记得之前提到的 JsonParse 么,它的 getAsJsonArray() 可以传入 数据头 拿到数组,当然不要忘了最外面一层是个 JsonObject 。
    • 拿到数组以后,我们就可以遍历了,经过第一二招的洗礼,相信在遍历上,应该没什么问题了,使用的还是之前提到的 JsonElement 。

    完整代码:

    /**
     * 有数据头 复杂数据 截取方式
     */
    private void parseComplexJArrayByDirect() {
        //拿到JSON字符串
        String strByJson = JsonToStringUtil.getStringByJson(this, R.raw.juser_3);
        List<UserBean> userBeanList = new ArrayList<>();
    
        //拿到数组
        JsonObject jsonObject = new JsonParser().parse(strByJson).getAsJsonObject();
        JsonArray jsonArray = jsonObject.getAsJsonArray("muser");
    
        //循环遍历数组
        for (JsonElement user : jsonArray) {
            UserBean userBean = new Gson().fromJson(user, new TypeToken<UserBean>() {
            }.getType());
            //根据条件过滤
            if (Integer.parseInt(userBean.getAge()) > 30) {
                userBeanList.add(userBean);
            }
        }
        mainLView.setAdapter(new UserAdapter(this, userBeanList));
    }

     

    解析一个很复杂的JSON数据

    {
      "group": {
        "user": {
          "name": "张三",
          "age": "10",
          "phone": "11111",
          "email": "11111@11.com"
        },
        "info": {
          "address": "北京",
          "work": "Android Dev",
          "pay": "10K",
          "motto": "先定一个小目标,比如我先赚一个亿"
        }
      }
    }

    解析过程

    /**
     * 通过JsonReader的方式去解析
     */
    private void parseComplexJArrayByReader() throws IOException {
        String strByJson = JsonToStringUtil.getStringByJson(this, R.raw.juser_4);
        JsonReader reader = new JsonReader(new StringReader(strByJson));
        try {
            reader.beginObject();
            String tagName = reader.nextName();
            if (tagName.equals("group")) {
                //读group这个节点
                readGroup(reader);
            }
            reader.endObject();
        } finally {
            reader.close();
        }
    }
    
    /**
     * 读group这个节点
     *
     * @param reader JsonReader
     */
    private void readGroup(JsonReader reader) throws IOException {
        reader.beginObject();
        while (reader.hasNext()) {
            String tagName = reader.nextName();
            if (tagName.equals("user")) {
                readUser(reader);
            } else if (tagName.equals("info")) {
                readInfo(reader);
            }
        }
        reader.endObject();
    }
    
    /**
     * 读用户基本消息 user节点
     *
     * @param reader JsonReader
     */
    private void readUser(JsonReader reader) throws IOException {
        reader.beginObject();
        while (reader.hasNext()) {
            String tag = reader.nextName();
            if (tag.equals("name")) {
                String name = reader.nextString();
                nameText.setText(name);
            } else if (tag.equals("age")) {
                String age = reader.nextString();
                ageText.setText(age);
            } 
            ...
            else {
                reader.skipValue();//忽略
            }
        }
        reader.endObject();
    }
    
    /**
     * 读用户其他消息 info节点
     *
     * @param reader JsonReader
     */
    private void readInfo(JsonReader reader) throws IOException {
        reader.beginObject();
        while (reader.hasNext()) {
            String tag = reader.nextName();
            if (tag.equals("address")) {
                String address = reader.nextString();
                addressText.setText(address);
            } else if (tag.equals("work")) {
                String work = reader.nextString();
                workText.setText(work);
            } 
            ...
            else {
                reader.skipValue();//忽略
            }
        }
        reader.endObject();
    }

    过程有省略。。。。

    参考:http://blog.csdn.net/qq_35114086/article/details/52705817

    https://www.tuicool.com/articles/FrI3uq

    http://blog.csdn.net/tkwxty/article/details/34474501/

    http://blog.csdn.net/chunqiuwei/article/details/49160321

    http://www.myexception.cn/program/1909359.html

     

    展开全文
  • Gson解析Json示例源码

    2017-09-13 22:54:59
    Gson类库有一个Gson类,这个Gson类提供了两个方法:toJson() 和fromJson(),我们主要就是调用这两个方法来分别实现序列化Java对象为JSON字符串和反序列化JSON字符串成Java对象。 通过代码示例来对Gson类的常用方法...
  • 针对于Gson解析,可能都有遇到某个字段类型不匹配导致整个json解析失败的问题,这不是我们期望的,我们期望的是一个字段解析失败不影响其他字段的解析。 那这种情况下怎么办呢? 下面就是踩坑记录和解决方案 二、...

    一、背景

    一般我们在进行网络请求拿到返回结果之后,我们期望能够转化成对应的Java实体类,在这个转化过程中,可以使用自动解析的方式,也可以使用三方提供的工具类,比如Gson、FastJson等。

    针对于Gson解析,可能都有遇到某个字段类型不匹配导致整个json解析失败的问题,这不是我们期望的,我们期望的是一个字段解析失败不影响其他字段的解析。

    那这种情况下怎么办呢?

    下面就是踩坑记录和解决方案

    二、问题 & 解决方案

    1. 绕过Kotlin非空判断问题

    问题描述

    data class User(
            val name: String = "",  //String类型
            val age: Int,           //Kotlin Int类型,不加?会转换成java的int类型,加?会转换成Integer类型
            val bad: Boolean,       //Kotlin Boolean类型,不加?会转换成java的boolean类型,加?会转换成Boolean类型
            val relation: String = "",
            val friends: User,      //对象类型
            val family: List<User>  //数组类型
    )
     
     
    fun main() {
        val gson = GsonBuilder().create()
     
        val jsonStr = "{}"
        val user = gson.fromJson(jsonStr, User::class.java)
        println(user)
    }
    

    猜想一下上面打印出来的结果是什么?

    答案是: User(name=null, age=0, bad=false, relation=null, friends=null, family=null)

    可以看到我们声明的各种属性包含String类型,对象类型,数组类型,都是非空的,但是解析出来的结果却是null, 这并不符合我们的预期,如果这样的代码上线了,线上肯定崩溃无疑。

    并且如果我们把age和bad属性添加?标识的话,我们将会得到下面的结果

    User(name=null, age=null, bad=null, relation=null, friends=null, family=null)

    所有的都变成null了。

    那为什么会这样呢?针对这种情况,网上也能搜到对应文章说明
    https://blog.csdn.net/lmj623565791/article/details/106631386

    我们知道Kotlin data class类所有属性都赋初始值的时候,才会默认生成无参构造方法

    由于上面的User类并没有所有的属性都赋初始值,最终导致生成的类没有无参的构造方法,而Kotlin data class的赋初始值的逻辑是在构造方法中实现的

    Gson在没有找到默认构造方法时,它就直接通过Unsafe的方法,绕过了构造方法,直接构建了一个对象。

    正是由于没走构造方法,所以默认值也不会被设置,最终数据的值就是Java中针对引用数据类型和基本数据类型对应的默认值了,即引用类型默认为null, 基本数据类型int 默认为0, boolean 默认为false

    那在平常的开发过程中我们怎么避免此类问题发生呢?

    解决方案

    1. data class的类所有属性都赋初始值,保证生成无参构造函数,使得默认值能够生效
    2. 对于引用数据类型尽量声明成可空类型,尽量确保程序可靠性
    3. 对于基本数据类型尽量声明成非可空类型,尽量减少内存消耗

    所以针对上面的User类,我们应该尽量写成以下方式

    //所有属性都赋初始值
    @Keep  //保持不被混淆
    data class User(
            val name: String? = "",
            val age: Int = 0,
            val bad: Boolean = false,
            val relation: String? = "",
            val friends: User? = null,
            val family: List<User>? = null
    )
    

    这样的话,上面打印出来的结果为:

    User(name=, age=0, bad=false, relation=, friends=null, family=null)

    另外一种解决方案就是:不使用data class, 而是直接使用class, 然后在类里面去声明对应的属性

    这种情况下对应属性必须赋初始值,并且会默认有无参的构造方法

    class User {
        private val name: String? = ""
        private val age: Int = 0
        private val bad: Boolean = false
        private val relation: String? = ""
        private val friends: User? = null
        private val family: List<User>? = null
     
        override fun toString(): String {
            return "User(name=$name, age=$age, bad=$bad, relation=$relation, friends=$friends, family=$family)"
        }
    }
    

    2. 类型不匹配导致解析失败问题

    fun main() {
        val gson = GsonBuilder().create()
     
     
        val jsonStr = "{'name':'Coder','age':'aaa'}"    // 1
    //  val jsonStr = "{'name':'Coder','friends':[]}"   // 2
    //  val jsonStr = "{'name':'Coder','family':{}}"    // 3
        val user = gson.fromJson(jsonStr, User::class.java)
        println(user)
    }
    

    针对上面三种情况,会发生什么样的结果?
    在这里插入图片描述在这里插入图片描述
    在这里插入图片描述
    可以看到这3中情况都会导致异常,程序不能正常运行

    但是实际情况中这种情况又不可能避免,服务端那边使用的是弱类型语言的话,这种情况发生的概率极大,端上不能完全依靠服务端去保证,不然crash率就会蹭蹭往上涨。

    解决方案

    自定义 TypeAdapterFactory

    gson 库会通过JsonReader对json对象的每个字段进项读取,当发现类型不匹配时抛出异常

    那么我们就在它抛出异常的时候进行处理,让它继续不中断接着往下读取其他的字段就好了

    具体代码为:

    public class GsonTypeAdapterFactory implements TypeAdapterFactory {
        @Override
        public <T> TypeAdapter<T> create(Gson gson, TypeToken<T> type) {
            final TypeAdapter<T> adapter = gson.getDelegateAdapter(this, type);
            return new TypeAdapter<T>() {
                @Override
                public void write(JsonWriter out, T value) throws IOException {
                    adapter.write(out, value);
                }
     
                @Override
                public T read(JsonReader reader) throws IOException {
                    try {
                        return adapter.read(reader);
                    } catch (Throwable e) {
                        e.printStackTrace();
                        if (reader.hasNext()) {
                            JsonToken peek = reader.peek();
                            if (peek == JsonToken.NAME) {
                                reader.nextName();
                            } else {
                                reader.skipValue();
                            }
                        }
                        return null;
                    }
                }
            };
        }
    }
     
     
    fun main() {
        val gson = GsonBuilder().registerTypeAdapterFactory(GsonTypeAdapterFactory()).create()  //gson创建的时候registerTypeAdapterFactory
     
        val jsonStr = "{'name':'Coder','age':'aaa'}"    // 1 
    //  val jsonStr = "{'name':'Coder','friends':[]}"   // 2
    //  val jsonStr = "{'name':'Coder','family':{}}"    // 3
        val user = gson.fromJson(jsonStr, User::class.java)
        println(user)
    }
    

    这种写法,上面三种情况都不会报错,并且最终解析的结果为:

    User(name=Coder, age=0, bad=false, relation=, friends=null, family=null)

    展开全文
  • Kotlin使用gson解析集合

    2020-12-18 16:19:08
    错误写法:val list = Gson().fromJson(集合字符串, ArrayList<T>()::class.java) 正确写法:val list = Gson().fromJson(集合字符串, object : TypeToken<ArrayList<T>>() {}.type)

     

    错误写法:val list = Gson().fromJson(集合字符串, ArrayList<T>()::class.java)

    正确写法:val list = Gson().fromJson(集合字符串, object : TypeToken<ArrayList<T>>() {}.type)

     

    展开全文
  • gson 解析 json 简单教学.zip,太多无法一一验证是否可用,程序如果跑不起来需要自调,部分代码功能进行参考学习。
  • Gson解析嵌套json

    2016-07-28 17:03:02
    Gson解析嵌套json
  • 使用GSON解析JSON数据

    千次阅读 2019-07-18 15:51:30
    GSON是谷歌提供的一个开源库,可以用来解析JSON数据 不过GSON并没有被添加到Android官方的API中,所以如果要使用这个开源库,我们就要先添加依赖,编辑app/build.gradle文件,在dependencies闭包中添加如下内容: ...
  • Android 使用gson解析接口数据 简要 据上一篇简述OkHttp的post请求方法,在总结那简单说了一下怎样获取数据后再赋值到页面上,现在展开说一下。 xml代码如下: <?xml version="1.0" encoding="utf-8"?> <...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 36,862
精华内容 14,744
关键字:

gson解析