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，你的关注和支持是每一个技术人前进的动力。

博客请点击周将的博客查看。
Github请点击Android进阶指南查看

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

且有大量模板 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

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

 

 

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

https://test.see.ltd:3389

 


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

	
nat里面点击“+”添加规则如下图：

	

	
	

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

	

	
	

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

	

	
 

 

前言

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

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

简单的下载方法

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

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

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

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