自定义Volley添加请求头、发送Post请求、Volley的同步和异步、getParams 不被调用

一、自定义Volley

我这里定义了fastJson和Volley的Request

• 1、首先创建一个类，继承Request类并在<>中写上要返回的类型

• 2、实现需要重写的方法

主要是parseNetworkResponse方法和deliverResponse

parseNetworkResponse（）：Volley在工作线程中调用该方法，它包含了一些请求的状态码、请求头等，它返回的数据类型必须是Response

deliverResponse（）：在主线程中回调parseNetworkResponse返回来的数据

public class MyRequest extends Request<JSONObject> {

    private Response.Listener<JSONObject> mListener;
    private  Map<String, String> headers;
    private Priority mPriority;

    public MyRequest(int method,String url,  Map<String, String> headers, Response.ErrorListener errorListener,Response.Listener listener){
        super(method,url,errorListener);
        this.mListener = listener;
        this.headers = headers;

    }

    public MyRequest(int method, String url, Response.ErrorListener listener) {
        super(method, url, listener);
    }

    //设置超时
    @Override
    public RetryPolicy getRetryPolicy() {
        RetryPolicy retryPolicy = new DefaultRetryPolicy(3000, DefaultRetryPolicy.DEFAULT_MAX_RETRIES, DefaultRetryPolicy.DEFAULT_BACKOFF_MULT);
        return retryPolicy;
    }
    //Post请求参数(参数是键值对)
    @Override
    protected Map<String, String> getParams() throws AuthFailureError {
        return super.getParams();
    }
    //Post请求参数(参数是json的形式,也可以是字符串类型，主要看服务器需求)
    @Override
    public byte[] getBody() throws AuthFailureError {
        return super.getBody();
    }

    public void setPriority(Priority priority) {
        mPriority = priority;
    }
    //设置优先级
    @Override
    public Priority getPriority() {
        return mPriority == null ? Priority.NORMAL : mPriority;
    }

    //设置请求头
    @Override
    public Map<String, String> getHeaders() throws AuthFailureError {

        Map<String, String> headers = new HashMap<String, String>();
        headers.put("Charset", "UTF-8");
        headers.put("Content-Type", "application/x-javascript");
        return headers;
    }
    @Override
    protected Response<JSONObject> parseNetworkResponse(NetworkResponse networkResponse) {
        String json = null;
        try {
            json = new String(networkResponse.data, HttpHeaderParser.parseCharset(networkResponse.headers));

            return  Response.success(JSON.parseObject(json),HttpHeaderParser.parseCacheHeaders(networkResponse));

        } catch (UnsupportedEncodingException e) {
            e.printStackTrace();
        }
        return null;
    }

    //将数据的返回结果回调给主线程
    @Override
    protected void deliverResponse(JSONObject jsonObject) {
        mListener.onResponse(jsonObject);
    }
}

二、发送POST请求

使用Volley发送POST请求的时候，需要注意是键值对的形式还是json的形式

• 如果使用的是键值对的方式可以通过getParams()方法直接设置

• 如果是通过json的形式需要通过getBody()方式进行设置

[Android] 解决Volley中JsonObjectRequest的Post请求添加参数的问题

注意
有的时候会发现getParams()这个方法没用被调用，如果自定义的Request是继承自JsonRequest那么他默认只会去掉用getBody()方法。直接继承Request就会避免这个问题了，可是有的时候我们还会发现只调用了getBody()方法没用掉用getParams()，那我们看看getParams()是怎么被调用的就知道了。

public byte[] getBody() throws AuthFailureError {
        Map<String, String> params = getParams();
        if (params != null && params.size() > 0) {
            return encodeParameters(params, getParamsEncoding());
        }
        return null;
    }

看到了吧，是在getBody()方法中调用的，所以当你重写了getBody() 方法时，并且添加一些相应的逻辑时，就可能不会掉用getParams()方法。所以这时要调用getParams()方法需要你自己做判断，及在需要调用的地方super.getBody();就可以了。

三、Volley的同步和异步

我们大部分人都可能知道Volley是异步请求的，它会循环开辟四个线程去执行相应的网络请求，也就是我们常用的方式。

有的时候根据需求我们可能会用到同步的网络请求，那么使用Volley如何解决呢？

public class SyncAsyncDemoActivity extends AppCompatActivity {

    private RequestQueue requestQueue;
    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_sync_async_demo);
        requestQueue = Volley.newRequestQueue(SyncAsyncDemoActivity.this);
    }

    //Volley同步网络请求，要在线程中去请求
    public void testOne(View view){

        new Thread(new Runnable() {
            @Override
            public void run() {
                RequestFuture<String> future = RequestFuture.newFuture();
                StringRequest stringRequest = new StringRequest("http://ofmudsqae.bkt.clouddn.com/mynewqq1.text",future,future);
                requestQueue.add(stringRequest);
                try {
                    String request = future.get();
                    future.get(3000, TimeUnit.SECONDS);//添加请求超时
                    Log.e("------------>","同步"+request);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                } catch (ExecutionException e) {
                    e.printStackTrace();
                } catch (TimeoutException e) {
                    e.printStackTrace();
                }
            }
        }).start();
    }
    //Volley的正常请求，不用在子线程中去请求
    public void testTwo(View view){

        StringRequest request = new StringRequest("http://ofmudsqae.bkt.clouddn.com/mynewqq1.text", new Response.Listener<String>() {
            @Override
            public void onResponse(String s) {
                Log.e("------------->","异步"+s);
            }
        }, new Response.ErrorListener() {
            @Override
            public void onErrorResponse(VolleyError volleyError) {

            }
        });

        requestQueue.add(request);
    }
}

一定要注意Volley的同步一定要自己开线程去处理。