Verwenden von Volley und Gson: Objekt- und Elementliste analysieren

Question

Eine Sache, die ich an Gson nie gemocht habe, ist die Tatsache, dass Sie ein Klassenobjekt oder ein TypeToken basierend darauf übergeben müssen, wenn Sie einen Gegenstand oder eine Liste von Gegenständen bekommen . Nun, wenn ich versuche, Volley mit Gson zu benutzen, bleibt dieses Problem bestehen und ich versuche eine GsonRequest-Klasse zu erstellen, die für beide Dinge verwendet werden kann.

Meine Lösung ist ziemlich hässlich, zwei verschiedene Konstrukteure: eine bekommt einen Class<T> Parameter und eine andere erhält eine Type Parameter. Dann wird in der parseNetworkResponse, gson.fromJson mit einem der Felder aufgerufen, wobei zu beachten ist, dass man null sein muss.

Haben Sie eine Idee, wie Sie dies besser umsetzen können? (Ich weiß nicht wie ein GsonRequest und eine GsonCollectionRequest fast gleich Klassen mit)

Mein Code, hier:

public class GsonRequest<T> extends Request<T> { 

    private final Gson gson; 
    private final Class<T> clazz; 
    private final Type type; 
    private final Listener<T> listener; 
    private final Map<String, String> headers; 
    private final Map<String, String> params; 

    public GsonRequest(int method, String url, Gson gson, Class<T> clazz, Map<String, String> headers, Map<String, String> params, Listener<T> listener, ErrorListener errorListener) { 
     super(method, url, errorListener); 
     this.gson = gson; 
     this.clazz = clazz; 
     this.type = null; 
     this.listener = listener; 
     this.headers = headers; 
     this.params = params; 
    } 

    public GsonRequest(int method, String url, Gson gson, Type type, Map<String, String> headers, Map<String, String> params, Listener<T> listener, ErrorListener errorListener) { 
     super(method, url, errorListener); 
     this.gson = gson; 
     this.clazz = null; 
     this.type = type; 
     this.listener = listener; 
     this.headers = headers; 
     this.params = params; 
    } 

    @Override 
    public Map<String, String> getHeaders() throws AuthFailureError { 
     return this.headers != null ? this.headers : super.getHeaders(); 
    } 

    @Override 
    protected Map<String, String> getParams() throws AuthFailureError { 
     return this.params != null ? this.params : super.getParams(); 
    } 

    @Override 
    protected Response<T> parseNetworkResponse(NetworkResponse response) { 
     try { 

      if (this.clazz != null) { 
       return Response.success(
         this.gson.fromJson(new String(response.data, HttpHeaderParser.parseCharset(response.headers)), this.clazz), 
         HttpHeaderParser.parseCacheHeaders(response)); 
      } else { 
       return (Response<T>) Response.success(
         this.gson.fromJson(new String(response.data, HttpHeaderParser.parseCharset(response.headers)), this.type), 
         HttpHeaderParser.parseCacheHeaders(response)); 
      } 

     } catch (JsonSyntaxException e) { 
      e.printStackTrace(); 
      return Response.error(new ParseError(e)); 
     } catch (UnsupportedEncodingException e) { 
      e.printStackTrace(); 
      return Response.error(new ParseError(e)); 
     } 
    } 

    @Override 
    protected void deliverResponse(T response) { 
     this.listener.onResponse(response); 
    } 

} 

Answer 1

Sie können einen neuen GsonRequest erstellen TypeToken als Type-Parameter verwenden.

Verwenden Sie generische GsonRequest wie diese GsonRequest.

Erstellen Sie eine einfache Anfrage für eine Gson Klasse ...

new GsonRequest<MyClass>(Request.Method.GET, uriBuilder.build().toString(), 
        MyClass.class, null, mResponseListener, mReponseErrorListener)); 

oder einen Typ für eine Arraylist erstellen ...

Type type = new TypeToken<ArrayList<MyClass>>() {}.getType(); 
new GsonRequest<ArrayList<MyClass>>(Request.Method.GET, uriBuilder.build().toString(), 
        type, null, mResponseListListener, mReponseErrorListener)); 

Answer 2

ich die JsonObject Antrag des Volley verwendet und gebraucht die Response.ToString(), um die JSON-Zeichenfolge über Gson zur Klasse zu analysieren.

Gson gson = new Gson(); 
ClassName obj = gson.fromJson(response.ToString(),ClassName.class); 

Jetzt haben Sie obj mit allen Daten.

Answer 3

Ich habe die folgende Methode verwendet, um eine JSON-Liste zu analysieren. Senden Sie als Erstes keine Klasse im Konstruktor, sondern übergeben Sie die Type-Klasse aus dem reflect-Paket.

Meine Klasse sieht wie folgt aus:

public class DownloadRequest<T> extends Request<T> { 

private final Gson gson = new Gson(); 
private final Type type; 
private final Map<String, String> params; 
private final Response.Listener<T> listener; 

public DownloadRequest(int method, String url, Map<String, String> params, Type type, Response.Listener<T> listener, Response.ErrorListener errorListener) { 
    super(method, url, errorListener); 
    this.type = type; 
    this.params = params; 
    this.listener = listener; 
} 

@Override 
protected Response<T> parseNetworkResponse(NetworkResponse networkResponse) { 

    try { 
     String json = new String(networkResponse.data, HttpHeaderParser.parseCharset(networkResponse.headers)); 
     T parseObject = gson.fromJson(json, type); 
     return Response.success(parseObject,HttpHeaderParser.parseCacheHeaders(networkResponse)); 
    } catch (UnsupportedEncodingException e) { 
     e.printStackTrace(); 
    } 

    return null; 
} 

@Override 
protected void deliverResponse(T t) { 
    listener.onResponse(t); 
} 

}

Die Linie T parseObject = gson.fromJson(json, type); wichtig ist, zu setzen, bevor Sie die Request.success Methode aufrufen.