3

Android各大网络请求库的比较及实战

 3 years ago
source link: http://www.androidchina.net/2421.html
Go to the source link to view the article. You can view the picture content, updated content and better typesetting reading experience. If the link is broken, please click the button below to view the snapshot at that time.
neoserver,ios ssh client

自己学习android也有一段时间了，在实际开发中，频繁的接触网络请求，而网络请求的方式很多，最常见的那么几个也就那么几个。本篇文章对常见的网络请求库进行一个总结。

HttpUrlConnection

最开始学android的时候用的网络请求是HttpUrlConnection，当时很多东西还不知道，但是在android 2.2及以下版本中HttpUrlConnection存在着一些bug，所以建议在android 2.3以后使用HttpUrlConnection，之前使用HttpClient。

在Android 2.2版本之前，HttpClient拥有较少的bug，因此使用它是最好的选择。而在Android 2.3版本及以后，HttpURLConnection则是最佳的选择。它的API简单，体积较小，因而非常适用于Android项目。压缩和缓存机制可以有效地减少网络访问的流量，在提升速度和省电方面也起到了较大的作用。对于新的应用程序应该更加偏向于使用HttpURLConnection，因为在以后的工作当中我们也会将更多的时间放在优化HttpURLConnection上面。

  • 比较轻便，灵活，易于扩展
  • 在3.0后以及4.0中都进行了改善，如对HTTPS的支持
  • 在4.0中，还增加了对缓存的支持
  1. 首先我们需要获取到一个HttpURLConnection实例，一般需要new出一个URL对象，并传入目标网络地址，通过调用openConnection()方法获得HttpURLConnection实例。
  2. 得到该实例后。我们需要设置一下http请求的的方法，这里我们主要研究get和post，默认是使用get方法。get一般用于从服务器获取数据，post一般用于向服务器提交数据，设置请求方法使用函数setRequestMethod(“POST”)进行设置。
  3. 此外可以进行一些请求的限制，比如连接超时的时间等，可以通过setConnectTimeout设置超时时间。
  4. 获取服务器返回的输入流，使用getInputStream方法获取。
  5. 读取内容并处理
  6. 关闭连接，通过调用disconnect方法关闭当前的连接。
    关键代码如下
    使用过程中不要忘记添加权限
<uses-permission android:name="android.permission.INTERNET" />

GET

public String get(String urlPath) {
HttpURLConnection connection = null;
InputStream is = null;
try {
URL url = new URL(urlPath);
//获得URL对象
connection = (HttpURLConnection) url.openConnection();
//获得HttpURLConnection对象
connection.setRequestMethod("GET");
// 默认为GET
connection.setUseCaches(false);
//不使用缓存
connection.setConnectTimeout(10000);
//设置超时时间
connection.setReadTimeout(10000);
//设置读取超时时间
connection.setDoInput(true);
//设置是否从httpUrlConnection读入，默认情况下是true;
if (connection.getResponseCode() == HttpURLConnection.HTTP_OK) {
//相应码是否为200
is = connection.getInputStream();
//获得输入流
BufferedReader reader = new BufferedReader(new InputStreamReader(is));
//包装字节流为字符流
StringBuilder response = new StringBuilder();
String line;
while ((line = reader.readLine()) != null) {
response.append(line);
}
return response.toString();
}
} catch (Exception e) {
e.printStackTrace();
} finally {
if (connection != null) {
connection.disconnect();
connection = null;
}
if (is != null) {
try {
is.close();
is = null;
} catch (IOException e) {
e.printStackTrace();
}
}
}
return null;
}

POST

private String post(String urlPath, Map<String, String> params) {
if (params == null || params.size() == 0) {
return get(urlPath);
}
OutputStream os = null;
InputStream is = null;
HttpURLConnection connection = null;
StringBuffer body = getParamString(params);
byte[] data = body.toString().getBytes();
try {
URL url = new URL(urlPath);
//获得URL对象
connection = (HttpURLConnection) url.openConnection();
//获得HttpURLConnection对象
connection.setRequestMethod("POST");
// 设置请求方法为post
connection.setUseCaches(false);
//不使用缓存
connection.setConnectTimeout(10000);
//设置超时时间
connection.setReadTimeout(10000);
//设置读取超时时间
connection.setDoInput(true);
//设置是否从httpUrlConnection读入，默认情况下是true;
connection.setDoOutput(true);
//设置为true后才能写入参数
connection.setRequestProperty("Content-Type", "application/x-www-form-urlencoded");
connection.setRequestProperty("Content-Length", String.valueOf(data.length));
os = connection.getOutputStream();
os.write(data);
//写入参数
if (connection.getResponseCode() == HttpURLConnection.HTTP_OK) {
//相应码是否为200
is = connection.getInputStream();
//获得输入流
BufferedReader reader = new BufferedReader(new InputStreamReader(is));
//包装字节流为字符流
StringBuilder response = new StringBuilder();
String line;
while ((line = reader.readLine()) != null) {
response.append(line);
}
return response.toString();
}
} catch (Exception e) {
e.printStackTrace();
} finally {
//关闭
if (os != null) {
try {
os.close();
} catch (IOException e) {
e.printStackTrace();
}
}
if (is != null) {
try {
is.close();
} catch (IOException e) {
e.printStackTrace();
}
}
if (connection != null) {
connection.disconnect();
connection = null;
}
}
return null;
}
private StringBuffer getParamString(Map<String, String> params) {
StringBuffer result = new StringBuffer();
Iterator<Map.Entry<String, String>> iterator = params.entrySet().iterator();
while (iterator.hasNext()) {
Map.Entry<String, String> param = iterator.next();
String key = param.getKey();
String value = param.getValue();
result.append(key).append('=').append(value);
if (iterator.hasNext()) {
result.append('&');
}
}
return result;
}

以上代码参考了部分LessCode项目

HttpClient

  • 高效稳定，但是维护成本高昂，故android 开发团队不愿意在维护该库而是转投更为轻便的HttpUrlConnection
  1. HttpClient是一个接口，因此无法直接创建它的实例，一般都是创建一个DefaultHttpClient实例
  2. 如果要发起Get请求，需要创建一个HttpGet对象，并传入请求地址
  3. 如果要发起Post请求，需要创建一个HttpPost对象。并传入请求地址，通过setEntity函数设置请求参数
  4. 调用execute方法，传入HttpGet或者HttpPost实例，执行后返回HttpResponse对象，判断响应状态码
  5. 解析响应结果，通过调用getEntity函数获得一个HttpEntity对象，之后可以通过EntityUtils.toString方法将其转换为字符串

由于在android2.3之后就被HttpUrlConnection取代了，这里也不过多介绍了，不过当初学习它的时候还没接触到其他库，就感觉它好方便，下面简单贴出使用方法

GET

private String get(String url){
HttpClient client=null;
HttpGet request=null;
try {
client=new DefaultHttpClient();
request=new HttpGet(url);
HttpResponse response=client.execute(request);
if(response.getStatusLine().getStatusCode()== HttpStatus.SC_OK){
String result=EntityUtils.toString(response.getEntity(),"UTF-8");
return result;
}
} catch (IOException e) {
e.printStackTrace();
}
return null;
}

POST

private String post(String url,List<NameValuePair> params){
HttpClient client=null;
HttpPost request=null;
try {
client=new DefaultHttpClient();
request=new HttpPost(url);
request.setEntity(new UrlEncodedFormEntity(params, HTTP.UTF_8));
HttpResponse response=client.execute(request);
if(response.getStatusLine().getStatusCode()== HttpStatus.SC_OK){
String result=EntityUtils.toString(response.getEntity(),"UTF-8");
return result;
}
} catch (IOException e) {
e.printStackTrace();
}
return null;
}

以上代码参考了郭霖《第一行代码》——HttpClient部分

Android Asynchronous Http Client

Android Asynchronous Http Client一看名字就知道它是基于Http Client的，但是呢在安卓中Http Client已经废弃了，所以也不建议使用这个库了。然后仍然有一些可取的内容值得学习，所以这里也介绍一下。

  • 所以请求在子线程中完成，请求回调在调用该请求的线程中完成
  • 使用线程池
  • 使用RequestParams类封装请求参数
  • 支持文件上传
  • 持久化cookie到SharedPreferences，个人感觉这一点也是这个库的重要特点，可以很方便的完成一些模拟登录
  • 支持json
  • 支持HTTP Basic Auth

编写一个静态的HttpClient

package cn.edu.zafu.http;
import com.loopj.android.http.AsyncHttpClient;
import com.loopj.android.http.AsyncHttpResponseHandler;
import com.loopj.android.http.RequestParams;
/**
* Created by lizhangqu on 2015/5/7.
*/
public class TestClient {
private static final String BASE_URL = "http://121.41.119.107/";
private static AsyncHttpClient client = new AsyncHttpClient();
public static void get(String url, RequestParams params, AsyncHttpResponseHandler responseHandler) {
client.get(getAbsoluteUrl(url), params, responseHandler);
}
public static void post(String url, RequestParams params, AsyncHttpResponseHandler responseHandler) {
client.post(getAbsoluteUrl(url), params, responseHandler);
}
private static String getAbsoluteUrl(String relativeUrl) {
return BASE_URL + relativeUrl;
}
}

调用get或者post方法

参数通过RequestParams传递，没有参数则传递null

RequestParams  params = new RequestParams();
params.put("","");

如果要保存cookie，在发起请求之前调用以下代码

PersistentCookieStore myCookieStore = new PersistentCookieStore(this);
client.setCookieStore(myCookieStore);

之后请求所得到的cookie都会自动持久化

如果要自己添加cookie，则调用以下代码

BasicClientCookie newCookie = new BasicClientCookie("cookiesare", "awesome");
newCookie.setVersion(1);
newCookie.setDomain("mydomain.com");
newCookie.setPath("/");
myCookieStore.addCookie(newCookie);

使用
在回调函数中处理返回结果

private void get(){
TestClient.get("test/index.php", null, new AsyncHttpResponseHandler() {
@Override
public void onSuccess(int statusCode, Header[] headers, byte[] responseBody) {
}
@Override
public void onFailure(int statusCode, Header[] headers, byte[] responseBody, Throwable error) {
}
});
}
private void post(){
RequestParams params = new RequestParams();
params.put("user","asas");
params.put("pass","12121");
params.put("time","1212121");
TestClient.post("test/login.php", params, new AsyncHttpResponseHandler() {
@Override
public void onSuccess(int statusCode, Header[] headers, byte[] responseBody) {
}
@Override
public void onFailure(int statusCode, Header[] headers, byte[] responseBody, Throwable error) {
}
});
}

以上代码参考了Android Asynchronous Http Client官方实例

Volley

既然在android2.2之后不建议使用Http Client，那么有没有一个库是android2.2及以下版本使用Http Client，而android2.3及以上版本使用HttpUrlConnection的呢，答案是肯定的，就是Volley,它是android开发团队在2013年Google I/O大会上推出了一个新的网络通信框架

Volley可以说是把AsyncHttpClient和Universal-Image-Loader的优点集于了一身，既可以像AsyncHttpClient一样非常简单地进行HTTP通信，也可以像Universal-Image-Loader一样轻松加载网络上的图片。除了简单易用之外，Volley在性能方面也进行了大幅度的调整，它的设计目标就是非常适合去进行数据量不大，但通信频繁的网络操作，而对于大数据量的网络操作，比如说下载文件等，Volley的表现就会非常糟糕

  1. Volley的优势在于处理小文件的http请求；
  2. 在Volley中也是可以使用Okhttp作为传输层
  3. Volley在处理高分辨率的图像压缩上有很好的支持；
  4. NetworkImageView在GC的使用模式上更加保守，在请求清理上也更加积极，networkimageview仅仅依赖于强大的内存引用，并当一个新请求是来自ImageView或ImageView离开屏幕时 会清理掉所有的请求数据。
  1. 创建一个RequestQueue对象。
  2. 创建一个Request对象。
  3. 将Request对象添加到RequestQueue里面。

下面一步一步来学习其用法

GET

private void get(){
RequestQueue queue= Volley.newRequestQueue(getApplicationContext());
StringRequest request=new StringRequest(url, new Response.Listener<String>() {
@Override
public void onResponse(String response) {
Log.d("TAG",response);
}
}, new Response.ErrorListener() {
@Override
public void onErrorResponse(VolleyError error) {
}
});
queue.add(request);
}

POST
通过指定请求方法为Request.Method.POST使其成为post请求，然后重新getParams方法设置请求参数。当发出POST请求的时候，Volley会尝试调用StringRequest的父类——Request中的getParams()方法来获取POST参数

private void post() {
RequestQueue queue = Volley.newRequestQueue(getApplicationContext());
StringRequest request = new StringRequest(Request.Method.POST, url, new Response.Listener<String>() {
@Override
public void onResponse(String response) {
Log.d("TAG", response);
}
}, new Response.ErrorListener() {
@Override
public void onErrorResponse(VolleyError error) {
}
}) {
//重写getParams方法设置参数
@Override
protected Map<String, String> getParams() throws AuthFailureError {
Map<String, String> params = new HashMap<String, String>();
params.put("user", "asas");
params.put("pass", "12121");
params.put("time", "1212121");
return params;
}
};
queue.add(request);
}

加载图片
加载图像的方法和前面类似，只不过不在是StringRequest而是ImageRequest。

private void getImage() {
RequestQueue queue = Volley.newRequestQueue(getApplicationContext());
//第三第四个参数分别用于指定允许图片最大的宽度和高度，如果指定的网络图片的宽度或高度大于这里的最大值，则会对图片进行压缩，指定成0的话就表示不管图片有多大，都不会进行压缩。
//第五个参数就是ImageView里中的属性ScaleType
//第六个参数用于指定图片的颜色属性
ImageRequest request = new ImageRequest(url, new Response.Listener<Bitmap>() {
@Override
public void onResponse(Bitmap response) {
ImageView iv= (ImageView) findViewById(R.id.iv);
iv.setImageBitmap(response);
}
}, 0, 0, ImageView.ScaleType.CENTER, Bitmap.Config.ARGB_8888, new Response.ErrorListener() {
@Override
public void onErrorResponse(VolleyError error) {
}
});
queue.add(request);
}

其实加载图片的功能还远远不止这些，使用ImageLoader可以实现对图片的缓存，还可以过滤重复链接，避免发送重复的请求
ImageLoader的使用方法概括为以下几步
1. 创建一个RequestQueue对象。
2. 创建一个ImageLoader对象。
3. 获取一个ImageListener对象。
4. 调用ImageLoader的get()方法加载网络上的图片。

//继承ImageCache，使用LruCache实现缓存
public class BitmapCache implements ImageLoader.ImageCache {
private LruCache<String, Bitmap> mCache;
public BitmapCache() {
int maxSize = 10 * 1024 * 1024;
mCache = new LruCache<String, Bitmap>(maxSize) {
@Override
protected int sizeOf(String key, Bitmap bitmap) {
return bitmap.getRowBytes() * bitmap.getHeight();
}
};
}
@Override
public Bitmap getBitmap(String url) {
return mCache.get(url);
}
@Override
public void putBitmap(String url, Bitmap bitmap) {
mCache.put(url, bitmap);
}
}
private void getImageByImageLoader() {
ImageView iv= (ImageView) findViewById(R.id.iv);
RequestQueue queue = Volley.newRequestQueue(getApplicationContext());
ImageLoader loader=new ImageLoader(queue,new BitmapCache() );
// 第一个参数指定用于显示图片的ImageView控件
// 第二个参数指定加载图片的过程中显示的图片
// 第三个参数指定加载图片失败的情况下显示的图片
ImageLoader.ImageListener listener=ImageLoader.getImageListener(iv,R.mipmap.ic_launcher,R.mipmap.ic_launcher);
// 调用ImageLoader的get()方法来加载图片
// 第一个参数就是图片的URL地址
// 第二个参数则是刚刚获取到的ImageListener对象
// 如果想对图片的大小进行限制，也可以使用get()方法的重载，指定图片允许的最大宽度和高度，即通过第三第四个参数指定
loader.get(url,listener);
}

最后，Volley提供了一种自定义ImageView来加载图片，其使用方法可概括为
1. 创建一个RequestQueue对象。
2. 创建一个ImageLoader对象。
3. 在布局文件中添加一个NetworkImageView控件。
4. 在代码中获取该控件的实例。
5. 设置要加载的图片地址。

我们在布局中申明该控件

<com.android.volley.toolbox.NetworkImageView
android:id="@+id/network_image_view"
android:layout_width="wrap_content"
android:layout_height="wrap_content"
android:layout_centerInParent="true"
/>

在程序中实现加载

public void networkImageView(){
RequestQueue queue = Volley.newRequestQueue(getApplicationContext());
ImageLoader loader=new ImageLoader(queue,new BitmapCache() );
NetworkImageView niv= (NetworkImageView) findViewById(R.id.network_image_view);
niv.setDefaultImageResId(R.mipmap.ic_launcher);//设置加载中显示的图片
niv.setErrorImageResId(R.mipmap.ic_launcher);//设置加载失败时显示的图片
niv.setImageUrl("https://www.baidu.com/img/bdlogo.png",  loader);//设置目标图片的URL地址
}

自定义Request

在实际应用中，往往需要将http请求与json进行集成，而Volley正恰恰支持这样的方式，不过需要我们自己自定义Request，这里我们使用google的Gson库进行集成。
1. 继承Request类
2. 重写parseNetworkResponse，实现json与实体类转换，由于实体类未定，所以采用泛型

下文用到的json字符串如下

{"name":"lizhangqu","age":16}
package cn.edu.zafu.http;
import com.android.volley.NetworkResponse;
import com.android.volley.ParseError;
import com.android.volley.Request;
import com.android.volley.Response;
import com.android.volley.toolbox.HttpHeaderParser;
import com.google.gson.Gson;
import java.io.UnsupportedEncodingException;
/**
* Created by lizhangqu on 2015/5/7.
*/
public class GsonRequest<T> extends Request<T> {
private final Response.Listener<T> mListener;
private Gson mGson;
private Class<T> mClass;
public GsonRequest(int method, String url, Class<T> clazz, Response.Listener<T> listener,
Response.ErrorListener errorListener) {
super(method, url, errorListener);
mGson = new Gson();
mClass = clazz;
mListener = listener;
}
public GsonRequest(String url, Class<T> clazz, Response.Listener<T> listener,
Response.ErrorListener errorListener) {
this(Method.GET, url, clazz, listener, errorListener);
}
@Override
protected Response<T> parseNetworkResponse(NetworkResponse response) {
try {
String jsonString = new String(response.data,
HttpHeaderParser.parseCharset(response.headers));
return Response.success(mGson.fromJson(jsonString, mClass),
HttpHeaderParser.parseCacheHeaders(response));
} catch (UnsupportedEncodingException e) {
return Response.error(new ParseError(e));
}
}
@Override
protected void deliverResponse(T response) {
mListener.onResponse(response);
}
}

编写测试实体类，两个字段一个name一个age

package cn.edu.zafu.http;
/**
* Created by lizhangqu on 2015/5/7.
*/
public class Person {
private String name;
private int age;
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public int getAge() {
return age;
}
public void setAge(int age) {
this.age = age;
}
@Override
public String toString() {
return "Person{" +
"name='" + name + '\'' +
", age=" + age +
'}';
}
}

调用方法和StringRequest是一样的。如下所示

private void json(){
RequestQueue queue = Volley.newRequestQueue(getApplicationContext());
GsonRequest<Person> request=new GsonRequest<Person>(url, Person.class, new Response.Listener<Person>() {
@Override
public void onResponse(Person response) {
Log.d("TAG",response.toString());
}
}, new Response.ErrorListener() {
@Override
public void onErrorResponse(VolleyError error) {
}
});
queue.add(request);
}

以上代码参考了郭霖三篇Volley博客文章，分别为
Android Volley完全解析(一)，初识Volley的基本用法
Android Volley完全解析(二)，使用Volley加载网络图片
Android Volley完全解析(三)，定制自己的Request

okHttp

okhttp 是一个 Java 的 HTTP+SPDY 客户端开发包，同时也支持 Android。需要Android 2.3以上。

  • OKHttp是Android版Http客户端。非常高效，支持SPDY、连接池、GZIP和 HTTP 缓存。
  • 默认情况下，OKHttp会自动处理常见的网络问题，像二次连接、SSL的握手问题。
  • 如果你的应用程序中集成了OKHttp，Retrofit默认会使用OKHttp处理其他网络层请求。
  • 从Android4.4开始HttpURLConnection的底层实现采用的是okHttp.
  1. 新建一个OkHttpClient对象
  2. 通过Request.Builder对象新建一个Request对象
  3. 返回执行结果

GET

private String get(String url) {
OkHttpClient client = new OkHttpClient();
Request request = new Request.Builder()
.url(url)
.build();
Response response = null;
try {
response = client.newCall(request).execute();
return response.body().string();
} catch (IOException e) {
e.printStackTrace();
}
return null;
}

POST

POST需要使用RequestBody对象，之后再构建Request对象时调用post函数将其传入即可

private String post(String url) {
OkHttpClient client = new OkHttpClient();
RequestBody formBody = new FormEncodingBuilder()
.add("user", "Jurassic Park")
.add("pass", "asasa")
.add("time", "12132")
.build();
Request request = new Request.Builder()
.url(url)
.post(formBody)
.build();
Response response = null;
try {
response = client.newCall(request).execute();
return response.body().string();
} catch (IOException e) {
e.printStackTrace();
}
return null;
}

此外，post的使用方法还支持文件等操作，具体使用方法有兴趣的可以自行查阅

对Gson的支持

okHttp还自带了对Gson的支持

private Person gson(String url){
OkHttpClient client = new OkHttpClient();
Gson gson = new Gson();
Request request = new Request.Builder()
.url(url)
.build();
Response response = null;
try {
response = client.newCall(request).execute();
Person person = gson.fromJson(response.body().charStream(), Person.class);
return person;
} catch (IOException e) {
e.printStackTrace();
}
return null;
}

异步操作

以上的两个例子必须在子线程中完成，同时okHttp还提供了异步的方法调用，通过使用回调来进行异步调用，然后okHttp的回调依然不在主线程中，因此该回调中不能操作UI

private void getAsync(String url) {
OkHttpClient client = new OkHttpClient();
Request request = new Request.Builder()
.url(url)
.build();
Response response = null;
client.newCall(request).enqueue(new Callback() {
@Override
public void onFailure(Request request, IOException e) {
}
@Override
public void onResponse(Response response) throws IOException {
String result = response.body().string();
Toast.makeText(getApplicationContext(),result,Toast.LENGTH_SHORT).show();
//不能操作ui，回调依然在子线程
Log.d("TAG", result);
}
});
}

okHttp的使用还有很多内容，这里也不过多介绍，更多内容，参考官方网址

Retrofit

  1. 性能最好，处理最快
  2. 使用REST API时非常方便；
  3. 传输层默认就使用OkHttp；
  4. 支持NIO；
  5. 拥有出色的API文档和社区支持
  6. 速度上比volley更快；
  7. 如果你的应用程序中集成了OKHttp，Retrofit默认会使用OKHttp处理其他网络层请求。
  8. 默认使用Gson

Retrofit支持同步和异步两种方式，在使用时，需要将请求地址转换为接口，通过注解来指定请求方法，请求参数，请求头，返回值等信息。还是使用之前的person的那段json值，get请求到服务器后从数据库查询数据，返回值为查询到的数据，post请求向服务器提交一条数据，返回值为提交的数据。
首先完成请求所用的service，是一个interface，完全通过注解完成配置

package cn.edu.zafu.http;
import retrofit.Callback;
import retrofit.http.Field;
import retrofit.http.FormUrlEncoded;
import retrofit.http.GET;
import retrofit.http.Headers;
import retrofit.http.POST;
import retrofit.http.Path;
import retrofit.http.Query;
/**
* Created by lizhangqu on 2015/5/11.
*/
public interface PersonService {
@Headers({
"Cache-Control: max-age=640000",
"User-Agent: Mozilla/5.0 (Windows NT 6.1; WOW64; Trident/7.0; rv:11.0) like Gecko"
})
//通过注解设置请求头
@GET("/{test}/rest.php")
//设置请求方法为get，相对路径为注解内内容，其中{test}会被@Path注解指定内容替换
Person getPerson(@Path("test") String dir,@Query("name") String name);
//@Query用于指定参数
@FormUrlEncoded
//urlencode
@POST("/test/rest1.php")
//post提交
Person updatePerson(@Field("name") String name,@Field("age") int age);
//@Field提交的域
@POST("/test/rest1.php")
void updatePerson(@Field("name") String name,@Field("age") int age, Callback<Person> callback);
//异步回调，不能指定返回值
}

GET
使用时，通过RestAdapter的实例获得一个接口的实例，其本质是动态代理，注意含有返回值的方法是同步的，不能UI线程中调用，应该在子线程中完成

RestAdapter restAdapter = new RestAdapter.Builder()
.setEndpoint("http://121.41.119.107")
.build();
PersonService personService=restAdapter.create(PersonService.class);
Person person=personService.getPerson("test","zhangsan");
Log.d("TAG",person.toString());

POST

POST的调用同Get，获得adapter后获得一个代理对象，然后通过这个代理对象进行网络请求

Person person1=personService.updatePerson("lizhangqu", 12);
Log.d("TAG",person1.toString());

异步请求

如果要使用异步请求，需要将接口中的方法返回值修改会void，再加入回调参数Callback，就如PersonService中第三个方法一样，请求完成后会回调该callback对象的success或者fail方法。

RestAdapter restAdapter = new RestAdapter.Builder()
.setEndpoint("http://121.41.119.107")
.build();
PersonService personService=restAdapter.create(PersonService.class);
personService.updatePerson("lizhangqu",23, new Callback<Person>() {
@Override
public void success(Person person, Response response) {
Log.d("TAG", person.toString());
}
@Override
public void failure(RetrofitError error) {
}
});

Retrofit的使用还有很多内容，剩下的就留给各位读者自行去发现了，而其官网页提供了及其详细的说明。下面提供官方网址

retrofit官网示例

这个库里面有很多精华的内容，建议各位仔细的阅读下官方的文档。

RoboSpice

见之前写的一篇博文

RoboSpice：android异步网络库简单用法

网络请求库多种多样，最终其本质思想是一致的，要学会融汇贯通，还是要fucking the source code。由于本篇文章已经过长，所以图片的网络加载准备另开一篇博客进行整理。

源码下载

转载请注明：Android开发中文站 » Android各大网络请求库的比较及实战


report

Recommend

About Joyk


Aggregate valuable and interesting links.
Joyk means Joy of geeK