retrofit2 源码分析(未完 待更新)

process

1 use(0.01)

  1. 新建接口APIService,定义方法、新增注解;
  2. 建造者模式新建retrofit实例;
  3. Retrofit.create(APIService.class)返回APIService对象实例;
  4. APIService.getData() 返回Call
  5. call.execute或者call.enqueue(callback)使用

2 Retrofit.class(40)

  • 2.1 Retrofit.create(APIService.class)方法


public  T create(final Class service) {
    Utils.validateServiceInterface(service);
    if (validateEagerly) {
      eagerlyValidateMethods(service);
    }
    // @{注解1  dynamic proxy }
    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 Object invoke(Object proxy, Method method, @Nullable Object[] args)
              throws Throwable {
            if (method.getDeclaringClass() == Object.class) {
              return method.invoke(this, args);
            }
            if (platform.isDefaultMethod(method)) {
              return platform.invokeDefaultMethod(method, service, proxy, args);
            }
            {@ 注解2  **实际调用httpServiceMethod.invoke 方法** }
            return loadServiceMethod(method).invoke(args != null ? args : emptyArgs);
          }
        });
  }

  • 2.2 Proxy调用 开闭原则

  • 2.3 封装OKHttp请求过程 迪米特法则

2.3.1 ServiceMethod 接口隔离
ServiceMethod loadServiceMethod(Method method) {
    // {@1} ConCurrentHAshMap 缓存ServiceMethod (原因请查看{@HttpServiceMethod.parseAnnotation 注解})
    ServiceMethod result = serviceMethodCache.get(method);
    if (result != null) return result;

    synchronized (serviceMethodCache) {
      result = serviceMethodCache.get(method);
      if (result == null) {
      
        //{@2   解析注解 生成httpServiceMethod实例 以及requestFactory实例 }
        
        result = ServiceMethod.parseAnnotations(this, method);
        serviceMethodCache.put(method, result);
      }
    }
    return result;
  }

生成httpServiceMethod以及requestFactory过程


abstract class ServiceMethod {
  static  ServiceMethod parseAnnotations(Retrofit retrofit, Method method) {
    {@1  通过解析注解生成request}
    RequestFactory requestFactory = RequestFactory.parseAnnotations(retrofit, method);

    Type returnType = method.getGenericReturnType();
    if (Utils.hasUnresolvableType(returnType)) {
      throw methodError(method,
          "Method return type must not include a type variable or wildcard: %s", returnType);
    }
    if (returnType == void.class) {
      throw methodError(method, "Service methods cannot return void.");
    }
    {@2  @link HttpServiceMethod {作用:将接口方法的调用调整为HTTP调用} 请求过程  }
    return HttpServiceMethod.parseAnnotations(retrofit, method, requestFactory);
  }
  
  @{Retrofit#create方法 中实际调用的方法(HttpServiceMethod#invoke方法)}
  @Override ReturnT invoke(Object[] args) {
   
    解释1:callAdapter 是在Retrofit.builder().build()中 注入的 ExecutorCallAdapterFactory 的get方法中拿到的

    
    {2.3.1 注解3 }HttpServiceMethod#invoke 方法返回OKHttpCall对象
    
    return callAdapter.adapt(
        new OkHttpCall<>(requestFactory, args, callFactory, responseConverter));
  }

2.3.2 httpServiceMethod#invoke 中的callAdapter来自哪呢?

结论:实际是在

Retrofit#loadServiceMethod --> 

ServiceMethod#parseAnnotations--> 

HttpServiceMethod#parseAnnotations-->

createCallAdapter()-->

retrofit#callAdapter-->

retrofit#nextCallAdapter(这个方法遍历了retrofi实例的callAdapterFactories,返回第一个不为空的callAdapter)

==最终其实回到了Retrofit的建造者的build方法中==


public Retrofit build() {
     ------
      List callAdapterFactories = new ArrayList<>(this.callAdapterFactories);
      
      callAdapterFactories.addAll(
      @{  2.3.2 注解1  默认的callAdapterFactory}
      platform.defaultCallAdapterFactories(callbackExecutor));
      
     -------
    }

{ @link 对 2.3.2 注解1的解释 }

List defaultCallAdapterFactories(
      @Nullable Executor callbackExecutor) {
    if (callbackExecutor != null) {
    @{  2.3.2 注解2  回调不 为空 }
      return singletonList(new ExecutorCallAdapterFactory(callbackExecutor));
    }
    @{  2.3.2 注解3  回调为空}
    return singletonList(DefaultCallAdapterFactory.INSTANCE);
  }

@{link ==2.3.2 注解2的解释==  ExecutorCallAdapterFactory#get }

@Override public @Nullable CallAdapter get(Type returnType,Annotation[] annotations, Retrofit retrofit) {
   // {@ 2.3.2 注解4  这个是 httpMethodService#invoke方法中的实际callAdapter  }
    return new CallAdapter>() {
      @Override public Type responseType() {
        return responseType;
      }

      @Override public Call adapt(Call call) {
      
        1、这个call是 httpMethodService#invoke(2.3.1 注解3)中传入的OkHttpCall 
        2、callbackExecutor实例是 在retrofit.builder()#build中注入的
        Android 平台默认使用MainThreadExecutor 切换到主线程
        
        return new ExecutorCallbackCall<>(callbackExecutor, call);
      }
    };
  }
 
 

// 最终调用过程

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

    @Override public void enqueue(final Callback callback) {
      checkNotNull(callback, "callback == null");
         
         1、这个delegate是 
         httpMethodService#invoke(2.3.1 注解3)中传入的OkHttpCall对象 
         
         2、okhttpcall.enqueue 方法下面有解析
         
      delegate.enqueue(new Callback() {
        @Override public void onResponse(Call call, final Response response) {
        
        // Android平台默认使用MainThreadExecutor 切换到主线程
        
          callbackExecutor.execute(new Runnable() {
            @Override public void run() {
              if (delegate.isCanceled()) {
                
                1、执行retrofit回调
                
                callback.onFailure(ExecutorCallbackCall.this, new IOException("Canceled"));
              } else {
                callback.onResponse(ExecutorCallbackCall.this, response);
              }
            }
          });
        }

        @Override public void onFailure(Call call, final Throwable t) {
        
        // Android 平台默认使用MainThreadExecutor 切换到主线程
        
          callbackExecutor.execute(new Runnable() {
            @Override public void run() {
              callback.onFailure(ExecutorCallbackCall.this, t);
            }
          });
        }
      });
    }

2.3.3 通过注解生成RequestBodyFactory继而生成request的过程
    1. 一个serviceMethod对应咱们定义的网络请求接口中的一个方法,比如栗子中的serviceApi()这个方法
    1. 二维数组:parameterAnnotationsArray[p][index]存所有annotation以及value 一个method N个参数parameter,一参数p对应多个annotation。
{@2.3.3 注解1  RequestFactory.Builder#build();}

RequestFactory build() {

      
      for (Annotation annotation : methodAnnotations) {
        //  解析方法名 相对路径 headers 以及path参数名
        parseMethodAnnotation(annotation);
      }

      // 方法中参数的数量
      
      int parameterCount = parameterAnnotationsArray.
      
      // ParameterHandler 用于处理方法中的参数
      
      parameterHandlers = new ParameterHandler[parameterCount];
      for (int p = 0; p < parameterCount; p++) {
        
        {@ 2.3.3 注解2 解析参数   }
        
        parameterHandlers[p] = parseParameter(p, parameterTypes[p], parameterAnnotationsArray[p]);
      }   
}
      
{ 对 2.3.3 注解2的 解释   }
private ParameterHandler parseParameter(
        int p, Type parameterType,@第一处 Annotation[] annotations) {
      ParameterHandler result = null;
      if (annotations != null) {
        for (Annotation annotation : annotations) {
          @第二处 从单个注解中解析多个参数注解
          ParameterHandler annotationAction =
              parseParameterAnnotation(p, parameterType, annotations, annotation);
              
          if (annotationAction == null) {
            continue;
          }
          result = annotationAction;
        }
      }
      return result;
    }

处理Method 中parameter 的annotation的逻辑,放入handler中

parseParameterAnnotation方法.png
2.3.4 HttpServiceMethod exatnd ServiceMethod(生成 HttpServiceMethod 的过程)
HttpServiceMethod.parseAnnotation(retrofit, method, requestFactory) 方法解析

static  HttpServiceMethod parseAnnotations(
  Retrofit retrofit, Method method, RequestFactory requestFactory) {
CallAdapter callAdapter = createCallAdapter(retrofit, method);
Type responseType = callAdapter.responseType();
Converter responseConverter =
    createResponseConverter(retrofit, method, responseType);

callFactory  这个注意一下 !!

okhttp3.Call.Factory callFactory = retrofit.callFactory;
return new HttpServiceMethod<>(requestFactory, callFactory, callAdapter, responseConverter); }

可以看到最终调用HttpServiceMethod的构造方法,callFactory 在OkHttp中会提到,至此retrofit的流程就结束了,紧接着就是okhttp的调用过程。

3. okHttp 调用过程(40 doing)

4. Retrofit 拓展(20)

你可能感兴趣的:(retrofit2 源码分析(未完 待更新))