精华内容
下载资源
问答
  • 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,你的关注和支持是每一个技术人前进的动力。

    在这里插入图片描述

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

    在这里插入图片描述

    展开全文
  • Gson 解析教程

    万次阅读 多人点赞 2016-05-18 13:43:38
    Gson 是google解析Json的一个开源框架,同类的框架fastJson,JackJson等等 本人fastJson用了两年,也是从去年才开始接触Gson,希望下面的总结会对博友有用,至于Gson与FastJson的对比,其实半斤八两的问题,不再赘述 第一...

    有部分博友问时间 货币等高级处理 可以参考:时间和货币 框架处理

    且有大量模板 https://github.com/NBXXF/xxf_android/tree/master/xxf_http/src/main/java/com/xxf/arch/json/typeadapter/format/impl/time

     

    Gson 是google解析Json的一个开源框架,同类的框架fastJson,JackJson等等

    本人fastJson用了两年,也是从去年才开始接触Gson,希望下面的总结会对博友有用,至于Gson与FastJson的对比,其实半斤八两的问题,不再赘述

    第一步:在AS下面创建java工程 并添加gson依赖

     

    compile 'com.google.code.gson:gson:2.6.2'

     

     

    Gson的实例化方式:

    1:Gson gson=newGson();

    2:通过GsonBuilder 可以配置多种选项

     

     gson = new GsonBuilder()
                        .setLenient()// json宽松
                        .enableComplexMapKeySerialization()//支持Map的key为复杂对象的形式
                        .serializeNulls() //智能null
                        .setPrettyPrinting()// 调教格式
                        .disableHtmlEscaping() //默认是GSON把HTML 转义的
                        .create();

    Gson的基本用法:

     

     JavaBean转换Json字符串

     gson提供 publicString toJson(Object src) 方法可以将对象转换成jsonStr

      

    package com.xuan.gson;
    
    import com.google.gson.Gson;
    
    /**
     * @author xuanyouwu
     * @email xuanyouwu@163.com
     * @time 2016-05-18 10:39
     */
    public class GsonTest1 {
        public static class Student {
            private String name;
            private int age;
    
            //省略setter getter equals
        }
    
        private static void log(String msg) {
            System.out.println(msg);
        }
    
    
        public static void main(String[] args) throws Exception {
            Gson gson = new Gson();
            Student student = new Student();
            student.setName("xuanyouwu");
            student.setAge(26);
            String jsonStr = gson.toJson(student);
            log("---->javabean convert jsonStr:" + jsonStr);
        }
    
    }
    

     

    运行结果:

    ---->javabean convert jsonStr:{"name":"xuanyouwu","age":26}

     

     

     

        List Map转Json字符串

     

    package com.xuan.gson;
    
    import com.google.gson.Gson;
    
    import java.util.Arrays;
    import java.util.HashMap;
    import java.util.List;
    import java.util.Map;
    
    /**
     * @author xuanyouwu
     * @email xuanyouwu@163.com
     * @time 2016-05-18 10:39
     */
    public class GsonTest1 {
    
        private static void log(String msg) {
            System.out.println(msg);
        }
    
    
        public static void main(String[] args) throws Exception {
            Gson gson = new Gson();
    
            List<String> list = Arrays.asList("1", "a", "3", "rt", "5");
            log("---->list convert jsonStr:" + gson.toJson(list));
    
            Map<String, Object> content = new HashMap<String, Object>();
            content.put("name", "xuanyouwu");
            content.put("age", "26");
            log("---->map convert jsonStr:" + gson.toJson(content));
        }
    
    }
    
    运行结果:
    ---->list convert jsonStr:["1","a","3","rt","5"]
    ---->map convert jsonStr:{"name":"xuanyouwu","age":"26"}
    

     

     

     

           Json字符串转JavaBean

     

            String studentJsonStr="{\"name\":\"xuanyouwu\",\"age\":26}";
    
            Student student1 = gson.fromJson(studentJsonStr, Student.class);
            log("------->json convert JavaBean:"+student1);


          运行结果:

     

                ------->json convert JavaBean:Student{name='xuanyouwu', age=26}

     

     

       Json字符串转List

     

            String listJsonStr="[\"1\",\"a\",\"3\",\"rt\",\"5\"]";
            Type type = new TypeToken<ArrayList<String>>() {
            }.getType();
            ArrayList<String> sList=gson.fromJson(listJsonStr, type);
            log("------->json convert List:"+sList);
        运行结果:
            ------->json convert List:[1, a, 3, rt, 5]
    </pre><pre code_snippet_id="1687762" snippet_file_name="blog_20160518_11_939636" name="code" class="java">  Gson封装的类型体系
        Gson里面有一个非常有意思的抽象基类JsonElement,他的继承体系:
        <img src="https://img-blog.csdn.net/20160518135136864?watermark/2/text/aHR0cDovL2Jsb2cuY3Nkbi5uZXQv/font/5a6L5L2T/fontsize/400/fill/I0JBQkFCMA==/dissolve/70/gravity/Center" alt="" />
     JsonObject等同于org的JSONObject,JsonArray也类似,
       JsonNull 其实就是null 字段
         JsonNull jsonNull=new JsonNull();//构造方法过时,推荐INSTANCE

     

    
     
          JsonNull jsonNull=JsonNull.INSTANCE;
            log("-----"+jsonNull);
       运行结果:
          -----null
    

     

         JsonPrimitive非常有意思,我们知道如果json转换成字符串 可能包含引号的转义,但是通过JsonPrimative我们可以获得为转义的字符串,看实例:

         

    package com.xuan.gson;
    
    import com.google.gson.JsonNull;
    import com.google.gson.JsonPrimitive;
    
    /**
     * @author xuanyouwu
     * @email xuanyouwu@163.com
     * @time 2016-05-18 11:20
     */
    public class GsonTest2 {
        private static void log(String msg) {
            System.out.println(msg);
        }
        public static void main(String[] args) throws Exception {
            String studentJsonStr="{\"name\":\"xuanyouwu\",\"age\":26}";
            log("------>studentJsonStr:"+studentJsonStr);
            JsonPrimitive jsonPrimitive=new JsonPrimitive(studentJsonStr);
            log("------>jsonPrimitive:"+jsonPrimitive);
            log("------>jsonPrimitive:"+jsonPrimitive.toString());
            log("------>jsonPrimitive:"+jsonPrimitive.getAsString());
    
            JsonPrimitive jsonPrimitive2=new JsonPrimitive("this is String");
            log("------>jsonPrimitive2:"+jsonPrimitive2);
            log("------>jsonPrimitive2:"+jsonPrimitive2.toString());
            log("------>jsonPrimitive2:"+jsonPrimitive2.getAsString());
        }
    }
    

     

         运行结果:

    ------>studentJsonStr:{"name":"xuanyouwu","age":26}
    ------>jsonPrimitive:"{\"name\":\"xuanyouwu\",\"age\":26}"
    ------>jsonPrimitive:"{\"name\":\"xuanyouwu\",\"age\":26}"
    ------>jsonPrimitive:{"name":"xuanyouwu","age":26}
    ------>jsonPrimitive2:"this is String"
    ------>jsonPrimitive2:"this is String"
    ------>jsonPrimitive2:this is String

     

     

           创建JsonObject

               通过addPropert(key,value)可以向jsonObject中添加字段 跟hashMap类似

     

            JsonObject jsonObject=new JsonObject();
            jsonObject.addProperty("name","xuanyouwu");
            jsonObject.addProperty("age",26);
            log("------>create jsonObject:"+jsonObject);

                运行结果:

     

                    ------>create jsonObject:{"name":"xuanyouwu","age":26}

     

     

        创建JsonArray       

     

         JsonArray jsonElements=new JsonArray();
            jsonElements.add("a");
            jsonElements.add("b");
            jsonElements.add("c");
            jsonElements.add("d");
            log("------>create jsonArray:"+jsonElements);

              运行结果:

     

              ------>create jsonArray:["a","b","c","d"]

     

     

         JsonObject 嵌套数组或者说嵌套JsonArray

               通过JsonObject的add(key,JsonElement)可以为jsonObject 添加一个数组的字段

     

            JsonObject jsonObject2=new JsonObject();
            jsonObject2.addProperty("name","xuanyouwu");
            jsonObject2.addProperty("age",26);
            JsonArray jsonElements2=new JsonArray();
            jsonElements2.add("骑车");
            jsonElements2.add("打游戏");
            jsonElements2.add("看电视");
            jsonObject2.add("hobby",jsonElements2);
            log("------>create jsonObject inner JsonArray:"+jsonObject2);

               运行结果:

     

                ------>create jsonObject inner JsonArray:{"name":"xuanyouwu","age":26,"hobby":["骑车","打游戏","看电视"]}

     

     

     

    Gson注解

              在Gson中有五类注解

              

     

     

     

              重命名注解:SerializedName 

                 作用:转换关键字key,json转换成JavaBean时,json字段的key 默认必须和我们声明类的字段名称一样,当服务器端返回了关键字怎么办,比如key 为new switch这样,我们    在声明类的时候不能写这样的字段,可能你想服务器端改动,他可能要改数据库,但是我告诉你,做服务端的大部分不愿意改动他的json,是很自私的!这时候重命名注解都排上用场了   第二种场景:服务器端返回的json 的key 简直太丑,或者太长,你想简化,my_parent_name,可以简化成mpn 比较优雅简介

              实例:

     

    package com.xuan.gson;
    
    import com.google.gson.Gson;
    import com.google.gson.annotations.SerializedName;
    
    /**
     * @author xuanyouwu
     * @email xuanyouwu@163.com
     * @time 2016-05-18 11:20
     */
    public class GsonTest3 {
        private static void log(String msg) {
            System.out.println(msg);
        }
    
        public static class User {
            public String name;
            public int age;
            @SerializedName("new")
            public int isnew;
    
            @Override
            public String toString() {
                return "User{" +
                        "name='" + name + '\'' +
                        ", age=" + age +
                        ", isnew=" + isnew +
                        '}';
            }
        }
    
        public static void main(String[] args) throws Exception {
    
            String jsonFromServer = "{\n" +
                    "    \"age\": 26,\n" +
                    "    \"name\": \"zhangsan\",\n" +
                    "    \"new\": 1\n" +
                    "}";
            Gson gson = new Gson();
            User user = gson.fromJson(jsonFromServer, User.class);
            log("------>user:" + user);
        }
    }
    

     

    运行结果: ------>user:User{name='zhangsan', age=26, isnew=1}

     

     

    package com.xuan.gson;
    
    import com.google.gson.Gson;
    import com.google.gson.annotations.SerializedName;
    
    /**
     * @author xuanyouwu
     * @email xuanyouwu@163.com
     * @time 2016-05-18 11:20
     */
    public class GsonTest3 {
        private static void log(String msg) {
            System.out.println(msg);
        }
    
        public static class User2 {
            public String name;
            public int age;
            @SerializedName("my_parent_name")
            public String pn;
    
            @Override
            public String toString() {
                return "User2{" +
                        "name='" + name + '\'' +
                        ", age=" + age +
                        ", pn='" + pn + '\'' +
                        '}';
            }
        }
    
        public static void main(String[] args) throws Exception {
            String jsonFromServer2="{\n" +
                    "    \"age\": 26,\n" +
                    "    \"my_parent_name\": \"zhangsanf\",\n" +
                    "    \"name\": \"zhangsan\"\n" +
                    "}";
            Gson gson2 = new Gson();
            User2 user2 = gson2.fromJson(jsonFromServer2, User2.class);
            log("------>user2:" + user2);
        }
    }
    

     

    运行结果: ------>user2:User2{name='zhangsan', age=26, pn='zhangsanf'}

     

     

            作用2:结合alternate 提供多种备用字段key来解析,@SerializedName(value ="desc",alternate = {"other","note"})  如果json中有other就会解析成desc 如果有note也会解析成desc,注意1:value中的值不能出现在alternate中,注意2:alternate的备选字段 会后面的替换前面的

       实例:

       

    package com.xuan.gson;
    
    import com.google.gson.Gson;
    import com.google.gson.annotations.SerializedName;
    
    /**
     * @author xuanyouwu
     * @email xuanyouwu@163.com
     * @time 2016-05-18 11:20
     */
    public class GsonTest4 {
        private static void log(String msg) {
            System.out.println(msg);
        }
    
        public static class User {
            public String name;
            public int age;
            @SerializedName(value = "desc",alternate = {"other","note"})
            public String desc;
    
            @Override
            public String toString() {
                return "User{" +
                        "name='" + name + '\'' +
                        ", age=" + age +
                        ", desc='" + desc + '\'' +
                        '}';
            }
        }
    
        public static void main(String[] args) throws Exception {
            String jsonFromServer = "{\n" +
                    "    \"age\": 26,\n" +
                    "    \"other\": \"成都人\",\n" +
                    "    \"name\": \"zhangsan\"\n" +
                    "}";
            Gson gson = new Gson();
            User user = gson.fromJson(jsonFromServer, User.class);
            log("------>user:" + user);
    
    
            String jsonFromServer2 = "{\n" +
                    "    \"age\": 26,\n" +
                    "    \"note\": \"成都人\",\n" +
                    "    \"name\": \"zhangsan\"\n" +
                    "}";
            User user2 = gson.fromJson(jsonFromServer2, User.class);
            log("------>user:" + user2);
    
            //包括desc 与note note在desc之后
            String jsonFromServer3="{\n" +
                    "    \"age\": 26,\n" +
                    "    \"desc\": \"desc成都人\",\n" +
                    "    \"name\": \"zhangsan\",\n" +
                    "    \"note\": \"note成都人\"\n" +
                    "}";
            User user3 = gson.fromJson(jsonFromServer3, User.class);
            log("------>user:" + user3);
    
            //包括desc 与note note在desc之前
            String jsonFromServer4="{\n" +
                    "    \"age\": 26,\n" +
                    "    \"note\": \"note成都人\",\n" +
                    "    \"name\": \"zhangsan\",\n" +
                    "    \"desc\": \"desc成都人\"\n" +
                    "}";
            User user4 = gson.fromJson(jsonFromServer4, User.class);
            log("------>user:" + user4);
        }
    }
    

      运行结果:

     

         ------>user:User{name='zhangsan', age=26, desc='成都人'}
    ------>user:User{name='zhangsan', age=26, desc='成都人'}
    ------>user:User{name='zhangsan', age=26, desc='note成都人'}
    ------>user:User{name='zhangsan', age=26, desc='desc成都人'}

     

     

      Gson @Expose过滤注解 

     

      源码:默认既可以序列化又可以反序列化

     

    @Retention(RetentionPolicy.RUNTIME)
    @Target(ElementType.FIELD)
    public @interface Expose {
      
      public boolean serialize() default true;
    
      public boolean deserialize() default true;
    }
    </pre><pre code_snippet_id="1687762" snippet_file_name="blog_20160518_25_4965554" name="code" class="java">可以排除不需要序列化的字段,需要配合GsonBuilder使用
    <pre style="font-family: 宋体; font-size: 9pt; background-color: rgb(255, 255, 255);"><pre name="code" class="java"> Gson gson = new GsonBuilder()
                    .excludeFieldsWithoutExposeAnnotation()
                    .create();

     

    
     

     

    
     

     

      不添加@Expose注解的字段将不会解析:
       分为以下几种情况:
        1:不添加@Expose注解等同于@Expose(deserialize = false,serialize = false) 不做任何解析
        2:@Expose(deserialize = true,serialize = false) 只解析用用,也就是反序列化可以,序列化不可以
        3:@Expose(deserialize = false,serialize = true) 序列化可以,反序列化不行
        4:@Expose(deserialize = true,serialize = true) 既可以序列化,也可以反序列化
        实例:将分别演示这四种情况
    
     
    
     
    
     
      不添加@Expose注解:等同于@Expose(deserialize = false,serialize = false)
    
     
    package com.xuan.gson; import com.google.gson.Gson; import com.google.gson.GsonBuilder; /** * @author xuanyouwu * @email xuanyouwu@163.com * @time 2016-05-18 11:20 */ public class GsonTest5 { private static void log(String msg) { System.out.println(msg); } public static class User { public String name; @Override public String toString() { return "User{" + "name='" + name + '\'' + '}'; } } public static void main(String[] args) throws Exception { String jsonFromServer = "{\"name\": \"zhangsan\"}"; Gson gson = new GsonBuilder() .excludeFieldsWithoutExposeAnnotation() .create(); User user = gson.fromJson(jsonFromServer, User.class); log("------>反序列化:" + user); User user1 = new User(); user1.name = "zhangsan2"; String userStr = gson.toJson(user1); log("------>序列化:" + userStr); } } 

     

    运行结果:

     

    ------>反序列化:User{name='null'}
    ------>序列化:{}
    
    
     
    
     
    
     
    
     
    
     
      添加@Expose注解 
    
     
    package com.xuan.gson; import com.google.gson.Gson; import com.google.gson.GsonBuilder; import com.google.gson.annotations.Expose; /** * @author xuanyouwu * @email xuanyouwu@163.com * @time 2016-05-18 11:20 */ public class GsonTest5 { private static void log(String msg) { System.out.println(msg); } public static class User { @Expose //等同于 @Expose(deserialize = true,serialize = true) public String name; @Override public String toString() { return "User{" + "name='" + name + '\'' + '}'; } } public static void main(String[] args) throws Exception { String jsonFromServer = "{\"name\": \"zhangsan\"}"; Gson gson = new GsonBuilder() .excludeFieldsWithoutExposeAnnotation() .create(); User user = gson.fromJson(jsonFromServer, User.class); log("------>反序列化:" + user); User user1 = new User(); user1.name = "zhangsan2"; String userStr = gson.toJson(user1); log("------>序列化:" + userStr); } } 

     

    运行结果:

     

    ------>反序列化:User{name='zhangsan'}
    ------>序列化:{"name":"zhangsan2"}

     

     

    @Expose注解 只序列化

     

    package com.xuan.gson;
    
    import com.google.gson.Gson;
    import com.google.gson.GsonBuilder;
    import com.google.gson.annotations.Expose;
    
    /**
     * @author xuanyouwu
     * @email xuanyouwu@163.com
     * @time 2016-05-18 11:20
     */
    public class GsonTest5 {
        private static void log(String msg) {
            System.out.println(msg);
        }
    
        public static class User {
            @Expose(deserialize = false,serialize = true)
            public String name;
    
            @Override
            public String toString() {
                return "User{" +
                        "name='" + name + '\'' +
                        '}';
            }
        }
    
        public static void main(String[] args) throws Exception {
            String jsonFromServer = "{\"name\": \"zhangsan\"}";
            Gson gson = new GsonBuilder()
                    .excludeFieldsWithoutExposeAnnotation()
                    .create();
            User user = gson.fromJson(jsonFromServer, User.class);
            log("------>反序列化:" + user);
    
            User user1 = new User();
            user1.name = "zhangsan2";
            String userStr = gson.toJson(user1);
            log("------>序列化:" + userStr);
        }
    }
    

     

    
     

    运行结果:

     

    ------>反序列化:User{name='null'}------>序列化:{"name":"zhangsan2"}

     

     

     

          @Expose 只反序列化

     

    package com.xuan.gson;
    
    import com.google.gson.Gson;
    import com.google.gson.GsonBuilder;
    import com.google.gson.annotations.Expose;
    
    /**
     * @author xuanyouwu
     * @email xuanyouwu@163.com
     * @time 2016-05-18 11:20
     */
    public class GsonTest5 {
        private static void log(String msg) {
            System.out.println(msg);
        }
    
        public static class User {
            @Expose(deserialize = true, serialize = false)
            public String name;
    
            @Override
            public String toString() {
                return "User{" +
                        "name='" + name + '\'' +
                        '}';
            }
        }
    
        public static void main(String[] args) throws Exception {
            String jsonFromServer = "{\"name\": \"zhangsan\"}";
            Gson gson = new GsonBuilder()
                    .excludeFieldsWithoutExposeAnnotation()
                    .create();
            User user = gson.fromJson(jsonFromServer, User.class);
            log("------>反序列化:" + user);
    
            User user1 = new User();
            user1.name = "zhangsan2";
            String userStr = gson.toJson(user1);
            log("------>序列化:" + userStr);
        }
    }
    

     

    运行结果:

     ------>反序列化:User{name='zhangsan'}
    ------>序列化:{}

     

     

        @Since(float v)注解  版本控制 

          结合GsonBuilder.setVersion(n)使用 当n>=v时 才会序列化解析

     

    package com.xuan.gson;
    
    import com.google.gson.Gson;
    import com.google.gson.GsonBuilder;
    import com.google.gson.annotations.Since;
    
    /**
     * @author xuanyouwu
     * @email xuanyouwu@163.com
     * @time 2016-05-18 11:20
     */
    public class GsonTest6 {
        private static void log(String msg) {
            System.out.println(msg);
        }
    
        public static class User {
            @Since(2)
            public String name;
    
            @Override
            public String toString() {
                return "User{" +
                        "name='" + name + '\'' +
                        '}';
            }
        }
    
        public static void main(String[] args) throws Exception {
            String jsonFromServer = "{\"name\": \"zhangsan\"}";
            Gson gson = new GsonBuilder()
                    .setVersion(1)//版本为1
                    .create();
            User user1 = gson.fromJson(jsonFromServer, User.class);
            log("------>反序列化v=1:" + user1);
    
            User user1_1 = new User();
            user1_1.name = "zhangsan2";
            String userStr = gson.toJson(user1_1);
            log("------>序列化v=1:" + userStr);
    
    
            Gson gson2 = new GsonBuilder()
                    .setVersion(2)//版本为2
                    .create();
            User user2 = gson2.fromJson(jsonFromServer, User.class);
            log("------>反序列化v=2:" + user2);
    
            User user2_1 = new User();
            user2_1.name = "zhangsan2";
            String userStr2_1 = gson2.toJson(user2_1);
            log("------>序列化v=2:" + userStr2_1);
    
            Gson gson3 = new GsonBuilder()
                    .setVersion(3)//版本为3
                    .create();
            User user3 = gson3.fromJson(jsonFromServer, User.class);
            log("------>反序列化v=3:" + user3);
    
            User user3_1 = new User();
            user3_1.name = "zhangsan2";
            String userStr3_1 = gson3.toJson(user3_1);
            log("------>序列化v=3:" + userStr3_1);
        }
    }
    

     

    运行结果:

    ------>反序列化v=1:User{name='null'}
    ------>序列化v=1:{}
    ------>反序列化v=2:User{name='zhangsan'}
    ------>序列化v=2:{"name":"zhangsan2"}
    ------>反序列化v=3:User{name='zhangsan'}
    ------>序列化v=3:{"name":"zhangsan2"}

     

     

        @Util(float v)注解 版本控制

          当gson的setVersion(n) n<v 才解析

     

    package com.xuan.gson;
    
    import com.google.gson.Gson;
    import com.google.gson.GsonBuilder;
    import com.google.gson.annotations.Until;
    
    /**
     * @author xuanyouwu
     * @email xuanyouwu@163.com
     * @time 2016-05-18 11:20
     */
    public class GsonTest6 {
        private static void log(String msg) {
            System.out.println(msg);
        }
    
        public static class User {
            @Until(2)
            public String name;
    
            @Override
            public String toString() {
                return "User{" +
                        "name='" + name + '\'' +
                        '}';
            }
        }
    
        public static void main(String[] args) throws Exception {
            String jsonFromServer = "{\"name\": \"zhangsan\"}";
            Gson gson = new GsonBuilder()
                    .setVersion(1)//版本为1
                    .create();
            User user1 = gson.fromJson(jsonFromServer, User.class);
            log("------>反序列化v=1:" + user1);
    
            User user1_1 = new User();
            user1_1.name = "zhangsan2";
            String userStr = gson.toJson(user1_1);
            log("------>序列化v=1:" + userStr);
    
    
            Gson gson2 = new GsonBuilder()
                    .setVersion(2)//版本为2
                    .create();
            User user2 = gson2.fromJson(jsonFromServer, User.class);
            log("------>反序列化v=2:" + user2);
    
            User user2_1 = new User();
            user2_1.name = "zhangsan2";
            String userStr2_1 = gson2.toJson(user2_1);
            log("------>序列化v=2:" + userStr2_1);
    
            Gson gson3 = new GsonBuilder()
                    .setVersion(3)//版本为3
                    .create();
            User user3 = gson3.fromJson(jsonFromServer, User.class);
            log("------>反序列化v=3:" + user3);
    
            User user3_1 = new User();
            user3_1.name = "zhangsan2";
            String userStr3_1 = gson3.toJson(user3_1);
            log("------>序列化v=3:" + userStr3_1);
        }
    }
    


    运行结果:

     

    ------>反序列化v=1:User{name='zhangsan'}
    ------>序列化v=1:{"name":"zhangsan2"}
    ------>反序列化v=2:User{name='null'}
    ------>序列化v=2:{}
    ------>反序列化v=3:User{name='null'}
    ------>序列化v=3:{}

     

    Gson 高级用法

        相信看过retrofit2.0 源码的同学都知道,其中有一个GsonConverterFactory 里面的用法十分精炼老成,这里来一段源码

     

     

       据说使用TypeAdapter 效率更高,本人还未对比测试,暂时放后吧,TypeAdapter是什么玩意呢?

       在源码中备注了一句 Converts Java objects to and from JSON 就是对象json之间的互相转换 接替了T 泛型类的序列化和反序列化的逻辑

       从源码中我们看到区分了2.1版本之前后之后的用法,2.1版本之前可以自定义adapter:

       

    public class PointAdapter extends TypeAdapter<Point> {
     *     public Point read(JsonReader reader) throws IOException {
     *       if (reader.peek() == JsonToken.NULL) {
     *         reader.nextNull();
     *         return null;
     *       }
     *       String xy = reader.nextString();
     *       String[] parts = xy.split(",");
     *       int x = Integer.parseInt(parts[0]);
     *       int y = Integer.parseInt(parts[1]);
     *       return new Point(x, y);
     *     }
     *     public void write(JsonWriter writer, Point value) throws IOException {
     *       if (value == null) {
     *         writer.nullValue();
     *         return;
     *       }
     *       String xy = value.getX() + "," + value.getY();
     *       writer.value(xy);
     *     }
     *   }}

     

     

     

        使用

      

    GsonBuilder builder = new GsonBuilder();
     *   builder.registerTypeAdapter(Point.class, new PointAdapter());
     *   // if PointAdapter didn't check for nulls in its read/write methods, you should instead use
     *   // builder.registerTypeAdapter(Point.class, new PointAdapter().nullSafe());
     *   ...
     *   Gson gson = builder.create();

     

     

     

        在2.1版本之后更推荐直接插入泛型就使用

     

    
     
    // String json = "{'origin':'0,0','points':['1,2','3,4']}"; // TypeAdapter<Graph> graphAdapter = gson.getAdapter(Graph.class); // Graph graph = graphAdapter.fromJson(json); // }</pre> // And an example for serialization: <pre> {@code // // Graph graph = new Graph(...); // TypeAdapter<Graph> graphAdapter = gson.getAdapter(Graph.class); // String json = graphAdapter.toJson(graph); // }</pre>

     

       实例:使用TypeAdapter 来序列化和反序列化

     

    
     
    package com.xuan.gson; import com.google.gson.Gson; import com.google.gson.TypeAdapter; /** * @author xuanyouwu * @email xuanyouwu@163.com * @time 2016-05-18 11:20 */ public class GsonTest7 { private static void log(String msg) { System.out.println(msg); } public static class User { public String name; public int age; @Override public String toString() { return "User{" + "name='" + name + '\'' + ", age=" + age + '}'; } } public static void main(String[] args) throws Exception { Gson gson = new Gson(); TypeAdapter<User> userTypeAdapter = gson.getAdapter(User.class); User user = new User(); user.name = "xuanyouwu"; user.age = 26; String userJsonStr = userTypeAdapter.toJson(user); log("------>序列化:" + userJsonStr); User user1 = userTypeAdapter.fromJson(userJsonStr); log("------>反序列化:" + user1); } } 
    运行结果:
    ------>序列化:{"name":"xuanyouwu","age":26}
    ------>反序列化:User{name='xuanyouwu', age=26}
    

     

    Gson的容错机制:

     

       为什么要容错了,在javaBean中声明了int类型的age 如果服务端 返回的是"" 空字符串怎么办呢?崩溃?
       如果json格式不规范如 {name=zhangsan,age:26,hobby=null}  发现不是普通的key value
      容错实现方式1:
      1:创建Gson的方式
    gson = new GsonBuilder() .setLenient()// json宽松 .create();

    2:使用JsonReader

       JsonReader jsonReader = gson.newJsonReader(value.charStream());
    jsonReader.<span style="font-family: 宋体; font-size: 9pt;">setLenient(true)</span>

     

        3:自定义TypeAdapter

        4:使用注解JsonAdapter,其实也是自定义Adapter

     

     1.2归为一类 由框架实现,基本json大格式规范,键值对不标准,多引号的问题等等,而不报错停止解析,但是功能相对较弱

     能解决bug 

      

     

    3,4归为一类,都属于自定义adapter,但是3与gson绑定,4使用注解和字段绑定

     实例:

       

    package com.xuan.gson;
    
    import com.google.gson.Gson;
    import com.google.gson.GsonBuilder;
    import com.google.gson.JsonParseException;
    import com.google.gson.TypeAdapter;
    import com.google.gson.stream.JsonReader;
    import com.google.gson.stream.JsonWriter;
    
    import java.io.IOException;
    
    /**
     * @author xuanyouwu
     * @email xuanyouwu@163.com
     * @time 2016-05-18 11:20
     */
    public class GsonTest8 {
        private static void log(String msg) {
            System.out.println(msg);
        }
    
        public static class User {
            public String name;
            public int age;
    
            @Override
            public String toString() {
                return "User{" +
                        "name='" + name + '\'' +
                        ", age=" + age +
                        '}';
            }
    
    
            ;
        }
    
        public static class UserTypeAdapter extends TypeAdapter<User> {
    
            @Override
            public void write(JsonWriter out, User value) throws IOException {
                out.beginObject();
                out.name("name").value(value.name);
                out.name("age").value(value.age);
                out.endObject();
            }
    
            @Override
            public User read(JsonReader in) throws IOException {
                User user = new User();
                in.beginObject();
                while (in.hasNext()) {
                    switch (in.nextName()) {
                        case "name":
                            user.name = in.nextString();
                            break;
                        case "age":
                            try {
                                String str = in.nextString();
                                user.age = Integer.valueOf(str);
                            } catch (Exception e) {
                            }
                            break;
                    }
                }
                in.endObject();
                return user;
            }
        }
    
        public static void main(String[] args) throws Exception {
            Gson gson = new Gson();
    
            String jsonStrFromServer = "{\n" +
                    "    \"age\": \"\",\n" +
                    "    \"name\": \"zhangsan\"\n" +
                    "}";
            log("------->jsonFromServer:"+jsonStrFromServer);
            try {
                User user = gson.fromJson(jsonStrFromServer, User.class);
                log("------>默认Gson 解析:" + user);
            } catch (JsonParseException e) {//java.lang.NumberFormatException: empty String
                log("------>默认Gson 解析 异常:" + e);
            }
    
            Gson gson2 = new GsonBuilder()
                    .registerTypeAdapter(User.class, new UserTypeAdapter()).create();
            try {
                User user2 = gson2.fromJson(jsonStrFromServer, User.class);
                log("------>自定义adapter 解析:" + user2);
            } catch (JsonParseException e) {//java.lang.NumberFormatException: empty String
                log("------>自定义adapter 异常:" + e);
            }
    
            try {
                UserTypeAdapter userTypeAdapter = new UserTypeAdapter();
                User user3 = userTypeAdapter.fromJson(jsonStrFromServer);
                log("------>自定义adapter 解析2:" + user3);
            } catch (Exception e) {
                log("------>自定义adapter 异常2:" + e);
            }
        }
    }
    

     

    运行结果:

    ------->jsonFromServer:{
        "age": "",
        "name": "zhangsan"
    }
    ------>默认Gson 解析 异常:com.google.gson.JsonSyntaxException: java.lang.NumberFormatException: empty String
    ------>自定义adapter 解析:User{name='zhangsan', age=0}
    ------>自定义adapter 解析2:User{name='zhangsan', age=0}

    可以看到 age是空字符串 但是不影响整体的解析流程,这对客户端是十分友好的

     

      基于注解的方式,上面的方式倾向于整体,注解的方式倾向于字段

      

    package com.xuan.gson;
    
    import com.google.gson.Gson;
    import com.google.gson.JsonParseException;
    import com.google.gson.TypeAdapter;
    import com.google.gson.annotations.JsonAdapter;
    import com.google.gson.stream.JsonReader;
    import com.google.gson.stream.JsonWriter;
    
    import java.io.IOException;
    
    /**
     * @author xuanyouwu
     * @email xuanyouwu@163.com
     * @time 2016-05-18 11:20
     */
    public class GsonTest9 {
        private static void log(String msg) {
            System.out.println(msg);
        }
    
        public static class User {
            public String name;
            @JsonAdapter(IntegerTypeAdapter.class)
            public int age;
    
            @Override
            public String toString() {
                return "User{" +
                        "name='" + name + '\'' +
                        ", age=" + age +
                        '}';
            }
        }
    
        public static class IntegerTypeAdapter extends TypeAdapter<Integer> {
    
            @Override
            public void write(JsonWriter out, Integer value) throws IOException {
                out.value(value);
            }
    
            @Override
            public Integer read(JsonReader in) throws IOException {
                int i = 0;
                try {
                    String str = in.nextString();
                    i = Integer.valueOf(str);
                } catch (Exception e) {
                }
                return i;
            }
        }
    
        public static class User2 {
            public String name;
            public int age;
    
            @Override
            public String toString() {
                return "User{" +
                        "name='" + name + '\'' +
                        ", age=" + age +
                        '}';
            }
        }
    
    
        public static void main(String[] args) throws Exception {
            Gson gson = new Gson();
    
            String jsonStrFromServer = "{\n" +
                    "    \"age\": \"\",\n" +
                    "    \"name\": \"zhangsan\"\n" +
                    "}";
            log("------->jsonFromServer:" + jsonStrFromServer);
            try {
                User2 user2 = gson.fromJson(jsonStrFromServer, User2.class);
                log("------>gson 解析:" + user2);
            } catch (Exception e) {
                log("------>gson 解析异常:" + e);
            }
    
    
            try {
                User user = gson.fromJson(jsonStrFromServer, User.class);
                log("------>JsonAdapter 注解 解析:" + user);
            } catch (JsonParseException e) {//java.lang.NumberFormatException: empty String
                log("------>JsonAdapter 注解 异常:" + e);
            }
        }
    }
    

     

     

     

    运行结果:

     

    ------->jsonFromServer:{
        "age": "",
        "name": "zhangsan"
    }
    ------>gson 解析异常:com.google.gson.JsonSyntaxException: java.lang.NumberFormatException: empty String
    ------>JsonAdapter 注解 解析:User{name='zhangsan', age=0}
    可以看到我们成功地跳过服务端返回json不合理的坑了吧
    </pre><pre code_snippet_id="1687762" snippet_file_name="blog_20160519_47_1535429" name="code" class="java">不得不吐槽啊,像这种服务器端错误,应该完全归结服务端json不合理返回,
    往往老板都会找客户端原因,怎么又崩溃了?怎么又不显示了?老板不会关心是不是数据返回不合理的问题的!
    做客户端需要相当的承受能力哈,同意的点个赞哈
    </pre><p>其实上面的方式保险是很保险,但是需要维护的地方多,代码量大,我们介绍另外一种方式:JsonSerializer与JsonDeserializer 之关系单方面的处理,可以全局注册某个类型的处理:看实例:</p><p><pre name="code" class="java">package com.xuan.gson;
    
    import com.google.gson.Gson;
    import com.google.gson.GsonBuilder;
    import com.google.gson.JsonDeserializationContext;
    import com.google.gson.JsonDeserializer;
    import com.google.gson.JsonElement;
    import com.google.gson.JsonParseException;
    
    import java.lang.reflect.Type;
    
    /**
     * @author xuanyouwu
     * @email xuanyouwu@163.com
     * @time 2016-05-18 11:20
     */
    public class GsonTest10 {
        private static void log(String msg) {
            System.out.println(msg);
        }
    
        public static class User {
            public String name;
            public int age;
    
            @Override
            public String toString() {
                return "User{" +
                        "name='" + name + '\'' +
                        ", age=" + age +
                        '}';
            }
        }
    
    
        public static void main(String[] args) throws Exception {
            JsonDeserializer<Integer> jsonDeserializer = new JsonDeserializer<Integer>() {
                @Override
                public Integer deserialize(JsonElement json, Type typeOfT, JsonDeserializationContext context) throws JsonParseException {
                    try {
                        return json.getAsInt();
                    } catch (NumberFormatException e) {
                        return 0;
                    }
                }
            };
            Gson gson = new GsonBuilder()
                    .registerTypeAdapter(int.class, jsonDeserializer)
                    .create();
    
            String jsonStrFromServer = "{\n" +
                    "    \"age\": \"\",\n" +
                    "    \"name\": \"zhangsan\"\n" +
                    "}";
            log("------->jsonFromServer:" + jsonStrFromServer);
            try {
                User user = gson.fromJson(jsonStrFromServer, User.class);
                log("------>  JsonDeserializer<Integer> 解析:" + user);
            } catch (Exception e) {
                log("------>  JsonDeserializer<Integer> 解析异常:" + e);
            }
    
            Gson gson1=new Gson();
            try {
                User user1 = gson1.fromJson(jsonStrFromServer, User.class);
                log("------> 默认gson 解析:" + user1);
            } catch (Exception e) {
                log("------>  默认gson 解析异常:" + e);
            }
    
    
        }
    }
    

    运行结果:

     

    ------->jsonFromServer:{
        "age": "",
        "name": "zhangsan"
    }
    ------>  JsonDeserializer<Integer> 解析:User{name='zhangsan', age=0}
    ------>  默认gson 解析异常:com.google.gson.JsonSyntaxException: java.lang.NumberFormatException: empty String

     这样定义全局的反序列化工具就能避免解析异常

     

     

    展开全文
  • 域名解析

    万次阅读 2020-01-16 19:25:12
    域名解析时,只能解析IP,用nginx隐射3389服务到域名,下图中添加内网的外网隐射为3389端口,用域名加3389端口就可以访问服务了。 https://test.see.ltd:3389 打开winbox客户端登陆之后,找到“ip”--”...

    域名解析时,只能解析IP,用nginx隐射3389服务到域名,下图中添加内网的外网隐射为3389端口,用域名加3389端口就可以访问服务了。

    https://test.see.ltd:3389

     

    1. 打开winbox客户端登陆之后,找到“ip”--”firewall”防火墙设置

    2. nat里面点击“+”添加规则如下图:

      blob.png

    3. 在一般“general”菜单中,如下图设置。Chain选择dstnat,协议protocl默认即可。Dst.Port是目标端口外网访问的端口,接着是入口选择上网的公网接口

      blob.png

    4. 然后在执行动作action选项设置,选择dst-nat,内网机器IP地址以及内网需要映射的端口

      blob.png

     

    展开全文
  • 抖音短视频去水印解析下载教程

    万次阅读 多人点赞 2018-09-11 16:03:17
    下面提到的地址已经停止服务了,新地址1111,方法一样 /3/28/2019 前言 抖音短视频APP里虽然有保存视频的按钮,但这种方式保存的视频右下角有抖音的水印,并且这种方式不适用于电脑。 所以,写这篇文章来分享...

     

    前言

    抖音短视频APP里虽然有保存视频的按钮,但这种方式保存的视频右下角有抖音的水印,并且这种方式不适用于电脑。

    所以,写这篇文章来分享如何下载没有水印的抖音视频到本地,此方法适用于电脑和手机,且不需要安装任何软件和插件。

    简单的下载方法

    1. 去抖音APP里点开某个视频,点击分享按钮,在分享弹框中点击复制链接或通过分享到微信QQ等获取分享链接。如果是朋友分享给你的链接,直接复制那个分享链接即可。

    2. 然后在浏览器(电脑和手机上都可以)中打开我们需要用到的在线抖音短视频解析下载工具:

    3. 在工具的输入框中粘贴我们刚才复制的地址,然后点击解析视频按钮,解析完成后,就可以下载视频和封面了。

    这种方式下载的视频是没有抖音水印的是不是觉得特别赞,觉得好就分享给更多的朋友知道吧。

    展开全文
  • SBJson解析

    千次下载 热门讨论 2012-08-08 15:21:07
    ios SBJson库解析json文件 解析使用
  • Java解析Excel实例解析

    万次阅读 2017-03-09 10:32:55
    Java解析Excel实例解析
  • 全面详解c语言使用cJSON解析JSON字符

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

    万次阅读 2020-06-29 17:28:56
    地址解析就是将地址(如:贵州省贵阳市)转换为地理坐标(如经度:106.71,纬度:26.57)的过程。 地理反解析和上面的过程相反是将地理坐标(如纬度:26.57,经度:106.71)转换为地址(中国贵州省贵阳市南明区翠微巷7号 ...
  • 使用BeautifulSoup4解析XML

    万次阅读 多人点赞 2018-11-22 10:04:59
    Beautiful Soup 是一个用来从HTML或XML文件中提取数据的Python库,它利用大家所喜欢的解析器提供了许多惯用方法用来对文档树进行导航、查找和修改。 帮助文档英文版:...
  • 经过前几个章节的介绍,终于把与列表解析的前置内容介绍完了,本节老猿将列表解析、字典解析、集合解析进行统一的介绍。 前面章节老猿好几次说到了要介绍列表解析,但老猿认为涉及知识层面比较多,一推再推,给人的...
  • 本文是一个详细的域名解析教程,以NameSilo为例,分别介绍NameSilo自带的域名解析,以及国外的Cloudflare域名解析与国内的DNSPod域名解析。域名解析介绍域名的NS记录(Name Server)是指处理域名解析的服务器,说白...
  • 默认使用 @PropertySource 可以指定解析 properties 和 xml 配置文件,却不可以解析 yaml 配置文件,因为 spring 默认没有 yaml 的解析工厂类,但是我们可以通过实现 PropertySourceFactory 接口自己...
  • XML解析之DOM解析详解

    万次阅读 多人点赞 2018-06-05 16:39:34
    Xml解析有两种方式,一种是DOM解析,另一种是SAX解析,两种操作的方式如图。       二、DOM解析   基于DOM解析的xml分析器是将其转换为一个对象模型的集合,用树这种数据结构对信息进行储存。通过DOM...
  • Java Sax解析xml

    万次阅读 2018-01-23 10:06:24
     SAX,全称Simple API for XML,是一种以事件驱动的XMl API,是XML解析的一种新的替代方法,解析XML常用的还有DOM解析,PULL解析(Android特有),SAX与DOM不同的是它边扫描边解析,自顶向下依次解析,由于边扫描边...
  • 解析ip到对应城市:ipdatabase

    万次阅读 2020-02-18 10:59:50
    解析网络访问日志的时候,ip是不可避免地分析KPI。而有时候需要把访问ip直接转换为对应城市,这样如果自己编写程序,就会浪费很多时间,在此介绍一个有效地开源github项目,可以实现ip到城市的映射。 二、实现...
  • DNS正向解析、反向解析、双向解析

    千次阅读 2019-05-16 00:33:25
    资源记录类型: SOA记录(Start Of Authority record...A 记录(Adress record) ##将域名解析到IPv4的IP地址 AAAA 记录(Adress record) ##将域名解析到IPv6的IP位址 CNAME(Canonical Name record) ##别名记录...
  • Spring解析,加载及实例化Bean的顺序(零配置)

    万次阅读 多人点赞 2018-02-16 14:23:31
    Spring零配置下@Bean,@Import,@ComponentScan形式定义Bean的解析,加载及实例化顺序
  • Xml解析——SAXParser解析

    千次阅读 2018-06-28 16:16:20
    Xml解析方式有两种:XmlPullParser解析、SAXParser解析,本篇介绍SAX解析。SAX解析方式和Pull方式不同,它不是利用游标一行一行地解析,而是利用消息处理机制,遇到什么就处理什么。比如当我们处理XML数据中遇到一个...
  • error LNK2019: 无法解析的外部符号

    万次阅读 多人点赞 2018-08-06 12:50:38
    11_ObjectDetection.obj : error LNK2019: 无法解析的外部符号 “public: __cdecl cv::VideoCapture::VideoCapture(void)” (??0VideoCapture@cv@@QEAA@XZ),该符号在函数 main 中被引用 1&amp;gt;11_Object...
  • 文件解析漏洞

    千次阅读 2018-09-25 08:40:27
    文件解析漏洞 IIS解析漏洞 目录解析漏洞(/test.asp/1.jpg) 文件名解析漏洞(test.asp;.jpg) 畸形解析漏洞(test.jpg/*.php) 其他解析漏洞 Ngnix解析漏洞 畸形解析漏洞(test.jpg/*.php) %00空字节代码解析漏洞 ...
  • DNS递归解析和迭代解析的区别

    千次阅读 2018-12-02 15:40:55
    11.3.7 DNS递归解析原理 “递归解析”(或叫“递归查询”,其实意思是一样的)是最常见,也是默认的解析方式。在这种解析方式中,如果客户端配置的本地名称服务器不能解析的话,则后面的查询全由本地名称服务器...
  • 解析函数

    千次阅读 2018-11-22 12:46:44
    文章目录一、解析函数的概念学习目标1、复变函数的导数2、解析函数的概念二、解析函数的充要条件学习目标三、初等函数学习目标 一、解析函数的概念 学习目标 会用求导定义公式求导 函数在一点解析的定义 函数...
  • XML解析工具 DOM解析原理: 1)JAXP (oracle-Sun公司官方) 2)JDOM工具(非官方) 3)Dom4J工具(非官方) 三大框架(默认读取xml的工具就是Dom4j) ....... SAX解析原理: 1)Sax解析工具(oracle-sun公司...
  • 淘口令解析

    千次阅读 2019-07-10 19:51:35
    淘口令解析,首先获取淘宝复制的淘口令信息,过滤无用信息,开始解析淘口令具体代码如下: demo链接地址:https://download.csdn.net/download/wanmeizty/11286264 /** * 解析淘口令 * @param commondSt...
  • PDF电子发票解析成excel,支持批量解析和导出功能

    万次阅读 多人点赞 2018-12-07 17:31:04
    PDF电子发票解析成excel,支持批量解析和导出功能 https://www.promiseblog.cn/tool/pdfParse https://www.promiseblog.cn 入口: 单张发票解析---解析步骤: 单张解析完成! 接下来介绍批量...
  • 域名内网解析和外网解析

    千次阅读 2020-02-29 15:47:00
    域名内网解析和外网解析 1、有时候我们通过cmd中的nslookup去解析相同的域名,得到的IP为不同值,这个原因很大可能是你公司有内网DNS和外网DNS,当你设置本地机器为内网DNS时,解析到的是内网的地址,设置为外网DNS...
  • 文章目录硬解析和软解析shared pool功能shared pool组成SQL语句 硬解析和软解析 Oracle数据信息全部存储在数据字典中, Oracle的解析有两种,软解析以及硬解析解析 hard parse 没有缓存进入硬解析解析内容...
  • springboot如何解析邮箱

    万次阅读 2020-11-19 22:14:48
    使用pop3协议解析邮箱 package com.domain.util; import javax.mail.*; import javax.mail.internet.InternetAddress; import javax.mail.internet.MimeMessage; import javax.mail.internet.MimeMultipart; ...
  • 今天给大家带来的是DNS域名解析服务的内容,将从以下几个内容来进行解析: 1、BIND域名服务基础:DNS系统的作用及类型BNID的安装和配置文件2、使用BIND构建域名或服务器:构建缓存域名服务器构建主、从域名服务器 ...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 932,322
精华内容 372,928
关键字:

解析