Android Retrofit源码的具体用法解析

简介

创新互联公司是专业的柳河网站建设公司，柳河接单;提供做网站、成都做网站,网页设计,网站设计,建网站,PHP网站建设等专业做网站服务;采用PHP框架,可快速的进行柳河网站开发网页制作和功能扩展;专业做搜索引擎喜爱的网站,专业的做网站团队,希望更多企业前来合作!

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

基本用法

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

 
 
   
  
  public interface GitHubService {   
  
    @GET("users/{user}/repos")   
  
    Call> listRepos(@Path("user") String user);   
  
  }

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

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

 
 
   
  
  Retrofit retrofit = new Retrofit.Builder()   
  
  .baseUrl("https://api.github.com/")   
  
  .addConverterFactory(GsonConverterFactory.create())   
  
  .build();   
  
     
  
  GitHubService service = retrofit.create(GitHubService.class);   
  
  Call> repos = service.listRepos("octocat");   
  
  repos.enqueue(new Callback>() {   
  
      @Override   
  
      public void onResponse(Call> call, Response> response) {   
  
                 
  
      }   
  
      @Override   
  
      public void onFailure(Call> call, Throwable t) {   
  
     
  
      }   
  
   });

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

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

源码分析

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

Retrofit 的创建

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

 
 
   
  
  //用于缓存解析出来的方法   
  
   private final Map serviceMethodCache = new LinkedHashMap<>();   
  
      
  
   //请求网络的OKHttp的工厂，默认是 OkHttpClient   
  
   private final okhttp3.Call.Factory callFactory;   
  
      
  
   //baseurl   
  
   private final HttpUrl baseUrl;   
  
      
  
   //请求网络得到的response的转换器的集合 默认会加入 BuiltInConverters        
  
   private final List converterFactories;   
  
      
  
   //把Call对象转换成其它类型   
  
   private final List adapterFactories;   
  
      
  
   //用于执行回调 Android中默认是 MainThreadExecutor   
  
   private final Executor callbackExecutor;   
  
      
  
   //是否需要立即解析接口中的方法   
  
   private final boolean validateEagerly;

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

 
 
   
  
  public Retrofit build() {   
  
    if (baseUrl == null) {   
  
      throw new IllegalStateException("Base URL required.");   
  
    }   
  
     
  
    okhttp3.Call.Factory callFactory = this.callFactory;   
  
    if (callFactory == null) {   
  
      //默认创建一个 OkHttpClient   
  
      callFactory = new OkHttpClient();   
  
    }   
  
     
  
    Executor callbackExecutor = this.callbackExecutor;   
  
    if (callbackExecutor == null) {   
  
       //Android 中返回的是 MainThreadExecutor   
  
      callbackExecutor = platform.defaultCallbackExecutor();   
  
    }   
  
     
  
    // Make a defensive copy of the adapters and add the default Call adapter.   
  
    List adapterFactories = new ArrayList<>(this.adapterFactories);   
  
    adapterFactories.add(platform.defaultCallAdapterFactory(callbackExecutor));   
  
     
  
    // Make a defensive copy of the converters.   
  
    List converterFactories = new ArrayList<>(this.converterFactories);   
  
     
  
    return new Retrofit(callFactory, baseUrl, converterFactories, adapterFactories,   
  
        callbackExecutor, validateEagerly);   
  
  }

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

create 方法

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

 
 
   
  
  public  T create(final Class service) {   
  
  Utils.validateServiceInterface(service);   
  
  if (validateEagerly) {   
  
    //提前解析方法   
  
    eagerlyValidateMethods(service);   
  
  }   
  
  return (T) Proxy.newProxyInstance(service.getClassLoader(), new Class[] { service },   
  
      new InvocationHandler() {   
  
        private final Platform platform = Platform.get();   
  
     
  
        @Override public Object invoke(Object proxy, Method method, Object... args)   
  
            throws Throwable {   
  
          // If the method is a method from Object then defer to normal invocation.如果是Object中的方法，直接调用   
  
          if (method.getDeclaringClass() == Object.class) {   
  
            return method.invoke(this, args);   
  
          }   
  
          //为了兼容 Java8 平台，Android 中不会执行   
  
          if (platform.isDefaultMethod(method)) {   
  
            return platform.invokeDefaultMethod(method, service, proxy, args);   
  
          }   
  
          //下面是重点，解析方法   
  
          ServiceMethod serviceMethod = loadServiceMethod(method);   
  
          OkHttpCall okHttpCall = new OkHttpCall<>(serviceMethod, args);   
  
          return serviceMethod.callAdapter.adapt(okHttpCall);   
  
        }   
  
  });

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 代码如下：

 
 
   
  
  ServiceMethod loadServiceMethod(Method method) {   
  
      ServiceMethod result;   
  
      synchronized (serviceMethodCache) {   
  
        result = serviceMethodCache.get(method);   
  
        if (result == null) {   
  
          result = new ServiceMethod.Builder(this, method).build();   
  
          serviceMethodCache.put(method, result);   
  
        }   
  
      }   
  
      return result;   
  
  }

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

 
 
   
  
  public ServiceMethod build() {   
  
    //获取 callAdapter   
  
    callAdapter = createCallAdapter();   
  
    responseType = callAdapter.responseType();   
  
    if (responseType == Response.class || responseType == okhttp3.Response.class) {   
  
      throw methodError("'"   
  
          + Utils.getRawType(responseType).getName()   
  
          + "' is not a valid response body type. Did you mean ResponseBody?");   
  
    }   
  
    //获取 responseConverter    
  
    responseConverter = createResponseConverter();   
  
     
  
    for (Annotation annotation : methodAnnotations) {   
  
      //解析注解   
  
      parseMethodAnnotation(annotation);   
  
      //省略了一些代码   
  
      ...   
  
    }   
  
  }

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

Response execute() throws IOException; //同步执行请求
void enqueue(Callback callback); //异步执行请求，callback 用于回调
boolean isExecuted(); //是否执行过
void cancel(); //取消请求
boolean isCanceled(); //是否取消了
Call 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，这里相当于适配器模式。默认情况下得到的是一个 Call 对象，它是ExecutorCallbackCall，代码如下：

 
 
   
  
  public CallAdapter> get(Type returnType, Annotation[] annotations, Retrofit retrofit) {   
  
  if (getRawType(returnType) != Call.class) {   
  
    return null;   
  
  }   
  
  final Type responseType = Utils.getCallResponseType(returnType);   
  
  return new CallAdapter>() {   
  
    @Override public Type responseType() {   
  
      return responseType;   
  
    }   
  
     
  
    @Override public  Call adapt(Call call) {   
  
      return new ExecutorCallbackCall<>(callbackExecutor, call);   
  
    }   
  
  };   
  
  }

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

 
 
   
  
  static final class ExecutorCallbackCall implements Call {   
  
  final Executor callbackExecutor;   
  
  final Call delegate;   
  
     
  
  ExecutorCallbackCall(Executor callbackExecutor, Call delegate) {   
  
    this.callbackExecutor = callbackExecutor;   
  
    this.delegate = delegate;   
  
  }   
  
     
  
  @Override public void enqueue(final Callback callback) {   
  
    if (callback == null) throw new NullPointerException("callback == null");   
  
     
  
    delegate.enqueue(new Callback() {   
  
      @Override public void onResponse(Call call, final Response response) {   
  
        callbackExecutor.execute(new Runnable() {   
  
          @Override public void run() {   
  
            if (delegate.isCanceled()) {   
  
              // Emulate OkHttp's behavior of throwing/delivering an IOException on cancellation.   
  
              callback.onFailure(ExecutorCallbackCall.this, new IOException("Canceled"));   
  
            } else {   
  
              callback.onResponse(ExecutorCallbackCall.this, response);   
  
            }   
  
          }   
  
        });   
  
      }   
  
     
  
      @Override public void onFailure(Call call, final Throwable t) {   
  
        callbackExecutor.execute(new Runnable() {   
  
          @Override public void run() {   
  
            callback.onFailure(ExecutorCallbackCall.this, t);   
  
          }   
  
        });   
  
      }   
  
    });   
  
  }

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

 
 
   
  
  @Override public void enqueue(final Callback callback) {   
  
      if (callback == null) throw new NullPointerException("callback == null");   
  
      //真正请求网络的 call   
  
      okhttp3.Call call;   
  
      Throwable failure;   
  
     
  
      synchronized (this) {   
  
        if (executed) throw new IllegalStateException("Already executed.");   
  
        executed = true;   
  
        //省略了部分发代码   
  
        ...   
  
        call = rawCall;   
  
        //enqueue 异步执行   
  
      call.enqueue(new okhttp3.Callback() {   
  
        @Override public void onResponse(okhttp3.Call call, okhttp3.Response rawResponse)   
  
            throws IOException {   
  
          Response response;   
  
          try {   
  
          //解析数据 会用到 conveterFactory，把 response 转换为对应 Java 类型   
  
            response = parseResponse(rawResponse);   
  
          } catch (Throwable e) {   
  
            callFailure(e);   
  
            return;   
  
          }   
  
          callSuccess(response);   
  
        }   
  
     
  
        @Override public void onFailure(okhttp3.Call call, IOException e) {   
  
          try {   
  
            callback.onFailure(OkHttpCall.this, e);   
  
          } catch (Throwable t) {   
  
            t.printStackTrace();   
  
          }   
  
        }   
  
     
  
    private void callFailure(Throwable e) {   
  
      try {   
  
        callback.onFailure(OkHttpCall.this, e);   
  
      } catch (Throwable t) {   
  
        t.printStackTrace();   
  
      }   
  
    }   
  
     
  
    private void callSuccess(Response response) {   
  
      try {   
  
        callback.onResponse(OkHttpCall.this, response);   
  
      } catch (Throwable t) {   
  
        t.printStackTrace();   
  
      }   
  
    }   
  
   });   
  
  }

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

总结

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

新闻名称：Android Retrofit源码的具体用法解析
分享链接：http://www.shufengxianlan.com/qtweb/news19/108869.html

网站建设、网络推广公司-创新互联，是专注品牌与效果的网站制作，网络营销seo公司；服务项目有等

声明：本网站发布的内容（图片、视频和文字）以用户投稿、用户转载内容为主，如果涉及侵权请尽快告知，我们将会在第一时间删除。文章观点不代表本网站立场，如需处理请联系客服。电话：028-86922220；邮箱：631063699@qq.com。内容未经允许不得转载，或转载时需注明来源：创新互联

猜你还喜欢下面的内容