Java 使用android volley库发送JSONArray POST请求

我想发送和接收一个带有截图的Json数组。 现在我可以接收一个数组了，但我不知道如何发送请求（例如：使用post方法）

JsonArrayRequest arrayReq=新的JsonArrayRequest（URL，
新侦听器（）{
}

以下是一个示例：

// Define the web service URL
final String URL = "http://www.someurl.com";

// POST params to be sent to the server
HashMap<String, String> params = new HashMap<String, String>();
params.put("name", "raha tamjid");

// Define the POST request
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);

在类

JsonArrayRequest

中，该类出现在

Volley

库代码中。现在您可以使用该类创建

JsonArrayRequest

对象，并将它们添加到

RequestQueue

编辑2:

1。从中获取Volley库项目。下载该项目并在IDE中进行设置

2.对

JsonRequest

类（位于

com.android.volley.toolbox

命名空间中）进行修改，如编辑1中所述

3.从应用程序项目的

libs

文件夹中删除

volley.jar

4.现在转到项目属性->Android->Library，点击添加。从这里选择

截击

项目。清理并重建

5.现在在您的应用程序项目中您可以制作一个POST

JsonArrayRequest

，就像我们制作一个POST

JsonObjectRequest

并在

响应中获得一个
JSONArray
列表map=new ArrayList（）；
 List<Map<String,String>> listMap =  new ArrayList<Map<String, String>>();
        Map<String,String> map  = new HashMap<String,String>();
        try {

            map.put("email", customer.getEmail());
            map.put("password",customer.getPassword());

        } catch (Exception e) {
            e.printStackTrace();
        }
        listMap.add(map);

        String url = PersonalConstants.BASE_URL+"/url";
        JsonObjectRequest jsonObjectRequest = new JsonObjectRequest(
                Request.Method.POST, url, String.valueOf(new JSONArray(listMap)),
                new Response.Listener<JSONObject>() {
                    @Override
                    public void onResponse(JSONObject jsonObject) {
                        Log.d(App.TAG, jsonObject.toString());
                    }
                }, new Response.ErrorListener (){

            @Override
            public void onErrorResponse(VolleyError volleyError) {
                Log.d(App.TAG,volleyError.toString());
            }
        }
        );
        App.getInstance().getmRequestQueue().add(jsonObjectRequest);

Map Map=newhashmap（）；
试一试{
map.put（“email”，customer.getEmail（））；
map.put（“password”，customer.getPassword（））；
}捕获（例外e）{
e、 printStackTrace（）；
}
添加（map）；
字符串url=PersonalConstants.BASE_url+“/url”；
JsonObjectRequest JsonObjectRequest=新JsonObjectRequest(
Request.Method.POST、url、String.valueOf（新JSONArray（listMap）），
新的Response.Listener（）{
@凌驾
公共void onResponse（JSONObject JSONObject）{
Log.d（App.TAG，jsonObject.toString（））；
}
}，new Response.ErrorListener（）{
@凌驾
公共错误响应（截击错误截击错误）{
Log.d（App.TAG，volleyError.toString（））；
}
}
);
App.getInstance（）.getmRequestQueue（）.add（jsonObjectRequest）；

创建一个类并扩展JsonArrayRequest，然后重写

@Override
protected Map<String, String> getParams() throws AuthFailureError {
    HashMap<String, String> params = new HashMap<String, String>();
    params.put("name", "value");
    return params;
}

and add a new constructor and in it call

super(Method.POST, url, null, listener, errorListener);

or use this class

public class PostJsonArrayRequest extends JsonRequest<JSONArray> {

    /**
     * Creates a new request.
     * @param url URL to fetch the JSON from
     * @param listener Listener to receive the JSON response
     * @param errorListener Error listener, or null to ignore errors.
     */
    public PostJsonArrayRequest(String url, Response.Listener<JSONArray> listener, Response.ErrorListener errorListener) {
        super(Method.POST, url, null, listener, errorListener);
    }

    @Override
    protected Map<String, String> getParams() throws AuthFailureError {
        HashMap<String, String> params = new HashMap<String, String>();
        params.put("name", "value");
        return params;
    }

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

@覆盖
受保护的映射getParams（）引发AuthFailureError{
HashMap params=新的HashMap（）；
参数put（“名称”、“值”）；
返回参数；
}
并添加一个新的构造函数并在其中调用
super（Method.POST、url、null、listener、errorListener）；
或者使用这个类
公共类PostJsonArrayRequest扩展了JsonRequest{
/**
*创建一个新请求。
*@param url从中获取JSON
*@param listener用于接收JSON响应
*@param errorListener Error listener，或null忽略错误。
*/
public PostJsonArrayRequest（字符串url，Response.Listener，Response.ErrorListener ErrorListener）{
super（Method.POST、url、null、listener、errorListener）；
}
@凌驾
受保护的映射getParams（）引发AuthFailureError{
HashMap params=新的HashMap（）；
参数put（“名称”、“值”）；
返回参数；
}
@凌驾
受保护的响应parseNetworkResponse（NetworkResponse响应）{
试一试{
字符串jsonString=
新字符串（response.data，HttpHeaderParser.parseCharset（response.headers））；
返回Response.success（新的JSONArray（jsonString），
HttpHeaderParser.parseCacheHeaders（响应））；
}捕获（不支持的编码异常e）{
返回Response.error（新的ParseError（e））；
}捕获（JSONException je）{
返回Response.error（newparseerror（je））；
}
}
}

创建一个名为JsonArrayPostRequest的新java类现在您可以像前面的请求一样使用它，只需将JSONArrayRequest替换为JsonArrayPostRequest并传递正确的参数即可

public  class JsonArrayPostRequest extends Request<JSONArray>{  
    private Map<String,String> mParam;  
    private Listener<JSONArray>  mListener;  


    public JsonArrayPostRequest(String url,Listener<JSONArray> listener, ErrorListener errorListener,Map param) {  
        super(Request.Method.POST, url, errorListener);  
        mListener=listener;  
        mParam=param;   
    }  
    @Override  
    protected Map<String, String> getParams() throws AuthFailureError {  
        return mParam;  
    }  

       @Override  
        protected Response<JSONArray> parseNetworkResponse(NetworkResponse response) {  
            try {  
                String jsonString =  
                    new String(response.data, HttpHeaderParser.parseCharset(response.headers));  
                return Response.success(new JSONArray(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(JSONArray response) {  
        mListener.onResponse(response);  

    }  

} 

公共类JsonArrayPostRequest扩展请求{
私人地图；
私人倾听者；
公共JsonArrayPostRequest（字符串url、侦听器侦听器、ErrorListener ErrorListener、映射参数）{
super（Request.Method.POST、url、errorListener）；
mListener=监听器；
mParam=param；
}  
@凌驾
受保护的映射getParams（）引发AuthFailureError{
返回内存；
}  
@凌驾
受保护的响应parseNetworkResponse（NetworkResponse响应）{
试试{
字符串jsonString=
新字符串（response.data，HttpHeaderParser.parseCharset（response.headers））；
返回Response.success（新的JSONArray（jsonString），
HttpHeaderParser.parseCacheHeaders（响应））；
}捕获（不支持的编码异常e）{
返回Response.error（新的ParseError（e））；
}捕获（JSONException je）{
返回Response.error（newparseerror（je））；
}  
}  
@凌驾
受保护的void deliverResponse（JSONArray响应）{
mListener.onResponse（response）；
}  
} 

使用：

JsonArrayPostRequest请求=新的JsonArrayPostRequest（URL，new Response.Listener（），
新的Response.ErrorListener（），参数）；

谢谢。但我想得到Json数组作为响应，而不是Json对象。不。我有截图的.jar文件。你能告诉我怎么做吗？谢谢

@Override
protected Map<String, String> getParams() throws AuthFailureError {
    HashMap<String, String> params = new HashMap<String, String>();
    params.put("name", "value");
    return params;
}

and add a new constructor and in it call

super(Method.POST, url, null, listener, errorListener);

or use this class

public class PostJsonArrayRequest extends JsonRequest<JSONArray> {

    /**
     * Creates a new request.
     * @param url URL to fetch the JSON from
     * @param listener Listener to receive the JSON response
     * @param errorListener Error listener, or null to ignore errors.
     */
    public PostJsonArrayRequest(String url, Response.Listener<JSONArray> listener, Response.ErrorListener errorListener) {
        super(Method.POST, url, null, listener, errorListener);
    }

    @Override
    protected Map<String, String> getParams() throws AuthFailureError {
        HashMap<String, String> params = new HashMap<String, String>();
        params.put("name", "value");
        return params;
    }

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

public  class JsonArrayPostRequest extends Request<JSONArray>{  
    private Map<String,String> mParam;  
    private Listener<JSONArray>  mListener;  


    public JsonArrayPostRequest(String url,Listener<JSONArray> listener, ErrorListener errorListener,Map param) {  
        super(Request.Method.POST, url, errorListener);  
        mListener=listener;  
        mParam=param;   
    }  
    @Override  
    protected Map<String, String> getParams() throws AuthFailureError {  
        return mParam;  
    }  

       @Override  
        protected Response<JSONArray> parseNetworkResponse(NetworkResponse response) {  
            try {  
                String jsonString =  
                    new String(response.data, HttpHeaderParser.parseCharset(response.headers));  
                return Response.success(new JSONArray(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(JSONArray response) {  
        mListener.onResponse(response);  

    }  

} 

JsonArrayPostRequest request = new JsonArrayPostRequest(URL,new Response.Listener<JSONArray>(),             
                new Response.ErrorListener() ,params);