Android 快速开发系列之网络篇(Retrofit 2.0)

网络请求库有很多优秀的开源项目okhttp,volley都是很不错的,但是个人比较喜欢Retrofit。原因有以下几点:
1.一个类型安全的REST客户端 。
2.通过GsonConverter可以直接把服务器响应的json字符串映射成对象,这一切都是自动化的。当然还有其他的转换器并且支持自定义非常的灵活。
3.支持同步请求和异步请求
4.2.0开始加入对Rxjava的支持,配合Rxjava编程爽爆了,代码变的很清晰。
5.2.0开始可以很轻松的取消请求,你只需调用call.cancel()
6.性能和速度都比volley等更好。

重要的事情强调一下本文针对的是Retrofit 2.0讲的,Retrofit 1.xx的版本和2.0版本有许多改动。

retrofit2.0 知识点

步骤:
1.首先导入需要的库
compile 'com.squareup.retrofit2:retrofit:2.0.2'
compile 'com.squareup.retrofit2:converter-gson:2.0.2'

2.新建一个interface接口,用于存放和服务器交互的接口,针对常用操作下面各写一个范例

  • Get无参数请求
      public interface MeizhiApi {
      @GET("data/福利/10/{day}")//()里面的是相对路径,当然绝对路径也是可以的
      public Call<BeanMezhi> getMeizhi(@Path("day") int day);//{}里面的是要替换的内容 用注解@Path映射
    

}

- Get单个参数请求
```java
  public interface SmsApi {
  @GET("http://xxx/getSmsCode")
  public Call<JSONObject> getSms(@Query("tel") String tel);//相当于http://xxx/getSmsCode?tel="xx"
}
  • Get多个参数请求
    public interface SmsApi {
      @GET("http://weixing.wxspider.com:8087/appVoip!getSmsCode")
      public Call<JSONObject> getSms(@QueryMap Map<String, String> options);
    

}

- Post请求
```java
public interface DemoApi {
  @POST("checkupdate")
  public Call<BeanVersion> getVersion(@Body HashMap type);//注意这里用的是@Body 
}
  • 表单请求

public interface DemoApi {
@FormUrlEncoded
@POST("user/edit")
Call<User> updateUser(@Field("first_name") String first, @Field("last_name") String last);
}

- 文件上传
```java
public interface DemoApi {
  @Multipart
  @PUT("user/photo")
  Call<User> updateUser(@Part("photo") RequestBody photo, @Part("description") RequestBody description);
}

注意:上面所有的接口返回的都是Call类型的这是和1.x版本不同的

3.实例化上面的接口

 public class ApiServiceManager {
 private static ApiServiceManager ourInstance = new ApiServiceManager();

 public static ApiServiceManager getInstance() {
     return ourInstance;
 }

 private DemoApi demoApi;
 private MeizhiApi meizhiApi;
 private SmsApi smsApi;

 private ApiServiceManager() {
     Retrofit.Builder builderWithGson = new Retrofit.Builder()
             .baseUrl(Config.DemoBaseUrl)//设置基础url
             .addConverterFactory(GsonConverterFactory.create());//Gson转换器直接返回对象
     Retrofit retrofit = builderWithGson.build();
     demoApi = retrofit.create(DemoApi.class);//拿到和服务器交互的接口实例
     builderWithGson.baseUrl(Config.MeizhiBaseUrl);
     retrofit = builderWithGson.build();
     meizhiApi = retrofit.create(MeizhiApi.class);
     Retrofit.Builder builderWithJson = new Retrofit.Builder()
             .addConverterFactory(JsonConverterFactory.create());//Json转换器返回JSONObject,因为有些接口返回的数据很简单不想写个Bean
     retrofit = builderWithJson.build();
     smsApi = retrofit.create(SmsApi.class);
 }

 public DemoApi getDemoApi() {
     return demoApi;
 }

 public MeizhiApi getMeizhiApi() {
     return meizhiApi;
 }

 public SmsApi getSmsApi() {
     return smsApi;
 }
}

4.使用接口

  • 同步请求使用方式
     new Thread(new Runnable() {
              @Override
              public void run() {
                  Call<BeanMezhi> mezhiCall = ApiServiceManager.getInstance().getMeizhiApi().getMeizhi(1);
                  Response<BeanMezhi> response = null;//同步请求会阻塞线程,因此你不能在安卓的主线程中调用,不然会面临NetworkOnMainThreadException,想调用execute方法,请在后台线程执行
                  try {
                      response = mezhiCall.execute();
                      if (response.body() != null) {//如果不能解析成对应的实体BeanMezhi则response.body()的值是空
                          Log.d(tag, new Gson().toJson(response.body()).toString());
                      }
                  } catch (IOException e) {
                      e.printStackTrace();
                  }
              }
          }).start();
    
  • 异步请求使用方式
    HashMap map = new HashMap();
        map.put("ostype", "android");
        Call<BeanVersion> versionCall = ApiServiceManager.getInstance().getDemoApi().getVersion(map);
        versionCall.enqueue(new Callback<BeanVersion>() {//异步请求
            @Override
            public void onResponse(Call<BeanVersion> call, Response<BeanVersion> response) {//回调运行在主线程
                if (response.body() != null) {
                    Log.d(tag, new Gson().toJson(response.body()).toString());
                }
            }
    
            @Override
            public void onFailure(Call<BeanVersion> call, Throwable t) {
                Log.d(tag, "onFail");
            }
        });
    

5.取消正在进行中的业务

 call.cancel();
  ```

基本使用介绍完了,如果需要自定义Converter或者自定义CallAdapter,那么请继续往下看。

---
**1. Converter** 官方提供的转换器有

Gson: com.squareup.retrofit:converter-gson

Jackson: com.squareup.retrofit:converter-jackson

Moshi: com.squareup.retrofit:converter-moshi

Protobuf: com.squareup.retrofit:converter-protobuf

Wire: com.squareup.retrofit:converter-wire

Simple XML: com.squareup.retrofit:converter-simplexml

如何自定义转换器?
你也可以通过实现Converter.Factory接口来创建一个自定义的converter。以JsonConverter示例:
```java
public class JsonConverterFactory extends Converter.Factory {

  public static JsonConverterFactory create() {
      return new JsonConverterFactory();
  }

  @Override
  public Converter<ResponseBody, ?> responseBodyConverter(Type type, Annotation[] annotations, Retrofit retrofit) {
      return new JsonResponseBodyConverter<JSONObject>();
  }

  @Override
  public Converter<?, RequestBody> requestBodyConverter(Type type, Annotation[] parameterAnnotations, Annotation[] methodAnnotations, Retrofit retrofit) {
      return new JsonRequestBodyConverter<JSONObject>();
  }
}
final class JsonRequestBodyConverter<T> implements Converter<T, RequestBody> {
  private static final MediaType MEDIA_TYPE = MediaType.parse("application/json; charset=UTF-8");

  JsonRequestBodyConverter() {

  }

  public RequestBody convert(T value) throws IOException {
      return RequestBody.create(MEDIA_TYPE, value.toString());
  }
}
 final class JsonResponseBodyConverter<T> implements Converter<ResponseBody, T> {

   JsonResponseBodyConverter() {

   }

   @Override
   public T convert(ResponseBody value) throws IOException {
       JSONObject jsonObj;
       try {
           jsonObj = new JSONObject(value.string());
           return (T) jsonObj;
       } catch(JSONException e) {
           return null;
       }
   }
}

2. CallAdapter

在interface接口定义中,retrofit2.0默认都是返回的Call<T>模式的,如果我们想返回其他的类型也是可以,retrofit已经为Rxjava粉丝们准备了CallAdapter,它将作为Observable返回。使用它必须引入以下两个库

compile 'io.reactivex:rxandroid:1.2.0'
compile 'com.squareup.retrofit2:adapter-rxjava:2.0.2'

并在Retrofit Builder链表中调用addCallAdapterFactory

Retrofit.Builder builderWithGson = new Retrofit.Builder()
              .baseUrl(Config.DemoBaseUrl)//设置基础url
              .addConverterFactory(GsonConverterFactory.create())//Gson转换器直接返回对象
              .addCallAdapterFactory(RxJavaCallAdapterFactory.create());//增加RxjavaCallAdapter
Retrofit retrofit = builderWithGson.build();

接下来看怎么结合Rxjava调用接口

  //定义接口
  @GET("data/福利/10/{day}")
  public Observable<BeanMezhi> getMeizhi2(@Path("day") int day);

  //调用接口
   Observable<BeanMezhi> observable = ApiServiceManager.getInstance().getMeizhiApi().getMeizhi2(1);
   observable.subscribeOn(Schedulers.io())//获取数据指定运行在io线程
             .observeOn(AndroidSchedulers.mainThread())//发布到android主线程
             .subscribe(new Action1<BeanMezhi>() {
                  @Override
                  public void call(BeanMezhi beanMezhi) {
                      Log.d(tag, new Gson().toJson(beanMezhi).toString());//处理数据这里已经是运行在主线程了
                  }
              });

在使用rxjava以后我们不在需要写new Thread().start 这些“脏”代码了,rxjava对线程的调度非常强大,那么有同学会说感觉还不如返回Call<T>模式的然后异步调用来的简单。好吧,如果要对返回的数据先过滤,在排序,还要存储数据库等等一系列处理,你该怎么办?有了rxjava处理这种复杂的数据流一切就会变的简单清晰,如果在配合lambda表达式可以说是如虎添翼。

项目主页: http://square.github.io/retrofit/
JSONCoverter:https://github.com/brokge/Retrofit2.0-JSONCoverter

推荐阅读更多精彩内容