Rénovation 2.0 Parse JSON dynamique de la classe même POJO

Question

Ce que j'ai

J'ai un serveur success response

{ 
    "response_code": 200, 
    "status": "success", 
    "message": "enqiry chat fetched successfully", 
    "meta_data": { 
    "count": "6" 
    }, 
    "data": { 
    "enquiries": [ 
    ] 
    } 
} 

Lorsque Error, les mêmes API retours

{ 
    "response_code": 500, 
    "status": "error", 
    "meta_data": { 
    "count": 0 
    }, 
    "data": [], 
    "message": "Please specify all required parameter to add enquiries" 
} 

Qu'est-il arrivé

À error scenario les données passe de JsonObject à JsonArray

Mon problème

Au succès, tout réponse fonctionne bien (parce que je fait POJO class de success response)

A erreur de réponse mon application se bloque en disant Essayé de lire l'objet mais fo tableau und

Ce que je ne peux pas faire

ne peut pas changer le back-end, car il est déjà développé et travaille pour le site Web aussi.

Ce que j'ai

J'ai googlé et trouvé beaucoup de solutions que je ne peux pas se rapporter à mes questions

POJO

public class ReviewModel { 

    @SerializedName("data") 
    private Data mData; 

    public Data getData() { 
     return mData; 
    } 

    public void setData(Data data) { 
     mData = data; 
    } 

    public class Data { 

     @SerializedName("reviews") 
     private List<Review> mReviews; 

     public List<Review> getReviews() { 
      return mReviews; 
     } 

     public void setReviews(List<Review> reviews) { 
      mReviews = reviews; 
     } 

    } 



    public class Review { 

     @SerializedName("comment_date") 
     private String mCommentDate; 

     public String getCommentDate() { 
      return mCommentDate; 
     } 

     public void setCommentDate(String comment_date) { 
      mCommentDate = comment_date; 
     } 

     } 
} 

Answer 1

Ma solution est d'utiliser quelque chose comme ça,

import com.google.gson.annotations.Expose; 
import com.google.gson.annotations.SerializedName; 

import java.util.List; 

public class Response { 

    @SerializedName("response_code") 
    @Expose 
    private Integer responseCode; 
    @SerializedName("status") 
    @Expose 
    private String status; 
    @SerializedName("meta_data") 
    @Expose 
    private MetaData metaData; 
    @SerializedName("data") 
    @Expose 
    private List<Object> data = null; 
    @SerializedName("message") 
    @Expose 
    private String message; 

    public Integer getResponseCode() { 
     return responseCode; 
    } 

    public void setResponseCode(Integer responseCode) { 
     this.responseCode = responseCode; 
    } 

    public String getStatus() { 
     return status; 
    } 

    public void setStatus(String status) { 
     this.status = status; 
    } 

    public MetaData getMetaData() { 
     return metaData; 
    } 

    public void setMetaData(MetaData metaData) { 
     this.metaData = metaData; 
    } 

    public List<Object> getData() { 
     return data; 
    } 

    public void setData(List<Object> data) { 
     this.data = data; 
    } 

    public String getMessage() { 
     return message; 
    } 

    public void setMessage(String message) { 
     this.message = message; 
    } 


    public class MetaData { 

     @SerializedName("count") 
     @Expose 
     private Integer count; 

     public Integer getCount() { 
      return count; 
     } 

     public void setCount(Integer count) { 
      this.count = count; 
     } 

    } 
} 

Et utiliser un adaptateur tableau personnalisé avec Gson,

classe ArrayAdapter

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(gson, 
         (Class) ((ParameterizedType) type.getType()) 
           .getActualTypeArguments()[0]); 
      } 
     } catch (Exception e) { 
      e.printStackTrace(); 
     } 

     return typeAdapter; 

    } 

} 

classe ArrayAdapterFactory

import com.google.gson.Gson; 
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; 
    private Gson gson; 

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

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

     List<T> list = new ArrayList<T>(); 

     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 { 

    } 
} 

Et enregistrer l'usine comme adaptateur ce,

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

Cette volonté aider à désérialiser la chaîne JSON.