JsonDeserializer——Gson自定义解析类型错误的字段

在开发中，定义好实体类和相应字段，Gson就可以很方便地帮助我们实现序列化和反序列化。

可是有时候，后台传给客户端的json数据格式有误，其中的某些字段类型错误，即，和我们在实体类中定义的字段类型不一致，此时就会出现类型转换错误，app原地爆炸！

假设有这么一个类Phone代表手机：

/**
 * Author: Sbingo
 * Date:   2017/4/23
 */

public class Phone {

    /**
     * 手机大小
     */
    private Size size;
    /**
     * 手机内app列表
     */
    private List<App> apps;

    public Size getSize() {
        return size;
    }

    public void setSize(Size size) {
        this.size = size;
    }

    public List<App> getApps() {
        return apps;
    }

    public void setApps(List<App> apps) {
        this.apps = apps;
    }
}

其中类Size如下：

/**
 * Author: Sbingo
 * Date:   2017/4/23
 */

class Size {

        private String length;
        private String width;
        private String height;

        public String getLength() {
            return length;
        }

        public void setLength(String length) {
            this.length = length;
        }

        public String getWidth() {
            return width;
        }

        public void setWidth(String width) {
            this.width = width;
        }

        public String getHeight() {
            return height;
        }

        public void setHeight(String height) {
            this.height = height;
        }
    }

类App如下：

/**
 * Author: Sbingo
 * Date:   2017/4/23
 */

class App {
        private String appName;
        private String developer;

        public String getAppName() {
            return appName;
        }

        public void setAppName(String appName) {
            this.appName = appName;
        }

        public String getDeveloper() {
            return developer;
        }

        public void setDeveloper(String developer) {
            this.developer = developer;
        }
    }

对于类Phone，实际中我碰到的数据类型错误情况有：

对象size变成了字符串；

数组apps变成了字符串；

下面将会针对这两种错误分别讨论，其他错误可以类似处理。

当然这里的字符串是带有转义字符的json字符串，还是包含正确信息的。因此以下对字符串的处理可能只适应这种错误情况。

如何解决这一问题？

最好的办法当然是后台确保数据类型正确，从源头上消灭问题。

作为客户端开发，我们也要做好错误处理，应对各种场景。

客户端怎么处理？

registerTypeAdapter

其实Gson允许我们自定义解析某种类型的数据，一般我们使用Gson可能就直接new出来一个，但如果这样实例化：

Gson gson = new GsonBuilder()
            .registerTypeAdapter(A.class, new ADeserializer())
            .registerTypeAdapter(B.class, new BDeserializer())
            .create()

得到的gson就会使用自定义的ADeserializer和BDeserializer分别反序列化类A和类B。

`registerTypeAdapter 方法用于配置Gson的序列化或反序列化，接收两个参数。

第一个参数是注册的类型，即希望自定义解析的数据类型。

第二个参数包含了自定义的解析过程，它必须至少是TypeAdapter、InstanceCreator、JsonSerializer、JsonDeserializer四者之一的实现。

JsonDeserializer

泛型接口JsonDeserializer中的方法deserialize允许我们自定义反序列化过程，返回相对应的对象。

该方法接收三个参数，Gson会在进行相应类型字段的反序列化时回调该方法。

第一个参数类型为JsonElement，其中包含了真实返回的数据，它是一个抽象类，可以是JsonObject、JsonArray、JsonPrimitive、JsonNull四者之一，看名字也能知道这四者的大致类型。

第二个参数是当前反序列化的数据类型。

第三个是上下文参数context。

在自定义反序列化时，我们要分别处理数据类型正确和错误的情况，具体处理过程视数据而定，以下仅供参考。

错误一：对象size变成了字符串

字段size为Size对象类型，当后台接口返回了字符串时，可以只对Size类型自定义反序列化，如下：

/**
 * Author: Sbingo
 * Date:   2017/4/23
 */

public class SizeDeserializer implements JsonDeserializer<Size> {
    @Override
    public Size deserialize(JsonElement json, Type typeOfT, JsonDeserializationContext context) throws JsonParseException {
        Size size = new Size();
        if (json.isJsonObject()) {
            //类型正确
            JsonObject jsonObject = json.getAsJsonObject();
            size.setLength(jsonObject.get("length").getAsString());
            size.setWidth(jsonObject.get("width").getAsString());
            size.setHeight(jsonObject.get("height") == null ? "" : jsonObject.get("height").getAsString());
        } else {
            //类型错误
            String value = json.getAsString();
            size = new Gson().fromJson(value, Size.class);
        }
        return size;
    }
}

泛型参数传入Size，当反序列化Size对象时，就会回调我们自定义的方法。

首先用isJsonObject()判断是否为对象

如果是，说明类型正确，接着依次设置各字段值。如果有些字段接口可能不会返回，记得判空，例如字段height。

如果类型错误，我遇到的错误情况只会是带有转义字符的字符串，所以直接按此处理了。调用json.getAsString()就能得到正确的json字符串，再通过Gson直接转换为Size类型。

这样不管接口返回数据中字段size类型正确与否，都能从容应对！

错误二：数组apps变成了字符串

字段apps是一个list，接口应该返回一个数组，如果类型错误，可以有两种方式来自定义解析，在我看来，这两种各有优劣，具体使用要结合实际。

自定义解析字段本身

这种方法和解析size类似，都是本着“谁类型错了，就解析谁”的原则。

由于没有找到用List作为泛型参数的方法，所以需要把类Phone中的字段apps从list改成数组，如果真只能改成数组，使用方便性可能较list略差。

定义AppDeserializer如下：

/**
 * Author: Sbingo
 * Date:   2017/4/23
 */

public class AppDeserializer implements JsonDeserializer<App[]> {


    @Override
    public App[] deserialize(JsonElement json, Type typeOfT, JsonDeserializationContext context) throws JsonParseException {
        if (json.isJsonArray()) {
            //类型正确
            JsonArray jsonArray = json.getAsJsonArray();
            App[] apps = new App[jsonArray.size()];
            for (int i = 0; i < jsonArray.size(); i++) {
                App app = new App();
                //获取app方法一
                JsonObject jsonObject = jsonArray.get(i).getAsJsonObject();
                app.setAppName(jsonObject.get("appName") == null ? "" : jsonObject.get("appName").getAsString());
                app.setDeveloper(jsonObject.get("developer") == null ? "" : jsonObject.get("developer").getAsString());
                //获取app方法二
//                app = context.deserialize(jsonObject, App.class);
                apps[i] = app;
            }
            return apps;
        } else if (json.isJsonObject()) {
            //类型错误1
            return null;
        } else if (json.isJsonPrimitive()) {
            //类型错误2，多为String
            String value = "";
            try {
                value = json.getAsString();
            } catch (Exception e) {
                e.printStackTrace();
            }
            if ("".equals(value)) {
                return null;
            } else {
                App[] apps = new Gson().fromJson(value, App[].class);
                return apps;
            }
        } else {
            //一般不出现这种情况
            return null;
        }
    }
}

泛型参数传入数组，当反序列化App类型的数组时，就会回调我们自定义的方法。

首先用isJsonArray()类型是否正确，正确时获取数组也有两种方法，如代码所示，

方法一和之前的分析差不多。

方法二注意context反序列化时要避免进入死循环。

类型错误时做了较多区分，具体还是要看实际情况。

自定义解析字段所在类

这种方法以错误字段apps所在类Phone为处理类型，好处是字段apps还是可以用list，但如果类中很多其他字段，工作量就大了一些，幸好此处只还有一个size。

定义AppListDeserializer如下：

/**
 * Author: Sbingo
 * Date:   2017/4/23
 */

public class AppListDeserializer implements JsonDeserializer<Phone> {
    @Override
    public Phone deserialize(JsonElement json, Type typeOfT, JsonDeserializationContext context) throws JsonParseException {
        Phone phone = new Phone();
        JsonObject jsonObject = json.getAsJsonObject();
        //此时不考虑size的类型错误情况
        if (jsonObject.get("size") != null) {
            jsonObject = jsonObject.get("size").getAsJsonObject();
            Size size = context.deserialize(jsonObject, Size.class);
            phone.setSize(size);
        }
        JsonElement appsArray = jsonObject.get("apps");
        if (appsArray != null) {
            List<App> apps = new ArrayList<>();
            if (appsArray.isJsonArray()) {
                //类型正确
                JsonArray jsonArray = appsArray.getAsJsonArray();
                for (int i = 0; i < jsonArray.size(); i++) {
                    JsonObject jo = jsonArray.get(i).getAsJsonObject();
                    App app = context.deserialize(jo, App.class);
                    apps.add(app);
                }
            } else {
                //类型错误
                String value = appsArray.getAsString();
                App[] a = new Gson().fromJson(value, App[].class);
                apps = Arrays.asList(a);
            }
            phone.setApps(apps);
        }
        return phone;
    }
}

泛型参数传入Phone，当反序列化Phone类型数据时，就会回调我们自定义的方法。

因为这里处理的是字段apps，所以不考虑字段size的类型正确与否。

Phone可以确定是个对象，所以直接用getAsJsonObject()方法获取一个JsonObject。

之后分别设置字段size和apps，其中用到的一些方法和上面类似。

JsonDeserializer自定义反序列化的思路大致就是这样，以后处理类似错误自当666。