精华内容
参与话题
问答
  • 超详细JSON解析步骤

    千次阅读 多人点赞 2016-05-08 18:48:34
    JSON简介 JAVAScript Object Notation是一种轻量级的数据交换格式 具有良好的可读和便于快速编写的特性。 业内主流技术为其提供了完整的解决方案(有点类似于正则表达式 ,获得了当今大部分语言的支持) JSON采用...

    JSON简介

    • JAVAScript Object Notation是一种轻量级的数据交换格式
    • 具有良好的可读和便于快速编写的特性。
    • 业内主流技术为其提供了完整的解决方案(有点类似于正则表达式 ,获得了当今大部分语言的支持)
    • JSON采用兼容性很高的文本格式,同时也具备类似于C语言体系的行为。 – Json.org
    • JSON作为数据是目前网络中主流的数据传输格式之一,应用十分广泛,说是使用率达到99%一点也不勉强

    JSON支持的数据类型

    我们要学习使用JSON解析,必须对JSON解析的规则原理有深刻的认识和了解,然后才知道它的一个实现原理
    JSON里面的数据是以一种键值对的方式存在
    (”key”:”value”)中值的类型可以是下面数据类型中的任意一种:
    1. 数字(整数或浮点数)
    2. 逻辑值(true 或 false)
    3. 字符串(在双引号中)
    4. 数组(在方括号中)
    5. 函数
    6. 对象(在大括号中)
    7. null

    JSON语法规则

    JSON的语法规则非常的简单,就是使用
    大括号’{}’,
    中括号’[]’,
    逗号’,’,
    冒号’:’,
    双引号’“”’。

    数据类型:
    嵌套对象、数组、字符串、数字、布尔值或空值。

    我们在JSON解析中只有三中情况出现
    1.{} 解析’大括号’类型
    2. [ ] 解析是’中括号’类型
    3. 其实只有两种,那第三种则是1与2的组合方法即”{’name’:’李书豪’ ,’hobby’:[‘编程’,’电竞’,’睡觉’]}”那么下面分别来看一些这三种类型以及解析

    JSON基本语法与图例

    • Object(对象类型)
      • 用{ }包含一系列无序的key–Value键值对表示,其中Key和Value之间用冒号分割,每个key-value之间用逗号分割。
      • 比如:这里写图片描述
    • Array(数组类型)
      • 使用[ ]包含所有元素,每个元素用逗号分隔,元素可以是任意的值
      • 比如:这里写图片描述
    • 组合形
      • 这里写图片描述
        这里写图片描述

    JSON数据解析

    • JSON解析一定要掌握的两条规则:

      • 1.如果看到是{ }–>使用JSONObject
      • 2.如果看到的[ ]–>使用JSONArray解析
    • 掌握了JSON的数据类型和基本语法后,下面我们将对JSON的各种语法类型进行详细解析(注意掌握两条规则的使用,掌握了JSON解析就那么回事)

    纯对象(Object)的解析{ }:

    import org.json.JSONException;
    import org.json.JSONObject;
    
    /**
     * JSON-->纯对象(Object)的解析
     * 
     * 注:我们在eclipse里面操作JSON解析的时候需要第三方jar包的支持
     * @author sKy°
     * @date 2016-5-8
     * @version 1.0
     */
    public class Json01 {
        public static void main(String[] args) {
    //      编辑一个我们要解析的数据对象
    //     根据JSON的官方定义,键,加"",值,如果是字符串,就加"",其他不加。
            String json="{'name':'李书豪','age':24}";
    
            try {
    //          创建JSON解析对象(两条规则的体现:大括号用JSONObject,注意传入数据对象)
                JSONObject obj = new JSONObject(json);
    //          obj.后面有各种数据类型,根据对象来选择使用的数据类型
                String name = obj.getString("name");
    //          同理如上,这里的age为Int类型,我们就用对应的类型进行解析
                int age = obj.getInt("age");
    //          最后输出到控制台
                System.out.println(name+"<--->"+age);
    
            } catch (JSONException e) {
                e.printStackTrace();
            }
    
        }
    }

    这里写图片描述

    纯数组(Array)的解析{ }:

    import org.json.JSONArray;
    import org.json.JSONException;
    
    /**
     * 对纯数组Aarry的解析
     * @author sKy°
     * @date 2016-5-8
     * @version 1.0
     */
    public class Json02 {
        public static void main(String[] args) {
    //      编辑一个我们要解析的数据对象
            String json="['天津冷','北京暖','东京热','南京凉']";
    
            try {
    //          创建JSON解析对象(两条规则的体现:中括号用JSONArray,注意传入数据对象)
                JSONArray jArray = new JSONArray(json);
    //          取得数组长度
                int length = jArray.length();
    //          回想数组的取值的方式? --->for循环遍历数组--->得到值
                for (int i = 0; i < length; i++) {
    //              根据解析的数据类型使用该类型的get方法得到该值,打印输出
                    String string = jArray.getString(i);
                    System.out.print(string+",");
                }
    
            } catch (JSONException e) {
                // TODO: handle exception
            }
    
    
        }
    }

    这里写图片描述

    组合类型的解析(一):

    • 例子: String json=”{‘name’:’李书豪’,’girlFriend’:{‘name’:’高圆圆’,’age’:18}}”;
    • 分析: 我们首先是解析外面的大括号的对象,然后,通过girlfFriend,获取到对应的被包含的里面大括号对象。所以这里我们需要建立一个类,封装对应的数据字段,根据setName ,setAge的方式在去得到对应的值
    /**
     * 创建一个Person用于接收解析数据,封装对应字段
     * @author sKy°
     * @date 2016-5-8
     * @version 1.0
     */
    public class Person {
    //    分析我们要解析的对象,根据解析对象的属性值去创建对应的属性值
    //    根据分析我们所要解析的对象,两条属性 1.name(String类型) 2.是girlFrien(类类型,意味着还需要在类中去嵌套一个类(创建类部类也可))
    
    //   封装字段
        private String name;
        private GirlFriend girlFriend;  //类类型
    //   setter getter方法
        public String getName() {
            return name;
        }
        public void setName(String name) {
            this.name = name;
        }
        public GirlFriend getGirlFriend() {
            return girlFriend;
        }
        public void setGirlFriend(GirlFriend girlFriend) {
            this.girlFriend = girlFriend;
        }
    
    //   toString方法用于控制台输出
        @Override
        public String toString() {
            return "Person [name=" + name + ", girlFriend=" + girlFriend + "]";
        }
    
    }
    
    // 为了方便咱们看,这里就直接在下面创建了一个GirlFriend这个类
    class GirlFriend{
    //   根据对象属性值,创建对应的值
        private String name;
        private int age;
    //   setter getter方法
        public String getName() {
            return name;
        }
        public void setName(String name) {
            this.name = name;
        }
        public int getAge() {
            return age;
        }
        public void setAge(int age) {
            this.age = age;
        }
    //   toString方法用于控制台输出
        @Override
        public String toString() {
            return "GirlFriend [name=" + name + ", age=" + age + "]";
        }
    
    
    
    }

    开始解析:

    import org.json.JSONException;
    import org.json.JSONObject;
    
    
    
    
    
    /**
     * 组合数据类型的解析--->对象嵌套对象类型
     * @author sKy°
     * @date 2016-5-8
     * @version 1.0
     */
    public class Json03 {
        public static void main(String[] args) {
    //      编辑一个我们要解析的数据对象
    //      分析: 应该先解析外面的大的对象,然后,通过girlfFriend,获取到对应的被包含的对象。
    //      所以这里我们需要建立一个类,封装对应的数据字段,根据setName ,setAge的方式在去得到对应的值
    
            String json="{'name':'李书豪','girlFriend':{'name':'高圆圆','age':18}}";
            try {
    //          1.创建JSON解析对象(两条规则的提现:大括号用JSONObject,注意传入数据对象)
                JSONObject jObj = new JSONObject(json);
    //          2.实例化Person对象获取对应的值--->这里是获得外面大括号{}的name值 思考?里面{}如何获得?
                Person per=new Person();
                String name = jObj.getString("name");
                per.setName(name);
    //          3.分析:里面{}是嵌套在外面大括号类的所以我们解析的对象是通过外面大括号去取得里面大括号值,注意看
                //取得对应里面大括号的girlFriend,取得name值,赋值给girlFriend对象
                GirlFriend girlFriend=new GirlFriend();
                JSONObject jObj1 = jObj.getJSONObject("girlFriend");
                String gfName = jObj1.getString("name");
                girlFriend.setName(gfName);
    //          获得age值并赋值
                int gfAge = jObj1.getInt("age");
                girlFriend.setAge(gfAge);
    //          通过set把girlFriend的值赋Person 用于toString的输出,不然为空
                per.setGirlFriend(girlFriend);
    //          输出
                System.out.println(per);
        }catch (JSONException e) {
            e.printStackTrace();
        }
        }
    }

    这里写图片描述
    小结: {[ {},{} ]}–>思路:第一步看到大括号:JSONObject去解,创建好对应里面的属性的值;第二步看到中括号:JSONArray去解析 对应创建好对应里面的属性值;第三步中括号里面的{},又是一个JSONObject。思路大致如此,强调注意的是,设置的属性值setXxx getXxx必须要和去获得值名称一致,不然会出错!!

    组合类型的解析(二):

    下面我们来解析一个略为复杂的JSON数据
    要解析的数据如下:

    {
        'desc': 'OK',
        'status': 1000,
        'data': {
            'wendu': '20',
            'ganmao': '相对于今天将会出现大幅度降温,易发生感冒,请注意适当增加衣服,加强自我防护避免感冒。',
            'forecast': [
                {
                    'fengxiang': '北风',
                    'fengli': '3-4级',
                    'high': '高温 27℃',
                    'type': '中雨',
                    'low': '低温 19℃',
                    'date': '6日星期五'
                },
                {
                    'fengxiang': '北风',
                    'fengli': '微风级',
                    'high': '高温 23℃',
                    'type': '大雨',
                    'low': '低温 17℃',
                    'date': '7日星期六'
                },
                {
                    'fengxiang': '北风',
                    'fengli': '微风级',
                    'high': '高温 26℃',
                    'type': '小雨',
                    'low': '低温 17℃',
                    'date': '8日星期天'
                },
                {
                    'fengxiang': '南风',
                    'fengli': '微风级',
                    'high': '高温 27℃',
                    'type': '多云',
                    'low': '低温 15℃',
                    'date': '9日星期一'
                },
                {
                    'fengxiang': '南风',
                    'fengli': '微风级',
                    'high': '高温 29℃',
                    'type': '多云',
                    'low': '低温 16℃',
                    'date': '10日星期二'
                }
            ],
            'yesterday': {
                'fl': '微风',
                'fx': '北风',
                'high': '高温 33℃',
                'type': '阴',
                'low': '低温 22℃',
                'date': '5日星期四'
            },
            'aqi': '58',
            'city': '成都'
        }
    }

    因为数据略大,不方便咱们看,这里给大家提供一个JSON在线解析工具http://json.phpddt.com/ 这是JSON在线高亮解析 ,可以很好的帮助咱们进行解析分析。下面是我用网页解析好的图片,可以思考下步骤(记住两条规则)
    这里写图片描述

    分析:
    这里写图片描述
    一:第一个大括号(JSONObject){”desc”: “status”: “data”}
    二:大括号里面有一个大括号(JSONObject){”wendu”: “20”, “ganmao”: “forecast”: “yesterday”: “aqi”: “city”: }
    三:第二个大括号里面有两个对象 1.数组形(JSONArray) 2.对象形( JSONObject )
    而数组形里面又套有数组的对象{} 。这就需要咱们在解析的时候需要很细致的去创建对应的属性值,JSON解析并不难,而难受的地方就提现在对类的创建中,只要够细心也超简单!

    开始封装字段
    import java.util.List;
    
    /**
     * 对应的字段的封装
     * @author sKy°
     * @date 2016-5-6
     * @version 1.0
     */
    public class Weather {
    //  外面大括号的字段封装 setter getter toString
        public String desc;
        public int status;
        public Data data;
        @Override
        public String toString() {
            return "Weather [desc=" + desc + ", status=" + status + ", data="
                    + data + "]";
        }
    
    
    }
    
    class Data{
    //  里面大括号的字段封装 setter getter toString 
    //  该类中包含有数组形和对象形,需要一并的封装在里面
        public String wendu;
        public String ganmao;
        public List<Forecast> forecast;
        public Yesterday yesterday;
        public String aqi;
        public String city;
        @Override
        public String toString() {
            return "Data [wendu=" + wendu + ", ganmao=" + ganmao + ", forecast="
                    + forecast + ", yesterday=" + yesterday + ", aqi=" + aqi
                    + ", city=" + city + "]";
        }
    
    
    }
    
    class Forecast{
    //  数组里面的大括号类型字段的封装
        public String fengxiang;
        public String fengli;
        public String high;
        public String type; 
        public String low;
        public String date;
        @Override
        public String toString() {
            return "Forecast [fengxiang=" + fengxiang + ", fengli=" + fengli
                    + ", high=" + high + ", type=" + type + ", low=" + low
                    + ", date=" + date + "]";
        }
    
    
    }
    class Yesterday{
    //   最后{}的字段封装
        public String fl;
        public String fx;
        public String high;
        public String type;
        public String low;
        public String date;
        @Override
        public String toString() {
            return "Yesterday [fl=" + fl + ", fx=" + fx + ", high=" + high
                    + ", type=" + type + ", low=" + low + ", date=" + date + "]";
        }
    
    }

    开始解析:

    import java.util.ArrayList;
    import java.util.List;
    
    import org.json.JSONArray;
    import org.json.JSONException;
    import org.json.JSONObject;
    
    
    
    
    /**
     * 组合类型二的解析
     * @author sKy°
     * @date 2016-5-6
     * @version 1.0
     */
    public class Test01 {
        public static void main(String[] args) throws Exception {
    
             //要解析的对象
            String json="{ 'desc': 'OK', 'status': 1000, 'data': { 'wendu': '20', 'ganmao': '相对于今天将会出现大幅度降温,易发生感冒,请注意适当增加衣服,加强自我防护避免感冒。', 'forecast': [ { 'fengxiang': '北风', 'fengli': '3-4级', 'high': '高温 27℃', 'type': '中雨', 'low': '低温 19℃', 'date': '6日星期五' }, { 'fengxiang': '北风', 'fengli': '微风级', 'high': '高温 23℃', 'type': '大雨', 'low': '低温 17℃', 'date': '7日星期六' }, { 'fengxiang': '北风', 'fengli': '微风级', 'high': '高温 26℃', 'type': '小雨', 'low': '低温 17℃', 'date': '8日星期天' }, { 'fengxiang': '南风', 'fengli': '微风级', 'high': '高温 27℃', 'type': '多云', 'low': '低温 15℃', 'date': '9日星期一' }, { 'fengxiang': '南风', 'fengli': '微风级', 'high': '高温 29℃', 'type': '多云', 'low': '低温 16℃', 'date': '10日星期二' } ], 'yesterday': { 'fl': '微风', 'fx': '北风', 'high': '高温 33℃', 'type': '阴', 'low': '低温 22℃', 'date': '5日星期四' }, 'aqi': '58', 'city': '成都' } }";
    
            Weather wea=new Weather();
    //      首先看到的是一个{}所以用JSON Object来进行解析
    //      获得外部的Weather
            JSONObject obj = new JSONObject(json);
            String desc = obj.getString("desc");
            int status = obj.getInt("status");
            wea.status=status;
            wea.desc=desc;
    
    //      获得内部Data的数据
            JSONObject obj1 = obj.getJSONObject("data");
            Data data=new Data();
            data.wendu=obj1.getString("wendu");
            data.ganmao=obj1.getString("ganmao");
            data.aqi=obj1.getString("aqi");
            data.city=obj1.getString("city");
            wea.data=data;
            List<Forecast> forecasts=new ArrayList<>();
    
    //      获取forecast数组
            JSONArray jArr = obj1.getJSONArray("forecast");
            for (int i = 0; i < jArr.length(); i++) {
                JSONObject obj2 = jArr.getJSONObject(i);
                Forecast forecast=new Forecast();
                forecast.date=obj2.getString("date");
                forecast.fengxiang=obj2.getString("fengxiang");
                forecast.high=obj2.getString("high");
                forecast.low=obj2.getString("low");
                forecast.fengli=obj2.getString("fengli");
                forecast.type=obj2.getString("type");
                forecasts.add(forecast);
            }
            data.forecast=forecasts;
            JSONObject obj3 = obj1.getJSONObject("yesterday");
            Yesterday yesterday=new Yesterday();
            yesterday.fl=obj3.getString("fl");
            yesterday.fx=obj3.getString("fx");
            yesterday.high=obj3.getString("high");
            yesterday.type=obj3.getString("type");
            yesterday.low=obj3.getString("low");
            yesterday.date=obj3.getString("date");
            data.yesterday=yesterday;
    
    //      输出字段
            System.out.println(wea);
        }
    
    }

    解析结果:

    这里写图片描述

    结语: 对于JSON解析个人的粗浅看法,
    1.首先是对JSON数据的一个分析
    2.其次是掌握JSON一些技巧(两条规则–对象形JSONObject ,数组形JSONArray)
    3.而后是对对应的属性值进行对应的字段封装建立对应的类(分析要细心,思路要清晰,程序这行需要有耐心不能浮躁)
    4.而后是解析中要有明确的思路

    (以上只是一个JSON初步的解析,但JSON解析的大致思路如此,后面有http套用的,无非也就把下载的文件转为JSON对象,后面解析思路也是如此,写的不好的地方大家包涵!有啥问题,欢迎留言!)

    展开全文
  • JSON的三种解析方式

    万次阅读 2018-08-17 11:49:45
    JSON的三种解析方式 一、什么是JSONJSON是一种取代XML的数据结构,和xml相比,它更小巧但描述能力却不差,由于它的小巧所以网络传输数据将减少更多流量从而加快速度。 JSON就是一串字符串 只不过元素会使用特定的...

    JSON的三种解析方式

    一、什么是JSON?

    JSON是一种取代XML的数据结构,和xml相比,它更小巧但描述能力却不差,由于它的小巧所以网络传输数据将减少更多流量从而加快速度。

    JSON就是一串字符串 只不过元素会使用特定的符号标注。

    {} 双括号表示对象

    [] 中括号表示数组

    "" 双引号内是属性或值

    : 冒号表示后者是前者的值(这个值可以是字符串、数字、也可以是另一个数组或对象)

    所以 {"name": "Michael"} 可以理解为是一个包含name为Michael的对象

    而[{"name": "Michael"},{"name": "Jerry"}]就表示包含两个对象的数组

    当然了,你也可以使用{"name":["Michael","Jerry"]}来简化上面一部,这是一个拥有一个name数组的对象

    二、JSON解析之传统的JSON解析

    1、生成json字符串

    public static String createJsonString(String key, Object value) {
            JSONObject jsonObject = new JSONObject();
            jsonObject.put(key, value);
            return jsonObject.toString();
    }

    2、解析JSON字符串

    分为以下三种情况,一个JavaBean,一个List数组,一个嵌套Map的List数组:

    复制代码

    import java.util.ArrayList;
    import java.util.HashMap;
    import java.util.Iterator;
    import java.util.List;
    import java.util.Map;
    
    import org.json.JSONArray;
    import org.json.JSONObject;
    
    import com.android.myjson.domain.Person;
    
    /**
     * 完成对json数据的解析
     * 
     */
    public class JsonTools {
    
    
        public static Person getPerson(String key, String jsonString) {
            Person person = new Person();
            try {
                JSONObject jsonObject = new JSONObject(jsonString);
                JSONObject personObject = jsonObject.getJSONObject("person");
                person.setId(personObject.getInt("id"));
                person.setName(personObject.getString("name"));
                person.setAddress(personObject.getString("address"));
            } catch (Exception e) {
                // TODO: handle exception
            }
            return person;
        }
    
        public static List getPersons(String key, String jsonString) {
            List list = new ArrayList();
            try {
                JSONObject jsonObject = new JSONObject(jsonString);
                // 返回json的数组
                JSONArray jsonArray = jsonObject.getJSONArray(key);
                for (int i = 0; i < jsonArray.length(); i++) {
                    JSONObject jsonObject2 = jsonArray.getJSONObject(i);
                    Person person = new Person();
                    person.setId(jsonObject2.getInt("id"));
                    person.setName(jsonObject2.getString("name"));
                    person.setAddress(jsonObject2.getString("address"));
                    list.add(person);
                }
            } catch (Exception e) {
                // TODO: handle exception
            }
            return list;
        }
    
        public static List getList(String key, String jsonString) {
            List list = new ArrayList();
            try {
                JSONObject jsonObject = new JSONObject(jsonString);
                JSONArray jsonArray = jsonObject.getJSONArray(key);
                for (int i = 0; i < jsonArray.length(); i++) {
                    String msg = jsonArray.getString(i);
                    list.add(msg);
                }
            } catch (Exception e) {
                // TODO: handle exception
            }
            return list;
        }
    
        public static List> listKeyMaps(String key,
                String jsonString) {
            List> list = new ArrayList>();
            try {
                JSONObject jsonObject = new JSONObject(jsonString);
                JSONArray jsonArray = jsonObject.getJSONArray(key);
                for (int i = 0; i < jsonArray.length(); i++) {
                    JSONObject jsonObject2 = jsonArray.getJSONObject(i);
                    Map map = new HashMap();
                    Iterator iterator = jsonObject2.keys();
                    while (iterator.hasNext()) {
                        String json_key = iterator.next();
                        Object json_value = jsonObject2.get(json_key);
                        if (json_value == null) {
                            json_value = "";
                        }
                        map.put(json_key, json_value);
                    }
                    list.add(map);
                }
            } catch (Exception e) {
                // TODO: handle exception
            }
            return list;
        }
    }

    复制代码

    三、JSON解析之GSON

    1、生成JSON字符串

    复制代码

    import com.google.gson.Gson;
    
    public class JsonUtils {
    
        public static String createJsonObject(Object obj) {
            Gson gson = new Gson();
            String str = gson.toJson(obj);
            return str;
    
        }
    }
    二、解析JSON
    
    import java.util.ArrayList;
    import java.util.List;
    import java.util.Map;
    
    import com.google.gson.Gson;
    import com.google.gson.reflect.TypeToken;
    
    ;
    public class GsonTools {
    
        public GsonTools() {
            // TODO Auto-generated constructor stub
        }
    
        /**
         * @param 
         * @param jsonString
         * @param cls
         * @return
         */
        public static  T getPerson(String jsonString, Class cls) {
            T t = null;
            try {
                Gson gson = new Gson();
                t = gson.fromJson(jsonString, cls);
            } catch (Exception e) {
                // TODO: handle exception
            }
            return t;
        }
    
        /**
         * 使用Gson进行解析 List
         * 
         * @param 
         * @param jsonString
         * @param cls
         * @return
         */
        public static  List getPersons(String jsonString, Class cls) {
            List list = new ArrayList();
            try {
                Gson gson = new Gson();
                list = gson.fromJson(jsonString, new TypeToken>() {
                }.getType());
            } catch (Exception e) {
            }
            return list;
        }
    
        /**
         * @param jsonString
         * @return
         */
        public static List getList(String jsonString) {
            List list = new ArrayList();
            try {
                Gson gson = new Gson();
                list = gson.fromJson(jsonString, new TypeToken>() {
                }.getType());
            } catch (Exception e) {
                // TODO: handle exception
            }
            return list;
        }
    
        public static List> listKeyMaps(String jsonString) {
            List> list = new ArrayList>();
            try {
                Gson gson = new Gson();
                list = gson.fromJson(jsonString,
                        new TypeToken>>() {
                        }.getType());
            } catch (Exception e) {
                // TODO: handle exception
            }
            return list;
        }
    }

    复制代码

    三、JSON解析之FastJSON

    复制代码

    import java.util.ArrayList;
    import java.util.List;
    import java.util.Map;
    
    import com.alibaba.fastjson.JSON;
    import com.alibaba.fastjson.TypeReference;
    
    public class JsonTool {
    
        public static  T getPerson(String jsonstring, Class cls) {
            T t = null;
            try {
                t = JSON.parseObject(jsonstring, cls);
            } catch (Exception e) {
                // TODO: handle exception
            }
            return t;
        }
    
        public static  List getPersonList(String jsonstring, Class cls) {
            List list = new ArrayList();
            try {
                list = JSON.parseArray(jsonstring, cls);
            } catch (Exception e) {
                // TODO: handle exception
            }
            return list;
        }
    
        public static  List> getPersonListMap1(
                String jsonstring) {
            List> list = new ArrayList>();
            try {
                list = JSON.parseObject(jsonstring,
                        new TypeReference>>() {
                        }.getType());
    
            } catch (Exception e) {
                // TODO: handle exception
            }
    
            return list;
        }
    }

    复制代码

    总结:

    JSON对于移动设备来说,尤其对于网络环境较差和流量限制的情况下,相对于XML格式的数据传输会更节省流量,传输效率更高。在这三种解析方式中FastJson是效率最高的,推荐使用。

    展开全文
  • JSON三种数据解析方法

    万次阅读 多人点赞 2018-01-15 13:05:01
    引言 JSON数据现在是我们开发中用的最多的,百分之八十的数据都是通过JSON方式进行传输,那么想要学好JSON解析就要了解什么是JSON数据,怎么快速解析它从而提升开发效率。

    JSON数据现在是我们开发中用的最多的,百分之九十的数据都是通过JSON方式进行传输,那么想要学好JSON解析就要了解什么是JSON数据,怎么快速解析它从而提升开发效率。

    1 什么是JSON数据?

    • 先看下面,这里有一段JSON数据,我们根据这段数进行讲解:
    {
      "paramz": {
        "feeds": [
          {
            "id": 299076,
            "oid": 288340,
            "category": "article",
            "data": {
              "subject": "荔枝新闻3.0:不止是阅读",
              "summary": "江苏广电旗下资讯类手机应用“荔枝新闻”于近期推出全新升级换代的3.0版。",
              "cover": "/Attachs/Article/288340/3e8e2c397c70469f8845fad73aa38165_padmini.JPG",
              "pic": "",
              "format": "txt",
              "changed": "2015-09-22 16:01:41"
            }
          }
        ],
        "PageIndex": 1,
        "PageSize": 20,
        "TotalCount": 53521,
        "TotalPage": 2677
      }
    }
    

    其实JSON数据就是一段字符串而已,只不过有不同意义的分隔符将其分割开来而已,我们看上面的符号,里面有[] ,{}等符号,其中

    • 1 []中括号代表的是一个数组;
    • 2 {}大括号代表的是一个对象
    • 3 双引号“”表示的是属性值
    • 4 冒号:代表的是前后之间的关系,冒号前面是属性的名称,后面是属性的值,这个值可以是基本数据类型,也可以是引用数据类型。

    2 了解了JSON数据的格式,怎么对这段数据进行解析呢?

    JSONObject系统自带的解析方式解析,我们先来JSONObject(系统自带的类)类中的方法:

    这里写图片描述

    • 上面用红框框出来的是我们手动解析最常用的方法了,好了,现在我们想要解析上面的一段数据,该怎么做呢?这里我写了一个解析类如下:
    public class JsonUtils {
    
        /**
         * 根据json数据解析返回一个List<HashMap<String, Object>>集合
         * @param json  json数据
         * @return
         */
        public static List<HashMap<String, Object>> getJsonList(String json) {
            List<HashMap<String, Object>> dataList;
            dataList = new ArrayList<>();
            try {
                JSONObject rootObject = new JSONObject(json);
                JSONObject paramzObject = rootObject.getJSONObject("paramz");
                JSONArray feedsArray = paramzObject.getJSONArray("feeds");
                for (int i = 0; i < feedsArray.length(); i++) {
                    JSONObject sonObject = feedsArray.getJSONObject(i);
                    JSONObject dataObject = sonObject.getJSONObject("data");
                    String subjectStr = dataObject.getString("subject");
                    String summaryStr = dataObject.getString("summary");
                    String coverStr = dataObject.getString("cover");
                    HashMap<String, Object> map = new HashMap<>();
                    map.put("subject", subjectStr);
                    map.put("summary", summaryStr);
                    map.put("cover", coverStr);
                    dataList.add(map);
                }
                return dataList;
            } catch (JSONException e) {
                e.printStackTrace();
            }
            return null;
        }
    }
    

    相信很简单一看就懂了吧,此方法写起来主要是比较费时间罢了,无非就是几个方法不停的调用而已,所以显得特别的费时费力,下面我又写了一个解析的方法,方法中会有一些冗余的代码,是为了更加深刻理解JSON解析而写的,实际中可以删掉,也用了一行GSON解析,GSON解析下面会见讲到:

    其中DataModel对象我是将data对象使用GsonFormat插件工具生成的,使用方式可以自行搜索

    public class DataModel {
    
        /**
         * subject : "荔枝新闻3.0:不止是阅读"
         * summary : "江苏广电旗下资讯类手机应用“荔枝新闻”于近期推出全新升级换代的3.0版。"
         * cover : "/Attachs/Article/288340/3e8e2c397c70469f8845fad73aa38165_padmini.JPG"
         * pic :
         * format : video
         * changed : 2015-11-07 14:35:22
         */
    
        public String subject;
        public String summary;
        public String cover;
        public String pic;
        public String format;
        public String changed;
    
        @Override
        public String toString() {
            return "DataModel{" +
                    "subject='" + subject + '\'' +
                    ", summary='" + summary + '\'' +
                    ", cover='" + cover + '\'' +
                    ", pic='" + pic + '\'' +
                    ", format='" + format + '\'' +
                    ", changed='" + changed + '\'' +
                    '}';
        }
    }
    
     /**
         * 根据json对象获取List<DataModel>集合
         * @param json 数据
         * @return
         */
        public static List<DataModel> getGsonList(String json) {
            List<DataModel> dataList;
            try {
                JSONObject rootObject = new JSONObject(json);
                JSONObject paramzObject = rootObject.getJSONObject("paramz");
    
                /**
                 * JSONArray的构造方法获取JSONArray对象
                 */
                JSONArray jsonArray = new JSONArray(paramzObject.getString("feeds"));
                Log.i(TAG, "jsonarray.length():"+jsonArray.length());
    
                /**
                 * 获取JSONObject对象的属性关键字
                 */
                Iterator<String> iterators = paramzObject.keys();
                while (iterators.hasNext()) {
                    Log.i(TAG, "iterators: " + iterators.next());
                }
                JSONArray feeds = paramzObject.getJSONArray("feeds");
                dataList = new ArrayList<>();
                for (int i = 0; i < feeds.length(); i++) {
                    JSONObject jsonObject = feeds.getJSONObject(i);
                    DataModel model = new Gson().fromJson(jsonObject.getString("data"), new TypeToken<DataModel>() {
                    }.getType());
                    Log.i(TAG, "DataModel: " + model.toString());
                    dataList.add(model);
                }
                return dataList;
            } catch (JSONException e) {
                // TODO Auto-generated catch block
                e.printStackTrace();
            }
    
            return null;
        }
    

    简单总结一下上面的解析吧:

    1 对于JSONObject对象来说,想要得到一个JSONObject对象通常可以通过

    • (a):构造方式:JSONObject(String json)-> JSONObject rootObject = new JSONObject(json);
    • (b):JSONObject getJSONObject(String name){}-> JSONObject paramzObject = rootObject.getJSONObject(“paramz”);

    2 对于JSONArray对象来说,想要得到一个JSONArray对象通常可以通过

    • (a):构造方式:JSONArray(String json)->JSONArray jsonArray = new JSONArray(paramzObject.getString(“feeds”));
    • (b):JSONObject getJSONObject(String name){}-> JSONArray feeds = paramzObject.getJSONArray(“feeds”);

    3 Gson解析

    我们如果懂得了上面的手动解析方式的话,那么对于Gson解析而言,就太简单了,下面我们就开始解析下面一段JSON数据:

    {
        "homeadlist": [
            {
                "id": 1,
                "imgurl": "/img/homead/a73b3f1d-0f14-429d-9d0f-70643fb0f0eb.jpg",
                "jumpflag": 0,
                "jumpurl": "",
                "posflag": 1,
                "remark": "1111",
                "cityid": 1
            },
            {
                "id": 12,
                "imgurl": "/img/homead/eb442fbf-49db-4ba6-a102-d781505f426d.jpg",
                "jumpflag": 0,
                "jumpurl": "",
                "posflag": 2,
                "remark": "",
                "cityid": 1
            },
            {
                "id": 14,
                "imgurl": "/img/homead/68109460-635d-4c5c-8be8-64d7c7889d18.jpg",
                "jumpflag": 0,
                "jumpurl": "http://shiranlife.kuaizhan.com/",
                "posflag": 4,
                "remark": "",
                "cityid": 1
            }
        ]
    }
    

    首先我们使用GsonFormat工具生成一个类HomeadListModel:

    public class HomeadListModel {
    
        /**
         * code : 1
         * data : {"homeadlist":[{"id":1,"imgurl":"/img/homead/a73b3f1d-0f14-429d-9d0f-70643fb0f0eb.jpg","jumpflag":0,"jumpurl":"","posflag":1,"remark":"1111","cityid":1},{"id":12,"imgurl":"/img/homead/eb442fbf-49db-4ba6-a102-d781505f426d.jpg","jumpflag":0,"jumpurl":"","posflag":2,"remark":"","cityid":1},{"id":14,"imgurl":"/img/homead/68109460-635d-4c5c-8be8-64d7c7889d18.jpg","jumpflag":0,"jumpurl":"http://shiranlife.kuaizhan.com/","posflag":4,"remark":"","cityid":1}]}
         */
    
        public int code;
        public DataBean data;
    
        public static class DataBean {
            public List<HomeadlistBean> homeadlist;
    
            public static class HomeadlistBean {
                public int id;
                public String imgurl;
                public int jumpflag;
                public String jumpurl;
                public int posflag;
                public String remark;
                public int cityid;
            }
        }
    }
    
    

    我们使用OKHttpClient,代码如下

    OkHttpClient.Builder builder = new OkHttpClient.Builder();
    
            Request request = new Request.Builder()
                    .url(url)
                    .get()
                    .build();
    
            builder.build().newCall(request).enqueue(new Callback() {
                @Override
                public void onFailure(Call call, IOException e) {
    
                }
    
                @Override
                public void onResponse(Call call, Response response) throws IOException {
                    Gson gson = new Gson();
                    /**
                     * java.lang.IllegalStateException: closed
                     * 因为OkHttp请求回调中response.body().string()只能有效调用一次
                     *
                     */
    
                    String string = response.body().string();
                    Log.i("aaa", "response: " + string);
                    /**
                     * 重新构建一个response 因为response.body().string()调用一次之后流就断掉了,只能有效调用一次
                     */
                    MediaType mediaType = response.body().contentType();
                    Response response1 = response.newBuilder().body(ResponseBody.create(mediaType, string)).build();
                    String string1 = response1.body().string();
                    Log.i("aaa", "response1: " + string1);
                    /**
                     * 将json数据转换为对象
                     */
                    HomeadListModel model = gson.fromJson(string1, HomeadListModel.class);
                    //HomeadListModel model2 = gson.fromJson(string1, new TypeToken<HomeadListModel>() {
                    }.getType());
                    /**
                     * 将对象转换为json数据
                     */
                    String jsonString = gson.toJson(model);
                    Log.i("aaa", "onResponse2: " + jsonString);
    
                    for (HomeadListModel.DataBean.HomeadlistBean data : model.data.homeadlist) {
                        mData.add(imageUrl + data.imgurl);
                    }
                    runOnUiThread(new Runnable() {
                        @Override
                        public void run() {
                            mAdapter.notifyDataSetChanged();
                        }
                    });
                }
            });
    

    我们想要将一个json数据转换为对象的话需要使用fromJson(String json, Class classOfT) /fromJson(String json, Type typeOfT),当我们需要将对象转换为String的时候根据String toJson(Object src)方法即可。这里需要注意一点,如果response.body().string()调用大于一次的话,就会报错java.lang.IllegalStateException: closed,因为response.body().string()调用一次之后流就断掉了,需要重新构建一个response;


    4 FastJson解析

    • 这个解析和Gson解析差不多,也是一行就搞定了,也是对上面的Gson数据进行解析,想要将json数据解析成对象需要使用 parseObject()方法,参数可以传Class,也可以传Type;当需要通过对象得到String字符串时候使用String json1 = JSONObject.toJSONString(model)即可,下面贴上代码:
    OkHttpClient.Builder builder = new OkHttpClient.Builder();
            Request request = new Request.Builder()
                    .url(url)
                    .get()
                    .build();
            builder.build().newCall(request).enqueue(new Callback() {
                @Override
                public void onFailure(Call call, IOException e) {
    
                }
    
                @Override
                public void onResponse(Call call, Response response) throws IOException {
    
                    String json = response.body().string();
                    /**
                     * 根据json数据获取对象
                     */
                    HomeadListModel model = JSONObject.parseObject(json, new TypeToken<HomeadListModel>() {
                    }.getType());
    //                HomeadListModel model2 = JSONObject.parseObject(json, HomeadListModel.class);
    
                    /**
                     * 根据对象获取json数据
                     */
                    String json1 = JSONObject.toJSONString(model);
                    Log.i("aaa", "fastJson: " + json1);
    
                    for (HomeadListModel.DataBean.HomeadlistBean data : model.data.homeadlist) {
                        mData.add(imageUrl + data.imgurl);
                    }
                    runOnUiThread(new Runnable() {
                        @Override
                        public void run() {
                            mAdapter.notifyDataSetChanged();
                        }
                    });
                }
            });
    

    结尾:上面写了三种解析JSON数据的方法,第一种是最麻烦的,但是不一定是最差的,后面两种Gson和FastJson都是最常用的方法,本博客里面用到的API也是最常用的API,基本开发都够用了,其余未涉及到的请自行查看源码学习吧。


    想要系统学习Android知识体系的,可以免费关注我的博客和Github,你的关注和支持是每一个技术人前进的动力。

    在这里插入图片描述

    在这里插入图片描述
    在这里插入图片描述

    在这里插入图片描述

    展开全文
  • JSON解析的几种方式

    万次阅读 2017-07-26 10:54:28
    JSON是首先一种数据结构,说白了就是对数据的描述,刚刚出现是为了取代XML,可惜并没有,但是在作为配置文件上,却是很好,由于它小巧灵活,描述数据很好,所以在网络上进行数据传输更加方便。 请记住JSON对数据...
    
    
    • JSON是首先一种
    数据结构,说白了就是对数据的描述,刚刚出现是为了取代XML,可惜并没有,但是在作为配置文件上,却是很好,由于它小巧灵活,描述数据很好,所以在网络上进行数据传输更加方便。
    请记住JSON对数据的描述形式,既然是形式,那么它的数据形式是什么样的:
    对象的描述是: {} 这个表示jsonobject(json对象)
    数组的描述是: [] 表示jsonarray(json数组)
    属性或值的描述是: “”
    连接之间的描述是: :

    在开发中,网络请求和json解析使用的频率是一样高的,因为网络请求返回来的一般都是json(当然还有xml),这里讨论的是json,网络请求的工具类前面我的博客已经写过了,这里给出网址:http://blog.csdn.net/u014727709/article/details/53389840 直接复制就可使用。

    解析json的方法有很多,我最开始接触的时候使用的是原生解析,第二种就是Gson解析,还有阿里巴巴的FastJson,JackJson等,这里看一下如何进行json解析,这里使用的网络请求就是上面提到的工具类。
    解析这个网址返回的json:http://www.qubaobei.com/ios/cf/dish_list.php?stage_id=1&page=1&limit=20 这是一个get请求
    格式是这样的:

    {
    “ret”: 1,
    “data”: [
    {
    “id”: “8289”,
    “title”: “油焖大虾”,
    “pic”: “http://www.qubaobei.com/ios/cf/uploadfile/132/9/8289.jpg“,
    “collect_num”: “1596”,
    “food_str”: “大虾 葱 生姜 植物油 料酒”,
    “num”: 1596
    },
    。。。
    第一种方法:原生解析

    首先要分析json的格式,这里首先是一个json对象(即JsonObject),里面还嵌套有一个json数组(即JsonArray),jsonarray里面又是一个json对象。分析清楚那就可以进行解析了,当然最好的话,还是要建立一个json所对应的实体类bean,这里我就不写了,下面会在提到的。
    这里的result就是网络请求返回来的json字符串。
    JSONObject jsonObject = new JSONObject(result);
    JSONArray jsonArray = jsonObject.getJSONArray(“data”);
    for (int j = 0; j < jsonArray.length(); j++) {
    JSONObject jsonObject2 = jsonArray.getJSONObject(j);
    String id = jsonObject2.getString(“id”);
    String title = jsonObject2.getString(“title”);
    String pic = jsonObject2.getString(“pic”);
    String collect_num = jsonObject2.getString(“collect_num”);
    String food_str = jsonObject2.getString(“food_str”);
    String num = jsonObject2.getString(“num”);
    Log.e(“json——->”, id+”,”+title+”,”+pic+”,”+collect_num+”,”+food_str+”,”+num);

    这里是输出的结果:
    这里写图片描述

    注意:解析json的时候,最使用json里面对应的数据类型进行解析,这里我统一使用的是String类型来获得解析的结果。例如:json里面最后一个num的类型是int,解析的时候可以int num = jsonObject2.getInt(“num”);
    解析出来的结果你可以存放在你建立的实体类bean里面,或者存在集合List< HashMap< String, Object>>里面也可以,但是一般的话,都是存放在实体类里面的。

    第二种解析方式:Gson解析
    Gson解析需要下载gson.jar包,自己去百度下载吧或者下载我的demo里面就有。
    这里解析就需要给json生成实体类,初学的话建议手写,熟悉的话可以使用Android Studio里面插件GsonFormat来自动生成,这里实体类我就不贴出来了,去我的demo里面看吧。
    解析就是一句话的事:
    MenuBean menuBean = new Gson().fromJson(result, MenuBean.class);
    Log.e(“MenuBean—–>”, menuBean.getRet()+”“);
    结果如下:
    这里写图片描述

    第三种解析方式:FastJson和Gson类似的,就不贴图了。
    MenuBean menuBean = JSON.parseObject(result,MenuBean.class);
    Log.e(“MenuBean—–>”, menuBean.getRet()+”“);
    Log.e(“MenuBean—–>”, menuBean.getData().get(0).getPic()+”“);

    第四种解析方式:JackJson解析,同样和上面类似
    MenuBean menuBean;
    menuBean = new ObjectMapper().readValue(result, MenuBean.class);
    Log.e(“MenuBean—–>”, menuBean.getRet()+”“);
    Log.e(“MenuBean—–>”, menuBean.getData().get(0).getPic()+”“);

    demo下载地址:http://download.csdn.net/detail/u014727709/9717408
    转载自:http://blog.csdn.net/u014727709/article/details/53782931

    欢迎start,欢迎评论,欢迎指正

    展开全文
  • 使用 JSONPath 解析 JSON 完整内容详解

    万次阅读 2018-11-15 21:49:02
    jsonpath的介绍: JsonPath是一种简单的方法...JsonPath提供的json解析非常强大,它提供了类似正则表达式的语法,基本上可以满足所有你想要获得的json内容。   github上有它的应用:https://github.com/json-path/...
  • JSONJSON的三种解析方式

    千次阅读 2018-06-03 16:32:02
    JSON的三种解析方式 一、JSON简介  JSON是一种取代XML的数据结构,和XML相比,它更小巧但描述能力却不差,由于它的小巧所以网络传输数据将减少更多流量从而加快速度。 JSON就是一串字符串 只不过元素会使用特定的...
  • json3.js 【JS / JavaScript 中解析JSON的js包,JSON官方的JSON解析包】。JavaScript中解析JSON的js包,页面中引入json3.js,即可使用。 使用方法:JSON.parse(str), JSON.stringify(obj) 更多详情请参考博文: ...
  • Json解析及解析原理

    千次阅读 2018-08-21 16:09:45
    1、JSON介绍 JSON(JavaScript Object Notation),类似于XML,是一种数据交换格式,相比之下,它比XML表达起来更简单。虽然它源自于JavaScript,但是只是一种数据格式,可以用于任何编程语言。   JSON 是 ...
  • JSON解析的步骤

    2020-10-19 20:39:27
    JSON解析步骤 概念 JSON(JavaScript Object Notation) 是JS对象简谱,是一种轻量级的数据交换格式。它具有良好的可读性和便于快速编写的特性,是目前网络中主流的数据传输格式之一。 数据格式 JSON中有两种数据格式...
  • 几种常用的JSON解析工具的使用

    万次阅读 2018-09-09 22:44:56
    目录 简介: (1)org.json的使用 ... (3)json-simple的使用 ...现在越来越多的网站采用JSON来交换数据,在Json.org网站上,Java可以使用的解析Json的组件就有超过20种。 Json官网:http://json.org/ 页面...
  • android json解析详解(json手动解析)

    万次阅读 2017-11-13 08:43:17
    一 .json简介 1)概念:json全称是javaScript object Notation,是一种病轻量级的数据交换格式。 2)特点: 1.本质就是具有特定格式的字符串 2,.json完全独立于编程语言 3.json比xml数据传输的有效性要高出很多...
  • JSON解析】浅谈JSONObject的使用

    万次阅读 多人点赞 2020-03-25 17:22:27
    JSON(JavaScript Object Notation)是一种轻量级的数据交换格式,同时也易于机器解析和生成、易于理解、阅读和撰写,而且Json采用完全独立于语言的文本格式,这使得Json成为理想的数据交换语言。 JSON建构于两种结构...
  • 一、简介利用递归的方式反射解析到bean里面二、详细代码1、 Json格式例如服务器指定规定json格式为:{ "code": "……" , // 返回代号,预留字段,默认返回null "type":"ERROR", // 返回类型,表示操作是成功或失败 ...
  • Android项目之JSON解析(3种解析技术详解)

    万次阅读 多人点赞 2016-11-26 16:35:00
    前言: ...差不多有3天没有写博客了,要想的、要做的事情太多了,额....原归正传,今天接着上一篇博客:Android项目之JSON解析(扯淡),继续分享我对JSON解析的了解。   一、用Android原生技术...
  • Go的json解析:Marshal与Unmarshal

    万次阅读 多人点赞 2018-05-03 14:42:14
    版权声明:本文为博主原创文章,博客地址: ... 简介 Json(Javascript Object Nanotation)是一种数据交换格式,常用于...任意一端将数据转换成json 字符串,另一端再将该字符串解析成相应的数据结构,如string...
  • JAVA中的四种JSON解析方式详解

    万次阅读 多人点赞 2017-08-02 10:52:25
    我们在日常开发中少不了和JSON数据打交道,那么我们来看看JAVA中常用的JSON解析方式。 1、JSON原生 2、GSON 3、FastJSON 4、jackson
  • JSON解析(C++)

    万次阅读 2019-08-21 17:20:33
    本文主要介绍使用 jsoncpp 库,编写C++语言的 JSON 解析程序。 1概述 jsoncpp 是一个可以与 JSON 进行交互的C++库。官网定义如下: jsoncpp is an implementation of a JSON reader and writer in C++. 通过使用...
  • 什么是json? 懵逼回答:【参考菜鸟教程】   a.JSON 指的是 JavaScript 对象表示法(JavaScript Object Notation)   b.JSON 是轻量级的文本数据交换格式...JSON 解析器和 JSON 库支持许多不同的编程语言。 目前...
  • golang中的使用json一点也不陌生,golang为我们提供了官方的encoding/json:Go语言学习之encoding/json包(The way to go)Go实战–net/http中JSON的使用(The way to go)今天,跟大家分享一个github上比较活的golang j
  • 全面详解c语言使用cJSON解析JSON字符

    万次阅读 多人点赞 2018-01-26 16:41:09
    为什么选择cJSON来解析JSON字符串?因为简洁又简单,而且效率又快,cJSON工程文件也非常简单,仅一个.c文件和一个.h文件! 如果要自己写的话就是重造轮子了,况且效率上也不一定会比cJSON更好! 且文件体积大小不...
  • IOS中Json解析的四种方法

    千次阅读 2018-06-30 15:36:11
    作为一种轻量级的数据交换格式,json正在逐步取代xml,成为网络数据的通用格式。 有的json代码格式比较混乱,可以使用此“http://www.bejson.com/”网站来进行JSON
  • 4种json解析技术对比

    千次阅读 2016-06-06 14:41:46
    json-lib最开始的也是应用最广泛的json解析工具,json-lib 不好的地方确实是依赖于很多第三方包, 包括commons-beanutils.jar,commons-collections-3.2.jar,commons-lang-2.6.jar,commons-logging-1.1.1.j
  • Unity的Json解析<一>--读取Json文件

    万次阅读 2015-12-21 18:06:26
    Unity的Json解析–读取Json文件因为需要做一个外部文件配置,考虑了XML和Json,而5.3版本对Json做了更新,所以就尝试一下。 版本更新的Json部分介绍哦: [Unity5.3版本更新的Json部分 ]Json的在线编辑Json parser :...
  • C#利用Newtonsoft.Json解析JSON

    千次阅读 2019-03-07 12:14:06
    项目需要,从postgreSQL读取数据,其中有部分字段为json格式,需要解析出部分内容进行统计 解决方法: using System; using System.Collections.Generic; using System.Linq; using System.Text; using ...
  • Java中JSON解析

    千次阅读 2016-08-09 08:47:05
    JSON数据解析 JSON(JavaScript Object Notation) 是一种轻量级的数据交换格式。 易于人阅读和编写。同时也易于机器解析和生成。 它基于JavaScript Programming Language, Standard ECMA-262 3rd Edition - December...
  • Dart复杂json解析

    千次阅读 2019-10-24 16:05:42
    写在前面:json 是一种轻量级数据交换格式,用于前后端的文本传输,json 本身并不复杂,稍微复杂一点的 json 就是嵌套,或者含有列表,今天就用 Dart 语言手动解析一下简单的 json,含有嵌套的 json 和 含有列表的 ...
  • 现在比较交流行和常用的对于网络请求数据的解析的方式基本就是XML解析和Json解析 下面我们来对这两种解析方式做一些总结 一、XML解析: 服务器端解析是通过一般的XSLT转换工具(如Java下的Xalan)将XML和XSL合成...
  • C++的Json解析库:jsoncpp和boost

    万次阅读 热门讨论 2011-12-29 23:57:44
    JSON(JavaScript Object Notation)跟xml一样也是一种数据交换格式,了解json请...json官网上列出了各种语言对应的json解析库,作者仅介绍自己使用过的两种C++的json解析库:jsoncpp(v0.5.0)和Boost(v1.34.0)。  一. 使
  • 最近有些项目在数据库oracle中使用到json格式的数据交互,对于oracle12以上的版本...下面就比较详细的说一下,关于oracle数据库在存储过程中的JSON解析应用: 一:先上一段存储过程解析JSON的存储过程,看你们能不...
  • Json解析(Json集合,Json嵌套)

    千次阅读 2018-12-02 16:15:15
    导入maven依赖: &lt;dependency&gt; &lt;groupId&gt;net.sf.json-lib&...json-lib&lt;/artifactId&gt; &lt;version&gt;2.4&lt;/version&gt; &lt;cl

空空如也

1 2 3 4 5 ... 20
收藏数 1,704,404
精华内容 681,761
关键字:

json解析