web-dev-qa-db-fra.com

Analyse de la réponse Android Volley JSONArray

J'envoie une demande GET JSONArray avec Volley, qui renvoie le tableau JSON spécifié. Voici ma demande:

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
}

Comme vous pouvez le constater, je suis en train de déconnecter la réponse. Je souhaite cependant analyser le tableau et afficher les résultats dans une liste. La documentation à ce sujet n'est pas géniale, et je suis assez vert en termes de développement Android. Quelle est la bonne façon d’analyser un tableau JSON à partir de Volley et d’afficher les résultats dans une liste? J'ai rassemblé que je devrais utiliser parseNetworkResponse, mais je ne sais pas comment le mettre en œuvre.

javaandroidjsonandroid-volley
9
settheline

Je vous recommande de vous en tenir à la bibliothèque GSON pour l'analyse JSON. Voici à quoi pourrait ressembler une demande Volley avec traitement JSON intégré: 

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));
        }
    }
}

Imaginons que vous disposiez d’une méthode serveur située à l’emplacement http://example.com/api/persons/ qui renvoie un tableau JSON de Person; Personne est comme suit:

public class Person {
    String firstName;
    String lastName;
}

Nous pouvons appeler la méthode susmentionnée comme ceci:

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);

Et enfin, en réponse, nous obtenons un tableau de Person qui peut être converti en liste et transmis à l’adaptateur de ListView.

40
Alexey Dmitriev

vous pouvez utiliser Gson project pour travailler avec json dans les applications Java et Android, il est si simple que ce lien est un exemple de lien d’utilisation de gson

Comment convertir un objet Java en/depuis JSON (Gson)

0
Amin Bahiraei

Vous pouvez soit utiliser la JSONParsor native dans le cadre Android, vos besoins sont comparativement inférieurs et la JSON est simple . Ici est un lien pour le tutoriel.

Mais si vous utilisez des objets complex JSON, utilisez des bibliothèques telles que 

  • GSON
  • Jackson

Je trouveGSONplus facile et plus efficace à utiliser. Vous en savez plus sur Ici

0
SathMK