retrofit解析总结

 

创建retrofit对象

public Retrofit provideRetrofit(OkHttpClient client) {
        Retrofit.Builder builder = newRetrofit.Builder()//1
               .baseUrl(Constants.BASE_URL)//请求地址 //2
                //可以接收自定义的Gson，当然也可以不传
//                .addConverterFactory(StringConverterFactory.create())
               .addConverterFactory(GsonConverterFactory.create())//3
//               .addConverterFactory(SimpleXmlConverterFactory.create())
                // 针对rxjava2.x
                .addCallAdapterFactory(RxJavaCallAdapterFactory.create())//4
                //设置自定义的OkHttpClient
                .client(client);//5
        return builder.build();//6

    }

 

注释1：Retrofit.Builder()；

Builder是retrofit的一个内部类

调用其实是调用了Builder的

publicBuilder() {
  this(Platform.get());
}

 

get()获取了一个Platform对象，

在findPlatform里的findPlatform方法里，

privatestatic Platform findPlatform() {
  try {
   Class.forName("android.os.Build");
    if (Build.VERSION.SDK_INT != 0) {
      return new Android();
    }
  } catch (ClassNotFoundException ignored){
  }
  try {
   Class.forName("java.util.Optional");
    return new Java8();
  } catch (ClassNotFoundExceptionignored) {
  }
  return new Platform();
}

再看build的构造方法

Builder(Platformplatform) {
 
//1 获取platform对象
this.platform = platform;
//2给converterFactories添加了一个BuiltInConverters对象
   converterFactories.add(newBuiltInConverters());

}

接下来再看build类的属性

privatefinal Platform platform;
private @Nullable okhttp3.Call.Factory callFactory;
private HttpUrl baseUrl;
private final List<Converter.Factory> converterFactories = newArrayList<>();
private final List<CallAdapter.Factory> adapterFactories = newArrayList<>();
private @Nullable Executor callbackExecutor;
private boolean validateEagerly;

platform根据包名来返回是android还是java

validateEagerly验证标识

callbackExecutor默认给了一个ExecutorCallAdapterFactory>

 

看注释2 : baseUrl : 根url

看注释3 :converterFactories Converter转换器的工厂类集合 ， 通过addConverterFactory(GsonConverterFactory.create())添加转换器，

看注释4 :

adapterFactories CallAdapter存储对call进行转化的对象，

 

看注释5 :

callFactory 是call的工厂类，

可以通过.client(OkHttpClient  client)设置自定义的call

OkHttpClient是负责请求网络的辅助类，并且添加拦截器就是给OkHttpClient添加的

还有ssl之类的

看注释6 :

目前将Build类分析了一边，接下来再调用builder.build() 的时候

publicRetrofit build() {
  if (baseUrl == null) {
    throw newIllegalStateException("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();
  }

  List<CallAdapter.Factory>adapterFactories = new ArrayList<>(this.adapterFactories);
 adapterFactories.add(platform.defaultCallAdapterFactory(callbackExecutor));

  List<Converter.Factory>converterFactories = new ArrayList<>(this.converterFactories);

  return new Retrofit(callFactory,baseUrl, converterFactories, adapterFactories, callbackExecutor,validateEagerly);
}

 

注释6：

publicRetrofit build() {
  if (baseUrl == null) {//1
    throw newIllegalStateException("Base URL required.");
  }

  okhttp3.Call.Factory callFactory =this.callFactory;
  if (callFactory == null) {//2
    callFactory = new OkHttpClient();
  }

  Executor callbackExecutor =this.callbackExecutor;
  if (callbackExecutor == null) {//3
    callbackExecutor =platform.defaultCallbackExecutor();
  }

  // Make a defensive copy of theadapters and add the default Call adapter.
  List<CallAdapter.Factory>adapterFactories = new ArrayList<>(this.adapterFactories);//4
 adapterFactories.add(platform.defaultCallAdapterFactory(callbackExecutor));

  // Make a defensive copy of theconverters.
  List<Converter.Factory>converterFactories = new ArrayList<>(this.converterFactories);//5

  return new Retrofit(callFactory,baseUrl, converterFactories, adapterFactories,
      callbackExecutor, validateEagerly);
}

 

注释1:

可以看出baseUrl必须有否则报错

注释2：

callFactory如果为null，则默认为OkHttpClient

注释3：

Executor 如果为null，则使用platform.defaultCallbackExecutor

因为是android系统所以会调用android类（Android类是Platform的一个内部类 ）的

staticclass Android extends Platform {
  @Override public ExecutordefaultCallbackExecutor() {
    return new MainThreadExecutor();
  }

MainThreadExecutor是Android的一个内部类，提供一个线程池（所以说Platform的作用就是根据系统（Android或者java）提供一个线程池）

static class MainThreadExecutor implements Executor {
            private final Handler handler = new Handler(Looper.getMainLooper());

            MainThreadExecutor() {
            }

            public void execute(Runnable r) {
                this.handler.post(r);
            }
        }

注释4：

adapterFactories 添加了一个callbackExecutor，

callbackExecutor是可以用retrofit.Build().callBackExecuter（）设置的

如果callbackExecutor为null，则会添加一个默认的

CallAdapter.FactorydefaultCallAdapterFactory(@Nullable Executor callbackExecutor) {
  if (callbackExecutor != null) {
    return newExecutorCallAdapterFactory(callbackExecutor);
  }
  returnDefaultCallAdapterFactory.INSTANCE;
}

DefaultCallAdapterFactory是一个将返回值转换为指定类型的类

finalclass DefaultCallAdapterFactory extends CallAdapter.Factory {
  static final CallAdapter.FactoryINSTANCE = new DefaultCallAdapterFactory();

  @Override
  public CallAdapter<?, ?> get(TypereturnType, Annotation[] annotations, Retrofit retrofit) {
    if (getRawType(returnType) !=Call.class) {
      return null;
    }

    final Type responseType =Utils.getCallResponseType(returnType);
    return new CallAdapter<Object,Call<?>>() {
      @Override public TyperesponseType() {
        return responseType;
      }

      @Override public Call<Object>adapt(Call<Object> call) {
        return call;
      }
    };
  }
}

 

如果callbackExecutor不为空

则创建一个ExecutorCallbackCall类，

看一下ExecutorCallbackCall类

staticfinal class ExecutorCallbackCall<T> implements Call<T> {
  final Executor callbackExecutor;
  final Call<T> delegate;

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

 

实现了call接口，并且持有Executor 和 call对象，

执行call的请求方法，将结果通过Executor返回给主线程

@Overridepublic void enqueue(final Callback<T> callback) {
    checkNotNull(callback, "callback== null");

    delegate.enqueue(newCallback<T>() {
      @Override public voidonResponse(Call<T> call, final Response<T> response) {
        callbackExecutor.execute(newRunnable() {
          @Override public void run() {
            if (delegate.isCanceled()) {
              // Emulate OkHttp'sbehavior of throwing/delivering an IOException on cancellation.
             callback.onFailure(ExecutorCallbackCall.this, newIOException("Canceled"));
            } else {
             callback.onResponse(ExecutorCallbackCall.this, response);
            }
          }
        });
      }

      @Override public voidonFailure(Call<T> call, final Throwable t) {
        callbackExecutor.execute(newRunnable() {
          @Override public void run() {
           callback.onFailure(ExecutorCallbackCall.this, t);
          }
        });
      }
    });
  }

  @Override public boolean isExecuted() {
    return delegate.isExecuted();
  }

  @Override public Response<T>execute() throws IOException {
    return delegate.execute();
  }

  @Override public void cancel() {
    delegate.cancel();
  }

  @Override public boolean isCanceled() {
    return delegate.isCanceled();
  }

  @SuppressWarnings("CloneDoesntCallSuperClone")// Performing deep clone.
  @Override public Call<T> clone(){
    return newExecutorCallbackCall<>(callbackExecutor, delegate.clone());
  }

  @Override public Request request() {
    return delegate.request();
  }
}

最后返回的是一个retrofit类的实力，此时第一部分完成

 

第二部分

publicinterface ApiService {
 
    /**
     * 验证短信验证码
     */
    @FormUrlEncoded
   @POST("user/checkMobileMac.action")
    publicObservable<BaseBean<BaseResponseString>>getcheckMobileMac(@Field("CLIENTDATA") String request);

 


public ApiService provideApiService(Retrofit retrofit) {
    returnretrofit.create(ApiService.class);//1
}

 

第二部分主要走了一个retrofit.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 Objectinvoke(Object proxy, Method method, @Nullable Object[] args)
//忽略次要代码
          ServiceMethod<Object,Object> serviceMethod =
              (ServiceMethod<Object,Object>) loadServiceMethod(method);//1
          OkHttpCall<Object>okHttpCall = new OkHttpCall<>(serviceMethod, args);//2
          return serviceMethod.callAdapter.adapt(okHttpCall);//3
        }
      });
}

 

看方法的传递 create> Proxy.newProxyInstanc> InvocationHandler> invoke

Invoke有三个参数（代理的对象，代理的方法，方法的参数）

也就是说当我们调用ApiService. getcheckMobileMac时 其实是调用了Invoke方法

Invote方法有几个重点

根据当前方法生成一个serviceMethod对象

根据serviceMethod生成一个okHttpcall对象，

将OKHttpCall对象传给ServiceMothod的callAdapter

接下来一条条分析

注释1：

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

  synchronized (serviceMethodCache) {
    result =serviceMethodCache.get(method);
    if (result == null) {
      result = newServiceMethod.Builder<>(this, method).build();
      serviceMethodCache.put(method,result);
    }
  }
  return result;
}

 

privatefinal Map<Method, ServiceMethod<?, ?>> serviceMethodCache = newConcurrentHashMap<>();

 

serviceMethodCache是一个map集合，在loadServiceMethod中，先判断serviceMethodCache中有没有这个ServiceMethod

如果有怎返回 没有根据method生成一个 并存储下来，并且返回

接下来看一下serviceMethod这个类

也是通过Builder模式建造的

有一系列属性

staticfinal class Builder<T, R> {
  final Retrofit retrofit;//持有retrofit对象
  final Method method;//持有该方法的对象
  final Annotation[] methodAnnotations;//方法注解集合
  final Annotation[][]parameterAnnotationsArray;//请求参数集合
  final Type[] parameterTypes;//请求类型集合
  Type responseType;//返回数据类型
  String httpMethod;//
  String relativeUrl;
  Headers headers;
  MediaType contentType;
  Set<String>relativeUrlParamNames;
  ParameterHandler<?>[]parameterHandlers;//报文头参数集合
  Converter<ResponseBody, T>responseConverter;//转换器集合
  CallAdapter<T, R> callAdapter;//执行请求的辅助类

 

接下来看一个构造方法

publicServiceMethod build() {
  callAdapter = createCallAdapter();//1
  responseType =callAdapter.responseType();//2
  responseConverter =createResponseConverter();//3

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

  int parameterCount = parameterAnnotationsArray.length;
  parameterHandlers = newParameterHandler<?>[parameterCount];
  for (int p = 0; p < parameterCount;p++) {
    parameterType);
    }

    Annotation[] parameterAnnotations =parameterAnnotationsArray[p];//5
    if (parameterAnnotations == null) {
      throw parameterError(p, "NoRetrofit annotation found.");
    }
    parameterHandlers[p] =parseParameter(p, parameterType, parameterAnnotations);
  }

  return new ServiceMethod<>(this);
}

 

注释1：

callAdapter= createCallAdapter();

 

privateCallAdapter<T, R> createCallAdapter() {
     return (CallAdapter<T, R>)retrofit.callAdapter(returnType, annotations);
 }

 

publicCallAdapter<?, ?> callAdapter(Type returnType, Annotation[] annotations){
  return nextCallAdapter(null,returnType, annotations);
}

 

publicCallAdapter<?, ?> nextCallAdapter(@Nullable CallAdapter.Factory skipPast,Type returnType,
    Annotation[] annotations) {
  for (int i = start, count =adapterFactories.size(); i < count; i++) {
    CallAdapter<?, ?> adapter =adapterFactories.get(i).get(returnType, annotations, this);
    if (adapter != null) {
      return adapter;
    }
  }
}

 

最终会调用retrofit的nextCallAdapter方法

循环adapterFactories 取出CallAdapter，如果没有设置callAdapter则有一个默认的DefaultCallAdapterFactory（把返回值转换为指定的类型）

注释2：

得到真实的数据类型

注释3：

通过遍历converterFactories获取转换器

注释4：

通过遍历methodAnnotations 获取请求方式和请求地址

注解5：

parameterAnnotationsArray 获取方法参数注解 并且解析 比如@ Url 或者@ Query

最后将生成的ServiceMethod返回

 

现在看okhttpcall

Okhttpcal<T>这个类实现了call<T>

真正的网络请求是在这个类里进行的看一下构造方法

OkHttpCall(ServiceMethod<T,?> serviceMethod, @Nullable Object[] args) {
  this.serviceMethod = serviceMethod;
  this.args = args;
}

 

 

接下来serviceMethod.callAdapter.adapt(okHttpCall)

将okHttpCall 付给了servicemethod的callAdapter对象

 

callAdapter可以有多个 可以用retrofit.build.addCallAdapterFactory设置的

比如.addCallAdapterFactory(RxJavaCallAdapterFactory.create())

 

callAdapter也有默认的 在retrofit的build时创建

此时的callAdapter是ExecutorCallAdapterFactory或者DefaultCallAdapterFactory

DefaultCallAdapterFactory：默认的比较简单就是将返回值转换为指定的对象Object

ExecutorCallAdapterFactory：如果callbackExecutor不为空的话则使用该类

该类的adapt其实是创建了一个内部类ExecutorCallbackCall

staticfinal class ExecutorCallbackCall<T> implements Call<T> {
  final Executor callbackExecutor;
  final Call<T> delegate;

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

 

 

ExecuteCallBackCall有两个属性，

Call<T> 就是我们生成的okhttpCall

callbackExecuter 是我们设置的callbackexecuter

下面我们看一下enquue方法

@Overridepublic void enqueue(final Callback<T> callback) {
   delegate.enqueue(newCallback<T>() {
    @Override public voidonResponse(Call<T> call, final Response<T> response) {
      callbackExecutor.execute(newRunnable() {
        @Override public void run() {
          if (delegate.isCanceled()) {
            // Emulate OkHttp's behaviorof throwing/delivering an IOException on cancellation.
           callback.onFailure(ExecutorCallbackCall.this, newIOException("Canceled"));
          } else {
           callback.onResponse(ExecutorCallbackCall.this, response);
          }
        }
      });
    }

    @Override public voidonFailure(Call<T> call, final Throwable t) {
      callbackExecutor.execute(newRunnable() {
        @Override public void run() {
         callback.onFailure(ExecutorCallbackCall.this, t);
        }
      });
    }
  });
}

 

 

其实是执行了delegate的enqueue方法，然后将返回结果传给callback的onresponse或者onfailure

 

那我们主要看一下okhttpcall的enqueue

OkHttpCall(ServiceMethod<T,?> serviceMethod, @Nullable Object[] args) {
  this.serviceMethod = serviceMethod;
  this.args = args;
}

 

 @Override public void enqueue(finalCallback<T> callback) {

  okhttp3.Call call;
  Throwable failure;

    call = rawCall;
    failure = creationFailure;
    if (call == null && failure== null) {
        call = rawCall = createRawCall();//1
  }
if (failure != null) {
  callback.onFailure(this, failure);//2
  return;
}


  call.enqueue(new okhttp3.Callback() {
    @Override public voidonResponse(okhttp3.Call call, okhttp3.Response rawResponse)
        throws IOException {
      Response<T> response;
      try {
        response =parseResponse(rawResponse);//3
      } catch (Throwable e) {
        callFailure(e);//4
        return;
      }
      callSuccess(response);//5
    }

    @Override public voidonFailure(okhttp3.Call call, IOException e) {
       callback.onFailure(OkHttpCall.this, e);
    }

    private void callFailure(Throwable e){
       callback.onFailure(OkHttpCall.this, e);
    }

    private voidcallSuccess(Response<T> response) {
       callback.onResponse(OkHttpCall.this, response);
        });
}

 

 

注释1：

privateokhttp3.Call createRawCall() throws IOException {
  Request request =serviceMethod.toRequest(args);
  okhttp3.Call call =serviceMethod.callFactory.newCall(request);
  if (call == null) {
    throw new NullPointerException("Call.Factoryreturned null.");
  }
  return call;
}

 

 

得到请求的返回值类型

根据返回值New出一个okttp3.call对象，

serviceMethod.callFactory.newCall 现在是OkhttpClient，

此时调用okhttpClient的newcall方法执行请求

注释2:

如果failure为null直接报错，交给callback.onFailure

 

注释3：

Response<T>parseResponse(okhttp3.Response rawResponse) throws IOException {
  ResponseBody rawBody =rawResponse.body();


  rawResponse = rawResponse.newBuilder()
      .body(newNoContentResponseBody(rawBody.contentType(), rawBody.contentLength()))
      .build();

  int code = rawResponse.code();
  if (code < 200 || code >= 300) {
    try {
      // Buffer the entire body to avoidfuture 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);
  }

  ExceptionCatchingRequestBodycatchingBody = new ExceptionCatchingRequestBody(rawBody);
  try {
    T body = serviceMethod.toResponse(catchingBody);
    return Response.success(body,rawResponse);
  } catch (RuntimeException e) {
    // If the underlying source threw anexception, propagate that rather than indicating it was
    // a runtime exception.
    catchingBody.throwIfCaught();
    throw e;
  }
}

 

解析返回的数据

注释4/5

根据结果调用不同的方法

callback.onFailure

或者

callback.onResponse