首先用Gson解析实体类好办，直接用
 
new Gson().fromJson(jsonString,object.class);
 
 但是如果我们想要解析，一个 String[] 类型的数组能显然用如下代码，是解析不出来的。
 
new Gson().fromJson(jsonString,String.class);
 
 自然它肯定有解决的办法,我们用如下代码，此时String[]当成一个实体类。
 
new Gson().fromJson(jsonString,String[].class);
 
 这时我们可能会想那我们的集合可不可以也用这种方法啊呢！来看看这段代码 
 
new Gson().fromJson(jsonString,List<Object>.class)
 
看起来没毛病但是写代码是就报错如下图
 
 
对于Java来说List<String>和List<User>这俩个的字节码文件只一个那就是List.class，这是Java泛型使用时要注意的问题 泛型擦除。
 当然有解决办法：
 
new Gson().fromJson(jsonArray, new TypeToken<List<Object>>(){}.getType());
 
或者
 
// List
Type type = new TypeToken<List<Object>>() {}.getType();
List<Object> list = gson.fromJson(record, type);

// Map
Type type = new TypeToken<Map<String, NetVO>>() {}.getType();
Map<String, NetVO> map = gson.fromJson(record, type);
 
Gson为我们提供了TypeToken来实现对泛型的支持，

 
 
五种方法解析各种情况下的JSON数组
 
"muser": [
    {
      "name": "zhangsan",
      "age": "10",
      "phone": "11111",
      "email": "11111@11.com"
    },
    ...
]
 
这里的 "muser" ，就是数组的名称，称它为数据头，防止跟里面的字段有歧义
如果没有数据头，那就叫它纯数据，或者纯数组数据
代码中用到的JsonArray/JsonObject等都来自GSON
没有数据头的纯数组JSON如何解析？
 
解析的JSON数组（JsonArray）：
 
[
  {
    "name": "zhangsan",
    "age": "10",
    "phone": "11111",
    "email": "11111@11.com"
  },
  {
    "name": "lisi",
    "age": "20",
    "phone": "22222",
    "email": "22222@22.com"
  },
  ...
]
 
这种JSON数组格式，强大的GSON会直接解析成一个List。但是这里我们先用原始的方法去解析。
 
首先我们需要建立一个Bean对象，注意变量名和字段名称一致（不一致时，可以使用序列化）：
public class UserBean {
    //变量名跟JSON数据的字段名需要一致
    private String name ;
    private String age;
    private String phone;
    private String email;
    ...
}
 
解析过程：
/**
 * 解析没有数据头的纯数组
 */
private void parseNoHeaderJArray() {
    //拿到本地JSON 并转成String
    String strByJson = JsonToStringUtil.getStringByJson(this, R.raw.juser_1);

    //Json的解析类对象
    JsonParser parser = new JsonParser();
    //将JSON的String 转成一个JsonArray对象
    JsonArray jsonArray = parser.parse(strByJson).getAsJsonArray();

    Gson gson = new Gson();
    ArrayList<UserBean> userBeanList = new ArrayList<>();

    //加强for循环遍历JsonArray
    for (JsonElement user : jsonArray) {
        //使用GSON，直接转成Bean对象
        UserBean userBean = gson.fromJson(user, UserBean.class);
        userBeanList.add(userBean);
    }
    mainLView.setAdapter(new UserAdapter(this, userBeanList));
}
 
步骤如下：
 
无论JSON来自本地还是网络获取，都要先将JSON转化成String;
需要一个JSON解析类对象将JSON字符串转换成JsonArray,前提是我们知道JSON 中只有纯数组；
循环遍历JsonArray,并用Gson解析成相应的对象
注意：
 
JsonParse，这是一个解析类它可以把json数据分别通过getAsJsonObject和getAsJsonArray解析成JsonObject和JsonArray.
JsonElement,一个抽象类，代表JSON串中的某一个元素，
有数据头的纯数组数据改如何解析？
 
内容和上面的JSON一样，只不过是加了一个名称“muser”，也就是约定好的数据头：
 
{
  "muser": [
    {
      "name": "zhangsan",
      "age": "10",
      "phone": "11111",
      "email": "11111@11.com"
    },
    {
      "name": "lisi",
      "age": "20",
      "phone": "22222",
      "email": "22222@22.com"
    },
    ...
  ]
}
 
解析过程：
 
/**
 * 解析有数据头的纯数组
 */
private void parseHaveHeaderJArray() {
    //拿到本地JSON 并转成String
    String strByJson = JsonToStringUtil.getStringByJson(this, R.raw.juser_2);

    //先转JsonObject
    JsonObject jsonObject = new JsonParser().parse(strByJson).getAsJsonObject();
    //再转JsonArray 加上数据头
    JsonArray jsonArray = jsonObject.getAsJsonArray("muser");

    Gson gson = new Gson();
    ArrayList<UserBean> userBeanList = new ArrayList<>();

    //循环遍历
    for (JsonElement user : jsonArray) {
        //通过反射 得到UserBean.class
        UserBean userBean = gson.fromJson(user, new TypeToken<UserBean>() {}.getType());
        userBeanList.add(userBean);
    }
    mainLView.setAdapter(new UserAdapter(this, userBeanList));
}
 
TypeToken
它其实是一个匿名内部类，官方解释：Gson提供了TypeToken这个类来帮助我们捕获像list这样的泛型信息。java编译器就会把捕获到的泛型信息编译到这个匿名内部类中，然后再运行时就会被getType（）方法用反射的API提取到。其实就是将T转成.class。
 
有数据头的复杂数据该如何解析？
 
{
  "code": 200,
  "msg": "OK",
  "muser": [
    {
      "name": "zhangsan",
      "age": "10",
      "phone": "11111",
      "email": "11111@11.com"
    },
    {
      "name": "lisi",
      "age": "20",
      "phone": "22222",
      "email": "22222@22.com"
    },
    ...
  ]
}
 
根据json建立Bean,注意这里的Bean是返回所有的字段，因为GSON能直接解析成list,所以Bean是下面这样的，
/**
 * Created by xiarui on 2016/8/30.
 * 返回所有结果的Bean
 */
public class ResultBean {
    //注意变量名与字段名一致
    private int code;
    private String msg;
    private List<UserBean> muser;

    public class UserBean{
        private String name ;
        private String age;
        private String phone;
        private String email;
        ...
    }
    ...
}
 
注意，这里ResultBean里面有一个UserBean,虽然和上面两种的内容一样，但是作用不一样，这里作为JsonArray解析后存入List中的对象。
 
/**
 * 有消息头 复杂数据 常规方式
 */
private void parseComplexJArrayByCommon() {
    //拿到Json字符串
    String strByJson = JsonToStringUtil.getStringByJson(this, R.raw.juser_3);
    //GSON直接解析成对象
    ResultBean resultBean = new Gson().fromJson(strByJson,ResultBean.class);
    //对象中拿到集合
    List<ResultBean.UserBean> userBeanList = resultBean.getMuser();
    //展示到UI中
    mainLView.setAdapter(new ResultAdapter(this, userBeanList));
}
 
 
 
直接解析复杂JSON中的数组或数组中的某部分内容
 
{
  "code": 200,
  "msg": "OK",
  "muser": [
    {
      "name": "zhangsan",
      "age": "10",
      "phone": "11111",
      "email": "11111@11.com"
    },
    {
      "name": "lisi",
      "age": "20",
      "phone": "22222",
      "email": "22222@22.com"
    },
    ...
  ]
}
 
假如只想取“muser”这个数组中的年龄大于30岁该怎么做？
 
第一点肯定就是刚才提到的遍历，这个很好理解，所以我们先要取这一个数组（JsonArray），那么如何取呢？还记得之前提到的 JsonParse 么，它的 getAsJsonArray() 可以传入 数据头 拿到数组，当然不要忘了最外面一层是个 JsonObject 。
拿到数组以后，我们就可以遍历了，经过第一二招的洗礼，相信在遍历上，应该没什么问题了，使用的还是之前提到的 JsonElement 。
完整代码：
 
/**
 * 有数据头 复杂数据 截取方式
 */
private void parseComplexJArrayByDirect() {
    //拿到JSON字符串
    String strByJson = JsonToStringUtil.getStringByJson(this, R.raw.juser_3);
    List<UserBean> userBeanList = new ArrayList<>();

    //拿到数组
    JsonObject jsonObject = new JsonParser().parse(strByJson).getAsJsonObject();
    JsonArray jsonArray = jsonObject.getAsJsonArray("muser");

    //循环遍历数组
    for (JsonElement user : jsonArray) {
        UserBean userBean = new Gson().fromJson(user, new TypeToken<UserBean>() {
        }.getType());
        //根据条件过滤
        if (Integer.parseInt(userBean.getAge()) > 30) {
            userBeanList.add(userBean);
        }
    }
    mainLView.setAdapter(new UserAdapter(this, userBeanList));
}
 
 
 
解析一个很复杂的JSON数据
 
{
  "group": {
    "user": {
      "name": "张三",
      "age": "10",
      "phone": "11111",
      "email": "11111@11.com"
    },
    "info": {
      "address": "北京",
      "work": "Android Dev",
      "pay": "10K",
      "motto": "先定一个小目标，比如我先赚一个亿"
    }
  }
}
 
解析过程
 
/**
 * 通过JsonReader的方式去解析
 */
private void parseComplexJArrayByReader() throws IOException {
    String strByJson = JsonToStringUtil.getStringByJson(this, R.raw.juser_4);
    JsonReader reader = new JsonReader(new StringReader(strByJson));
    try {
        reader.beginObject();
        String tagName = reader.nextName();
        if (tagName.equals("group")) {
            //读group这个节点
            readGroup(reader);
        }
        reader.endObject();
    } finally {
        reader.close();
    }
}

/**
 * 读group这个节点
 *
 * @param reader JsonReader
 */
private void readGroup(JsonReader reader) throws IOException {
    reader.beginObject();
    while (reader.hasNext()) {
        String tagName = reader.nextName();
        if (tagName.equals("user")) {
            readUser(reader);
        } else if (tagName.equals("info")) {
            readInfo(reader);
        }
    }
    reader.endObject();
}

/**
 * 读用户基本消息 user节点
 *
 * @param reader JsonReader
 */
private void readUser(JsonReader reader) throws IOException {
    reader.beginObject();
    while (reader.hasNext()) {
        String tag = reader.nextName();
        if (tag.equals("name")) {
            String name = reader.nextString();
            nameText.setText(name);
        } else if (tag.equals("age")) {
            String age = reader.nextString();
            ageText.setText(age);
        } 
        ...
        else {
            reader.skipValue();//忽略
        }
    }
    reader.endObject();
}

/**
 * 读用户其他消息 info节点
 *
 * @param reader JsonReader
 */
private void readInfo(JsonReader reader) throws IOException {
    reader.beginObject();
    while (reader.hasNext()) {
        String tag = reader.nextName();
        if (tag.equals("address")) {
            String address = reader.nextString();
            addressText.setText(address);
        } else if (tag.equals("work")) {
            String work = reader.nextString();
            workText.setText(work);
        } 
        ...
        else {
            reader.skipValue();//忽略
        }
    }
    reader.endObject();
}
 
过程有省略。。。。
 
参考：http://blog.csdn.net/qq_35114086/article/details/52705817
 
https://www.tuicool.com/articles/FrI3uq
 
http://blog.csdn.net/tkwxty/article/details/34474501/
 
http://blog.csdn.net/chunqiuwei/article/details/49160321
 
http://www.myexception.cn/program/1909359.html
 
 

一、背景
 
一般我们在进行网络请求拿到返回结果之后，我们期望能够转化成对应的Java实体类，在这个转化过程中，可以使用自动解析的方式，也可以使用三方提供的工具类，比如Gson、FastJson等。
 
针对于Gson解析，可能都有遇到某个字段类型不匹配导致整个json解析失败的问题，这不是我们期望的，我们期望的是一个字段解析失败不影响其他字段的解析。
 
那这种情况下怎么办呢？
 
下面就是踩坑记录和解决方案
 
二、问题 & 解决方案
 
1. 绕过Kotlin非空判断问题
 
问题描述
 
data class User(
        val name: String = "",  //String类型
        val age: Int,           //Kotlin Int类型，不加？会转换成java的int类型，加？会转换成Integer类型
        val bad: Boolean,       //Kotlin Boolean类型，不加？会转换成java的boolean类型，加？会转换成Boolean类型
        val relation: String = "",
        val friends: User,      //对象类型
        val family: List<User>  //数组类型
)
 
 
fun main() {
    val gson = GsonBuilder().create()
 
    val jsonStr = "{}"
    val user = gson.fromJson(jsonStr, User::class.java)
    println(user)
}
 
猜想一下上面打印出来的结果是什么？
 
答案是: User(name=null, age=0, bad=false, relation=null, friends=null, family=null)
 
可以看到我们声明的各种属性包含String类型，对象类型，数组类型，都是非空的，但是解析出来的结果却是null, 这并不符合我们的预期，如果这样的代码上线了，线上肯定崩溃无疑。
 
并且如果我们把age和bad属性添加?标识的话，我们将会得到下面的结果
 
User(name=null, age=null, bad=null, relation=null, friends=null, family=null)
 
所有的都变成null了。
 
那为什么会这样呢？针对这种情况，网上也能搜到对应文章说明
 https://blog.csdn.net/lmj623565791/article/details/106631386
 
我们知道Kotlin data class类所有属性都赋初始值的时候，才会默认生成无参构造方法
 
由于上面的User类并没有所有的属性都赋初始值，最终导致生成的类没有无参的构造方法，而Kotlin data class的赋初始值的逻辑是在构造方法中实现的
 
Gson在没有找到默认构造方法时，它就直接通过Unsafe的方法，绕过了构造方法，直接构建了一个对象。
 
正是由于没走构造方法，所以默认值也不会被设置，最终数据的值就是Java中针对引用数据类型和基本数据类型对应的默认值了，即引用类型默认为null, 基本数据类型int 默认为0， boolean 默认为false
 
那在平常的开发过程中我们怎么避免此类问题发生呢？
 
解决方案
 
data class的类所有属性都赋初始值，保证生成无参构造函数，使得默认值能够生效
对于引用数据类型尽量声明成可空类型，尽量确保程序可靠性
对于基本数据类型尽量声明成非可空类型，尽量减少内存消耗
 
所以针对上面的User类，我们应该尽量写成以下方式
 
//所有属性都赋初始值
@Keep  //保持不被混淆
data class User(
        val name: String? = "",
        val age: Int = 0,
        val bad: Boolean = false,
        val relation: String? = "",
        val friends: User? = null,
        val family: List<User>? = null
)
 
这样的话，上面打印出来的结果为：
 
User(name=, age=0, bad=false, relation=, friends=null, family=null)
 
另外一种解决方案就是：不使用data class, 而是直接使用class, 然后在类里面去声明对应的属性
 
这种情况下对应属性必须赋初始值，并且会默认有无参的构造方法
 
class User {
    private val name: String? = ""
    private val age: Int = 0
    private val bad: Boolean = false
    private val relation: String? = ""
    private val friends: User? = null
    private val family: List<User>? = null
 
    override fun toString(): String {
        return "User(name=$name, age=$age, bad=$bad, relation=$relation, friends=$friends, family=$family)"
    }
}
 
2. 类型不匹配导致解析失败问题
 
fun main() {
    val gson = GsonBuilder().create()
 
 
    val jsonStr = "{'name':'Coder','age':'aaa'}"    // 1
//  val jsonStr = "{'name':'Coder','friends':[]}"   // 2
//  val jsonStr = "{'name':'Coder','family':{}}"    // 3
    val user = gson.fromJson(jsonStr, User::class.java)
    println(user)
}
 
针对上面三种情况，会发生什么样的结果？
 
 
 可以看到这3中情况都会导致异常，程序不能正常运行
 
但是实际情况中这种情况又不可能避免，服务端那边使用的是弱类型语言的话，这种情况发生的概率极大，端上不能完全依靠服务端去保证，不然crash率就会蹭蹭往上涨。
 
解决方案
 
自定义 TypeAdapterFactory
 
gson 库会通过JsonReader对json对象的每个字段进项读取,当发现类型不匹配时抛出异常
 
那么我们就在它抛出异常的时候进行处理,让它继续不中断接着往下读取其他的字段就好了
 
具体代码为:
 
public class GsonTypeAdapterFactory implements TypeAdapterFactory {
    @Override
    public <T> TypeAdapter<T> create(Gson gson, TypeToken<T> type) {
        final TypeAdapter<T> adapter = gson.getDelegateAdapter(this, type);
        return new TypeAdapter<T>() {
            @Override
            public void write(JsonWriter out, T value) throws IOException {
                adapter.write(out, value);
            }
 
            @Override
            public T read(JsonReader reader) throws IOException {
                try {
                    return adapter.read(reader);
                } catch (Throwable e) {
                    e.printStackTrace();
                    if (reader.hasNext()) {
                        JsonToken peek = reader.peek();
                        if (peek == JsonToken.NAME) {
                            reader.nextName();
                        } else {
                            reader.skipValue();
                        }
                    }
                    return null;
                }
            }
        };
    }
}
 
 
fun main() {
    val gson = GsonBuilder().registerTypeAdapterFactory(GsonTypeAdapterFactory()).create()  //gson创建的时候registerTypeAdapterFactory
 
    val jsonStr = "{'name':'Coder','age':'aaa'}"    // 1 
//  val jsonStr = "{'name':'Coder','friends':[]}"   // 2
//  val jsonStr = "{'name':'Coder','family':{}}"    // 3
    val user = gson.fromJson(jsonStr, User::class.java)
    println(user)
}
 
这种写法，上面三种情况都不会报错，并且最终解析的结果为:
 
User(name=Coder, age=0, bad=false, relation=, friends=null, family=null)

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

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