Retrofit 源码简单分析

发表于

众所周知，在现在的Android开发中，针对与网络请求，Retrofit+okHtt的组合绝对是不二之选，而在网上针对与Retrofit分析的文章也有很多了，这次我也分享一些阅读Retrofit源码的心得，希望能够对大家有所帮助。由于我在工作中使用的版本为2.1，所以本次也是针对2.1版本进行分析，首先来看看Retrofit一种简单的用法：

Retrofit简单使用示例

首先创建出Retrofit对象，进行相应的初始化配置：

1
2
3
4
5
retrofit=new Retrofit.Builder()
    .baseUrl(baseUrl)
    .addConverterFactory(GsonConverterFactory.create())
    .client(getClient())
    .build();

然后在Service接口中写入相应方法，并加上相应的注解：

1
2
3
4
public interface Api {
    @GET(apiUrl)
    Call<Response> methodName();
}

最后传入请求的回调方法Callback就可以就完成了：

1
retrofit.create(Api.class).methodName().enqueue(Callback);

对于Retrofit对象的Build中，主要的都是对于参数的初始化，所以本次就从Retrofit类中的create(final Class service)入手

Retrofit.create

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
public <T> T create(final Class<T> service) {
    //api类必须为接口，且不能实现或继承其他接口，否则在动态代理步骤将会抛出异常
    Utils.validateServiceInterface(service);
    if (validateEagerly) {
        //立即开始遍历调用service中的所有方法
        eagerlyValidateMethods(service);
    }
    //返回service类的动态代理对象，当调用service中的方法时，就会进入其中进行处理
    return (T) Proxy.newProxyInstance(service.getClassLoader(), new Class<?>[] { service },
        new InvocationHandler() {
          //获取当前平台（Android或Java8）
          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.
            // 如果该方法为Class类中的方法，则直接执行
            if (method.getDeclaringClass() == Object.class) {
              return method.invoke(this, args);
            }
            //判断给方法是否为default method，针对Android平台，该值永远为false，所以不应在Service类中加入default方法，经尝试可能会导致崩溃
            //关于default method可以参考 http://ebnbin.com/2015/12/20/java-8-default-methods/
            if (platform.isDefaultMethod(method)) {
              return platform.invokeDefaultMethod(method, service, proxy, args);
            }
            //1.获取调用方法的ServiceMethod对象
            ServiceMethod serviceMethod = loadServiceMethod(method);
            //2.创建OkHttpCall对象
            OkHttpCall okHttpCall = new OkHttpCall<>(serviceMethod, args);
            //3.将上一步生成的OkHttpCall对象转换为在service中所配置的Call对象
            return serviceMethod.callAdapter.adapt(okHttpCall);
          }
        });
 }

在这段代码的最后所返回的Call对象就是用来使用的Call对象了。

其中有一个很有趣的地方，在 Platform 类中有一个通过判断特定的类是否存在的方式获取当前平台的步骤，在我的2.1版本中有这么一段代码：

1
2
3
4
try {
    Class.forName("org.robovm.apple.foundation.NSObject");
    return new IOS();
} catch (ClassNotFoundException ignored) {}

但在最新的2.3版本中这段代码已被移除，这说明Retrofit在之前版本中有对IOS平台的支持，但是我在网上却没有找到相关的资料，不知道有没有哪位朋友能为我解答一下。

在上面的代码中，重点是最后的三行代码，下面就分别对于这三行代码进分析：

1.ServiceMethod serviceMethod = loadServiceMethod(method);

Retrofit.loadServiceMethod

下面来通过loadServiceMethod方法看看ServiceMethod对象是如何创建出来的

1
2
3
4
5
6
7
8
9
10
11
12
13
ServiceMethod loadServiceMethod(Method method) {
  ServiceMethod result;
  synchronized (serviceMethodCache) {
    //该方法的ServiceMethod对象是否已存在缓存中，如果是，则直接使用缓存中的对象
    result = serviceMethodCache.get(method);
    if (result == null) {
      //创建ServiceMethod对象并将其放入缓存
      result = new ServiceMethod.Builder(this, method).build();
      serviceMethodCache.put(method, result);
    }
  }
  return result;
}

在代码中可以看出创建ServiceMethod对象主要都在ServiceMethod.Builder之中

在其中我发现了一点，在我所使用的2.1版本中，作为缓存使用的serviceMethodCache为LinkedHashMap，但在最新的2.3版本中已被换成了线程安全的ConcurrentHashMap。

ServiceMethod.Builder.Builder

首先看看Build中的构造方法：

1
2
3
4
5
6
7
public Builder(Retrofit retrofit, Method method) {
  this.retrofit = retrofit;  //retrofit对象
  this.method = method;  //所调用的方法
  this.methodAnnotations = method.getAnnotations();  //方法上的注解
  this.parameterTypes = method.getGenericParameterTypes();  //方法中参数的类型
  this.parameterAnnotationsArray = method.getParameterAnnotations();  //方法中参数上的注解
}

可以看出，构造方法中的代码很简单，就是针对各个变量的赋值操作。下面就是ServiceMethod中的重头戏，也就是build方法，对于注解的解析也都是在这里完成的，这一部分的代码虽多，但是大部分都是对于注解的解析与异常的判断，还是一样先来看看代码：

ServiceMethod.Builder.build

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
public ServiceMethod build() {
  //代码中将略去其中的合法性检测部分

  //通过retrofit中的CallAdapterFactory生成CallAdapter，用以生成网络请求所需的执行器
  callAdapter = createCallAdapter();
  //数据数据转换工厂，例如常用的GsonConverterFactory
  responseConverter = createResponseConverter();

  //解析方法上的注解
  for (Annotation annotation : methodAnnotations) {
    parseMethodAnnotation(annotation);
  }

  //解析方法中各参数上的注解
  int parameterCount = parameterAnnotationsArray.length;
  parameterHandlers = new ParameterHandler<?>[parameterCount];
  for (int p = 0; p < parameterCount; p++) {
    Type parameterType = parameterTypes[p];

    Annotation[] parameterAnnotations = parameterAnnotationsArray[p];

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

  //返回ServiceMethod对象
  return new ServiceMethod<>(this);
}

其中最重要的应该是属于对于方法与参数的注解解析的部分了，这也是Retrofit的特色之一，先来看看对于方法部分的注解解析：

ServiceMethod.parseMethodAnnotation

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
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);
  } else if (annotation instanceof HEAD) {
    parseHttpMethodAndPath("HEAD", ((HEAD) annotation).value(), false);
  } else if (annotation instanceof PATCH) {
    parseHttpMethodAndPath("PATCH", ((PATCH) annotation).value(), true);
  } else if (annotation instanceof POST) {
    parseHttpMethodAndPath("POST", ((POST) annotation).value(), true);
  } else if (annotation instanceof PUT) {
    parseHttpMethodAndPath("PUT", ((PUT) annotation).value(), true);
  } else if (annotation instanceof OPTIONS) {
    parseHttpMethodAndPath("OPTIONS", ((OPTIONS) annotation).value(), false);
  } else if (annotation instanceof HTTP) {
    HTTP http = (HTTP) annotation;
    parseHttpMethodAndPath(http.method(), http.path(), http.hasBody());
  } else if (annotation instanceof retrofit2.http.Headers) {
    String[] headersToParse = ((retrofit2.http.Headers) annotation).value();
    headers = parseHeaders(headersToParse);
  } else if (annotation instanceof Multipart) {
    isMultipart = true;
  } else if (annotation instanceof FormUrlEncoded) {
    isFormEncoded = true;
  }
}

可以看出来，这个方法中的逻辑很简单，主要是判断出注解的类型，并将对应的字符串传入之后的处理中，真正的处理还是在parseHttpMethodAndPath与parseHeaders两个方法中

ServiceMethod.parseHttpMethodAndPath

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
private void parseHttpMethodAndPath(String httpMethod, String value, boolean hasBody) {
  //除去异常判断后的代码
  
  //方法的类型（如GET，POST，PUT等）
  this.httpMethod = httpMethod;
  //是否含有Body
  this.hasBody = hasBody;

  //判断相对路径是否为空
  if (value.isEmpty()) {
    return;
  }

  //将相对路径
  this.relativeUrl = value;
  //解析相对路径中的参数
  this.relativeUrlParamNames = parsePathParameters(value);
}

在除去其中异常判断后，这个方法的逻辑就变得非常清晰了

ServiceMethod.parsePathParameters

1
2
3
4
5
6
7
8
9
static Set<String> parsePathParameters(String path) {
  // PARAM_URL_REGEX = \{([a-zA-Z][a-zA-Z0-9_-]*)\}
  Matcher m = PARAM_URL_REGEX.matcher(path);
  Set<String> patterns = new LinkedHashSet<>();
  while (m.find()) {
    patterns.add(m.group(1));
  }
  return patterns;
}

这个方法也很好理解，使用正则表达式匹配出相对路径中以”{}”包裹的变量，然后放入Set集合中

ServiceMethod.parseHeaders

该方法的作用为Header注解的解析：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
private Headers parseHeaders(String[] headers) {
  Headers.Builder builder = new Headers.Builder();
  for (String header : headers) {
    //解析出header中的key和value
    int colon = header.indexOf(':');
    String headerName = header.substring(0, colon);
    String headerValue = header.substring(colon + 1).trim();
    //针对Content-type的头，将其存入contentType变量中
    if ("Content-Type".equalsIgnoreCase(headerName)) {
      MediaType type = MediaType.parse(headerValue);
      contentType = type;
    } else {
      builder.add(headerName, headerValue);
    }
  }
  //创建Headers对象
  return builder.build();
}

ServiceMethod.parseParameterAnnotation

这个方法用于参数注解的解析

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
private ParameterHandler<?> parseParameterAnnotation(
    int p, Type type, Annotation[] annotations, Annotation annotation) {
  if (annotation instanceof Url) {
    //do something
  } else if (annotation instanceof Path) {
    //do something
  } else if (annotation instanceof Query) {
    //do something
  } else if (annotation instanceof QueryMap) {
   //do something
  } else if (annotation instanceof Header) {
    //do something
  } else if (annotation instanceof HeaderMap) {
    //do something
  } else if (annotation instanceof Field) {
    //do something
  } else if (annotation instanceof FieldMap) {
    //do something
  } else if (annotation instanceof Part) {
    //do something
  } else if (annotation instanceof PartMap) {
    gotPart = true;
    //do something
  } else if (annotation instanceof Body) {
    //do something
  }

  return null; // Not a Retrofit annotation.
}

parseParameterAnnotation这个方法中的代码虽然多，但是在简化之后可以看出来，就是针对不同的参数类型进行不同的处理然后返回相应的ParameterHandler对象，因为其中针对各个类型参数的处理比较繁琐，就不一一列举了。

需要提到的是，在这个方法中，有一个类的出现频率非常的高，这就是ParameterHandler类，这个类的主要作用是将注解中的各项参数通过RequestBuilder类转换为okHttp中使用的Request。

2.OkHttpCall okHttpCall = new OkHttpCall<>(serviceMethod, args);

在OkHttpCall类中，最主要的就是execute与enqueue两个方法，分别为同步与异步的网络请求，但是需要注意的是，这两个方法并不是我们在使用中所调用的方法，真正提供给外界调用的方法，会在文章之后的部分讲到。

OkHttpCall.execute

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
@Override public Response<T> execute() throws IOException {
  //okHttp中的call对象，由于本次分析限于Retrofit中，所以不做深究
  okhttp3.Call call;

  synchronized (this) {
    //一个OkhttpCall对象只能执行一次网络请求
    if (executed) throw new IllegalStateException("Already executed.");
    executed = true;

    //省略部分异常判断代码

    call = rawCall;
    if (call == null) {
      try {
        //如果okHttp对象未创建，则在创建后赋值给变量call
        call = rawCall = createRawCall();
      } catch (IOException | RuntimeException e) {
        creationFailure = e;
        throw e;
      }
    }
  }

  //防止当调用过cancel方法后新创建的Call未被cancel的情况
  if (canceled) {
    call.cancel();
  }

  //使用okhttp开始执行网络请求
  return parseResponse(call.execute());
}

OkHttpCall.enqueue

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
@Override public void enqueue(final Callback<T> callback) {
  if (callback == null) throw new NullPointerException("callback == null");

  //okHttp中的call对象，由于本次分析限于Retrofit中，所以不做深究
  okhttp3.Call call;
  Throwable failure;

  //一个OkhttpCall对象只能执行一次网络请求
  synchronized (this) {
    if (executed) throw new IllegalStateException("Already executed.");
    executed = true;

    call = rawCall;
    failure = creationFailure;
    if (call == null && failure == null) {
      try {
        //如果okHttp对象未创建，则在创建后赋值给变量call
        call = rawCall = createRawCall();
      } catch (Throwable t) {
        failure = creationFailure = t;
      }
    }
  }

  //创建okhttp对象失败时，直接进行Fail的回调方法
  if (failure != null) {
    callback.onFailure(this, failure);
    return;
  }

  //防止当调用过cancel方法后新创建的Call未被cancel的情况
  if (canceled) {
    call.cancel();
  }

  //使用okhttp开始执行网络请求，并针对返回结果调用Callback中相应的回调方法
  call.enqueue(new okhttp3.Callback() {
    @Override public void onResponse(okhttp3.Call call, okhttp3.Response rawResponse)
        throws IOException {
      Response<T> response;
      try {
        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<T> response) {
      try {
        callback.onResponse(OkHttpCall.this, response);
      } catch (Throwable t) {
        t.printStackTrace();
      }
    }
  });
}

enqueue方法在主要的逻辑上，与上面的execute是基本相同的，但是有一点需要注意，就是当收到Response时并不会马上进行Callback中的onResponse回调，而是会调用parseResponse方法对返回的Response进行一次解析，如果解析中出现了异常，依然会进行onFailure的回调方法。

OkHttpCall.parseResponse

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
Response<T> parseResponse(okhttp3.Response rawResponse) throws IOException {
  // 取出Response中的Body
  ResponseBody rawBody = rawResponse.body();

  // 这个变量就是最后获得的Response中的rawResponse，这实际上是一个在请求中返回的，去除了body部分的okhttp.Response原始对象
  // 移除okhttp3.Response中的Source部分并重建一个okhttp.Response对象
  // Remove the body's source (the only stateful object) so we can pass the response along.
  rawResponse = rawResponse.newBuilder()
      .body(new NoContentResponseBody(rawBody.contentType(), rawBody.contentLength()))
      .build();

  int code = rawResponse.code();
  //如果code不在200~299的范围内，则代表请求异常
  if (code < 200 || code >= 300) {
    try {
      // Buffer the entire body to avoid future I/O.
      ResponseBody bufferedBody = Utils.buffer(rawBody);
      return Response.error(bufferedBody, rawResponse);
    } finally {
      rawBody.close();
    }
  }

  // 204 NO CONTENT 与 205 RESET CONTENT 两个code是不含有body的
  // 具体可以查阅https://developer.mozilla.org/en-US/docs/Web/HTTP/Status/204与
  //           https://developer.mozilla.org/en-US/docs/Web/HTTP/Status/205
  if (code == 204 || code == 205) {
    return Response.success(null, rawResponse);
  }

  // ExceptionCatchingRequestBody是为了捕获在解析rawBody中的内容的buffer时抛出的异常
  ExceptionCatchingRequestBody catchingBody = new ExceptionCatchingRequestBody(rawBody);
  try {
    // 通过Converter（如：GsonResponseBodyConverter）将Response中的流解析为所需的返回类型
    T body = serviceMethod.toResponse(catchingBody);
    return Response.success(body, rawResponse);
  } catch (RuntimeException e) {
    // If the underlying source threw an exception, propagate that rather than indicating it was
    // a runtime exception.
    catchingBody.throwIfCaught();
    throw e;
  }
}

这个方法主要是对okhttp中返回的response进行一次解析，对其进行一些预处理，并将其转换为更易于使用的Response对象

OkHttpCall.createRawCall

1
2
3
4
5
6
7
8
9
10
private okhttp3.Call createRawCall() throws IOException {
  //获取ServiceMethod生成的Request对象
  Request request = serviceMethod.toRequest(args);
  //通过callFactory将Request转换为Okhttp3.Call
  okhttp3.Call call = serviceMethod.callFactory.newCall(request);
  if (call == null) {
    throw new NullPointerException("Call.Factory returned null.");
  }
  return call;
}

这个方法主要用于创建okHttp中的Call对象，逻辑非常简单，就不多做分析了

3.serviceMethod.callAdapter.adapt(okHttpCall)

这个方法实际是使用在创建Retrofit对象时传入的CallAdapterFactory将OkHttpCall对象转换为最后使用所需的对象，Retrofit中会默认配置一个ExecutorCallAdapterFactory，除此之外还有常用的RxJavaCallAdapterFactory与一个最简单的DefaultCallAdapterFactory。我们抽取出其中的adapt方法来看一看：

DefaultCallAdapterFactory

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
final class DefaultCallAdapterFactory extends CallAdapter.Factory {
  //DefaultCallAdapterFactory在返回时为一个单例对象
  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<Call<?>>() {
      //获取返回值的类型
      @Override public Type responseType() {
        return responseType;
      }

      //将传入的Call对象转换为最后处理所需要的对象返回，在DefaultCallAdapterFactory中为将传入其中的对象直接返回
      @Override public <R> Call<R> adapt(Call<R> call) {
        return call;
      }
    };
  }
}

这个是Retrofit中最为基本的CallAdapter，也只有在平台为Java8或者无法判断平台时才会使用，也由于这个类的逻辑非常简单，也可以通过这个类了解到CallAdapter.Factory最核心的两个方法的作用

ExecutorCallAdapterFactory

ExecutorCallAdapterFactory类为Android平台的默认CallAdapter：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
final class ExecutorCallAdapterFactory extends CallAdapter.Factory { 
  final Executor callbackExecutor;
  
  //构造方法
  ExecutorCallAdapterFactory(Executor callbackExecutor) {
    this.callbackExecutor = callbackExecutor;
  }

  //获取CallAdapter对象
  @Override
  public CallAdapter<Call<?>> get(Type returnType, Annotation[] annotations, Retrofit retrofit) {
    if (getRawType(returnType) != Call.class) {
      return null;
    }
    final Type responseType = Utils.getCallResponseType(returnType);
    return new CallAdapter<Call<?>>() {
      //获取返回参数的类型
      @Override public Type responseType() {
        return responseType;
      }

      //将传入的Call对象转换为最后处理所需要的对象返回,在这里的返回类型为内部类ExecutorCallbackCall
      @Override public <R> Call<R> adapt(Call<R> call) {
        return new ExecutorCallbackCall<>(callbackExecutor, call);
      }
    };
  }

  //这就是在ExecutorCallAdapterFactory中返回给外界去使用的对象，也就是在文章开头调用了相应的api方法后所返回的对象
  static final class ExecutorCallbackCall<T> implements Call<T> {
    final Executor callbackExecutor;
    final Call<T> delegate;

    ExecutorCallbackCall(Executor callbackExecutor, Call<T> delegate) {
      this.callbackExecutor = callbackExecutor;
      this.delegate = delegate;
    }

    //在文章开头的使用示例中所传入的CallBack实际就是在这里调用相应的回调方法
    @Override public void enqueue(final Callback<T> callback) {
      if (callback == null) throw new NullPointerException("callback == null");

      delegate.enqueue(new Callback<T>() {
        @Override public void onResponse(Call<T> call, final Response<T> response) {
          //这里的callbackExecutor来源于针对当前平台的对象Platform中的defaultCallbackExecutor方法
          //在Android平台中，该方法的返回语句为 return new MainThreadExecutor(); 
          //MainThreadExecutor的实现为通过handler将Runnable对象发送至主线程执行
          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<T> call, final Throwable t) {
          //此处callbackExecutor作用同上
          callbackExecutor.execute(new Runnable() {
            @Override public void run() {
              callback.onFailure(ExecutorCallbackCall.this, t);
            }
          });
        }
      });
    }
    
    //do something
  }

结语

那么，到现在为止，我们简单梳理了Retrofit中的Call的创建流程与ServiceMethod类中的主要逻辑，而这些，也只是Retrofi中的一部分而已，而我也是第一次写这样的文章，加上我的技术还不到位，所以肯定会有很多的不足，欢迎大家来批评指正。