Chciałbym wysłać nową JsonObjectRequest
prośbę:
- Chcę otrzymać dane JSON (odpowiedź z serwera): OK
Chcę wysłać dane w formacie JSON z tym żądaniem do serwera
JsonObjectRequest request = new JsonObjectRequest( Request.Method.POST, "myurl.com", null, new Response.Listener<JSONObject>() { @Override public void onResponse(JSONObject response) { //... } }, new Response.ErrorListener() { @Override public void onErrorResponse(VolleyError error) { //... } }) { @Override protected Map<String,String> getParams() { // something to do here ?? return params; } @Override public Map<String, String> getHeaders() throws AuthFailureError { // something to do here ?? return params; } };
PS Używam również biblioteki GSON w moim projekcie.
HashMap
twoim przykładzie jest to trochę zbyteczne. Możesz umieścić „token” bezpośrednio wJSONObject
mapie bez pośredniej mapy.new JSONObject("{\"type\":\"example\"}")
zamiast tego - mój błąd.Wiem, że ten wątek jest dość stary, ale miałem ten problem i wymyśliłem fajne rozwiązanie, które może być bardzo przydatne dla wielu, ponieważ poprawia / rozszerza bibliotekę Volley pod wieloma względami.
Zauważyłem kilka nieobsługiwanych funkcji Volley po wyjęciu z pudełka:
JSONObjectRequest
nie jest idealne:JSON
na końcu musisz się spodziewać (patrzResponse.Listener<JSONObject>
).ResponseListener
?Z grubsza skompilowałem wiele rozwiązań w dużej klasie ogólnej, aby uzyskać rozwiązanie całego zacytowanego problemu.
/** * Created by laurentmeyer on 25/07/15. */ public class GenericRequest<T> extends JsonRequest<T> { private final Gson gson = new Gson(); private final Class<T> clazz; private final Map<String, String> headers; // Used for request which do not return anything from the server private boolean muteRequest = false; /** * Basically, this is the constructor which is called by the others. * It allows you to send an object of type A to the server and expect a JSON representing a object of type B. * The problem with the #JsonObjectRequest is that you expect a JSON at the end. * We can do better than that, we can directly receive our POJO. * That's what this class does. * * @param method: HTTP Method * @param classtype: Classtype to parse the JSON coming from the server * @param url: url to be called * @param requestBody: The body being sent * @param listener: Listener of the request * @param errorListener: Error handler of the request * @param headers: Added headers */ private GenericRequest(int method, Class<T> classtype, String url, String requestBody, Response.Listener<T> listener, Response.ErrorListener errorListener, Map<String, String> headers) { super(method, url, requestBody, listener, errorListener); clazz = classtype; this.headers = headers; configureRequest(); } /** * Method to be called if you want to send some objects to your server via body in JSON of the request (with headers and not muted) * * @param method: HTTP Method * @param url: URL to be called * @param classtype: Classtype to parse the JSON returned from the server * @param toBeSent: Object which will be transformed in JSON via Gson and sent to the server * @param listener: Listener of the request * @param errorListener: Error handler of the request * @param headers: Added headers */ public GenericRequest(int method, String url, Class<T> classtype, Object toBeSent, Response.Listener<T> listener, Response.ErrorListener errorListener, Map<String, String> headers) { this(method, classtype, url, new Gson().toJson(toBeSent), listener, errorListener, headers); } /** * Method to be called if you want to send some objects to your server via body in JSON of the request (without header and not muted) * * @param method: HTTP Method * @param url: URL to be called * @param classtype: Classtype to parse the JSON returned from the server * @param toBeSent: Object which will be transformed in JSON via Gson and sent to the server * @param listener: Listener of the request * @param errorListener: Error handler of the request */ public GenericRequest(int method, String url, Class<T> classtype, Object toBeSent, Response.Listener<T> listener, Response.ErrorListener errorListener) { this(method, classtype, url, new Gson().toJson(toBeSent), listener, errorListener, new HashMap<String, String>()); } /** * Method to be called if you want to send something to the server but not with a JSON, just with a defined String (without header and not muted) * * @param method: HTTP Method * @param url: URL to be called * @param classtype: Classtype to parse the JSON returned from the server * @param requestBody: String to be sent to the server * @param listener: Listener of the request * @param errorListener: Error handler of the request */ public GenericRequest(int method, String url, Class<T> classtype, String requestBody, Response.Listener<T> listener, Response.ErrorListener errorListener) { this(method, classtype, url, requestBody, listener, errorListener, new HashMap<String, String>()); } /** * Method to be called if you want to GET something from the server and receive the POJO directly after the call (no JSON). (Without header) * * @param url: URL to be called * @param classtype: Classtype to parse the JSON returned from the server * @param listener: Listener of the request * @param errorListener: Error handler of the request */ public GenericRequest(String url, Class<T> classtype, Response.Listener<T> listener, Response.ErrorListener errorListener) { this(Request.Method.GET, url, classtype, "", listener, errorListener); } /** * Method to be called if you want to GET something from the server and receive the POJO directly after the call (no JSON). (With headers) * * @param url: URL to be called * @param classtype: Classtype to parse the JSON returned from the server * @param listener: Listener of the request * @param errorListener: Error handler of the request * @param headers: Added headers */ public GenericRequest(String url, Class<T> classtype, Response.Listener<T> listener, Response.ErrorListener errorListener, Map<String, String> headers) { this(Request.Method.GET, classtype, url, "", listener, errorListener, headers); } /** * Method to be called if you want to send some objects to your server via body in JSON of the request (with headers and muted) * * @param method: HTTP Method * @param url: URL to be called * @param classtype: Classtype to parse the JSON returned from the server * @param toBeSent: Object which will be transformed in JSON via Gson and sent to the server * @param listener: Listener of the request * @param errorListener: Error handler of the request * @param headers: Added headers * @param mute: Muted (put it to true, to make sense) */ public GenericRequest(int method, String url, Class<T> classtype, Object toBeSent, Response.Listener<T> listener, Response.ErrorListener errorListener, Map<String, String> headers, boolean mute) { this(method, classtype, url, new Gson().toJson(toBeSent), listener, errorListener, headers); this.muteRequest = mute; } /** * Method to be called if you want to send some objects to your server via body in JSON of the request (without header and muted) * * @param method: HTTP Method * @param url: URL to be called * @param classtype: Classtype to parse the JSON returned from the server * @param toBeSent: Object which will be transformed in JSON via Gson and sent to the server * @param listener: Listener of the request * @param errorListener: Error handler of the request * @param mute: Muted (put it to true, to make sense) */ public GenericRequest(int method, String url, Class<T> classtype, Object toBeSent, Response.Listener<T> listener, Response.ErrorListener errorListener, boolean mute) { this(method, classtype, url, new Gson().toJson(toBeSent), listener, errorListener, new HashMap<String, String>()); this.muteRequest = mute; } /** * Method to be called if you want to send something to the server but not with a JSON, just with a defined String (without header and not muted) * * @param method: HTTP Method * @param url: URL to be called * @param classtype: Classtype to parse the JSON returned from the server * @param requestBody: String to be sent to the server * @param listener: Listener of the request * @param errorListener: Error handler of the request * @param mute: Muted (put it to true, to make sense) */ public GenericRequest(int method, String url, Class<T> classtype, String requestBody, Response.Listener<T> listener, Response.ErrorListener errorListener, boolean mute) { this(method, classtype, url, requestBody, listener, errorListener, new HashMap<String, String>()); this.muteRequest = mute; } @Override protected Response<T> parseNetworkResponse(NetworkResponse response) { // The magic of the mute request happens here if (muteRequest) { if (response.statusCode >= 200 && response.statusCode <= 299) { // If the status is correct, we return a success but with a null object, because the server didn't return anything return Response.success(null, HttpHeaderParser.parseCacheHeaders(response)); } } else { try { // If it's not muted; we just need to create our POJO from the returned JSON and handle correctly the errors String json = new String(response.data, HttpHeaderParser.parseCharset(response.headers)); T parsedObject = gson.fromJson(json, clazz); return Response.success(parsedObject, HttpHeaderParser.parseCacheHeaders(response)); } catch (UnsupportedEncodingException e) { return Response.error(new ParseError(e)); } catch (JsonSyntaxException e) { return Response.error(new ParseError(e)); } } return null; } @Override public Map<String, String> getHeaders() throws AuthFailureError { return headers != null ? headers : super.getHeaders(); } private void configureRequest() { // Set retry policy // Add headers, for auth for example // ... } }
Może się to wydawać trochę przesadzone, ale fajnie jest mieć wszystkich tych konstruktorów, ponieważ masz wszystkie przypadki:
(Główny konstruktor nie miał być używany bezpośrednio, chociaż jest to oczywiście możliwe).
Oczywiście, aby to działało, musisz mieć GSON Lib Google; poprostu dodaj:
compile 'com.google.code.gson:gson:x.y.z'
do twoich zależności (aktualna wersja to
2.3.1
).źródło
toBeSent
parametrów zObject
naT
dla większego bezpieczeństwa typu.final String URL = "/volley/resource/12"; // Post params to be sent to the server HashMap<String, String> params = new HashMap<String, String>(); params.put("token", "AbCdEfGh123456"); JsonObjectRequest req = new JsonObjectRequest(URL, new JSONObject(params), new Response.Listener<JSONObject>() { @Override public void onResponse(JSONObject response) { try { VolleyLog.v("Response:%n %s", response.toString(4)); } catch (JSONException e) { e.printStackTrace(); } } }, new Response.ErrorListener() { @Override public void onErrorResponse(VolleyError error) { VolleyLog.e("Error: ", error.getMessage()); } }); // add the request object to the queue to be executed ApplicationController.getInstance().addToRequestQueue(req);
odnosić się
źródło
Utwórz obiekt
RequestQueue
klasy.RequestQueue queue = Volley.newRequestQueue(this);
Utwórz
StringRequest
z odpowiedzią i nasłuchiwaniem błędów.StringRequest sr = new StringRequest(Request.Method.POST,"http://api.someservice.com/post/comment", new Response.Listener<String>() { @Override public void onResponse(String response) { mPostCommentResponse.requestCompleted(); } }, new Response.ErrorListener() { @Override public void onErrorResponse(VolleyError error) { mPostCommentResponse.requestEndedWithError(error); } }){ @Override protected Map<String,String> getParams(){ Map<String,String> params = new HashMap<String, String>(); params.put("user",userAccount.getUsername()); params.put("pass",userAccount.getPassword()); params.put("comment", Uri.encode(comment)); params.put("comment_post_ID",String.valueOf(postId)); params.put("blogId",String.valueOf(blogId)); return params; } @Override public Map<String, String> getHeaders() throws AuthFailureError { Map<String,String> params = new HashMap<String, String>(); params.put("Content-Type","application/x-www-form-urlencoded"); return params; } };
Dodaj swoje żądanie do
RequestQueue
.queue.add(jsObjRequest);
Utwórz
PostCommentResponseListener
interfejs tylko po to, aby go zobaczyć. Jest to prosty delegat dla żądania asynchronicznego.public interface PostCommentResponseListener { public void requestStarted(); public void requestCompleted(); public void requestEndedWithError(VolleyError error); }
Uwzględnij uprawnienia INTERNET w
AndroidManifest.xml
pliku.<uses-permission android:name="android.permission.INTERNET"/>
źródło
final String url = "some/url";
zamiast:
final JSONObject jsonBody = "{\"type\":\"example\"}";
możesz użyć:
JSONObject jsonBody = new JSONObject(); try { jsonBody.put("type", "my type"); } catch (JSONException e) { e.printStackTrace(); } new JsonObjectRequest(url, jsonBody, new Response.Listener<JSONObject>() { ... });
źródło
final Map<String,String> params = new HashMap<String,String>(); params.put("email", customer.getEmail()); params.put("password", customer.getPassword()); String url = Constants.BASE_URL+"login"; doWebRequestPost(url, params); public void doWebRequestPost(String url, final Map<String,String> json){ getmDialogListener().showDialog(); StringRequest post = new StringRequest(Request.Method.POST, url, new Response.Listener<String>() { @Override public void onResponse(String response) { try { getmDialogListener().dismissDialog(); response.... } catch (Exception e) { e.printStackTrace(); } } }, new Response.ErrorListener() { @Override public void onErrorResponse(VolleyError error) { Log.d(App.TAG,error.toString()); getmDialogListener().dismissDialog(); } }){ @Override protected Map<String, String> getParams() throws AuthFailureError { Map<String,String> map = json; return map; } }; App.getInstance().getRequestQueue().add(post); }
źródło
Możesz również wysłać dane przez nadpisanie
getBody()
metodyJsonObjectRequest
class. Jak pokazano niżej.@Override public byte[] getBody() { JSONObject jsonObject = new JSONObject(); String body = null; try { jsonObject.put("username", "user123"); jsonObject.put("password", "Pass123"); body = jsonObject.toString(); } catch (JSONException e) { // TODO Auto-generated catch block e.printStackTrace(); } try { return body.toString().getBytes("utf-8"); } catch (UnsupportedEncodingException e) { // TODO Auto-generated catch block e.printStackTrace(); } return null; }
źródło
protected Map<String, String> getParams() { Map<String, String> params = new HashMap<String, String>(); JSONObject JObj = new JSONObject(); try { JObj.put("Id","1"); JObj.put("Name", "abc"); } catch (Exception e) { e.printStackTrace(); } params.put("params", JObj.toString()); // Map.Entry<String,String> Log.d("Parameter", params.toString()); return params; }
źródło