Retrofit-2.4.0結合Rxjava2.3.0源碼分析 我們先從Retrofit的普通調用看起

我們先從Retrofit的普通調用看起

BaseNetEngine.getInstance().getsApiService(ApiInterface.class) //1
                .mPutCommunityBind(thirdID) //2
                .compose(bindToLifecycle()) //3
                .compose(RxSchedulersHelper.io_main()) //4
                .subscribe(deviceBindBean -> {  //5   
                        網絡調用返回......
                }, throwable -> {
                        ......   
                });
                

上面是普通的調用，我們一行行的來分析.

開頭註釋的第一行代碼分析

ApiInterface.class 這個是一個接口，裏面定義了我們請求的方法， 如下

public interface ApiInterface {
        
    @PUT(URLManager.PUT_COMMUNITY_BIND+"{id}")
    Flowable<DeviceBindBean> mPutCommunityBind(@Path("id") String id);
}

上面定義了一個接口方法。

BaseNetEngine.getInstance() 是一個單例類，然後 getsApiService方法如下

public synchronized <T> T getsApiService(Class<T> clazz) {
    T obj = (T) hashMap.get(clazz.getName());
        if (obj == null) {
            obj = getRetrofit().create(clazz);
            hashMap.put(clazz.getName(), obj);
        }   
    return obj;
}

接着看一下getRetrofit()方法

 public Retrofit getRetrofit() {
    if (sOkHttpClient == null) {
      initOkHttp();
    }
    if (sRetrofit == null) {
      ExtensionRegistry registry = ExtensionRegistry.newInstance();
      sRetrofit = new Retrofit.Builder()
          .baseUrl(BuildConfig.urlMAPI)
          .client(sOkHttpClient)
          .addConverterFactory(new NullOnEmptyConverterFactory())
          .addConverterFactory(ProtoConverterFactory.createWithRegistry(registry))//一定要在gsonconvert
          .addConverterFactory(GsonConverterFactory.create())
          .addCallAdapterFactory(RxJava2CallAdapterFactory.create())
          .build();
    }
    return sRetrofit;
  }

該方法，先是初始化Okhttp, 然後就是addConverterFactory， 進行相關的配置。

接着看一下create()方法

  public <T> T create(final Class<T> service) {
    Utils.validateServiceInterface(service);
    if (validateEagerly) {
      eagerlyValidateMethods(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);
          }
        });
  }
  

create()方法返回的是一個代理類， 代理對象會調用ApiInterface.class 這個接口中的方法，當我們調用該接口裏面的方法時，其實調用的是上述InvocationHandler()裏面的invoke()方法。

開頭註釋的第二行代碼分析

第二行通過代理對象調用了mPutCommunityBind(thirdID)方法，這個方法是ApiInterface.class裏面的方法，所以會調用InvocationHandler裏面的invoke方法，所以重點來了,會調用下面的方法，然後返回的是一個observable對象

ServiceMethod<Object, Object> serviceMethod =
                (ServiceMethod<Object, Object>) loadServiceMethod(method);
OkHttpCall<Object> okHttpCall = new OkHttpCall<>(serviceMethod, args);
return serviceMethod.adapt(okHttpCall);
            

• 首先看下 ServiceMethod， 這裏會創建ServiceMethod對象

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

 public ServiceMethod build() {
       //這裏的callAdapter就是之前配置的RxJava2CallAdapterFactory.create()
      callAdapter = createCallAdapter();      
      
      responseType = callAdapter.responseType();
    
       ......   
       //這裏的responseConver也是之前配置的GsonConverterFactory.create()
      responseConverter = createResponseConverter();

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

    ......
    ......  
    return new ServiceMethod<>(this);
}      

ServiceMethod 主要是處理之前Retrofit的配置，其內部解析相關注解。

• 然後接着看OkHttpCall方法。這裏面封裝了okhttp的方法，比如request,response方法

• 然後接着看serviceMethod.adapt(okHttpCall); 這裏的adapt方法是callAdapter.adapt(call); 這裏的callAdapter是RxJava2CallAdapter。所以我們進入到RxJava2CallAdapter的adapt方法看一看，如下

 @Override public Object adapt(Call<R> call) {
    
    //這裏主要根據isAsync創建同步或者異步的Observable�, 其主要作用的是爲了請求是同步還是異步
    Observable<Response<R>> responseObservable = isAsync
        ? new CallEnqueueObservable<>(call)
        : new CallExecuteObservable<>(call);

    Observable<?> observable;
    if (isResult) {
      observable = new ResultObservable<>(responseObservable);
    } else if (isBody) {
      observable = new BodyObservable<>(responseObservable);
    } else {
      observable = responseObservable;
    }

    if (scheduler != null) {
      observable = observable.subscribeOn(scheduler);
    }

    if (isFlowable) {
      return observable.toFlowable(BackpressureStrategy.LATEST);
    }
   
    ......
    
    return observable;
  }
  

所以調用第二行代碼返回CallEnqueueObservable，或者CallExecuteObservable 默認是返回CallExecuteObservable進行同步的請求

開頭註釋的第五行代碼分析

第三行，第四行主要是Rxjava相關的方法，第三行是綁定Rx生命週期，第四行是Rx的線程切換，所以我們主要看第五行。第五行主要是方法請求，這裏面會進行網絡調用。

我們進入subscribe源碼看一下

    public final void subscribe(FlowableSubscriber<? super T> s) {
        ObjectHelper.requireNonNull(s, "s is null");
        try {
            ......  
            subscribeActual(z);
        } catch (NullPointerException e) { // NOPMD
            throw e;
        } catch (Throwable e) {
         ......
        }
    }
    

這是Flowable裏面的抽象方法
protected abstract void subscribeActual(Subscriber<? super T> s);

我們知道第二步返回的對象是CallExecuteObservable， 那麼看下該對象下的subscribeActual方法，，這裏的網絡請求是同步的方法

final class CallExecuteObservable<T> extends Observable<Response<T>> {

  @Override protected void subscribeActual(Observer<? super Response<T>> observer) {
    // Since Call is a one-shot type, clone it for each new observer.
    Call<T> call = originalCall.clone();
    observer.onSubscribe(new CallDisposable(call));

    boolean terminated = false;
    try {
      //這裏進行真正的網絡請求
      Response<T> response = call.execute();
      if (!call.isCanceled()) {
        observer.onNext(response);
      }
      if (!call.isCanceled()) {
        terminated = true;
        observer.onComplete();
      }
    } catch (Throwable t) {
      Exceptions.throwIfFatal(t);
      if (terminated) {
        RxJavaPlugins.onError(t);
      } else if (!call.isCanceled()) {
        try {
          observer.onError(t);
        } catch (Throwable inner) {
          Exceptions.throwIfFatal(inner);
          RxJavaPlugins.onError(new CompositeException(t, inner));
        }
      }
    }
  }

}

所以當調用第五行的時候，會進行真正的網絡請求

總結