Parsen Android Volley JSONArray Antwort

Question

Ich sende eine JSONArray GET-Anfrage mit Volley, und es gibt das angegebene JSON-Array zurück. Hier ist meine Anfrage:

JsonArrayRequest getRequest = new JsonArrayRequest(url, 
        new Response.Listener<JSONArray>() 
        { 
         @Override public void onResponse(JSONArray response) { 

          Log.d("Response", response.toString()); 
         } 
        }, 
        new Response.ErrorListener() 
        { 
         @Override public void onErrorResponse(VolleyError error) { 
          Log.d("Error.Response", error.toString()); 
         } 
        } 
       ); 
        VolleySingleton.getInstance(this).addToRequestQueue(getRequest); //Call to get dashboard feed 
} 

Wie Sie sehen können, bin ich derzeit gerade die Antwort ausloggen. Ich möchte das Array jedoch analysieren und die Ergebnisse in einer Listenansicht anzeigen. Die Dokumentation dafür ist nicht großartig, und ich bin ziemlich grün in Bezug auf Android-Dev. Was ist der richtige Weg, um ein JSON-Array von Volley zu analysieren und die Ergebnisse in einer Listenansicht anzuzeigen? I've gathered, dass ich parseNetworkResponse verwenden sollte, aber nicht sicher, wie zu implementieren.

Answer 1

Ich würde empfehlen, an der GSON-Bibliothek für JSON-Parsing bleiben. Hier ist, wie ein Volley Anfrage mit eingebetteten JSON Verarbeitung dann aussehen könnte:

import java.io.UnsupportedEncodingException; 

import com.android.volley.NetworkResponse; 
import com.android.volley.ParseError; 
import com.android.volley.Request; 
import com.android.volley.Response; 
import com.android.volley.Response.ErrorListener; 
import com.android.volley.Response.Listener; 
import com.android.volley.toolbox.HttpHeaderParser; 
import com.google.gson.Gson; 
import com.google.gson.JsonSyntaxException; 

/** 
* Volley GET request which parses JSON server response into Java object. 
*/ 
public class GsonRequest<T> extends Request<T> { 

    /** JSON parsing engine */ 
    protected final Gson gson; 

    /** class of type of response */ 
    protected final Class<T> clazz; 

    /** result listener */ 
    private final Listener<T> listener; 

    public GsonRequest(String url, Class<T> clazz, Listener<T> listener, 
      ErrorListener errorListener) { 
     super(Method.GET, url, errorListener); 

     this.clazz = clazz; 
     this.listener = listener; 
     this.gson = new Gson(); 
    } 

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

    @Override 
    protected Response<T> parseNetworkResponse(NetworkResponse response) { 
     try { 
      String json = new String(
        response.data, HttpHeaderParser.parseCharset(response.headers)); 
      return Response.success(
        gson.fromJson(json, clazz), HttpHeaderParser.parseCacheHeaders(response)); 

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

wir uns vor, Sie eine Server-Methode bei http://example.com/api/persons/ befindet sich haben, die ein JSON-Array von Person zurückgibt; Person ist wie folgt:

public class Person { 
    String firstName; 
    String lastName; 
} 

Wir können das oben genannte Verfahren wie folgt aufrufen:

GsonRequest<Person[]> getPersons = 
     new GsonRequest<Person[]>("http://example.com/api/persons/", Person[].class, 

      new Listener<Person[]>() { 
       @Override 
       public void onResponse(Person[] response) { 
        List<Person> persons = Arrays.asList(response); 
        // TODO deal with persons 
       } 

      }, new ErrorListener() { 
       @Override 
       public void onErrorResponse(VolleyError error) { 
        // TODO deal with error 
       } 
      }); 

VolleyQueue.get().add(getPersons); 

Und schließlich als Reaktion Zuhörer bekommen wir eine Reihe von Personen, die umgewandelt werden können aufzulisten und gefüttert Listview des Adapters .

Answer 2

Sie Gson Projekt auf die Zusammenarbeit mit json in Java und Android-App verwenden können, ist es so einfach Link eine Probe Link der Verwendung Gson

ist

How To Convert Java Object To/From JSON (Gson)

Answer 3

Sie entweder die native JSONParsor können in Das Android-Framework Ihre Anforderungen sind vergleichsweise weniger und die JSON ist einfach. Here ist ein Link für das Tutorial.

Aber wenn Sie komplexeJSON Objekte verwenden, benutzen Sie Bibliotheken wie

• Gson
• Jackson

Ich finde Gson einfacher und effektiver zu bedienen . Sie wissen mehr darüber aus Here