Retrofit源码解析-重点整理

末蓝、 2023-10-10 10:59 22阅读 0赞

#### Retrofit源码解析 ####

基于Retrofit2.7.1

implementation 'com.squareup.retrofit2:retrofit:2.7.1'
    implementation 'com.squareup.retrofit2:converter-gson:2.7.1'

Retrofit的基本使用

val retrofit = Retrofit.Builder()
        .baseUrl("https://api.github.com")
        .addConverterFactory(GsonConverterFactory.create())
        .build()
    
    val service = retrofit.create(GitHubService::class.java)
    val repos: Call<List<Repo>> = service.listRepos("octocat")
    
    repos.enqueue(object : Callback<List<Repo>?> {
        
        override fun onFailure(call: Call<List<Repo>?>, t: Throwable) {
        
    
        }
    
        override fun onResponse(call: Call<List<Repo>?>, response: Response<List<Repo>?>) {
        
    
        }
    })

#### retrofit.create ####

首先来看retrofit.create

public <T> T create(final Class<T> service) {
        
    	validateServiceInterface(service);
    	return (T) Proxy.newProxyInstance(service.getClassLoader(), new Class<?>[] {
         service },
    		new InvocationHandler() {
        
    	  private final Platform platform = Platform.get();
    	  private final Object[] emptyArgs = new Object[0];
    	
    	  @Override public @Nullable 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);
    	    }
    	    return loadServiceMethod(method).invoke(args != null ? args : emptyArgs);
    	  }
    	});
    }

##### validateServiceInterface #####

在validateServiceInterface中，会去检查GitHubService.class写的是否正确，如果不正确会抛出异常。

> 并且会将所有`GithubService.class`中的方法预先加载到缓存中

private void validateServiceInterface(Class<?> service) {
        
        if (!service.isInterface()) {
         //检查是否是接口
          throw new IllegalArgumentException("API declarations must be interfaces.");
        }
    
        Deque<Class<?>> check = new ArrayDeque<>(1);
        check.add(service);
        while (!check.isEmpty()) {
        
          Class<?> candidate = check.removeFirst();
          if (candidate.getTypeParameters().length != 0) {
         //检查是否有泛型
            StringBuilder message = new StringBuilder("Type parameters are unsupported on ")
                .append(candidate.getName());
            if (candidate != service) {
        
              message.append(" which is an interface of ")
                  .append(service.getName());
            }
            throw new IllegalArgumentException(message.toString());
          }
          Collections.addAll(check, candidate.getInterfaces());
        }
    
        if (validateEagerly) {
         //如果配置了validateEagerly，会检查接口方法编写是否正确
          Platform platform = Platform.get();
          for (Method method : service.getDeclaredMethods()) {
        
            if (!platform.isDefaultMethod(method) && !Modifier.isStatic(method.getModifiers())) {
        
              loadServiceMethod(method);
            }
          }
        }
      }

PS: 由此可知，在实际使用中，可以在生产环境中设置validateEagerly为false，来加快初始化速度，测试环境中，设置validateEagerly为true，来更快地暴露问题。

##### Proxy.newProxyInstance #####

再接下来看具体创建

//动态代理
    return (T) Proxy.newProxyInstance(service.getClassLoader(), new Class<?>[] {
         service },
        new InvocationHandler() {
        
          private final Platform platform = Platform.get();
          private final Object[] emptyArgs = new Object[0];
    
          @Override public @Nullable Object invoke(Object proxy, Method method,
              @Nullable Object[] args) throws Throwable {
        
            // Object的方法直接调用原方法
            if (method.getDeclaringClass() == Object.class) {
        
              return method.invoke(this, args);
            }
            if (platform.isDefaultMethod(method)) {
        
              return platform.invokeDefaultMethod(method, service, proxy, args);
            }
            return loadServiceMethod(method).invoke(args != null ? args : emptyArgs);
          }
        });

这里采用了动态代理，这里主要来看`loadServiceMethod(method).invoke(args != null ? args : emptyArgs);`

来看`loadServiceMethod`

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

可以看到，这里主要就用到了一个缓存。如果serviceMethodCache里有就直接返回，如果没有，那么解析这个method，保存到serviceMethodCache中。

而invoke实际调用的时`HttpServiceMethod.invoke`

@Override final @Nullable ReturnT invoke(Object[] args) {
        
    	Call<ResponseT> call = new OkHttpCall<>(requestFactory, args, callFactory, responseConverter);
    	return adapt(call, args);
    }

所以，我们在执行`repos.enqueue`的时候，实际是在执行`OkHttpCall.enqueue`

Override public void enqueue(final Callback<T> callback) {
        
    	Objects.requireNonNull(callback, "callback == null");
    	
    	okhttp3.Call call;
    	Throwable failure;
    	
    	synchronized (this) {
        
    	  if (executed) throw new IllegalStateException("Already executed.");
    	  executed = true;
    	
    	  call = rawCall;
    	  failure = creationFailure;
    	  if (call == null && failure == null) {
        
    	    try {
        
    	      call = rawCall = createRawCall();
    	    } catch (Throwable t) {
        
    	      throwIfFatal(t);
    	      failure = creationFailure = t;
    	    }
    	  }
    	}
    	
    	if (failure != null) {
        
    	  callback.onFailure(this, failure);
    	  return;
    	}
    	
    	if (canceled) {
        
    	  call.cancel();
    	}
    	
    	call.enqueue(new okhttp3.Callback() {
        
    	  @Override public void onResponse(okhttp3.Call call, okhttp3.Response rawResponse) {
        
    	    Response<T> response;
    	    try {
        
    	      response = parseResponse(rawResponse);
    	    } catch (Throwable e) {
        
    	      throwIfFatal(e);
    	      callFailure(e);
    	      return;
    	    }
    	
    	    try {
        
    	      callback.onResponse(OkHttpCall.this, response);
    	    } catch (Throwable t) {
        
    	      throwIfFatal(t);
    	      t.printStackTrace(); // TODO this is not great
    	    }
    	  }
    	
    	  @Override public void onFailure(okhttp3.Call call, IOException e) {
        
    	    callFailure(e);
    	  }
    	
    	  private void callFailure(Throwable e) {
        
    	    try {
        
    	      callback.onFailure(OkHttpCall.this, e);
    	    } catch (Throwable t) {
        
    	      throwIfFatal(t);
    	      t.printStackTrace(); // TODO this is not great
    	    }
    	  }
    	});
    }

这里调用okhttp的`call.enqueue`，并在onResponse中，通过parseResponse解析成Response，即，**Retrofit只是对OkHttp封装了一层。**

#### 线程切换 ####

我们回到`HttpServiceMethod.invoke`方法

可以看到这里还有行`adapt(call, args)`，这里最终在`DefaultCallAdapterFactory`

public Call<Object> adapt(Call<Object> call) {
        
        return (Call)(executor == null ? call : new DefaultCallAdapterFactory.ExecutorCallbackCall(executor, call));
    }

这里的executor，是在Retrofit构建的时候，就创建的。  
Retorift\#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();
          }
    
          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> callAdapterFactories = new ArrayList<>(this.callAdapterFactories);
          callAdapterFactories.addAll(platform.defaultCallAdapterFactories(callbackExecutor));
    
          // Make a defensive copy of the converters.
          List<Converter.Factory> converterFactories = new ArrayList<>(
              1 + this.converterFactories.size() + platform.defaultConverterFactoriesSize());
    
          // 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);
          converterFactories.addAll(platform.defaultConverterFactories());
    
          return new Retrofit(callFactory, baseUrl, unmodifiableList(converterFactories),
              unmodifiableList(callAdapterFactories), callbackExecutor, validateEagerly);
    }

可以看到，executor就是`platform.defaultCallbackExecutor`

static final class Android extends Platform {
        
        Android() {
        
          super(Build.VERSION.SDK_INT >= 24);
        }
    
        @Override public Executor defaultCallbackExecutor() {
        
          return new MainThreadExecutor();
        }
    
        static class MainThreadExecutor implements Executor {
        
          private final Handler handler = new Handler(Looper.getMainLooper());
    
          @Override public void execute(Runnable r) {
        
            handler.post(r);
          }
        }
      }

即，线程切换就是调用了主线程的Handler。

为什么这么设计 ?  
因为这样不仅可以用来切换线程，还可以用来干别的事情。

我们也可以通过`addCallAdapterFactory`来添加相应的Adapter，比如转换为RxJava，  
同时，我们也可以通过`addConverterFactory`来添加需要的转换器。

#### OkHttp.call是怎么创建出来的 ####

通过`requestFactoryequestFactory.create`创建okhttp的请求并发起请求。

(rawCall = createRawCall()).request();
    
    private okhttp3.Call createRawCall() throws IOException {
        
        okhttp3.Call call = callFactory.newCall(requestFactory.create(args));
        if (call == null) {
        
          throw new NullPointerException("Call.Factory returned null.");
        }
        return call;
      }

而请求的参数，是在`loadServiceMethod> ServiceMethod.parseAnnotations > equestFactory.parseAnnotations > RequestFactory.build`中就进行了解析的

#### 收到结果后是怎么解析的 ####

来看`OkHttpCall#parseResponse`

Response<T> parseResponse(okhttp3.Response rawResponse) throws IOException {
        
        ResponseBody rawBody = rawResponse.body();
    
        // 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();
        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();
          }
        }
    
        if (code == 204 || code == 205) {
        
          rawBody.close();
          return Response.success(null, rawResponse);
        }
    
        ExceptionCatchingResponseBody catchingBody = new ExceptionCatchingResponseBody(rawBody);
        try {
        
          T body = responseConverter.convert(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;
        }
      }

判断code之后，会调用`responseConverter.convert(catchingBody);`，通过responseConverter进行解析，比如GsonConverterFactory。

来看下GsonConverterFactory

@Override
    public Converter<ResponseBody, ?> responseBodyConverter(Type type, Annotation[] annotations,
        Retrofit retrofit) {
        
      TypeAdapter<?> adapter = gson.getAdapter(TypeToken.get(type));
      return new GsonResponseBodyConverter<>(gson, adapter);
    }

> 本文基于Retrofit2.7.1