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

时间  2020-06-21
标签 android 进阶 retrofit2.0 retrofit 原理 解析 流程 栏目 Android 繁體版
原文   原文链接
retrofit已经流行好久了，它是Square开源的一款优秀的网络框架，这个框架对okhttp进行了封装，让咱们使用okhttp作网路请求更加简单。可是光学会使用只是让咱们多了一个技能，学习其源码才能让咱们更好的成长。

本篇文章是在分析retrofit的源码流程，有大量的代码，读者最好把【源码】下载下来导入IDE，而后跟着一块儿看，效果会更好
一.retrofit入门android

  • 定义网络请求的API接口：
interface GithubApiService {
        @GET("users/{name}/repos")
        Call<ResponseBody> searchRepoInfo(@Path("name") String name);
    }

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

  • 初始化一个retrofit的实例：
Retrofit retrofit = new Retrofit.Builder()
            .baseUrl("https://api.github.com/")
            .build();

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

  • 生成接口实现类：
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的核心工做是如何完成的！api

二.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 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方法已经帮咱们实现了咱们定义的接口，并返回咱们须要的值。

四.请求参数整理
咱们定义的接口已经被实现，可是咱们仍是不知道咱们注解的请求方式，参数类型等是如何发起网络请求的呢？
这时咱们可能应该关注一下ServiceMethod<Object, Object>对象的构建了：

ServiceMethod<Object, Object> serviceMethod =
                (ServiceMethod<Object, Object>) loadServiceMethod(method);

主要的逻辑都在这个loadServiceMethod(method)里面，咱们看看方法体：

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;
  }

逻辑很简单，就是先从一个 serviceMethodCache中取ServiceMethod<?, ?>对象，若是没有，则构建ServiceMethod<?, ?>对象，而后放进去serviceMethodCache中，这个serviceMethodCache是一个HashMap:

private final Map<Method, ServiceMethod<?, ?>> serviceMethodCache = new ConcurrentHashMap<>();

因此构建ServiceMethod<?, ?>对象的主要逻辑还不在这个方法里，应该在new ServiceMethod.Builder<>(this, method).build();里面。这也是个链式调用，通常都是参数赋值，咱们先看看Builder<>(this, method)方法：

Builder(Retrofit retrofit, Method method) {
      this.retrofit = retrofit;
      this.method = method;
      this.methodAnnotations = method.getAnnotations();
      this.parameterTypes = method.getGenericParameterTypes();
      this.parameterAnnotationsArray = method.getParameterAnnotations();
    }

果真，这里获取了几个重要的参数：

  • retrofit实例
  • method，接口方法
  • 接口方法的注解methodAnnotations，在retrofit里通常为请求方式
  • 参数类型parameterTypes
  • 参数注解数组parameterAnnotationsArray，一个参数可能有多个注解

咱们再看看build()的方法：

public ServiceMethod build() {
      callAdapter = createCallAdapter();
      responseType = callAdapter.responseType();
      responseConverter = createResponseConverter();

      for (Annotation annotation : methodAnnotations) {
        parseMethodAnnotation(annotation);
      }

      if (httpMethod == null) {
        throw methodError("HTTP method annotation is required (e.g., @GET, @POST, etc.).");
      }

      int parameterCount = parameterAnnotationsArray.length;
      parameterHandlers = new ParameterHandler<?>[parameterCount];
      for (int p = 0; p < parameterCount; p++) {
        Type parameterType = parameterTypes[p];
        if (Utils.hasUnresolvableType(parameterType)) {
          throw parameterError(p, "Parameter type must not include a type variable or wildcard: %s",
              parameterType);
        }

        Annotation[] parameterAnnotations = parameterAnnotationsArray[p];
        if (parameterAnnotations == null) {
          throw parameterError(p, "No Retrofit annotation found.");
        }

        parameterHandlers[p] = parseParameter(p, parameterType, parameterAnnotations);
      }

      return new ServiceMethod<>(this);
    }

这个方法挺长的，删了些可有可无的代码仍是很长。首先一开始先获取几个重要对象：callAdapter、responseType和responseConverter，这三个对象都跟最后的结果有关，咱们先无论。
看到一个for循环，遍历方法的注解，而后解析：

for (Annotation annotation : methodAnnotations) {
        parseMethodAnnotation(annotation);
      }
private void parseMethodAnnotation(Annotation annotation) {
      if (annotation instanceof DELETE) {
        parseHttpMethodAndPath("DELETE", ((DELETE) annotation).value(), false);
      } else if (annotation instanceof GET) {
        parseHttpMethodAndPath("GET", ((GET) annotation).value(), false);
      } 

        ....

这个方法的方法体我删掉了后面的一部分，由于逻辑都是同样，根据不一样的方法注解做不一样的解析，获得网络请求的方式httpMethod。可是主要的方法体仍是if里面的方法：

private void parseHttpMethodAndPath(String httpMethod, String value, boolean hasBody) {

      ....

      // Get the relative URL path and existing query string, if present.
      int question = value.indexOf('?');
      if (question != -1 && question < value.length() - 1) {
        // Ensure the query string does not have any named parameters.
        String queryParams = value.substring(question + 1);
        Matcher queryParamMatcher = PARAM_URL_REGEX.matcher(queryParams);
        if (queryParamMatcher.find()) {
          throw methodError("URL query string \"%s\" must not have replace block. "
              + "For dynamic query parameters use @Query.", queryParams);
        }
      }

      this.relativeUrl = value;
      this.relativeUrlParamNames = parsePathParameters(value);
    }

逻辑不复杂，就是校验这个value的值 是否合法，规则就是不能有“？”若是有则须要使用@Query注解。最后this.relativeUrl = value;。这个relativeUrl就至关于省略域名的URL，通常走到这里咱们能获得的是：users/{name}/repos这样的。里面的“{name}”是一会咱们须要赋值的变量。
咱们继续看刚才的build()方法：
解析完方法的注解以后，须要解析参数的注解数组，这里实例化了一个一维数组：

parameterHandlers = new ParameterHandler<?>[parameterCount];

而后遍历取出参数的类型：

Type parameterType = parameterTypes[p];

取出参数注解：

Annotation[] parameterAnnotations = parameterAnnotationsArray[p];

而后把参数类型、参数注解都放在一块儿进行解析，解析的结果放到刚才实例化的数组parameterHandlers里面：

parameterHandlers[p] = parseParameter(p, parameterType, parameterAnnotations);

那咱们再看看这个方法里作了什么：

private ParameterHandler<?> parseParameter(int p, Type parameterType, Annotation[] annotations) {
      ParameterHandler<?> result = null;
      for (Annotation annotation : annotations) {
        ParameterHandler<?> annotationAction = parseParameterAnnotation(
            p, parameterType, annotations, annotation);
      }

    }

这个方法的主要代码也很简单，解析参数注解，获得一个ParameterHandler<?> annotationAction对象。
那我继续看方法里面的代码。当咱们点进parseParameterAnnotation( p, parameterType, annotations, annotation);的源码里面去以后发现这个方法的代码接近500行！可是大部分逻辑相似，都是经过if else判断参数的注解，咱们取一段咱们刚才的例子相关的代码出来：

if (annotation instanceof Path) {
        if (gotQuery) {
          throw parameterError(p, "A @Path parameter must not come after a @Query.");
        }
        if (gotUrl) {
          throw parameterError(p, "@Path parameters may not be used with @Url.");
        }
        if (relativeUrl == null) {
          throw parameterError(p, "@Path can only be used with relative url on @%s", httpMethod);
        }
        gotPath = true;

        Path path = (Path) annotation;
        String name = path.value();
        validatePathName(p, name);

        Converter<?, String> converter = retrofit.stringConverter(type, annotations);
        return new ParameterHandler.Path<>(name, converter, path.encoded());

      }

前面作了一些校验，后面取出注解的名字：name，而后用正则表达校验这个name是否合法。而后构建一个Converter<?, String>对象：

Converter<?, String> converter = retrofit.stringConverter(type, annotations);

点击去看看：

public <T> Converter<T, String> stringConverter(Type type, Annotation[] annotations) {
      ....
    for (int i = 0, count = converterFactories.size(); i < count; i++) {
      Converter<?, String> converter =
          converterFactories.get(i).stringConverter(type, annotations, this);
      if (converter != null) {
        //noinspection unchecked
        return (Converter<T, String>) converter;
      }
    }
    return (Converter<T, String>) BuiltInConverters.ToStringConverter.INSTANCE;
  }

看到核心代码是converter的stringConverter(type, annotations, this)方法：
由于咱们刚才的示例中被没有经过：addConverterFactory(ConverterFactory)添加一个ConverterFactory，因此这里会返回一个空：

public @Nullable Converter<?, String> stringConverter(Type type, Annotation[] annotations,
        Retrofit retrofit) {
      return null;
    }

因此最后会执行最后一句代码：
return (Converter<T, String>) BuiltInConverters.ToStringConverter.INSTANCE;
咱们点进去看看这个INSTANCE：

static final ToStringConverter INSTANCE = new ToStringConverter();

是BuiltInConverters内的内部类ToStringConverter的单例。因此这里咱们获得的就
是BuiltInConverters.ToStringConverter的实例。
最后用这个对象构建一个Path（由于示例中的参数类型是path，因此咱们看这个代码）：

new ParameterHandler.Path<>(name, converter, path.encoded());

咱们看看这个Path类的构造函数：

Path(String name, Converter<T, String> valueConverter, boolean encoded) {
      this.name = checkNotNull(name, "name == null");
      this.valueConverter = valueConverter;
      this.encoded = encoded;
    }

只是赋值，而且咱们看到这个类继承自：ParameterHandler<T>，因此咱们回到刚才的build()方法，发现把参数类型，参数注解放在一块儿解析以后存储到了这个ParameterHandler<T>数组中，中间主要作了多种合法性校验，并根据注解的类型，生成不一样的
ParameterHandler<T>子类，如注解是Url则生成ParameterHandler.RelativeUrl()对象，若是注解是Path，则生成：
ParameterHandler.Path<>(name, converter, path.encoded())对象等等。
咱们查看了ParameterHandler<T>类，发现它有一个抽象方法：

abstract void apply(RequestBuilder builder, @Nullable T value) throws IOException;

这个方法每一个子类都必须复写，那咱们看看Path里面怎么复写的：

@Override 
    void apply(RequestBuilder builder, @Nullable T value) throws IOException {
         builder.addPathParam(name, valueConverter.convert(value), encoded);
    }

就是把value被添加到RequestBuilder中，咱们看一下这个addPathParam方法

void addPathParam(String name, String value, boolean encoded) {

    relativeUrl = relativeUrl.replace("{" + name + "}", canonicalizeForPath(value, encoded));
  }

这个方法把咱们传进来的值value按照编码格式转换，而后替换relativeUrl中的{name}，构成一个有效的省略域名的URL。至此，URL的拼接已经完成！

总结：Retrofit使用动态代理模式实现咱们定义的网络请求接口，在重写invoke方法的时候构建了一个ServiceMethod对象，在构建这个对象的过程当中进行了方法的注解解析获得网络请求方式httpMethod，以及参数的注解分析，拼接成一个省略域名的URL

五.Retrofit网络请求
咱们刚才解析了apply方法，咱们看看apply方法是谁调用的呢？跟踪一下就发先只有toCall(args);方法：

okhttp3.Call toCall(@Nullable Object... args) throws IOException {
    RequestBuilder requestBuilder = new RequestBuilder(httpMethod, baseUrl, relativeUrl, headers,
        contentType, hasBody, isFormEncoded, isMultipart);

    @SuppressWarnings("unchecked") // It is an error to invoke a method with the wrong arg types.
    ParameterHandler<Object>[] handlers = (ParameterHandler<Object>[]) parameterHandlers;

    int argumentCount = args != null ? args.length : 0;
    if (argumentCount != handlers.length) {
      throw new IllegalArgumentException("Argument count (" + argumentCount
          + ") doesn't match expected count (" + handlers.length + ")");
    }

    for (int p = 0; p < argumentCount; p++) {
      handlers[p].apply(requestBuilder, args[p]);
    }

    return callFactory.newCall(requestBuilder.build());
  }

这个方法一开始就构建了RequestBuilder，传进去的参数包含：
httpMethod，baseUrl，relativeUrl，headers，contentType，hasBody，isFormEncoded，isMultipart！
而后获取了parameterHandlers，咱们上边分析的时候，知道这个数组是存参数注解的解析结果的，并对其进行遍历调用了以下方法：

for (int p = 0; p < argumentCount; p++) {
      handlers[p].apply(requestBuilder, args[p]);
    }

把参数值传进RequestBuilder中。
最后调用callFactory.newCall(requestBuilder.build())生成一个okhttp3.Call。
咱们看一下这个build方法：

Request build() {
    HttpUrl url;
    HttpUrl.Builder urlBuilder = this.urlBuilder;
    if (urlBuilder != null) {
      url = urlBuilder.build();
    } else {
      // No query parameters triggered builder creation, just combine the relative URL and base URL.
      //noinspection ConstantConditions Non-null if urlBuilder is null.
      url = baseUrl.resolve(relativeUrl);
      if (url == null) {
        throw new IllegalArgumentException(
            "Malformed URL. Base: " + baseUrl + ", Relative: " + relativeUrl);
      }
    }

    RequestBody body = this.body;
    if (body == null) {
      // Try to pull from one of the builders.
      if (formBuilder != null) {
        body = formBuilder.build();
      } else if (multipartBuilder != null) {
        body = multipartBuilder.build();
      } else if (hasBody) {
        // Body is absent, make an empty body.
        body = RequestBody.create(null, new byte[0]);
      }
    }

    MediaType contentType = this.contentType;
    if (contentType != null) {
      if (body != null) {
        body = new ContentTypeOverridingRequestBody(body, contentType);
      } else {
        requestBuilder.addHeader("Content-Type", contentType.toString());
      }
    }

    return requestBuilder
        .url(url)
        .method(method, body)
        .build();
  }

能够看到okhttp的请求体在这里构建，当全部的参数知足的时候，则调用了

Request.Builder requestBuilder
        .url(url)
        .method(method, body)
        .build();

这是发起okhttp的网络请求 。
那这个toCall(args);谁调用的呢？继续往回跟！

private okhttp3.Call createRawCall() throws IOException {
    okhttp3.Call call = serviceMethod.toCall(args);
    return call;
  }

那谁调用了createRawCall()呢？继续看谁调用了！因而发现调用方有三个地方，而且都是OkHttpCall里面！咱们一个一个看吧：

1.Request request()方法：
2.enqueue(final Callback callback)方法
3.Response execute()的方法 很明显上面三个方法都是retrofit的发起网络请求的方式，分别是同步请求和异步请求。咱们的示例中在最后一步就是调用了request方法和enqueue方法发起网络请求。至此咱们已经疏通了retrofit是如何进行网络请求的了
总结：当咱们调用Retrofit的网络请求方式的时候，就会调用okhttp的网络请求方式，参数使用的是实现接口的方法的时候拿到的信息构建的RequestBuilder对象，而后在build方法中构建okhttp的Request，最终发起网络请求

六. 总结
至此retrofit的流程讲完了，文章很长，代码不少，读者最好下载代码导入IDE，跟着文章一块儿看代码。
Retrofit主要是在create方法中采用动态代理模式实现接口方法，这个过程构建了一个ServiceMethod对象，根据方法注解获取请求方式，参数类型和参数注解拼接请求的连接，当一切都准备好以后会把数据添加到Retrofit的RequestBuilder中。而后当咱们主动发起网络请求的时候会调用okhttp发起网络请求，okhttp的配置包括请求方式，URL等在Retrofit的RequestBuilder的build()方法中实现，并发起真正的网络请求。
Retrofit封装了okhttp框架，让咱们的网络请求更加简洁，同时也能有更高的扩展性。固然咱们只是窥探了Retrofit源码的一部分，他还有更复杂更强大的地方等待咱们去探索包括返回值转换工厂，拦截器等，这些都属于比较难的地方，咱们须要按部就班的去学习，当咱们一点一点的看透框架的本质以后，咱们使用起来才会熟能生巧。大神的代码，对于Android想要进阶的同窗来讲颇有好处，不只教会咱们如何设计代码更多的是解决思想。

写在最后
若是喜欢个人文章，想与一群资深开发者一块儿交流学习的话，欢迎加入个人合做群Android Senior Engineer技术交流群。有flutter—性能优化—移动架构—资深UI工程师 —NDK相关专业人员和视频教学资料
群号：925019412

相关文章
相关标签/搜索
每日一句
    每一个你不满意的现在，都有一个你没有努力的曾经。
本站公众号
   欢迎关注本站公众号,获取更多信息
联系我们 最近搜索 最新文章 沪ICP备13005482号-10 MyBatis教程 SQL 教程 MySQL教程 Java 教程 Thymeleaf 教程 Hibernate教程 Spring教程 Redis教程