美文网首页开源项目源码解析
Android 网络框架--Retrofit2 源码分析(上)

Android 网络框架--Retrofit2 源码分析(上)

作者: 嘎啦果安卓兽 | 来源:发表于2017-09-11 10:37 被阅读159次

    Retrofit是Square公司出品的一款产品,主要完成封装符合RESTful风格 的 HTTP的网络框架。Retrofit在2.0之后,HTTP网络框架内置了OKHttp,不能再配置其他的HTTP网络框架。它是一个高聚低耦的的代码结构,Client可以根据需要选择采用何种数据格式(XML/Json等)与Server交换数据,以及异步的请求结果以何种方式通知主线程(Call/Observable等)。

    先从一个简单的例子说起

    public interface GitHub {
            @GET("/repos/{owner}/{repo}/contributors")
            Call<List<Contributor>> contributors(
                    @Path("owner") String owner,
                    @Path("repo") String repo);
        }
        public static void main(String... args) throws IOException {
            Retrofit retrofit = new Retrofit.Builder()
                    .baseUrl(API_URL)
                    .addConverterFactory(GsonConverterFactory.create())
                    .build();
            GitHub github = retrofit.create(GitHub.class);
            Call<List<Contributor>> call = github.contributors("square", "retrofit");
            List<Contributor> contributors = call.execute().body();
            call.enqueue(new Callback<List<Contributor>>() {
                @Override
                public void onResponse(Call<List<Contributor>> call, Response<List<Contributor>> response) {
                    List<Contributor> data = response.body();
                }
                @Override
                public void onFailure(Call<List<Contributor>> call, Throwable t) {
                }
            });
            for (Contributor contributor : contributors) {
                System.out.println(contributor.login + " (" + contributor.contributions + ")");
            }
        }
    

    以上的代码演示了retrofit的基本使用方法和步骤:

    1. 定义数据Bean结构
    2. 设计api接口
    3. 配置Retrofit对象
    4. 获得api接口的代理对象
    5. 执行http请求并处理返回的数据

    需要一提的是,api接口的设计采用了注解的方式,好处是省去了开发者复杂的数据封装。
    本篇文章主要对以上步骤3,4,5内容分析。

    Retrofit类分析

    retrofit类.png

    Retrofit类内部主要管理3个对象

    • Converter.Factory列表:主要用来管理数据序列化的,每一个converter代表一种数据格式,例如Json、Protobuf等。Retrofit允许client和server之间的数据传输可以采用多种数据格式。
    • CallAdapter.Factory列表:主要管理返回结果异步处理方式,每一个callAdater代表了一种异步的处理方式,如Call,Rxjava等。Retrofit允许同时配置多种异步处理方式,默认的情况是Call的方式,现在比较流行的是Rxjava。
    • ServiceMethod列表:serviceMethod是retrofit中关键的类,它完成了主要的请求封装,以及根据数据类型和api的返回类型完成converter和callAdapter的选择。

    Retrofit的 配置主要就是设置Converter.Factory和 CallAdapter.Factory,以及配置一些okhttp相关的url,拦截器等。

    api接口代理对象的产生过程

    retrofit_stay.png

    上图简单的展示了代理对象的产生过程:(图片来源 http://www.jianshu.com/p/45cb536be2f4

    public <T> T create(final Class<T> 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.
                if (method.getDeclaringClass() == Object.class) {
                  return method.invoke(this, args);
                }
                if (platform.isDefaultMethod(method)) {
                  return platform.invokeDefaultMethod(method, service, proxy, args);
                }
                ServiceMethod<Object, Object> serviceMethod =
                    (ServiceMethod<Object, Object>) loadServiceMethod(method);
                OkHttpCall<Object> okHttpCall = new OkHttpCall<>(serviceMethod, args);
                return serviceMethod.callAdapter.adapt(okHttpCall);
              }
            });
      }
    
    1. 先获取serviceMethod:如果有缓存则从缓存中获取,否则创建一个新的对象。serviceMethod的创建过程非常繁琐,包括从配置的converterfactory,callAdapterFactory中选择适合该api接口的converter和callAdapter、注解的参数解析成http协议字段
    2. 利用serviceMethod和注解参数创建OkhttpCall,OkhttpCall是对Okhttp的封装,Retrofit2.0之后默内置了Okhttp,不再支持其他的网络框架。
    3. 将OkhttpCall通过callAdapter的方法adapt()转换之后返回,结果可以是Call、Obsevable等。

    serviceMethod的创建过程

     public ServiceMethod build() {
          callAdapter = createCallAdapter();
         ...
          responseConverter = createResponseConverter();
    
          for (Annotation annotation : methodAnnotations) {
            parseMethodAnnotation(annotation);
          }
    
         ...
            parameterHandlers[p] = parseParameter(p, parameterType, parameterAnnotations);
          ...
    
          return new ServiceMethod<>(this);
        }
    
    • 首先选择该接口的callAdapter
    • 然后选择Response的converter
    • 解析接口的Method和Header
    • 解析接口的参数,同时会选择Request的converter

    callAdapter和converter的选择过程是retrofit设计高解耦低聚合的经典的地方,我们重点分析一下这里的源码。

    serviceMethod的创建过程 -- callAdapter的选择过程

    public CallAdapter<?, ?> nextCallAdapter(CallAdapter.Factory skipPast, Type returnType,
          Annotation[] annotations) {
        checkNotNull(returnType, "returnType == null");
        checkNotNull(annotations, "annotations == null");
    
        int start = adapterFactories.indexOf(skipPast) + 1;
        for (int i = start, count = adapterFactories.size(); i < count; i++) {
          CallAdapter<?, ?> adapter = adapterFactories.get(i).get(returnType, annotations, this);
          if (adapter != null) {
            return adapter;
          }
        }
    ...
         new IllegalArgumentException(builder.toString());
      }
    

    从之前配置的callAdapter.Factory列表中依次判断是否支持某种返回类型,如果找到就返回callAdapter,否则就抛出异常。Retrofit把判断是否支持某种返回类型的操作交给了CallAdapter.Factory来做,而CallAdapter.factory是开发者自己实现的,可以自己定义CallAdapter.Factory支持哪些类型的api接口返回类型,从而实现了与Retrofit解耦。Retrofit提供了Rxjava类型的CallAdapter.Factory,开发者可以参考实现自己的CallAdapter.Factory。

    serviceMethod的创建过程 -- Converter的选择过程

     public <T> Converter<T, RequestBody> nextRequestBodyConverter(Converter.Factory skipPast,
          Type type, Annotation[] parameterAnnotations, Annotation[] methodAnnotations) {
        checkNotNull(type, "type == null");
        checkNotNull(parameterAnnotations, "parameterAnnotations == null");
        checkNotNull(methodAnnotations, "methodAnnotations == null");
    
        int start = converterFactories.indexOf(skipPast) + 1;
        for (int i = start, count = converterFactories.size(); i < count; i++) {
          Converter.Factory factory = converterFactories.get(i);
          Converter<?, RequestBody> converter =
              factory.requestBodyConverter(type, parameterAnnotations, methodAnnotations, this);
          if (converter != null) {
            //noinspection unchecked
            return (Converter<T, RequestBody>) converter;
          }
        }
    
      ...
        throw new IllegalArgumentException(builder.toString());
      }
    

    与callAdapter的选择过程类似,从之前配置的Converter.Factory列表中依次判断是否支持某种返回的数据类型,如果找到就返回converter,否则就抛出异常。Retrofit把判断是否支持某种返回数据类型的操作交给了Converter.Factory来做,而Converter.factory是开发者自己实现的,可以自己定义Converter.Factory支持哪些类型的api接口返回数据类型,从而实现了与Retrofit解耦。Retrofit提供了Json,Protobuf类型的Converter.Factory,开发者可以参考实现自己的Converter.Factory。

    将OkhttpCall通过callAdapter的方法adapt()转换之后返回

    在动态代理的创建过程中,最后调用CallAdapter.adapter(okhttpcall)返回,callAdapter是serviceMethod创建过程中选择的。如果没有设置Calladapter.Factory,retrofit会提供默认的CallAdapter.Factory。我们以Retrofit默认的CallAdapter.Factory为例分析。

    final class DefaultCallAdapterFactory extends CallAdapter.Factory {
      static final CallAdapter.Factory INSTANCE = new DefaultCallAdapterFactory();
    
      @Override
      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<Object, Call<?>>() {
          @Override public Type responseType() {
            return responseType;
          }
    
          @Override public Call<Object> adapt(Call<Object> call) {
            return call;
          }
        };
      }
    

    可以看出,默认的callAdapter返回的是Call对象。

    执行http请求

    http请求的细节过程可以参考下一篇文章

    相关文章

      网友评论

        本文标题: Android 网络框架--Retrofit2 源码分析(上)

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