Senden Sie formulierte Parameter in einem POST-Anforderung Android Volley

Question

Ich möchte einen POST JSONObjectRequest mit urlcodierten Formparametern erstellen. Wie kann ich das machen? Ich habe den folgenden Code versucht, aber ohne Erfolg.

final String api = "http://api.url";
final JSONObject jobj = new JSONObject();
jobj.put("Username", "usr");
jobj.put("Password", "passwd");
jobj.put("grant_type", "password");

final JsonObjectRequest jor = new JsonObjectRequest(

    Request.Method.POST, 
    api, jobj, 
    new Response.Listener() {
        @Override
        public void onResponse(JSONObject response) {
            Toast.makeText(getApplicationContext(), "Login erfolgreich!", Toast.LENGTH_LONG).show();
            //andere Dinge mit dem empfangenen JSONObject machen
        }
    }, 
    new Response.ErrorListener() {
        @Override
        public void onErrorResponse(VolleyError error) {
            Toast.makeText(getApplicationContext(), "Fehler!", Toast.LENGTH_LONG).show();
        }
    }) {

    @Override
    public Map getHeaders() throws AuthFailureError {
        Map pars = new HashMap();
        pars.put("Content-Type", "application/x-www-form-urlencoded");
        return pars;
    }
};

//der Anforderungswarteschlange hinzufügen
requestqueue.AddToRequestQueue(jor);

Ich erhalte einen 400 Bad Request mit dem API-Aufruf! Wie kann ich das beheben?

Answer 1

Ich habe Antworten in der Kotlin-Sprache gesucht. Senden Sie x-www-form-urlencoded-Parameter in einer Post-Anfrage mit Android Volley in der Kotlin-Sprache:

    val queue = Volley.newRequestQueue(this)

    val stringRequest: StringRequest = object : StringRequest(
        Method.POST,
        link,
        Response.Listener { response ->
            Log.i("response:", response)
        },

        Response.ErrorListener { error ->
            Log.i("response error:", "$error")
            error.printStackTrace()
        }) {
        override fun getBodyContentType(): String {
            return "application/x-www-form-urlencoded"
        }

        override fun getHeaders(): Map {
            val headers: MutableMap =
                HashMap()
            headers["Content-Type"] = "application/x-www-form-urlencoded"
            headers["Accept"] = "application/json"
            return headers
        }

        @Throws(AuthFailureError::class)
        override fun getParams(): Map {
            val params: MutableMap =
                HashMap()
            params["value1"] = "value1"
            params["value2"] = "value2"
            return params
        }
    }

    queue.add(stringRequest)

Answer 2

Es gibt keinen vordefinierten Konstruktor in JsonObjectRequest, der Post-Parameter akzeptiert, also hast du deinen eigenen Konstruktor gemacht

Du musst sowohl deine Map einer bereits deklarierten Variable in dieser Methode innerhalb deines Konstruktors zuweisen, als auch diese Methode hinzufügen

@Override
protected Map getParams() throws AuthFailureError {
    return this.params;
}

Answer 3

public void sendUserRegistrationRequest(final UserRequest userRequest, final ResponseListener responseListener) {
    String url = Api.POST_NRNA_REGISTRATION;

    StringRequest userRegistrationRequest = new StringRequest(Request.Method.POST, url, new com.android.volley.Response.Listener() {
        @Override
        public void onResponse(String response) {

            JSONObject jsonObject = GsonUtils.getJSONObject(response);
            LoggerUtils.log(TAG, "" + jsonObject.toString());

        }
    }, new com.android.volley.Response.ErrorListener() {
        @Override
        public void onErrorResponse(VolleyError error) {
            LoggerUtils.log(TAG, GsonUtils.toString(error));
            responseListener.onError(GsonUtils.toString(error));
        }
    }) {

        //use this if you have to use form posting : for application/x-www-form-urlencoded;
        @Override
        protected Map getParams() throws AuthFailureError {
            return GsonUtils.getHashMap(userRequest);
        }

        @Override
        public String getBodyContentType() {
            return "application/x-www-form-urlencoded; charset=UTF-8";
        }

    };
    VolleyRequestQueue.getInstance(context).addToRequestQueue(userRegistrationRequest);
}

Verwenden Sie dies, wenn Sie wie "application/json" senden müssen

        @Override
        public byte[] getBody() throws AuthFailureError {
            String jsonData = GsonUtils.toString(userRequest);
            return jsonData.getBytes();
        }

        @Override
        public String getBodyContentType() {
            return "application/json";
        }

public class GsonUtils {

public static String TAG = GsonUtils.class.getSimpleName();

public static  T toObject(String data, Class type) {
    Gson gson = new Gson();
    return gson.fromJson(data, type);
}

public static String toString(Object src) {
    if (src == null) {
        return null;
    }
    GsonBuilder builder = new GsonBuilder();
    builder.setPrettyPrinting();
    Gson gson = builder.create();
    return gson.toJson(src);
}

public static  T toObject(String data, Type type) {
    try {
        Gson gson = new Gson();
        return gson.fromJson(data, type);
    } catch (Exception ex) {
        Timber.v(ex.getMessage());
        return null;
    }
}

public static JSONObject getJSONObject(Object src) {
    String data = toString(src);
    LoggerUtils.log(TAG, data);
    try {
        return new JSONObject(data);
    } catch (JSONException e) {
        LoggerUtils.log(TAG, e.getMessage());
    }
    return null;
}

public static JSONObject getJSONObject(String data) {
    try {
        return new JSONObject(data);
    } catch (JSONException e) {
        LoggerUtils.log(TAG, e.getMessage());
    }
    return null;
}

public static HashMap getHashMap(Object src) {
    String data = toString(src);
    LoggerUtils.log(TAG, data);
    return toObject(data, new TypeToken>() {
    }.getType());
}

}