Android Retrofit：如何对JSON中POJO未定义字段触发警告？

其实Retrofit本身不负责JSON解析的逻辑，它是依赖Gson、Moshi这类序列化库来完成解析工作的。默认情况下这些库都会直接忽略POJO中未定义的JSON字段，要实现警告功能，得从序列化库的配置入手，下面分两种主流库给你说具体做法：

一、用Gson作为解析器的情况 #

Gson在2.8.6及以上版本提供了setOnUnknownFieldListener方法，可以直接监听未知字段并打印警告日志，步骤非常简单：

1. 先构建一个带监听逻辑的Gson实例：

Gson gson = new GsonBuilder()
    .setOnUnknownFieldListener((fieldName, context) -> {
        // 自定义警告内容，清晰展示未知字段名和对应的POJO类
        Log.w("Retrofit警告", String.format("发现未在POJO中定义的JSON字段: %s，所属类: %s", 
            fieldName, context.getRawType().getName()));
    })
    .create();

2. 把这个配置好的Gson实例传给Retrofit的转换器：

Retrofit retrofit = new Retrofit.Builder()
    .baseUrl("你的API基础地址")
    .addConverterFactory(GsonConverterFactory.create(gson))
    .build();

这样配置后，只要JSON里出现POJO没定义的字段，Logcat里就会弹出对应的警告，你就能及时发现API新增了哪些字段。

二、用Moshi作为解析器的情况 #

Moshi默认遇到未知字段会直接抛出JsonDataException导致崩溃，如果只想打警告而不崩溃，需要自定义一个适配器工厂来检测未知字段：

1. 构建带自定义逻辑的Moshi实例：

Moshi moshi = new Moshi.Builder()
    .add(new JsonAdapter.Factory() {
        @Override
        public JsonAdapter<?> create(Type type, Set<? extends Annotation> annotations, Moshi moshi) {
            JsonAdapter<Object> delegate = moshi.nextAdapter(this, type, annotations);
            return new JsonAdapter<Object>() {
                @Override
                public Object fromJson(JsonReader reader) throws IOException {
                    // 先关闭"未知字段崩溃"的默认行为
                    reader.setFailOnUnknown(false);
                    // 记录当前解析路径，后续要还原保证默认解析正常工作
                    JsonReader.Path previousPath = reader.getPath();
                    
                    // 遍历JSON对象的所有字段
                    reader.beginObject();
                    while (reader.hasNext()) {
                        String fieldName = reader.nextName();
                        // 检查当前POJO类是否包含这个字段（支持@Json注解的自定义字段名）
                        if (!isFieldExist(type, fieldName)) {
                            Log.w("Retrofit警告", String.format("发现未在POJO中定义的JSON字段: %s，所属类: %s",
                                fieldName, type.getTypeName()));
                        }
                        reader.skipValue(); // 跳过当前值，后续交给默认解析器处理
                    }
                    reader.endObject();
                    
                    // 还原解析路径，让默认解析器正常工作
                    reader.setPath(previousPath);
                    return delegate.fromJson(reader);
                }

                @Override
                public void toJson(JsonWriter writer, Object value) throws IOException {
                    delegate.toJson(writer, value);
                }

                // 递归检查类和父类是否包含目标字段
                private boolean isFieldExist(Type type, String fieldName) {
                    if (!(type instanceof Class<?>)) return false;
                    Class<?> clazz = (Class<?>) type;
                    
                    // 检查当前类的字段
                    for (Field field : clazz.getDeclaredFields()) {
                        Json jsonAnno = field.getAnnotation(Json.class);
                        if (jsonAnno != null && jsonAnno.name().equals(fieldName)) {
                            return true;
                        }
                        if (field.getName().equals(fieldName)) {
                            return true;
                        }
                    }
                    
                    // 检查父类字段
                    Class<?> superClass = clazz.getSuperclass();
                    if (superClass != null && superClass != Object.class) {
                        return isFieldExist(superClass, fieldName);
                    }
                    return false;
                }
            };
        }
    })
    .build();

2. 把这个Moshi实例传给Retrofit：

Retrofit retrofit = new Retrofit.Builder()
    .baseUrl("你的API基础地址")
    .addConverterFactory(MoshiConverterFactory.create(moshi))
    .build();

这样配置后，Moshi遇到未知字段就会打印警告日志，而不是直接抛出异常导致崩溃。

如果你用的是其他序列化库（比如Jackson），思路也是类似的：找到对应库的未知字段监听配置，把默认的"忽略"逻辑改成"打印警告"即可。

内容的提问来源于stack exchange，提问作者Theano T