众所周知,Android常用的网络开发无外乎HTTP和socket,其中HTTP是应用层协议,TCP/UDP是传输层协议。本文主要来讲讲HTTP协议,其实,HTTP也是用socket封装的,用起来更方便,由于是封装过的,它提供了更强大的功能。Android的HTTP(超文本传输协议)包括两种接口:
1、标准Java接口(java.net) —-HttpURLConnection,可以实现简单的基于URL的请求、响应功能。
2、Apache接口(org.appache.http)—-HttpClient,使用起来更方面更强大。
Android SDK中包含了HttpClient,在Android6.0版本直接删除了HttpClient类库,如果仍想使用则解决方法是:在libs中加入org.apache.http.legacy.jar
这个jar包在:**sdk\platforms\android-23\optional目录中(需要下载android 6.0的SDK)
HttpURLConnection和HttpClient,这两种方式都支持HTTPS协议、以流的形式进行上传和下载、配置超时时间、IPv6、以及连接池等功能。
HttpURLConnection
HttpURLConnection是Java的标准类,继承自URLConnection,用它可以发送和接受任何类型和长度的数据,且预先不用知道数据流的长度,可以设置请求方式GET或POST、超时时间、缓存处理(4.0以上)等,HttpUrlConnection直接支持GZIP压缩。
Android 2.2版本之前,HttpURLConnection一直存在着一些令人厌烦的bug。比如说对一个可读的InputStream调用close()方法时,就有可能会导致连接池失效了。那么我们通常的解决办法就是直接禁用掉连接池的功能:
private void disableConnectionReuseIfNecessary() {
// 这是一个2.2版本之前的bug
if (Integer.parseInt(Build.VERSION.SDK) < Build.VERSION_CODES.FROYO) {
System.setProperty("http.keepAlive", "false");
}
}
所以在Android 2.2版本以及之前的版本使用HttpClient是较好的选择,而在Android 2.3版本及以后,HttpURLConnection则是最佳的选择,它的API简单,体积较小,因而非常适用于Android项目。压缩和缓存机制可以有效地减少网络访问的流量,在提升速度和省电方面也起到了较大的作用。另外在Android 6.0版本中,HttpClient库被移除了,HttpURLConnection则是以后我们唯一的选择。
public static String requestContentWithGet(String urlStr) {
String content = null;
if (urlStr != null && urlStr.startsWith("http://")) {
URL url = null;
HttpURLConnection conn = null;
try {
url = new URL(urlStr);
conn = (HttpURLConnection) url.openConnection();
conn.setDoOutput(true); //设置是否向conn输出,因为这个是post请求,参数要放在http正文内,因此需要设为true, 默认情况下是false
conn.setDoInput(true); //设置是否从conn读入,默认情况下是true
conn.setUseCaches(false); //Post请求不能使用缓存
conn.setRequestMethod("POST"); // 设定请求的方法为"POST",默认是GET
conn.setConnectTimeout(6*1000); //设置连接主机超时
conn.setReadTimeout(6*1000); //设置从主机读取数据超时
conn.setRequestProperty("Content-type", "application/x-java-serialized-object"); //设定传送的内容类型是可序列化的java对象,(如果不设此项,在传送序列化对象时,当WEB服务默认的不是这种类型时可能抛java.io.EOFException)
conn.setRequestProperty("accept", "*/*");
conn.setRequestProperty("Charset", "UTF-8");
conn.connect(); //连接,所有的配置必须要在connect之前完成
OutputStream outStrm = conn.getOutputStream(); //此处getOutputStream会隐含的进行connect(即:如同调用上面的connect()方法,所以在开发中不调用上述的connect()也可以)。
ObjectOutputStream objOutputStrm = new ObjectOutputStream(outStrm); //现在通过输出流对象构建对象输出流对象,以实现输出可序列化的对象。
objOutputStrm.writeObject(new String("我是测试数据")); //向对象输出流写出数据,这些数据将存到内存缓冲区中
objOutputStm.flush(); //刷新对象输出流
objOutputStm.close(); //关闭流对象。此时,不能再向对象输出流写入任何数据,先前写入的数据存在于内存缓冲区中,在调用下边的getInputStream()函数时才把准备好的http请求正式发送到服务器
int responseCode = conn.getResponseCode();
if (responseCode == HttpURLConnection.HTTP_OK) {
//调用conn连接对象的getInputStream()函数, 将内存缓冲区中封装好的完整的HTTP请求电文发送到服务端。
content = convertStream2String(conn.getInputStream()); //getInputStream()方法已调用,本次HTTP请求已结束,下边向对象输出流的输出已无意义,因此,要重新发送数据时需要重新创建连接、重新设参数、重新创建流对象、重新写数据
} else {
content = "";
}
} catch (Exception e) {
} finally {
if (conn != null) {
conn.disconnect();
conn = null;
}
}
}
return content;
}
注:
(1)URL请求的类别:
- GET:get请求可以获取静态页面,也可以把参数放在URL字串后面,传递给servlet。
/**
* 发送GET请求
* @param path 请求路径
* @param params 请求参数
* @param encoding 编码
* @return 请求是否成功
*/
private static boolean sendGETRequest(String urlStr, Map<String, String> params, String encoding) throws Exception{
StringBuilder url = new StringBuilder(urlStr);
url.append("?");
for(Map.Entry<String, String> entry : params.entrySet()){
url.append(entry.getKey()).append("=");
url.append(URLEncoder.encode(entry.getValue(), encoding));
url.append("&");
}
url.deleteCharAt(url.length() - 1);
HttpURLConnection conn = (HttpURLConnection)new URL(url.toString()).openConnection();
conn.setConnectTimeout(5000);
conn.setRequestMethod("GET");
if(conn.getResponseCode() == 200){
return true;
}
return false;
}
- POST:post与get的不同之处在于post的参数不是放在URL字串里面,而是放在http请求的正文内。
/**
* 发送Post请求
* @param path 请求路径
* @param params 请求参数
* @param encoding 编码
* @return 请求是否成功
*/
private static boolean sendPOSTRequest(String path, Map<String, String> params, String encoding) throws Exception{
StringBuilder data = new StringBuilder();
if(params!=null && !params.isEmpty()){
for(Map.Entry<String, String> entry : params.entrySet()){
data.append(entry.getKey()).append("=");
data.append(URLEncoder.encode(entry.getValue(), encoding));
data.append("&");
}
data.deleteCharAt(data.length() - 1);
}
byte[] entity = data.toString().getBytes();//生成实体数据,Post方式提交参数的话,不能省略内容类型与长度
HttpURLConnection conn = (HttpURLConnection) new URL(path).openConnection();
conn.setConnectTimeout(5000);
conn.setRequestMethod("POST");
conn.setDoOutput(true);//允许对外输出数据
conn.setRequestProperty("Content-Type", "application/x-www-form-urlencoded");
conn.setRequestProperty("Content-Length", String.valueOf(entity.length));
OutputStream outStream = conn.getOutputStream();
outStream.write(entity);
if(conn.getResponseCode() == 200){
return true;
}
return false;
}
(2)Http请求头(Header):
所有关于此次http请求的配置都在http头里面定义,connect()函数会根据HttpURLConnection对象的配置值生成http头信息,因此在调用connect函数之前,就必须把所有的配置(那一堆set函数)准备好。
(3)Http请求消息体(Body):
在http头后面紧跟着的是http请求的正文,正文的内容是通过outputStream流写入的,实际上outputStream不是一个网络流,充其量是个字符串流,往里面写入的东西不会立即发送到网络,而是存在于内存缓冲区中,待outputStream流关闭时,根据输入的内容生成http正文。至此,http请求的东西已经全部准备就绪。在getInputStream()函数调用的时候,就会把准备好的http请求(包括http头和正文)正式发送到服务器了,然后返回一个输入流,用于读取服务器对于此次http请求的返回信息。由于http请求在getInputStream的时候已经发送出去了,因此在getInputStream()函数之后对connection对象进行设置(对http头的信息进行修改)或者写入outputStream(对正文进行修改)都是没有意义的了,执行这些操作会导致异常的发生。
任何一种接口,无外乎四个基本功能:访问网页、下载图片或文件、上传文件。下面我们逐一看一下。
(1)访问网页:
GET:
/**
* @Description Get获取网络资源
* @param urlPath 网络资源的地址
* @param params Get请求参数
* @param encoding 发送内容编码方式
* @return 返回网络资源的内容(字符串)
*/
public static String sendGetRequest(String urlPath, Map<String, String> params, String encoding) throws Exception {
// 使用StringBuilder对象
StringBuilder sb = new StringBuilder(urlPath);
sb.append('?');
// 迭代Map
for (Map.Entry<String, String> entry : params.entrySet()) {
//解决请求参数中含有中文导致乱码问题
sb.append(entry.getKey()).append('=').append(URLEncoder.encode(entry.getValue(), encoding)).append('&');
}
sb.deleteCharAt(sb.length() - 1);
// 打开链接
URL url = new URL(sb.toString());
HttpURLConnection conn = (HttpURLConnection) url.openConnection();
conn.setRequestMethod("GET");
conn.setRequestProperty("Content-Type", "text/xml");
conn.setRequestProperty("Charset", encoding);
conn.setConnectTimeout(PARAM_CONNECT_TIMEOUT);
// 如果请求响应码是200,则表示成功
if (conn.getResponseCode() == 200) {
// 获得服务器响应的数据
BufferedReader in = new BufferedReader(new InputStreamReader(conn.getInputStream(), encoding));
// 数据
String retData = null;
String responseData = "";
while ((retData = in.readLine()) != null) {
responseData += retData;
}
in.close();
return responseData;
}
return "sendGetRequest error!";
}
POST:
/**
* 通过Post方式提交参数给服务器
*/
public static String sendPostRequest(String urlPath,Map<String, String> params, String encoding) throws Exception {
StringBuilder sb = new StringBuilder();
// 如果参数不为空
if (params != null && !params.isEmpty()) {
for (Map.Entry<String, String> entry : params.entrySet()) {
// Post方式提交参数的话,不能省略内容类型与长度
sb.append(entry.getKey()).append('=').append(URLEncoder.encode(entry.getValue(), encoding)).append('&');
}
sb.deleteCharAt(sb.length() - 1);
}
// 得到实体的二进制数据
byte[] entitydata = sb.toString().getBytes();
URL url = new URL(urlPath);
HttpURLConnection conn = (HttpURLConnection) url.openConnection();
conn.setRequestMethod("POST");
conn.setConnectTimeout(PARAM_CONNECT_TIMEOUT);
// 如果通过post提交数据,必须设置允许对外输出数据
conn.setDoOutput(true);
// 这里只设置内容类型与内容长度的头字段
conn.setRequestProperty("Content-Type","application/x-www-form-urlencoded");
// conn.setRequestProperty("Content-Type", "text/xml");
conn.setRequestProperty("Charset", encoding);
conn.setRequestProperty("Content-Length", String.valueOf(entitydata.length));
OutputStream outStream = conn.getOutputStream();
// 把实体数据写入是输出流
outStream.write(entitydata);
// 内存中的数据刷入
outStream.flush();
outStream.close();
// 如果请求响应码是200,则表示成功
if (conn.getResponseCode() == 200) {
// 获得服务器响应的数据
BufferedReader in = new BufferedReader(new InputStreamReader(conn.getInputStream(), encoding));
// 数据
String retData = null;
String responseData = "";
while ((retData = in.readLine()) != null) {
responseData += retData;
}
in.close();
return responseData;
}
return "sendPostRequest error!";
}
/**
* 通过Post方式传送文本给服务器,例如Json,xml等
*/
public static String sendTxtWithPost(String urlPath, String txt, String encoding) throws Exception {
byte[] sendData = txt.getBytes(encoding);
URL url = new URL(urlPath);
HttpURLConnection conn = (HttpURLConnection) url.openConnection();
conn.setRequestMethod("POST");
conn.setConnectTimeout(PARAM_CONNECT_TIMEOUT);
// 如果通过post提交数据,必须设置允许对外输出数据
conn.setDoOutput(true);
conn.setRequestProperty("Content-Type", "text/xml");
conn.setRequestProperty("Charset", encoding);
conn.setRequestProperty("Content-Length", String.valueOf(sendData.length));
OutputStream outStream = conn.getOutputStream();
outStream.write(sendData);
outStream.flush();
outStream.close();
if (conn.getResponseCode() == 200) {
// 获得服务器响应的数据
BufferedReader in = new BufferedReader(new InputStreamReader(conn.getInputStream(), encoding));
// 数据
String retData = null;
String responseData = "";
while ((retData = in.readLine()) != null) {
responseData += retData;
}
in.close();
return responseData;
}
return "sendTxtWithPost error!";
}
(2)下载文件或图片:
/**
* @Description Get获取网络资源
* @param urlPath 网络资源的地址
* @param params Get请求参数
* @param encoding 发送内容编码方式
* @return 返回下载结果
*/
public static String downloadFileWithGet(String urlPath, String dirPath, String filename, String encoding) throws Exception {
// 使用StringBuilder对象
StringBuilder sb = new StringBuilder(urlPath);
sb.append('?');
//解决请求参数中含有中文导致乱码问题
sb.append("filename").append('=').append(URLEncoder.encode(filename, encoding));
// 打开链接
URL url = new URL(sb.toString());
HttpURLConnection conn = (HttpURLConnection) url.openConnection();
conn.setRequestMethod("GET");
conn.setRequestProperty("Content-Type", "image/png");
conn.setRequestProperty("Charset", encoding);
conn.setConnectTimeout(PARAM_CONNECT_TIMEOUT);
// 如果请求响应码是200,则表示成功
if (conn.getResponseCode() == 200) {
// 获得服务器响应的数据
InputStream in = conn.getInputStream();
File resultFile = write2SDFromInput(dirPath, filename, in);
in.close();
if (resultFile == null) {
return "下载失败";
}
return "下载成功";
}
return "下载失败";
}
/**
* 将一个InputStream里面的数据写入到SD卡中
*/
private static File write2SDFromInput(String directory, String fileName,InputStream input) {
File file = null;
FileOutputStream output = null;
File dir = new File(directory);
if (!dir.exists()) {
dir.mkdir();
}
try {
file = new File(dir + File.separator + fileName);
file.createNewFile();
output = new FileOutputStream(file);
byte buffer[] = new byte[1024];
while ((input.read(buffer)) != -1) {
output.write(buffer);
}
output.flush();
} catch (IOException e) {
e.printStackTrace();
} finally {
try {
output.close();
} catch (IOException e) {
e.printStackTrace();
}
}
return file;
}
(3)上传文件
/**
* 上传文件,这里不支持进度显示和断点续传
* @param urlPath 上传的服务器的路径
* @param filePath 需要上传的文件路径
* @param newName 上传的文件名称,不填写将为需要上传文件表单中的名字
* @throws IOException
*/
public static String sendFileWithPost (String urlPath, String filePath,String newName) throws Exception {
String end = "\r\n";
String twoHyphens = "--";
String boundary = "*****";
StringBuilder sb = new StringBuilder();
/**
* 上传文件的头
*/
sb.append(twoHyphens + boundary + end);
sb.append("Content-Disposition: form-data; " + "name=\"uploadFile\";filename=\"" + newName + "\"" + end);
// sb.append("Content-Type: image/png" + "\r\n");// 如果服务器端有文件类型的校验,必须明确指定ContentType
sb.append(end);
byte[] headerInfo = sb.toString().getBytes("UTF-8");
byte[] endInfo = (end + twoHyphens + boundary + twoHyphens + end).getBytes("UTF-8");
URL url = new URL(urlPath);
HttpURLConnection con = (HttpURLConnection) url.openConnection();
/* 允许Input、Output,不使用Cache */
con.setDoInput(true);
con.setDoOutput(true);
con.setUseCaches(false);
/* 设置传送的method=POST */
con.setRequestMethod("POST");
/* setRequestProperty */
con.setRequestProperty("Connection", "Keep-Alive");
con.setRequestProperty("Charset", "UTF-8");
con.setRequestProperty("Content-Type", "multipart/form-data;boundary=" + boundary);
/* 设置OutputStream */
OutputStream out = con.getOutputStream();
out.write(headerInfo);
/* 取得文件的FileInputStream */
FileInputStream in = new FileInputStream(filePath);
/* 设置每次写入1024bytes */
int bufferSize = 1024;
byte[] buffer = new byte[bufferSize];
int length = -1;
/* 从文件读取数据至缓冲区 */
while ((length = in.read(buffer)) != -1) {
/* 将资料写入DataOutputStream中 */
out.write(buffer, 0, length);
}
out.write(endInfo);
/* close streams */
in.close();
// 内存中的数据刷入
out.flush();
out.close();
/* 取得Response内容 */
// 如果请求响应码是200,则表示成功
if (con.getResponseCode() == 200) {
// 获得服务器响应的数据
BufferedReader bf = new BufferedReader(new InputStreamReader(con.getInputStream(), "utf-8"));
// 数据
String retData = null;
String responseData = "";
while ((retData = bf.readLine()) != null) {
responseData += retData;
}
bf.close();
return responseData;
}
return "sendFileWithPost error!";
}
HttpClient
如果只是向Web站点的某个简单页面提交请求并获取服务器响应,HttpURLConnection完全可以胜任。但在绝大部分情况下,Web站点的网页可能没这么简单,这些页面并不是通过一个简单的URL就可访问的,可能需要用户登录而且具有相应的权限才可访问该页面。在这种情况下,就需要涉及Session、Cookie的处理了,如果打算使用HttpURLConnection来处理这些细节,当然也是可能实现的,只是处理起来难度就大了。
为了更好地处理向Web站点请求,包括处理Session、Cookie等细节问题,Apache开源组织提供了一个HttpClient项目,它是一个简单的HTTP客户端(并不是浏览器),可以用于发送HTTP请求,接收HTTP响应,但不会缓存服务器的响应,不能执行HTML页面中嵌入的JavaScript代码;也不会对页面内容进行任何解析、处理。它只是关注于如何发送请求、接收响应,以及管理HTTP连接。
其实访问Web应用中被保护的页面,使用浏览器则十分简单,用户通过系统提供的登录页面登录系统,浏览器会负责维护与服务器之间的Sesion,如果用户登录的用户名、密码符合要求,就可以访问被保护资源了。在Android应用程序中,则可使用HttpClient来登录系统,只要应用程序使用同一个HttpClient发送请求,HttpClient会自动维护与服务器之间的Session状态,也就是说程序第一次使用HttpClient登录系统后,接下来使用HttpClient即可访问被保护页而了。
HttpClient有三个已知的实现类分别是:AbstractHttpClient, AndroidHttpClient, DefaultHttpClient,会发现有一个专门为Android应用准备的实现类AndroidHttpClient,当然使用常规的DefaultHttpClient也可以实现功能,但是既然开发的是Android应用程序,还是使用Android专有的实现类,一定有其优势。HttpClient支持但默认不带GZIP压缩,可以自己写。
使用方法:
1. 创建HttpClient对象。
2. 创建请求方法的实例,并指定请求URL。如果需要发送GET请求,创建HttpGet对象;如果需要发送POST请求,创建HttpPost对象。
3. 如果需要发送请求参数,可调用HttpGet、HttpPost共同的setParams(HttpParams params)方法来添加请求参数;对于HttpPost对象而言,也可调用setEntity(HttpEntity entity)方法来设置请求参数。
4. 调用HttpClient对象的execute(HttpUriRequest request)发送请求,该方法返回一个HttpResponse。
5. 调用HttpResponse的getAllHeaders()、getHeaders(String name)等方法可获取服务器的响应头;调用HttpResponse的getEntity()方法可获取HttpEntity对象,该对象包装了服务器的响应内容。程序可通过该对象获取服务器的响应内容。
6. 释放连接。无论执行方法是否成功,都必须释放连接。
public static String sendHttpClientWithPost(String urlPath,Map<String, String> params, String encoding) throws Exception {
BasicHttpParams params = new BasicHttpParams();
HttpConnectionParams.setConnectionTimeout(params, 6000); //连接超时
HttpConnectionParams.setSoTimeout(params, 6000); //等待数据超时
DefaultHttpClient client = new DefaultHttpClient(params);
// 需要把参数放到NameValuePair
List<NameValuePair> paramPairs = new ArrayList<NameValuePair>();
if (params != null && !params.isEmpty()) {
for (Map.Entry<String, String> entry : params.entrySet()) {
paramPairs.add(new BasicNameValuePair(entry.getKey(), entry.getValue()));
}
}
// 对请求参数进行编码,得到实体数据
UrlEncodedFormEntity entitydata = new UrlEncodedFormEntity(paramPairs, encoding);
// 构造一个请求路径
HttpPost post = new HttpPost(urlPath);
//添加请求头
post.addHeader("Connection", "Keep-Alive");
// 设置请求实体
post.setEntity(entitydata);
// 执行post请求
HttpResponse response = client.execute(post);
// 从状态行中获取状态码,判断响应码是否符合要求
if (response.getStatusLine().getStatusCode() == 200) {
HttpEntity entity = response.getEntity();
InputStream inputStream = entity.getContent();
InputStreamReader inputStreamReader = new InputStreamReader(inputStream, encoding);
BufferedReader reader = new BufferedReader(inputStreamReader);// 读字符串用的。
String s;
String responseData = "";
while (((s = reader.readLine()) != null)) {
responseData += s;
}
reader.close();// 关闭输入流
return responseData;
}
return "sendHttpClientPost error!";
}
选用:
1、涉及Session、Cookie的处理建议使用HttpClient。
2、在Android 2.2版本之前,HttpClient拥有较少的bug,因此使用它是最好的选择。而在Android 2.3版本及以后,HttpURLConnection则是最佳的选择。它的API简单,体积较小,因而非常适用于Android项目。压缩和缓存机制可以有效地减少网络访问的流量,在提升速度和省电方面也起到了较大的作用。对于新的应用程序应该更加偏向于使用HttpURLConnection,因为在以后的工作当中我们也会将更多的时间放在优化HttpURLConnection上面。
AsyncHttpClient
HttpURLConnection和HttpClient的用法还是稍微有些复杂的,如果不进行适当封装的话,很容易就会写出不少重复代码。于是乎,一些Android网络通信框架也就应运而生,比如说AsyncHttpClient(需要导入JAR包),它把HTTP所有的通信细节全部封装在了内部,我们只需要简单调用几行代码就可以完成通信操作了。它是专门针对Android在Apache的HttpClient基础上构建的异步的callback-based http client。所有的请求全在UI线程之外发生,而callback发生在创建它的线程中,应用了Android的Handler发送消息机制。你也可以把AsyncHttpClient应用在Service中或者后台线程中,库代码会自动识别出它所运行的context。
AsyncHttpClient client = new AsyncHttpClient();
client.get("http://www.google.com", new AsyncHttpResponseHandler() {
@Override
public void onStart() {
// called before request is started
}
@Override
public void onSuccess(int statusCode, Header[] headers, byte[] response) {
// called when response HTTP status is "200 OK"
}
@Override
public void onFailure(int statusCode, Header[] headers, byte[] errorResponse, Throwable e) {
// called when response HTTP status is "4XX" (eg. 401, 403, 404)
}
@Override
public void onRetry(int retryNo) {
// called when request is retried
}
});
这里你只需要通过匿名内部类的方式实现AsyncHttpResponseHandler,而且更棒的是你只需要override感兴趣的方法,比如一般都是onSuccess和onFailure。这个版本的get方法没有为请求传递任何参数,当然你也可以通过RequestParams来传递各种参数,如下:
AsyncHttpClient client = new AsyncHttpClient();
RequestParams params = new RequestParams();
params.put("key", "value");
params.put("more", "data");
client.get("http://www.google.com", params, new AsyncHttpResponseHandler() {
@Override
public void onSuccess(int statusCode, Header[] headers, byte[] responseBody) {
String reponse = new String(responseBody);
Log.d("onSuccess", reponse );
}
@Override
public void onFailure(int statusCode, Header[] headers, byte[] responseBody, Throwable error) {
Log.d("onFailure", error);
}
}
);
以上的例子是返回的response直接是原生字节流的情况,如果你需要把返回的结果当一个String对待,这时只需要匿名实现一个TextHttpResponseHandler就行,其继承自AsyncHttpResponse,并将原生的字节流根据指定的encoding转化成了string对象
AsyncHttpClient client = new AsyncHttpClient();
RequestParams params = new RequestParams();
params.put("key", "value");
params.put("more", "data");
client.get("http://www.google.com", params, new TextHttpResponseHandler() {
@Override
public void onSuccess(int statusCode, Header[] headers, String responseBody) {
Log.d("onSuccess", responseBody);
}
@Override
public void onFailure(int statusCode, Header[] headers, String responseBody, Throwable error) {
Log.d("onFailure", error);
}
}
);
同样的方式,你可以实现JsonHttpResponseHandler,返回的response已经自动转化成JSONObject了,当然也支持JSONArray类型,override你需要的那个版本就行。
AsyncHttpClient client = new AsyncHttpClient();
RequestParams params = new RequestParams();
params.put("key", "value");
params.put("more", "data");
client.get("http://www.google.com", params, new JsonHttpResponseHandler() {
@Override
public void onSuccess(int statusCode, Header[] headers, JSONObject responseBody) {
// Handle resulting parsed JSON response here
}
@Override
public void onSuccess(int statusCode, Header[] headers, JSONArray responseBody) {
// Handle resulting parsed JSON response here
}
});