用Gson反序列化一个复杂的JSON（几个嵌套元素）

Question

我想将一个JSON对象（来自一个API）反序列化到它们各自的Java对象中。我正在使用gson库（对于Android）。事情是，我已经尝试了好几天，并且没有运气测试了很多种选择，所以我真的很感谢这一点的帮助。

*检索到JSON。所有我从API收到JSONs遵循以下结构：

{ 
"status_code": 200, 
"status_message": "Here the status message", 
"result": { 
    "success": true, 
    "internalStatusCall": 1, 
    "response": 
      /* Can be a JSON object or a JSON array of objects */ 
    } 
} 

由于所有JSONs的结构收到有异曲同工之处，我想利用这个优势并扩展对象从JSON映射。

我想的东西，如：

public class TABaseObject { 

@SerializedName("status_code") 
protected int status_code; 

@SerializedName("status_message") 
protected String status_message; 

protected String type; 

public TABaseObject(int status_code, String status_message, String type) { 
    this.status_code = status_code; 
    this.status_message = status_message; 
    this.type = type; 
} 
} 

从此对象扩展，内部对象是：

public class TAResultObject extends TABaseObject{ 

@SerializedName("exito") 
protected boolean exito; 

@SerializedName("codigoEstado") 
protected int codigoEstado; 

public TAResultObject(int status_code, String status_message, boolean exito, int codigoEstado) { 
    super(status_code, status_message, "resultado"); 
    this.exito = exito; 
    this.codigoEstado = codigoEstado; 
} 

@Override 
public String toString() { 
    return super.toString() + " ////// " + "TAResultObject{" + 
      "exito=" + exito + 
      ", codigoEstado=" + codigoEstado + 
      '}'; 
} 

，并从该其他对象，我将扩展TAResultObject到通信对象。

我已经尝试了几种反序列化方法（TypeAdapterFactory，RuntimeTypeAdapterFactory等），没有运气。

是否有任何策略能够反序列化提到的JSON。我真的很感谢任何帮助。

Answer 1

这是我与响应级的解决方案，

import java.util.List; 
import java.util.Map; 

import com.google.gson.annotations.SerializedName; 

    public class TAObject { 

     @SerializedName("status_code") 
     Integer status_code ; 

     @SerializedName("status_message") 
     String status_message ; 

     @SerializedName("result") 
     Result result ; 

     public class Result { 

      @SerializedName("success") 
      Boolean success ; 

      @SerializedName("internalStatusCall") 
      Integer internalStatusCall ; 

      @SerializedName("response") 
      List<Map> response ; 

     } 
    } 

使用这个类使用自定义TypeAdapter沿着GSON。然后将两个表工作，物体响应。

一个ArrayAdapter类

import com.google.gson.Gson; 
import com.google.gson.GsonBuilder; 
import com.google.gson.TypeAdapter; 
import com.google.gson.stream.JsonReader; 
import com.google.gson.stream.JsonToken; 
import com.google.gson.stream.JsonWriter; 

import java.io.IOException; 
import java.util.ArrayList; 
import java.util.List; 


class ArrayAdapter<T> extends TypeAdapter<List<T>> { 

    private Class<T> adapterclass; 

    public ArrayAdapter(Class<T> adapterclass) { 
     this.adapterclass = adapterclass; 
    } 

    @Override 
    public List<T> read(JsonReader reader) throws IOException { 

     List<T> list = new ArrayList<T>(); 
     Gson gson = new GsonBuilder().registerTypeAdapterFactory(new ArrayAdapterFactory()).create(); 

     final JsonToken token = reader.peek(); 
     System.out.println(token); 
     // Handling of Scenario 2(Check JavaDoc for the class) : 
     if (token == JsonToken.STRING || token == JsonToken.NUMBER || 
       token == JsonToken.BOOLEAN) { 
      T inning = (T) gson.fromJson(reader, adapterclass); 
      list.add(inning); 
     } else if (token == JsonToken.BEGIN_OBJECT) { 
      // Handling of Scenario 1(Check JavaDoc for the class) : 
      T inning = (T) gson.fromJson(reader, adapterclass); 
      list.add(inning); 
     } else if (token == JsonToken.BEGIN_ARRAY) { 
      reader.beginArray(); 
      while (reader.hasNext()) { 
       @SuppressWarnings("unchecked") 
       T inning = (T) gson.fromJson(reader, adapterclass); 
       list.add(inning); 
      } 
      reader.endArray(); 
     } 

     return list; 
    } 

    @Override 
    public void write(JsonWriter writer, List<T> value) throws IOException { 

    } 


} 

ArrayAdapterFactory类

import com.google.gson.Gson; 
import com.google.gson.TypeAdapter; 
import com.google.gson.TypeAdapterFactory; 
import com.google.gson.reflect.TypeToken; 

import java.lang.reflect.ParameterizedType; 
import java.util.ArrayList; 
import java.util.List; 

public class ArrayAdapterFactory implements TypeAdapterFactory { 

    @Override 
    @SuppressWarnings({ "unchecked", "rawtypes" }) 
    public <T> TypeAdapter<T> create(final Gson gson, final TypeToken<T> type) 
    { 

     TypeAdapter<T> typeAdapter = null; 
     try { 
      if (type.getRawType() == List.class || type.getRawType() == ArrayList.class) { 

       typeAdapter = new ArrayAdapter(
         (Class) ((ParameterizedType) type.getType()) 
           .getActualTypeArguments()[0]); 
      } 
     } catch (Exception e) { 
      e.printStackTrace(); 
     } 

     return typeAdapter; 

    } 

} 

并注册适配器工厂这样，

Gson gson = new GsonBuilder().registerTypeAdapterFactory(new ArrayAdapterFactory()).create();