it-swarm.com.de

Volley - POST/GET-Parameter

Ich habe Google IO 2013 über Volley gesehen und erwäge, auf Volleyball umzusteigen. Unterstützt Volley das Hinzufügen von POST/GET-Parametern zur Anforderung? Wenn ja, wie kann ich das machen?

71
Ziem

Überschreiben Sie in Ihrer Request-Klasse (die Request erweitert) die getParams () -Methode. Sie würden dasselbe für Header tun, überschreiben Sie einfach getHeaders ().

Wenn Sie sich die PostWithBody-Klasse in TestRequest.Java in Volley-Tests anschauen, finden Sie ein Beispiel . Es geht ungefähr so

public class LoginRequest extends Request<String> {

    // ... other methods go here

    private Map<String, String> mParams;

    public LoginRequest(String param1, String param2, Listener<String> listener, ErrorListener errorListener) {
        super(Method.POST, "http://test.url", errorListener);
        mListener = listener;
        mParams = new HashMap<String, String>();
        mParams.put("paramOne", param1);
        mParams.put("paramTwo", param2);

    }

    @Override
    public Map<String, String> getParams() {
        return mParams;
    }
}

Evan Charlton war so nett, ein schnelles Beispielprojekt zu machen, um uns zu zeigen, wie man Volley benutzt . https://github.com/evancharlton/folly/

60
AfzalivE

Für die GET-Parameter gibt es zwei Alternativen:

First: Wie in einem Kommentar unter der Frage vorgeschlagen, können Sie einfach String verwenden und die Parameter-Platzhalter durch ihre Werte ersetzen:

String uri = String.format("http://somesite.com/some_endpoint.php?param1=%1$s&param2=%2$s",
                           num1,
                           num2);

StringRequest myReq = new StringRequest(Method.GET,
                                        uri,
                                        createMyReqSuccessListener(),
                                        createMyReqErrorListener());
queue.add(myReq);

dabei sind num1 und num2 String-Variablen, die Ihre Werte enthalten.

Second: Wenn Sie newer external HttpClient (4.2.x zum Beispiel) verwenden, können Sie URIBuilder verwenden, um Ihren Uri zu erstellen. Der Vorteil ist, dass, wenn Ihre URI-Zeichenfolge bereits Parameter enthält, diese leichter an URIBuilder übergeben werden kann und anschließend ub.setQuery(URLEncodedUtils.format(getGetParams(), "UTF-8")); zum Hinzufügen zusätzlicher Parameter verwendet wird. Auf diese Weise prüfen Sie nicht, ob "?" ist bereits zum uri hinzugefügt oder fehlt einiges & eliminiert somit eine Quelle für mögliche Fehler.

Für die Parameter POST ist es wahrscheinlich manchmal einfacher als die akzeptierte Antwort:

StringRequest myReq = new StringRequest(Method.POST,
                                        "http://somesite.com/some_endpoint.php",
                                        createMyReqSuccessListener(),
                                        createMyReqErrorListener()) {

    protected Map<String, String> getParams() throws com.Android.volley.AuthFailureError {
        Map<String, String> params = new HashMap<String, String>();
        params.put("param1", num1);
        params.put("param2", num2);
        return params;
    };
};
queue.add(myReq);

z.B. um einfach die getParams() Methode zu überschreiben.

Ein Arbeitsbeispiel (zusammen mit vielen anderen grundlegenden Volley-Beispielen) finden Sie im Projekt Andorid Volley Examples

73
Ognyan

CustomRequest ist ein Weg, um zu lösen, dass JSONObjectRequest der Volley keine Parameter wie StringRequest posten kann

hier ist die Hilfsklasse, die das Hinzufügen von Parametern erlaubt:

    import Java.io.UnsupportedEncodingException;
    import Java.util.Map;    
    import org.json.JSONException;
    import org.json.JSONObject;    
    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;

    public class CustomRequest extends Request<JSONObject> {

    private Listener<JSONObject> listener;
    private Map<String, String> params;

    public CustomRequest(String url, Map<String, String> params,
            Listener<JSONObject> reponseListener, ErrorListener errorListener) {
        super(Method.GET, url, errorListener);
        this.listener = reponseListener;
        this.params = params;
    }

    public CustomRequest(int method, String url, Map<String, String> params,
            Listener<JSONObject> reponseListener, ErrorListener errorListener) {
        super(method, url, errorListener);
        this.listener = reponseListener;
        this.params = params;
    }

    protected Map<String, String> getParams()
            throws com.Android.volley.AuthFailureError {
        return params;
    };

    @Override
    protected Response<JSONObject> parseNetworkResponse(NetworkResponse response) {
        try {
            String jsonString = new String(response.data,
                    HttpHeaderParser.parseCharset(response.headers));
            return Response.success(new JSONObject(jsonString),
                    HttpHeaderParser.parseCacheHeaders(response));
        } catch (UnsupportedEncodingException e) {
            return Response.error(new ParseError(e));
        } catch (JSONException je) {
            return Response.error(new ParseError(je));
        }
    }

    @Override
    protected void deliverResponse(JSONObject response) {
        // TODO Auto-generated method stub
        listener.onResponse(response);
    }

}

dank an Greenchiu

20
LOG_TAG

Diese Hilfsklasse verwaltet die Parameter fürGETundPOST-Anfragen:

import Java.io.UnsupportedEncodingException;
import Java.util.Iterator;
import Java.util.Map;    

import org.json.JSONException;
import org.json.JSONObject;

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;

public class CustomRequest extends Request<JSONObject> {
    private int mMethod;
    private String mUrl;
    private Map<String, String> mParams;
    private Listener<JSONObject> mListener;

    public CustomRequest(int method, String url, Map<String, String> params,
            Listener<JSONObject> reponseListener, ErrorListener errorListener) {
        super(method, url, errorListener);
        this.mMethod = method;
        this.mUrl = url;
        this.mParams = params;
        this.mListener = reponseListener;
    }

@Override
public String getUrl() {
    if(mMethod == Request.Method.GET) {
        if(mParams != null) {
            StringBuilder stringBuilder = new StringBuilder(mUrl);
            Iterator<Map.Entry<String, String>> iterator = mParams.entrySet().iterator();
            int i = 1;
            while (iterator.hasNext()) {
                Map.Entry<String, String> entry = iterator.next();
                if (i == 1) {
                    stringBuilder.append("?" + entry.getKey() + "=" + entry.getValue());
                } else {
                    stringBuilder.append("&" + entry.getKey() + "=" + entry.getValue());
                }
                iterator.remove(); // avoids a ConcurrentModificationException
                i++;
            }
            mUrl = stringBuilder.toString();
        }
    }
    return mUrl;
}

    @Override
    protected Map<String, String> getParams()
            throws com.Android.volley.AuthFailureError {
        return mParams;
    };

    @Override
    protected Response<JSONObject> parseNetworkResponse(NetworkResponse response) {
        try {
            String jsonString = new String(response.data,
                    HttpHeaderParser.parseCharset(response.headers));
            return Response.success(new JSONObject(jsonString),
                    HttpHeaderParser.parseCacheHeaders(response));
        } catch (UnsupportedEncodingException e) {
            return Response.error(new ParseError(e));
        } catch (JSONException je) {
            return Response.error(new ParseError(je));
        }
    }

    @Override
    protected void deliverResponse(JSONObject response) {
        // TODO Auto-generated method stub
        mListener.onResponse(response);
    }
}
9
Andrea Motto

Umgang mitGETparameters Ich wiederholte die Lösung von Andrea Motto. Das Problem war, dass Volley mehrmals GetUrl rief und seine Lösung mit einem Iterator das ursprüngliche Map-Objekt zerstörte. Die nachfolgenden Volley-internen Anrufe hatten ein leeres Params-Objekt.

Ich habe auch die Kodierung der Parameter hinzugefügt.

Dies ist eine Inline-Verwendung (keine Unterklasse).

public void GET(String url, Map<String, String> params, Response.Listener<String> response_listener, Response.ErrorListener error_listener, String API_KEY, String stringRequestTag) {
    final Map<String, String> mParams = params;
    final String mAPI_KEY = API_KEY;
    final String mUrl = url;

    StringRequest stringRequest = new StringRequest(
            Request.Method.GET,
            mUrl,
            response_listener,
            error_listener
    ) {
        @Override
        protected Map<String, String> getParams() {
            return mParams;
        }

        @Override
        public String getUrl() {
            StringBuilder stringBuilder = new StringBuilder(mUrl);
            int i = 1;
            for (Map.Entry<String,String> entry: mParams.entrySet()) {
                String key;
                String value;
                try {
                    key = URLEncoder.encode(entry.getKey(), "UTF-8");
                    value = URLEncoder.encode(entry.getValue(), "UTF-8");
                    if(i == 1) {
                        stringBuilder.append("?" + key + "=" + value);
                    } else {
                        stringBuilder.append("&" + key + "=" + value);
                    }
                } catch (UnsupportedEncodingException e) {
                    e.printStackTrace();
                }
                i++;

            }
            String url = stringBuilder.toString();

            return url;
        }

        @Override
        public Map<String, String> getHeaders() {
            Map<String, String> headers = new HashMap<>();
            if (!(mAPI_KEY.equals(""))) {
                headers.put("X-API-KEY", mAPI_KEY);
            }
            return headers;
        }
    };

    if (stringRequestTag != null) {
        stringRequest.setTag(stringRequestTag);
    }

    mRequestQueue.add(stringRequest);
}

Diese Funktion verwendet Header, um ein APIKEY zu übergeben, und setzt eine TAG auf die Anforderung, um sie vor dem Abschluss abzubrechen.

Hoffe das hilft.

5
Paolo Casciello

Das kann Ihnen helfen ...

private void loggedInToMainPage(final String emailName, final String passwordName) {

    String tag_string_req = "req_login";
    StringRequest stringRequest = new StringRequest(Request.Method.POST, "http://localhost/index", new Response.Listener<String>() {
        @Override
        public void onResponse(String response) {
            Log.d(TAG, "Login Response: " + response.toString());
            try {
                JSONObject jsonObject = new JSONObject(response);
                Boolean error = jsonObject.getBoolean("error");
                if (!error) {

                    String uid = jsonObject.getString("uid");
                    JSONObject user = jsonObject.getJSONObject("user");
                    String email = user.getString("email");
                    String password = user.getString("password");


                    session.setLogin(true);
                    Intent intent = new Intent(getApplicationContext(), MainActivity.class);
                    startActivity(intent);
                    finish();
                    Toast.makeText(getApplicationContext(), "its ok", Toast.LENGTH_SHORT).show();
                }
            } catch (JSONException e) {
                e.printStackTrace();
            }

        }
    }, new Response.ErrorListener() {
        @Override
        public void onErrorResponse(VolleyError volleyError) {
            System.out.println("volley Error .................");
        }
    }) {
        @Override
        protected Map<String, String> getParams() throws AuthFailureError {
            Map<String, String> params = new HashMap<String, String>();
            params.put("tag", "login");
            params.put("email", emailName);
            params.put("password", passwordName);
            return params;
        }
    };


    MyApplication.getInstance().addToRequestQueue(stringRequest,tag_string_req);
}
3
Mahbod

Für zukünftige Leser

Ich arbeite sehr gerne mit Volley . Um Entwicklungszeit zu sparen, habe ich versucht, eine kleine praktische Bibliothek Gloxey Netwok Manager zu schreiben, um Volley mit meinem Projekt zu konfigurieren. Es enthält einen JSON-Parser und verschiedene andere Methoden, mit denen die Verfügbarkeit des Netzwerks überprüft werden kann. 

Verwenden Sie ConnectionManager.class, in dem verschiedene Methoden für die Anforderung Volley String und Volley JSON verfügbar sind . Sie können Anforderungen an GET, PUT, POST, DELETE mit oder ohne Kopf stellen. Sie können die vollständige Dokumentation hier lesen.

Fügen Sie diese Zeile einfach in Ihre Gradle-Datei ein.

  dependencies { 

       compile 'io.gloxey.gnm:network-manager:1.0.1'
   }

Volley StringRequest

Methode GET (ohne Kopfzeile)

    ConnectionManager.volleyStringRequest(context, isDialog, progressDialogView, requestURL, volleyResponseInterface);

Wie benutzt man?

     Configuration                Description

     Context                      Context 
     isDialog                     If true dialog will appear, otherwise not.
     progressView                 For custom progress view supply your progress view id and make isDialog true. otherwise pass null. 
     requestURL                   Pass your API URL.  
     volleyResponseInterface      Callback for response.  

Beispiel

    ConnectionManager.volleyStringRequest(this, false, null, "url", new VolleyResponse() {
    @Override
    public void onResponse(String _response) {

        /**
         * Handle Response
         */
    }

    @Override
     public void onErrorResponse(VolleyError error) {

        /**
         * handle Volley Error
         */
    }

    @Override
    public void isNetwork(boolean connected) {

        /**
         * True if internet is connected otherwise false
         */
    }
});

Volley StringRequest

Methode POST/PUT/DELETE (ohne Kopfzeile)

    ConnectionManager.volleyStringRequest(context, isDialog, progressDialogView, requestURL, requestMethod, params, volleyResponseInterface);

Beispiel

Use Method : Request.Method.POST
             Request.Method.PUT
             Request.Method.DELETE

Your params : 

HashMap<String, String> params = new HashMap<>();
params.put("param 1", "value");
params.put("param 2", "value");

ConnectionManager.volleyStringRequest(this, true, null, "url", Request.Method.POST, params, new VolleyResponse() {
    @Override
    public void onResponse(String _response) {

        /**
         * Handle Response
         */
    }

    @Override
    public void onErrorResponse(VolleyError error) {

        /**
         * handle Volley Error
         */
    }

    @Override
    public void isNetwork(boolean connected) {

        /**
         * True if internet is connected otherwise false
         */
    }
});

Bonus

Gloxey JSON Parser

Fühlen Sie sich frei, Gloxey Json Parser zu verwenden, um Ihre Antwort auf die API zu analysieren.

  YourModel yourModel = GloxeyJsonParser.getInstance().parse(stringResponse, YourModel.class);

Beispiel

ConnectionManager.volleyStringRequest(this, false, null, "url", new VolleyResponse() {
    @Override
    public void onResponse(String _response) {

        /**
         * Handle Response
         */

         try {

          YourModel yourModel = GloxeyJsonParser.getInstance().parse(_response, YourModel.class);

            } catch (Exception e) {
                e.printStackTrace();
            }

    }

    @Override
     public void onErrorResponse(VolleyError error) {

        /**
         * handle Volley Error
         */
         if (error instanceof TimeoutError || error instanceof NoConnectionError) {

                showSnackBar(parentLayout, getString(R.string.internet_not_found), getString(R.string.retry), new View.OnClickListener() {
                    @Override
                    public void onClick(View view) {

                     //handle retry button

                    }
                });

            } else if (error instanceof AuthFailureError) {
            } else if (error instanceof ServerError) {
            } else if (error instanceof NetworkError) {
            } else if (error instanceof ParseError) {
            }

    }

    @Override
    public void isNetwork(boolean connected) {

        /**
         * True if internet is connected otherwise false
         */
          if (!connected) {
                showSnackBar(parentLayout, getString(R.string.internet_not_found), getString(R.string.retry), new View.OnClickListener() {
                    @Override
                    public void onClick(View view) {
                        //Handle retry button
                    }
                });
    }
});


     public void showSnackBar(View view, String message) {
            Snackbar.make(view, message, Snackbar.LENGTH_LONG).show();
     }

     public void showSnackBar(View view, String message, String actionText, View.OnClickListener onClickListener) {
            Snackbar.make(view, message, Snackbar.LENGTH_LONG).setAction(actionText, onClickListener).show();
     }
1

Um POST-Parameter bereitzustellen, senden Sie Ihren Parameter als JSONObject in an den JsonObjectRequest-Konstruktor. Der dritte Parameter akzeptiert eine JSONObject, die im Anforderungshauptteil verwendet wird.

JSONObject paramJson = new JSONObject();

paramJson.put("key1", "value1");
paramJson.put("key2", "value2");


JsonObjectRequest jsonObjectRequest = new JsonObjectRequest(Request.Method.POST,url,paramJson,
    new Response.Listener<JSONObject>() {
        @Override
        public void onResponse(JSONObject response) {

        }
    },
    new Response.ErrorListener() {
        @Override
        public void onErrorResponse(VolleyError error) {

        }
    });
requestQueue.add(jsonObjectRequest);
0
Abu Yousuf