|
|
51CTO旗下网站
|
|
移动端

Android Retrofit源码的具体用法解析

Retrofit 是 Square 推出的 HTTP 框架,主要用于 Android 和 Java。Retrofit 将网络请求变成方法的调用,使用起来非常简洁方便。本文先简要介绍一下 Retrofit 的用法,然后具体分析其源码执行的流程。

作者:佚名来源:segmentfault|2016-08-31 13:48

简介

Retrofit 是 Square 推出的 HTTP 框架,主要用于 Android 和 Java。Retrofit 将网络请求变成方法的调用,使用起来非常简洁方便。本文先简要介绍一下 Retrofit 的用法,然后具体分析其源码执行的流程。

基本用法

Retrofit 把HTTP API 变成 Java 的接口。下面是 Retrofit 官网的一个例子:

  1. public interface GitHubService { 
  2.   @GET("users/{user}/repos"
  3.   Call<List<Repo>> listRepos(@Path("user") String user); 
  4.  

在 GithubService 接口中有一个方法 listRepos,这个方法用了 @GET 的方式注解,这表明这是一个 GET 请求。在后面的括号中的users/{user}/repos 是请求的路径,其中的 {user} 表示的是这一部分是动态变化的,它的值由方法的参数传递过来,而这个方法的参数@Path("user") String user 即是用于替换 {user} 。另外注意这个方法的返回值是 Call<List<Repo>>。可以看出 Retrofit 用注解的方式来描述一个网络请求相关的参数。

上面才是开始,下面要发出这个网络请求:

  1. Retrofit retrofit = new Retrofit.Builder() 
  2. .baseUrl("https://api.github.com/"
  3. .addConverterFactory(GsonConverterFactory.create()) 
  4. .build(); 
  5.  
  6. GitHubService service = retrofit.create(GitHubService.class); 
  7. Call<List<Repo>> repos = service.listRepos("octocat"); 
  8. repos.enqueue(new Callback<List<Repo>>() { 
  9.     @Override 
  10.     public void onResponse(Call<List<Repo>> call, Response<List<Repo>> response) { 
  11.              
  12.     } 
  13.     @Override 
  14.     public void onFailure(Call<List<Repo>> call, Throwable t) { 
  15.  
  16.     } 
  17.  });  

可以看出,先是构建了一个 Retrofit 对象,其中传入了 baseUrl 参数,baseUrl 和上面的 GET 方法后面的路径组合起来才是一个完整的 url。除了 baseUrl,还有一个 converterFactory,它是用于把返回的 http response 转换成 Java 对象,对应方法的返回值Call<List<Repo>> 中的 List<Repo>>,其中 Repo 是自定义的类。有了Retrofit 对象,接着调用它的 create 方法创建了GitHubService 的实例,然后就可以调用这个实例的方法来请求网络了。调用 listRepo 方法得到一个 Call对象,然后可以使用enqueue 或者 execute 来执行发起请求,enqueue 是是异步执行,而 execute 是同步执行。

Retrofit 的基本用法就是这样,其它还有一些细节可以查看官网。

源码分析

我***次接触 Retrofit 的时候觉得这个东西挺神奇的,用法跟一般的网络请求不一样。下面就来看看 Retrofit 的源码是怎么实现的。

Retrofit 的创建

从 Retrofit 的创建方法可以看出,使用的是 Builder 模式。Retrofit 中有如下的几个关键变量:

  1. //用于缓存解析出来的方法 
  2.  private final Map<Method, ServiceMethod> serviceMethodCache = new LinkedHashMap<>(); 
  3.   
  4.  //请求网络的OKHttp的工厂,默认是 OkHttpClient 
  5.  private final okhttp3.Call.Factory callFactory; 
  6.   
  7.  //baseurl 
  8.  private final HttpUrl baseUrl; 
  9.   
  10.  //请求网络得到的response的转换器的集合 默认会加入 BuiltInConverters      
  11.  private final List<Converter.Factory> converterFactories; 
  12.   
  13.  //把Call对象转换成其它类型 
  14.  private final List<CallAdapter.Factory> adapterFactories; 
  15.   
  16.  //用于执行回调 Android中默认是 MainThreadExecutor 
  17.  private final Executor callbackExecutor; 
  18.   
  19.  //是否需要立即解析接口中的方法 
  20.  private final boolean validateEagerly; 
  21.    

再看一下Retrofit 中的内部类 Builder 的 builder 方法:

  1. public Retrofit build() { 
  2.   if (baseUrl == null) { 
  3.     throw new IllegalStateException("Base URL required."); 
  4.   } 
  5.  
  6.   okhttp3.Call.Factory callFactory = this.callFactory; 
  7.   if (callFactory == null) { 
  8.     //默认创建一个 OkHttpClient 
  9.     callFactory = new OkHttpClient(); 
  10.   } 
  11.  
  12.   Executor callbackExecutor = this.callbackExecutor; 
  13.   if (callbackExecutor == null) { 
  14.      //Android 中返回的是 MainThreadExecutor 
  15.     callbackExecutor = platform.defaultCallbackExecutor(); 
  16.   } 
  17.  
  18.   // Make a defensive copy of the adapters and add the default Call adapter. 
  19.   List<CallAdapter.Factory> adapterFactories = new ArrayList<>(this.adapterFactories); 
  20.   adapterFactories.add(platform.defaultCallAdapterFactory(callbackExecutor)); 
  21.  
  22.   // Make a defensive copy of the converters. 
  23.   List<Converter.Factory> converterFactories = new ArrayList<>(this.converterFactories); 
  24.  
  25.   return new Retrofit(callFactory, baseUrl, converterFactories, adapterFactories, 
  26.       callbackExecutor, validateEagerly); 
  27.  

在创建 Retrofit 的时候,如果没有指定 OkHttpClient,会创建一个默认的。如果没有指定 callbackExecutor,会返回平台默认的,在 Android 中是 MainThreadExecutor,并利用这个构建一个 CallAdapter加入 adapterFactories。

create 方法

有了 Retrofit 对象后,便可以通过 create 方法创建网络请求接口类的实例,代码如下:

  1. public <T> T create(final Class<T> service) { 
  2. Utils.validateServiceInterface(service); 
  3. if (validateEagerly) { 
  4.   //提前解析方法 
  5.   eagerlyValidateMethods(service); 
  6. return (T) Proxy.newProxyInstance(service.getClassLoader(), new Class<?>[] { service }, 
  7.     new InvocationHandler() { 
  8.       private final Platform platform = Platform.get(); 
  9.  
  10.       @Override public Object invoke(Object proxy, Method method, Object... args) 
  11.           throws Throwable { 
  12.         // If the method is a method from Object then defer to normal invocation.如果是Object中的方法,直接调用 
  13.         if (method.getDeclaringClass() == Object.class) { 
  14.           return method.invoke(this, args); 
  15.         } 
  16.         //为了兼容 Java8 平台,Android 中不会执行 
  17.         if (platform.isDefaultMethod(method)) { 
  18.           return platform.invokeDefaultMethod(method, service, proxy, args); 
  19.         } 
  20.         //下面是重点,解析方法 
  21.         ServiceMethod serviceMethod = loadServiceMethod(method); 
  22.         OkHttpCall okHttpCall = new OkHttpCall<>(serviceMethod, args); 
  23.         return serviceMethod.callAdapter.adapt(okHttpCall); 
  24.       } 
  25. });  

create 方法接受一个 Class 对象,也就是我们编写的接口,里面含有通过注解标识的请求网络的方法。注意 return 语句部分,这里调用了 Proxy.newProxyInstance 方法,这个很重要,因为用了动态代理模式。关于动态代理模式,可以参考这篇文章:http://www.codekk.com/blogs/d...。简单的描述就是,Proxy.newProxyInstance 根据传进来的 Class 对象生成了一个实例 A,也就是代理类。每当这个代理类 A 执行某个方法时,总是会调用 InvocationHandler(Proxy.newProxyInstance 中的第三个参数) 的invoke 方法,在这个方法中可以执行一些操作(这里是解析方法的注解参数等),通过这个方法真正的执行我们编写的接口中的网络请求。

方法解析和类型转换

下面具体看一下在 invoke 中解析网络请求方法的几行。首先是 ServiceMethod serviceMethod = loadServiceMethod(method);,其中 loadServiceMethod 代码如下:

  1. ServiceMethod loadServiceMethod(Method method) { 
  2.     ServiceMethod result; 
  3.     synchronized (serviceMethodCache) { 
  4.       result = serviceMethodCache.get(method); 
  5.       if (result == null) { 
  6.         result = new ServiceMethod.Builder(this, method).build(); 
  7.         serviceMethodCache.put(method, result); 
  8.       } 
  9.     } 
  10.     return result; 
  11.  

可以看出,这里是先到缓存中找,缓存中没有再去创建。这里创建了 ServiceMethod 对象。ServiceMethod 用于把接口方法的调用转换成一个 HTTP 请求。其实,在 ServiceMethod 中,会解析接口中方法的注解、参数等,它还有个 toRequest 方法,用于生成一个 Request 对象。这个 Request 对象就是 OkHttp 中的 Request,代表了一条网络请求(Retrofit 实际上把真正请求网络的操作交给了 OkHttp 执行)。下面是创建 ServiceMethod 的部分代码:

  1. public ServiceMethod build() { 
  2.   //获取 callAdapter 
  3.   callAdapter = createCallAdapter(); 
  4.   responseType = callAdapter.responseType(); 
  5.   if (responseType == Response.class || responseType == okhttp3.Response.class) { 
  6.     throw methodError("'" 
  7.         + Utils.getRawType(responseType).getName() 
  8.         + "' is not a valid response body type. Did you mean ResponseBody?"); 
  9.   } 
  10.   //获取 responseConverter  
  11.   responseConverter = createResponseConverter(); 
  12.  
  13.   for (Annotation annotation : methodAnnotations) { 
  14.     //解析注解 
  15.     parseMethodAnnotation(annotation); 
  16.     //省略了一些代码 
  17.     ... 
  18.   } 
  19.  

在得到 ServiceMethod 对象后,把它连同方法调用的相关参数传给了 OkHttpCall 对象,也就是这行代码: OkHttpCall okHttpCall = new OkHttpCall<>(serviceMethod, args);。 下面介绍 OkHttpCall,OkHttpCall继承于 Call 接口。Call 是Retrofit 的基础接口,代表发送网络请求与响应调用,它包含下面几个接口方法:

  • Response<T> execute() throws IOException; //同步执行请求
  • void enqueue(Callback<T> callback); //异步执行请求,callback 用于回调
  • boolean isExecuted(); //是否执行过
  • void cancel(); //取消请求
  • boolean isCanceled(); //是否取消了
  • Call<T> clone(); //克隆一条请求
  • Request request(); //获取原始的request

OkHttpCall 是 Call 的一个实现类,它里面封装了 OkHttp 中的原生 Call,在这个类里面实现了 execute 以及 enqueue 等方法,其实是调用了 OkHttp 中原生 Call 的对应方法。

接下来把 OkHttpCall 传给 serviceMethod.callAdapter 对象,这里的callAdapter又是什么?在上面创建 ServiceMethod 的代码中有一行代码: callAdapter = createCallAdapter(),这里创建了 calladapter,在这个代码内部是根据方法的返回类型以及注解去寻找对应的 CallAdapter,去哪里寻找?去 Retrofit 对象的 adapterFactories 集合中找。当我们创建 Retrofit 的时候,可以调用 addCallAdapter 向 adapterFactories 中添加 CallAdapter。在前面的基本用法里面,我们并没有添加任何 CallAdapter,但adapterFactories 中默认会添加一个 ExecutorCallAdapterFactory,调用其 get 方法便可获得 CallAdapter 对象。

那么 CallAdapter 是干嘛的呢?上面调用了adapt 方法,它是为了把一个 Call 转换成另一种类型,比如当 Retrofit 和 RxJava 结合使用的时候,接口中方法可以返回 Observable<T>,这里相当于适配器模式。默认情况下得到的是一个 Call 对象,它是ExecutorCallbackCall,代码如下:

  1. public CallAdapter<Call<?>> get(Type returnType, Annotation[] annotations, Retrofit retrofit) { 
  2. if (getRawType(returnType) != Call.class) { 
  3.   return null
  4. final Type responseType = Utils.getCallResponseType(returnType); 
  5. return new CallAdapter<Call<?>>() { 
  6.   @Override public Type responseType() { 
  7.     return responseType; 
  8.   } 
  9.  
  10.   @Override public <R> Call<R> adapt(Call<R> call) { 
  11.     return new ExecutorCallbackCall<>(callbackExecutor, call); 
  12.   } 
  13. }; 
  14.  

这个 ExecutorCallbackCall 接受一个 callbackExecutor(Android 中默认为 MainThreadExecutor,把返回的数据传回主线程) 和一个 call,也就是 OkhttpCall。看下 ExecutorCallbackCall 部分代码:

  1. static final class ExecutorCallbackCall<T> implements Call<T> { 
  2. final Executor callbackExecutor; 
  3. final Call<T> delegate; 
  4.  
  5. ExecutorCallbackCall(Executor callbackExecutor, Call<T> delegate) { 
  6.   this.callbackExecutor = callbackExecutor; 
  7.   this.delegate = delegate; 
  8.  
  9. @Override public void enqueue(final Callback<T> callback) { 
  10.   if (callback == null) throw new NullPointerException("callback == null"); 
  11.  
  12.   delegate.enqueue(new Callback<T>() { 
  13.     @Override public void onResponse(Call<T> call, final Response<T> response) { 
  14.       callbackExecutor.execute(new Runnable() { 
  15.         @Override public void run() { 
  16.           if (delegate.isCanceled()) { 
  17.             // Emulate OkHttp's behavior of throwing/delivering an IOException on cancellation. 
  18.             callback.onFailure(ExecutorCallbackCall.this, new IOException("Canceled")); 
  19.           } else { 
  20.             callback.onResponse(ExecutorCallbackCall.this, response); 
  21.           } 
  22.         } 
  23.       }); 
  24.     } 
  25.  
  26.     @Override public void onFailure(Call<T> call, final Throwable t) { 
  27.       callbackExecutor.execute(new Runnable() { 
  28.         @Override public void run() { 
  29.           callback.onFailure(ExecutorCallbackCall.this, t); 
  30.         } 
  31.       }); 
  32.     } 
  33.   }); 
  34.  

在 enqueue 方法中,调用了 OkHttpCall 的 enqueue,所以这里相当于静态的代理模式。OkHttpCall 中的 enqueue 其实又调用了原生的 OkHttp 中的 enqueue,这里才真正发出了网络请求,部分代码如下:

  1. @Override public void enqueue(final Callback<T> callback) { 
  2.     if (callback == null) throw new NullPointerException("callback == null"); 
  3.     //真正请求网络的 call 
  4.     okhttp3.Call call; 
  5.     Throwable failure; 
  6.  
  7.     synchronized (this) { 
  8.       if (executed) throw new IllegalStateException("Already executed."); 
  9.       executed = true
  10.       //省略了部分发代码 
  11.       ... 
  12.       call = rawCall; 
  13.       //enqueue 异步执行 
  14.     call.enqueue(new okhttp3.Callback() { 
  15.       @Override public void onResponse(okhttp3.Call call, okhttp3.Response rawResponse) 
  16.           throws IOException { 
  17.         Response<T> response; 
  18.         try { 
  19.         //解析数据 会用到 conveterFactory,把 response 转换为对应 Java 类型 
  20.           response = parseResponse(rawResponse); 
  21.         } catch (Throwable e) { 
  22.           callFailure(e); 
  23.           return
  24.         } 
  25.         callSuccess(response); 
  26.       } 
  27.  
  28.       @Override public void onFailure(okhttp3.Call call, IOException e) { 
  29.         try { 
  30.           callback.onFailure(OkHttpCall.this, e); 
  31.         } catch (Throwable t) { 
  32.           t.printStackTrace(); 
  33.         } 
  34.       } 
  35.  
  36.   private void callFailure(Throwable e) { 
  37.     try { 
  38.       callback.onFailure(OkHttpCall.this, e); 
  39.     } catch (Throwable t) { 
  40.       t.printStackTrace(); 
  41.     } 
  42.   } 
  43.  
  44.   private void callSuccess(Response<T> response) { 
  45.     try { 
  46.       callback.onResponse(OkHttpCall.this, response); 
  47.     } catch (Throwable t) { 
  48.       t.printStackTrace(); 
  49.     } 
  50.   } 
  51.  }); 
  52.  

OkHttp 获取数据后,解析数据并回调callback响应的方法,一次网络请求便完成了。

总结

Retrofit 整个框架的代码不算太多,还是比较易读的。主要就是通过动态代理的方式把 Java 接口中的解析为响应的网络请求,然后交给 OkHttp 去执行。并且可以适配不同的 CallAdapter,可以方便与 RxJava 结合使用。

【编辑推荐】

  1. Android自定义线程池的编程实战
  2. iOS vs Android苹果将重蹈PC业务覆辙?
  3. Linux内核现流量劫持缺陷 8成Android设备中枪
  4. 由Android、iPhone***出货量对比来看它们的系统占有率
  5. 细数Android 7.0“牛轧糖”的五大缺陷:不支持悬浮窗口
【责任编辑:枯木 TEL:(010)68476606】

点赞 0
分享:
大家都在看
猜你喜欢

订阅专栏+更多

16招轻松掌握PPT技巧

16招轻松掌握PPT技巧

GET职场加薪技能
共16章 | 晒书包

289人订阅学习

20个局域网建设改造案例

20个局域网建设改造案例

网络搭建技巧
共20章 | 捷哥CCIE

645人订阅学习

WOT2019全球人工智能技术峰会

WOT2019全球人工智能技术峰会

通用技术、应用领域、企业赋能三大章节,13大技术专场,60+国内外一线人工智能精英大咖站台,分享人工智能的平台工具、算法模型、语音视觉等技术主题,助力人工智能落地。
共50章 | WOT峰会

0人订阅学习

读 书 +更多

设计模式:可复用面向对象软件的基础(双语版)

《设计模式:可复用面向对象软件的基础》(双语版)是引导读者走入软件设计迷宫的指路明灯,凝聚了软件开发界几十年的设计经验。四位顶尖的...

订阅51CTO邮刊

点击这里查看样刊

订阅51CTO邮刊

51CTO服务号

51CTO播客