Android进阶：7、Retrofit2.0原理解析之最简流程【上】

retrofit 已经流行好久了，它是Square开源的一款优秀的网络框架，这个框架对okhttp进行了封装，让咱们使用okhttp作网路请求更加简单。可是光学会使用只是让咱们多了一个技能，学习其源码才能让咱们更好的成长。

本篇文章是在分析retrofit的源码流程，有大量的代码，读者最好把源码下载下来导入IDE，而后跟着一块儿看，效果会更好(文末有源码获取方式）

一.retrofit入门

• 定义网络请求的API接口：

interface GithubApiService {
        @GET("users/{name}/repos")
        Call<ResponseBody> searchRepoInfo(@Path("name") String name);
    }
复制代码

使用了注解代表请求方式，和参数类型，这是retrofit的特性，也正是简化了咱们的网络请求过程的地方！

• 初始化一个retrofit的实例：

Retrofit retrofit = new Retrofit.Builder()
                .baseUrl("https://api.github.com/")
                .build();
复制代码

retrofit的实例化很简单，采用链式调用的设计，把须要的参数传进去便可，复杂的参数咱们这里就不举例了。

• 生成接口实现类：

GithubApiService githubService = retrofit.create(service)
Call<ResponseBody> call = githubService.searchRepoInfo("changmu175");
复制代码

咱们调用retrofit的create方法就能够把咱们定义的接口转化成实现类，咱们能够直接调用咱们定义的方法进行网络请求，可是咱们只定义了一个接口方法，也没有方法体，请求方式和参数类型都是注解，create是如何帮咱们整理参数，实现方法体的呢？一会咱们经过源码解析再去了解。

• 发起网络请求

//同步请求方式
 call.request();
 //异步请求方式
 call.enqueue(new Callback<ResponseBody>() {
            @Override
            public void onResponse(Call<ResponseBody> call, Response<ResponseBody> response) {
                //请求成功回调
            }

            @Override
            public void onFailure(Call<ResponseBody> call, Throwable t) {
                //请求与失败回调
            }
        });
复制代码

至此，retrofit的一次网络请求示例已经结束，基于对okhttp的封装，让网络请求已经简化了不少。固然retrofit最适合的仍是REST API类型的接口，方便简洁。

下面咱们就看看retrofit的核心工做是如何完成的！

二.retrofit初始化

retrofit的初始化采用了链式调用的设计

Retrofit retrofit = new Retrofit.Builder()
                       .baseUrl("https://api.github.com/")
                       .build();
复制代码

很明显这个方法是在传一些须要的参数，咱们简单的跟踪一下：

首先看看Builder()的源码：

public Builder() {
      this(Platform.get());
    }
复制代码

这句代码很简单就是调用了本身的另外一个构造函数：

Builder(Platform platform) {
      this.platform = platform;
    }
复制代码

这个构造函数也很简单，就是一个赋值，咱们把以前的Platform.get()点开，看看里面作在什么：

private static final Platform PLATFORM = findPlatform();

static Platform get() {
    return PLATFORM;
  }
复制代码

咱们发现这里使用使用了一个饿汉式单例，使用Platform.get()返回一个实例，这样写的好处是简单，线程安全，效率高，不会生成多个实例！

咱们再看看findPlatform() 里作了什么：

private static Platform findPlatform() {
    try {
      Class.forName("android.os.Build");
      if (Build.VERSION.SDK_INT != 0) {
        return new Android();
      }
    } catch (ClassNotFoundException ignored) {
    }

    ....省略部分代码...
 }
复制代码

因此是判断了一下系统，而后根据系统实例化一个对象。这里面应该作了一些和Android平台相关的事情，属于细节，咱们追究，感兴趣的能够只看看。
再看看baseUrl(url)的源码

public Builder baseUrl(String baseUrl) {
      checkNotNull(baseUrl, "baseUrl == null");
      HttpUrl httpUrl = HttpUrl.parse(baseUrl);
      ....
      return baseUrl(httpUrl);
    }

public Builder baseUrl(HttpUrl baseUrl) {
      checkNotNull(baseUrl, "baseUrl == null");
      ....
      this.baseUrl = baseUrl;
      return this;
    }
复制代码

这两段代码也很简单，校验URL，生成httpUrl对象，而后赋值给baseUrl

看看build() 方法在作什么
参数基本设置完了，最后就要看看build() 这个方法在作什么：

public Retrofit build() {
      if (baseUrl == null) {
        throw new IllegalStateException("Base URL required.");
      }

      okhttp3.Call.Factory callFactory = this.callFactory;
      if (callFactory == null) {
        callFactory = new OkHttpClient();
      }
      ....

      return new Retrofit(callFactory, baseUrl, unmodifiableList(converterFactories),
          unmodifiableList(callAdapterFactories), callbackExecutor, validateEagerly);
    }
  }
}
复制代码

代码中有大量的参数校验，有些复杂的参数咱们没有传，因此我就把那些代码删除了。简单看一下也能知道，这段代码就是作一些参数校验，baseUrl不能为空不然会抛异常，至于其余的参数若是为null则会建立默认的对象。其中callFactory就是okhttp的工厂实例，用于网络请求的。
最后咱们看到，这个方法最终返回的是一个Retrofit的对象，初始化完成。

三.生成接口实现类

刚才咱们就讲过retrofit.create这个方法很重要，它帮咱们生成了接口实现类，并完成了方法体的建立，省去了咱们不少工做量。那咱们来看看它是如何帮咱们实现接口的。

public <T> T create(final Class<T> 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, @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.adapt(okHttpCall);
          }
        });
  }
复制代码

这段代码其实是使用了动态代理的设计模式，并且这个方法封装的很是好，咱们只须要调用 方法就能够得到咱们须要的实现类，遵循了迪米特法则（最少知道原则）。

了解动态代理的人都知道咱们要重写Object invoke(Object proxy, Method method,[@Nullable](https://xiaozhuanlan.com/u/undefined) Object[] args) 方法，这个方法会传入咱们须要的实现的方法，和参数，并返回咱们须要的返回值。

retrofit在重写这个方法的时候作了三件事：

• 先判断了这个方法的类是否是一个Object.class)，就直接返回方法原有的返回值。
• 判断这个方法是否是DefaultMethod，你们都知道这个方法是Java 8出来的新属性，表示接口的方法体。
• 构建一个ServiceMethod<Object, Object>对象和OkHttpCall<Object>对象，并调用
  serviceMethod.adapt(okHttpCall)方法将两者绑定。

咱们看看这个方法的源码：

T adapt(Call<R> call) {
    return callAdapter.adapt(call);
  }
复制代码

这个callAdapter咱们在初始化retrofit的时候没有使用：
addCallAdapterFactory(CallAdapterFactory)传值，因此这里是默认的DefaultCallAdapterFactory

那咱们再看看DefaultCallAdapterFactory里的adapt(call)方法：

@Override public Call<Object> adapt(Call<Object> call) {
        return call;
      }
复制代码

直接返回参数，也就是OkHttpCall<Object>的对象。因此若是没有自定义callAdapter的时候，咱们定义接口的时候返回值类型应该是个Call类型的。
那么，至此这个create方法已经帮咱们实现了咱们定义的接口，并返回咱们须要的值。

因为文字过长的原因，咱们暂且分为上下两文，下文讲讲到请求参数整理丶Retrofit网络请求已经本身的一些总结，固然凡事无绝对，只是本身Retrofit原理的一些见解

文章开头说的源码领取方式：关注我私信【资料】