创建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