安卓Volley设置post带参数请求

Volley带参数POST请求方法一

. Volley请求最终会被封装成HttpRequest子类对象HttpUrlRequest,该方法在HttpClientStack中的createHttpRequest()方法

    @SuppressWarnings("deprecation")
     protected  static HttpUriRequest createHttpRequest(Request<?> request,
            Map<String, String>additionalHeaders) throws AuthFailureError {
        switch (request.getMethod()) {
            case Method.DEPRECATED_GET_OR_POST:{
                byte[] postBody =request.getPostBody();
                if (postBody != null) {
                    HttpPost postRequest = new HttpPost(request.getUrl());
                    postRequest.addHeader(HEADER_CONTENT_TYPE,request.getPostBodyContentType());
                    HttpEntity entity;
                    entity = new ByteArrayEntity(postBody);
                   postRequest.setEntity(entity);
                    return postRequest;
                } else {
                    return newHttpGet(request.getUrl());
                }
            }
            case Method.GET:
                return newHttpGet(request.getUrl());
            case Method.DELETE:
                return newHttpDelete(request.getUrl());
            case Method.POST: {
                HttpPost postRequest = new HttpPost(request.getUrl());
               postRequest.addHeader(HEADER_CONTENT_TYPE,request.getBodyContentType());
                //设置请求体 body信息 --post请求
                setEntityIfNonEmptyBody(postRequest, request);
                return postRequest;
            }
            case Method.PUT: {
                HttpPut putRequest = new HttpPut(request.getUrl());
               putRequest.addHeader(HEADER_CONTENT_TYPE, request.getBodyContentType());
               setEntityIfNonEmptyBody(putRequest, request);
                return putRequest;
            }
            case Method.HEAD:
                return new HttpHead(request.getUrl());
            case Method.OPTIONS:
                return new HttpOptions(request.getUrl());
            case Method.TRACE:
                return new HttpTrace(request.getUrl());
            case Method.PATCH: {
                HttpPatch patchRequest = newHttpPatch(request.getUrl());
               patchRequest.addHeader(HEADER_CONTENT_TYPE,request.getBodyContentType());
               setEntityIfNonEmptyBody(patchRequest, request);
                return patchRequest;
            }
            default:
                throw newIllegalStateException("Unknown request method.");
        }
    }

从上面代码中可以看到，当请求方式为POST的时候，会通过setEntityIfNonEmptyBody(postRequest, request) 的方式设置请求体；

setEntityIfNonEmptyBody(postRequest, request)

 /**
     * 如果request的请求体不为空，进行设置请求体信息
     * @param httpRequest
     * @param request
     * @throws AuthFailureError
     */
    private static void setEntityIfNonEmptyBody(HttpEntityEnclosingRequestBase httpRequest,
            Request<?> request) throws AuthFailureError {
        byte[] body = request.getBody();
        if (body != null) {
            HttpEntity entity = new ByteArrayEntity(body);
            httpRequest.setEntity(entity);
        }
    }

接着，我们会发现，byte[] body = request.getBody()，是通过request的getBody()方法来获取参数的，接着看getVBody()方法：

request.getBody()

/**
     * 如果请求是POST或者PUT方法，去获取请求参数信息，然后设置到请求中
     */
    public byte[] getBody() throws AuthFailureError {
        //获取请求参数信息
        Map<String, String> params =getParams();
        if (params != null &¶ms.size() > 0) {
            return encodeParameters(params,getParamsEncoding());
        }
        return null;
    }

在这。会发现getBody()中是通过getParams()来获取参数map的，接着来看getParams()：

getParams()

protected Map<String, String> getParams() throws AuthFailureError {
        return null;
    }

我们会发现，getParams()中直接返回了null，但是，可以修改Volley中的代码来使得POST请求携带参数

具体如下：

/**
     * 自定义修改 新增POST请求参数map
     */
    protected Map<String,String> mParams=null;
    public void setParams(Map<String,String> params) {
        this.mParams = params;
    }

在getParams()返回mParams:

/**
     * 进行获取post请求参数数据
     */
    protected Map<String, String> getParams() throws AuthFailureError {
        //return null;
        //之前返回的为null，重新返回params
        return mParams;
    }

接着，对StringRequest类进行扩展一个构造方法

/**
     * 扩展POST请求构造函数
     * @param url 请求地址
     * @param listener   数据请求加载成功监听器
     * @param errorListener  数据请求加载失败监听器
     * @param params  POST请求参数
     */
    public StringRequest(String url,Listener<String> listener, ErrorListenererrorListener,Map<String,String> params) {
        this(Method.POST, url, listener,errorListener);
        //进行初始化Request中post 请求参数
        setParams(params);
    }

之后，StringRequest携带参数请求

 String url = HttpUrl.LoginInUrl;
RequestQueue requestQueue=Volley.newRequestQueue(this);
              //修改Volley源代码,扩展StringRequest支持post参数设置
                Map<String,String>params=new HashMap<String,String>();
               params.put("username","admin");
               params.put("password","110110");
                StringRequest post_stringRequest=new StringRequest(url ,new Response.Listener<String>() {
                    @Override
                    public void onResponse(String response) {
                         Log.e("response", "---" + response);
                    }
                }, new Response.ErrorListener(){
                    @Override
                    public void onErrorResponse(VolleyError error) {
                            Log.e("onErrorResponse", "---" + error);
                    }
                },params);
               requestQueue.add(post_stringRequest)

Volley带参数POST请求方法二

重写getParams()方法，返回参数集合

        String url = HttpUrl.LoginInUrl;
        RequestQueue requestQueue = Volley.newRequestQueue(this);
        StringRequest sr = new StringRequest(Request.Method.POST, url, new Response.Listener<String>() {
            @Override
            public void onResponse(String response) {
                Log.e("response", "---" + response);
        }, new Response.ErrorListener() {
            @Override
            public void onErrorResponse(VolleyError error) {
                Log.e("onErrorResponse", "---" + error);
            }
        }) {
            @Override
            protected Map<String, String> getParams() {
                Map<String, String> params = new HashMap<>();
                params.put("mobile", phone_number.getText().toString());
                params.put("password", password.getText().toString());
                return params;
            }
        };
        requestQueue.add(sr);