Android 快速开发系列之网络篇（Retrofit 2.0）

作者: 西瓜太郎123 | 来源:发表于2016-05-13 14:49 被阅读808次

网络请求库有很多优秀的开源项目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

网友评论

本文标题：Android 快速开发系列之网络篇（Retrofit 2.0）

本文链接：https://www.haomeiwen.com/subject/ypkprttx.html

延伸阅读

深度阅读

您也可以注册成为美文阅读网的作者，发表您的原创作品、分享您的心情！

Android 快速开发系列之网络篇（Retrofit 2.0）

相关文章

网友评论

延伸阅读

深度阅读

栏目导航

热点阅读

RxJava

Android开发

Android知识

Android开发经验谈

赏味不足