美文网首页
Retrofit源码学习梳理

Retrofit源码学习梳理

作者: 三季人 | 来源:发表于2017-11-02 13:14 被阅读89次

    Retrofit已经出来很多时间了,项目中也一直在用,只知道它的功能强大,不知其原理,这不是一个号的开发,所以最近一段时间把retrofit源码研究了一下。我们先从它的功能说起。

    retrofit功能

    retrofit 是一个网络情况框架,配合Okhttp进行网络请求,但是retrofit本身实际是不参与网络请求的过程,它只是根据我们接口定义的参数和配置,生成对应的网络请求类(这个类默认是Httpclient)。

    说完了功能,下面我们一点一点的来了解retrofit是怎样的工作流程。

    1. Retrofit的创建

            Retrofit retrofit = new Retrofit.Builder()
                                                  .baseUrl(baseUrl)
                                                  .build();
    

    retrofit的创建是通过retrofit内部的builder来构建的,使用了建造者模式很好的将使用者和调用者分离开了。

    retrofit.builder中的属性很多,我们直接跳到build()方法看生产Retrofit

        public Retrofit build() {
              if (baseUrl == null) {
                throw new IllegalStateException("Base URL required.");
              }
    
              okhttp3.Call.Factory callFactory = this.callFactory;
              if (callFactory == null) {
                callFactory = new OkHttpClient();
              }
    
              Executor callbackExecutor = this.callbackExecutor;
              if (callbackExecutor == null) {
                callbackExecutor = platform.defaultCallbackExecutor();
              }
    
              // Make a defensive copy of the adapters and add the default Call adapter.
              List<CallAdapter.Factory> adapterFactories = new ArrayList<>(this.adapterFactories);
              adapterFactories.add(platform.defaultCallAdapterFactory(callbackExecutor));
    
              // Make a defensive copy of the converters.
              List<Converter.Factory> converterFactories =
                  new ArrayList<>(1 + this.converterFactories.size());
    
              // Add the built-in converter factory first. This prevents overriding its behavior but also
              // ensures correct behavior when using converters that consume all types.
              converterFactories.add(new BuiltInConverters());
              converterFactories.addAll(this.converterFactories);
    
              return new Retrofit(callFactory, baseUrl, converterFactories, adapterFactories,
                  callbackExecutor, validateEagerly);
            }
    

    中间主要是对retrofit 中设置一些默认的属性

    • baseUrl:请求的base地址,不能为null,否则抛异常
    • callFactory: 默认的网络请求,okhttpclient
    • callbackExecutor:通过Platform获取到默认的请求线程调度器
    • adapterFactories: 网络请求类转换器,默认添加了DefaultCallAdapterFactory
    • converterFactories:网络结果response转化对象,默认添加了BuiltInConverters

    简单说下PlatForm
    platform会更具不同的平台处理不同的代码,这里我们主要关注的是Android

      static class Android extends Platform {
            @Override public Executor defaultCallbackExecutor() {
              return new MainThreadExecutor();
            }
    
            @Override CallAdapter.Factory defaultCallAdapterFactory(@Nullable Executor callbackExecutor) {
              if (callbackExecutor == null) throw new AssertionError();
              return new ExecutorCallAdapterFactory(callbackExecutor);
            }
    
            static class MainThreadExecutor implements Executor {
              private final Handler handler = new Handler(Looper.getMainLooper());
    
              @Override public void execute(Runnable r) {
                handler.post(r);
              }
            }
          }
    

    可以留意到platform中提供两个方法
    - defaultCallbackExecutor()默认的调度器,用来指定,我们回调在哪个线程调用
    - defaultCallAdapterFactory()默认的CallAdapterFactory(这个类主要是用来将retrofit2.call请求类型转化为我们接口定义的类型转换器),具体后面会说明

    小结: 在retrofit创建的时候,已经初始化指定了一些默认参数
    1. baseUrl:请求base地址
    2. CallFactory: 网络请求类 OkhttpClient
    3. CallBackExcutor: 网络返回调度器(默认是在主线程)
    4. CallAdapterFactory: 网络请求类转换器(转换我们接口中定义的请求网络返回类型)
    5. Convert: 默认返回response转换器

    好了,retrofit的创建基本已经分析完了,下面的自定义的接口实例的创建了。

    2.自定义接口类型的创建

    retrofit.create(Interface.class)进去看方法。

        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, @Nullable 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);
                  }
                });
    

    使用动态代理返回的是接口类的一个代理类,我们先不看代理类做了哪些额外的工作,先往下走流程,拿到代理类之后,该请求网络了。

    Call<List<Repo>> repos = service.listRepos("octocat");
    repos.execute().body()

    直接调用代理接口类中的方法,返回了一个网络请求对象retrofit2.call
    最后通过retrofit2.call.execute().body()返回请求结果

    我们重点就在retrofit.create()生成接口代理类,以及接口代理类调用方法返回网络请求对象的过程了。

    invocationHandeler中的invoke主要如下:

    ServiceMethod<Object, Object> serviceMethod =
                    (ServiceMethod<Object, Object>) loadServiceMethod(method);
                OkHttpCall<Object> okHttpCall = new OkHttpCall<>(serviceMethod, args);
                return serviceMethod.callAdapter.adapt(okHttpCall);
    

    第一步:通过loadServiceMethod()获取ServiceMethod对象

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

    先从缓存中获取method方法,没有,在创建一个新的放入缓存。
    注意: serviceMethod 实际上就是对应的一个接口中请求方法,每一个方法只会创建一个,其余从缓存里取。

    再来看看ServiceMethod.Builder和retrofit中的Builder一样,都是使用了建造者模式方面使用者和调用者分离。

    serviceMethod的创建是在build()方法中,主要是通过invok()中的方法,获取方法中的参数和注解,生成相关的属性:
    更具接口定义主要获取如下:

    • CallAdapter:获取定义接口中的网络请求返回转换类型
    • responseConvert:获取接口定义中返回response需要转换的数据结构类型
    • parameterHandlers: 通过解析注解得到注解中的参数,例如请求地址,请求参数等。

    第二步创建一个OkhttpCall(retrofit2.call)
    默认的具体实现网络请求的对象,内部实现了retrofit.call接口,但内部真正使用的是okhttp3.call对象,这里使用了依赖倒置模式使得可以更好的扩展

    内部,包含了enqueue()异步请求、execute同步请求、cancel、取消网络请求等。

    第三步通过callAdapter将返回类型的retrofit2.call转化成我们接口定义的类型,例如observable<Object>、Flowable<Object>等

    servicemethod会调用retrofit中的callAdapter,内部回去遍历所有的callAdapterFactory去尝试创建callAdapter,直到创建成功。

    最后调用callAdapter中的adapter,将okhttpCall转化为我们接口定义的返回类型。

    好了,retrofit源码的学习基本就到这里了。过程有点简单,只是简单的梳理了一下。

    引用

    从架构角度看Retrofit的作用、原理和启示

    你真的会用Retrofit2吗?Retrofit2完全教程

    相关文章

      网友评论

          本文标题:Retrofit源码学习梳理

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