当前版本2.9.0
简单示例
- 添加依赖
implementation 'com.squareup.retrofit2:retrofit:2.9.0'
implementation 'com.squareup.retrofit2:converter-gson:2.9.0'
implementation 'com.squareup.retrofit2:adapter-rxjava2:2.9.0'
- 代码
interface GitHubService {
@GET("users/{user}/repos")
Call<List<Repo>> listRepos(@Path("user") String user);
}
// 创建Retrofit
Retrofit retrofit =
new Retrofit.Builder()
.baseUrl("https://api.github.com/")
.addConverterFactory(GsonConverterFactory.create())
.addCallAdapterFactory(RxJava2CallAdapterFactory.create())
.build();
// 创建目标对象的代理对象(动态代理实现)
GitHubService service = retrofit.create(GitHubService.class);
// 返回Call对象,该对象中包含OkHttpCall
Call<List<Repo>> call = service.listRepos("octocat");
try {
// 同步请求
call.execute();
} catch (IOException e) {
e.printStackTrace();
}
// 异步请求
call.enqueue(new Callback<List<Repo>>() {
@Override
public void onResponse(Call<List<Repo>> call, Response<List<Repo>> response) {
}
@Override
public void onFailure(Call<List<Repo>> call, Throwable t) {
}
});
Retrofit客户端创建
Retrofit.Builder()
与.baseUrl(XXXX)
public final class Retrofit {
...
public static final class Builder {
// 最终走这里
Builder(Platform platform) {
this.platform = platform;
}
public Builder() {
// 看看Platform
this(Platform.get());
}
// 为Retrofit.Builder设置BaseUrl
public Builder baseUrl(String baseUrl) {
// HttpUrl.get(baseUrl): 将字符串解析为HttpUrl对象.此处不细看了.
return baseUrl(HttpUrl.get(baseUrl));
}
public Builder baseUrl(HttpUrl baseUrl) {
Objects.requireNonNull(baseUrl, "baseUrl == null");
List<String> pathSegments = baseUrl.pathSegments();
// baseUrl最后必须是"/"结尾
if (!"".equals(pathSegments.get(pathSegments.size() - 1))) {
throw new IllegalArgumentException("baseUrl must end in /: " + baseUrl);
}
// 为Retrofit.Builder设置BaseUrl
this.baseUrl = baseUrl;
return this;
}
}
}
Platform.get()
class Platform {
// Platform对象是一个单例
private static final Platform PLATFORM = findPlatform();
// 获取Platform对象
static Platform get() {
return PLATFORM;
}
private static Platform findPlatform() {
return "Dalvik".equals(System.getProperty("java.vm.name"))
? new Android() // Android平台
: new Platform(true);
}
// Android类
static final class Android extends Platform {
Android() {
super(Build.VERSION.SDK_INT >= 24);
}
// response回调到主线程将由MainThreadExecutor对象来处理
@Override
public Executor defaultCallbackExecutor() {
return new MainThreadExecutor();
}
// MainThreadExecutor类
static final class MainThreadExecutor implements Executor {
// 主线程Handler,可以将执行任务切换到主线程中执行
private final Handler handler = new Handler(Looper.getMainLooper());
@Override
public void execute(Runnable r) {
handler.post(r);
}
}
}
}
.addConverterFactory(GsonConverterFactory.create())
与.addCallAdapterFactory(RxJava2CallAdapterFactory.create())
添加转换器工厂,比如需要将请求服务器得到的Json数据格式化为Call<List<Repo>>
类型.
public final class Retrofit {
public static final class Builder {
// 为Retrofit.Builder对象中的converterFactories集合中添加数据转换器工厂
// converterFactories为Builder中专门存放数据转换器工程的集合
public Builder addConverterFactory(Converter.Factory factory) {
converterFactories.add(Objects.requireNonNull(factory, "factory == null"));
return this;
}
// 为Retrofit.Builder对象中的callAdapterFactories集合中添呼叫适配器工厂,比如Retrofit自带的DefaultCallAdapterFactory.
public Builder addCallAdapterFactory(CallAdapter.Factory factory) {
callAdapterFactories.add(Objects.requireNonNull(factory, "factory == null"));
return this;
}
}
}
.build();
public final class Retrofit {
public static final class Builder {
public Retrofit build() {
// BaseUrl必须存在
if (baseUrl == null) {
throw new IllegalStateException("Base URL required.");
}
okhttp3.Call.Factory callFactory = this.callFactory;
if (callFactory == null) {
// callFactory可以自己手动添加client(OkHttpClient client)
// 如果不添加,则默认创建一个OkHttpClient对象.
callFactory = new OkHttpClient();
}
Executor callbackExecutor = this.callbackExecutor;
if (callbackExecutor == null) {
// 从platform对象中获取一个回调执行器,下面会看下这里
callbackExecutor = platform.defaultCallbackExecutor();
}
// 在之前呼叫适配器工厂集合基础上重新构建一个集合
List<CallAdapter.Factory> callAdapterFactories = new ArrayList<>(this.callAdapterFactories);
// 另外这里将Retrofit中默认的呼叫适配器工厂也添加到了集合中
callAdapterFactories.addAll(platform.defaultCallAdapterFactories(callbackExecutor));
// 数据转换器工厂集合
List<Converter.Factory> converterFactories =
new ArrayList<>(
1 + this.converterFactories.size() + platform.defaultConverterFactoriesSize());
// BuiltInConverters 数据转换器是给Streaming注解使用的,下面会详细分析.
converterFactories.add(new BuiltInConverters());
// 将Builder对象中的数据转换器工厂集合全部添加到新的集合中
converterFactories.addAll(this.converterFactories);
// 另外这里将Retrofit中默认的数据转换器工厂添加到新集合中
converterFactories.addAll(platform.defaultConverterFactories());
// 最后一步是创建Retrofit对象
return new Retrofit(
callFactory,
baseUrl,
unmodifiableList(converterFactories),
unmodifiableList(callAdapterFactories),
callbackExecutor,
validateEagerly);
}
}
}
platform.defaultCallbackExecutor()
与platform.defaultConverterFactories()
,platform.defaultCallAdapterFactories(callbackExecutor)
class Platform {
// 返回一个数据转换器工厂集合,集合中的成员变量类型OptionalConverterFactory,这个工厂最终会生成一个OptionalConverter对象,
// 将Response转换之后生成Optional<T>类型,这个没用过.
List<? extends Converter.Factory> defaultConverterFactories() {
return hasJava8Types ? singletonList(OptionalConverterFactory.INSTANCE) : emptyList();
}
// 返回一个数据呼叫适配器工厂集合
List<? extends CallAdapter.Factory> defaultCallAdapterFactories(
@Nullable Executor callbackExecutor) {
// executorFactory: 这个是Retrofit 中自带默认呼叫适配器工厂.
DefaultCallAdapterFactory executorFactory = new DefaultCallAdapterFactory(callbackExecutor);
return hasJava8Types
? asList(CompletableFutureCallAdapterFactory.INSTANCE, executorFactory)
: singletonList(executorFactory);
}
...
// Android类
static final class Android extends Platform {
Android() {
super(Build.VERSION.SDK_INT >= 24);
}
// platform.defaultCallbackExecutor() 返回回调执行器对象
@Override
public Executor defaultCallbackExecutor() {
return new MainThreadExecutor();
}
...
}
}
new Retrofit()
public final class Retrofit {
private final Map<Method, ServiceMethod<?>> serviceMethodCache = new ConcurrentHashMap<>();
final okhttp3.Call.Factory callFactory;
final HttpUrl baseUrl;
final List<Converter.Factory> converterFactories;
final List<CallAdapter.Factory> callAdapterFactories;
final @Nullable Executor callbackExecutor;
final boolean validateEagerly;
Retrofit(
okhttp3.Call.Factory callFactory,
HttpUrl baseUrl,
List<Converter.Factory> converterFactories,
List<CallAdapter.Factory> callAdapterFactories,
@Nullable Executor callbackExecutor,
boolean validateEagerly) {
this.callFactory = callFactory;
this.baseUrl = baseUrl;
this.converterFactories = converterFactories; // Copy+unmodifiable at call site.
this.callAdapterFactories = callAdapterFactories; // Copy+unmodifiable at call site.
this.callbackExecutor = callbackExecutor;
this.validateEagerly = validateEagerly;
}
}
创建API接口的代理对象以及接口中方法调用
retrofit.create(GitHubService.class);
public final class Retrofit {
private final Map<Method, ServiceMethod<?>> serviceMethodCache = new ConcurrentHashMap<>();
final okhttp3.Call.Factory callFactory;
final HttpUrl baseUrl;
final List<Converter.Factory> converterFactories;
final List<CallAdapter.Factory> callAdapterFactories;
final @Nullable Executor callbackExecutor;
final boolean validateEagerly;
Retrofit(
okhttp3.Call.Factory callFactory,
HttpUrl baseUrl,
List<Converter.Factory> converterFactories,
List<CallAdapter.Factory> callAdapterFactories,
@Nullable Executor callbackExecutor,
boolean validateEagerly) {
this.callFactory = callFactory;
this.baseUrl = baseUrl;
this.converterFactories = converterFactories; // Copy+unmodifiable at call site.
this.callAdapterFactories = callAdapterFactories; // Copy+unmodifiable at call site.
this.callbackExecutor = callbackExecutor;
this.validateEagerly = validateEagerly;// 该变量表示是否需要提前加载API接口中的方法信息
}
public <T> T create(final Class<T> service) {
// 是否需要提交加载API接口中方法信息
validateServiceInterface(service);
// 这里就是创建API接口的代理对象
// 当由代理对象调用接口中的方法时,最终会调用到代理对象中的invoke().
return (T)
Proxy.newProxyInstance(
service.getClassLoader(),
new Class<?>[] {service},
new InvocationHandler() {
private final Platform platform = Platform.get();
private final Object[] emptyArgs = new Object[0];
===================================================
// 注意:当前方法将在调用service.listRepos("XXX");时候触发
===================================================
@Override
public @Nullable Object invoke(Object proxy, Method method, @Nullable Object[] args)
throws Throwable {
...
args = args != null ? args : emptyArgs;
// 最终执行 loadServiceMethod(method).invoke(args);
// method: 对应的就是代理对象所调用的方法
// loadServiceMethod(method): 最终返回的是HttpServiceMethod对象
return platform.isDefaultMethod(method)
? platform.invokeDefaultMethod(method, service, proxy, args)
: loadServiceMethod(method).invoke(args);
}
});
}
// 该方法作用是是否提前解析API接口
private void validateServiceInterface(Class<?> service) {
...
// validateEagerly: 该变量表示是否需要提前加载API接口中的方法信息
if (validateEagerly) {
Platform platform = Platform.get();
for (Method method : service.getDeclaredMethods()) {
if (!platform.isDefaultMethod(method) && !Modifier.isStatic(method.getModifiers())) {
// 是否将API接口中的方法信息加载到serviceMethodCache中
loadServiceMethod(method);
}
}
}
}
// 该方法将根据网络API接口方法信息返回HttpServiceMethod对象
ServiceMethod<?> loadServiceMethod(Method method) {
ServiceMethod<?> result = serviceMethodCache.get(method);
// 假如API方法信息已经解析过了,就将HttpServiceMethod对象返回.
if (result != null) return result;
synchronized (serviceMethodCache) {
result = serviceMethodCache.get(method);
if (result == null) {
// 如果API方法信息还没解析,就开始解析.
result = ServiceMethod.parseAnnotations(this, method);
// 将解析后的HttpServiceMethod对象存入集合中
serviceMethodCache.put(method, result);
}
}
return result;
}
}
ServiceMethod.parseAnnotations(this, method);
abstract class ServiceMethod<T> {
// 通过API接口方法信息解析
static <T> ServiceMethod<T> parseAnnotations(Retrofit retrofit, Method method) {
// RequestFactory.parseAnnotations(retrofit, method):解析API接口中的方法,得到请求报文工厂
RequestFactory requestFactory = RequestFactory.parseAnnotations(retrofit, method);
// 通过API接口方法信息得到方法的返回类型
Type returnType = method.getGenericReturnType();
...
// 返回类型不能为空
if (returnType == void.class) {
throw methodError(method, "Service methods cannot return void.");
}
// 返回一个HttpServiceMethod对象看看.
return HttpServiceMethod.parseAnnotations(retrofit, method, requestFactory);
}
// 这是一个抽象方法,当API接口代理对象调用接口中方法时候,代理对象的invoke()将被调用, 最后会委托给HttpServiceMethod对象的invoke().
abstract @Nullable T invoke(Object[] args);
}
final class RequestFactory {
static RequestFactory parseAnnotations(Retrofit retrofit, Method method) {
// 这里也是用的构建者模式
return new Builder(retrofit, method).build();
}
// Builder类
static final class Builder {
Builder(Retrofit retrofit, Method method) {
this.retrofit = retrofit;
this.method = method;
this.methodAnnotations = method.getAnnotations(); //获取API接口方法中的注解
this.parameterTypes = method.getGenericParameterTypes(); // 获取API接口方法中的参数类型
this.parameterAnnotationsArray = method.getParameterAnnotations();// 获取API接口中方法的参数注解
}
RequestFactory build() {
for (Annotation annotation : methodAnnotations) {
// 这个方法是解析GET,POST,Headers,FormUrlEncoded等等信息
parseMethodAnnotation(annotation);
}
...
// 最后返回RequestFactory, 这个类就是将API接口中方法注解逐步的拆解,得到请求报文工厂
return new RequestFactory(this);
}
}
}
HttpServiceMethod.parseAnnotations(retrofit, method, requestFactory);
abstract class HttpServiceMethod<ResponseT, ReturnT> extends ServiceMethod<ReturnT> {
static <ResponseT, ReturnT> HttpServiceMethod<ResponseT, ReturnT> parseAnnotations(Retrofit retrofit, Method method, RequestFactory requestFactory) {
// 获取API接口方法的返回值类型
Type adapterType = method.getGenericReturnType();
...
// 通过返回值类型,API接口方法信息等,创建一个呼叫适配器
CallAdapter<ResponseT, ReturnT> callAdapter =createCallAdapter(retrofit, method, adapterType, annotations);
// 获取响应数据类型
Type responseType = callAdapter.responseType();
...
// 通过响应数据类型,API接口方法信息等创建一个响应数据转换器
Converter<ResponseBody, ResponseT> responseConverter =createResponseConverter(retrofit, method, responseType);
// 这个是OkHttp对象
okhttp3.Call.Factory callFactory = retrofit.callFactory;
// 最后返回CallAdapted对象,这个不要与上面的callAdapter对象弄混淆了
return new CallAdapted<>(requestFactory, callFactory, responseConverter, callAdapter);
}
// 创建真实的呼叫适配器对象
private static <ResponseT, ReturnT> CallAdapter<ResponseT, ReturnT> createCallAdapter(Retrofit retrofit, Method method, Type returnType, Annotation[] annotations) {
try {
return (CallAdapter<ResponseT, ReturnT>) retrofit.callAdapter(returnType, annotations);
} catch (RuntimeException e) { // Wide exception range because factories are user code.
throw methodError(method, e, "Unable to create call adapter for %s", returnType);
}
}
// 创建响应数据转换器
private static <ResponseT> Converter<ResponseBody, ResponseT> createResponseConverter(Retrofit retrofit, Method method, Type responseType) {
Annotation[] annotations = method.getAnnotations();
try {
return retrofit.responseBodyConverter(responseType, annotations);
} catch (RuntimeException e) { // Wide exception range because factories are user code.
throw methodError(method, e, "Unable to create converter for %s", responseType);
}
}
}
retrofit.callAdapter(returnType, annotations)
与retrofit.responseBodyConverter(responseType, annotations);
这一段是创建呼叫适配器,以便返回相匹配的Call.另外还会创建匹配的数据转换器,以便返回正确的响应数据类型.
public final class Retrofit {
public CallAdapter<?, ?> callAdapter(Type returnType, Annotation[] annotations) {
return nextCallAdapter(null, returnType, annotations);
}
public CallAdapter<?, ?> nextCallAdapter(@Nullable CallAdapter.Factory skipPast, Type returnType, Annotation[] annotations) {
...
// start = 0
int start = callAdapterFactories.indexOf(skipPast) + 1;
for (int i = start, count = callAdapterFactories.size(); i < count; i++) {
// 呼叫适配器工厂集合, 这里拿Retrofit默认呼叫适配器对象来分析吧
// 假如callAdapterFactories.get(i)取得的对象是DefaultCallAdapterFactory类型,来分析他的get()
CallAdapter<?, ?> adapter = callAdapterFactories.get(i).get(returnType, annotations, this);
if (adapter != null) {
return adapter;
}
}
...
}
// 创建响应数据转换器
public <T> Converter<ResponseBody, T> responseBodyConverter(Type type, Annotation[] annotations) {
return nextResponseBodyConverter(null, type, annotations);
}
public <T> Converter<ResponseBody, T> nextResponseBodyConverter(@Nullable Converter.Factory skipPast, Type type, Annotation[] annotations) {
Objects.requireNonNull(type, "type == null");
Objects.requireNonNull(annotations, "annotations == null");
// start = 0
int start = converterFactories.indexOf(skipPast) + 1;
for (int i = start, count = converterFactories.size(); i < count; i++) {
// 这里和查找匹配的呼叫适配器是一样的操作
// 这里假如converterFactories.get(i)找到的是GsonConverterFactory,来看看他的responseBodyConverter()方法
// type是一个JavaBean类,就是请求网络返回的数据类型.
Converter<ResponseBody, ?> converter =converterFactories.get(i).responseBodyConverter(type, annotations, this);
}
}
}
// DefaultCallAdapterFactory类
final class DefaultCallAdapterFactory extends CallAdapter.Factory {
@Override
public @Nullable CallAdapter<?, ?> get(Type returnType, Annotation[] annotations, Retrofit retrofit) {
// 假如API接口方法中的返回值类型不是Call.class,那就说明这个呼叫工厂适配器就不满足这个API接口方法,
// 那么上一步中的nextCallAdapter()方法中的循环遍历查找呼叫适配器工厂集合还会继续遍历
if (getRawType(returnType) != Call.class) {
return null;
}
...
// 获取最终返回的数据类型,例如returnType的类型为Call<List<Repo>>
// Utils.getParameterUpperBound(0, (ParameterizedType) returnType)最终得到的类型就是List<Repo>
// 参考文章:https://www.jianshu.com/p/cfa74c980b25
final Type responseType = Utils.getParameterUpperBound(0, (ParameterizedType) returnType);
...
return new CallAdapter<Object, Call<?>>() {
// 该方法是用来返回响应数据类型的
@Override
public Type responseType() {
return responseType;
}
// 该方法用来返回网络请求的代理对象Call.
@Override
public Call<Object> adapt(Call<Object> call) {
return executor == null ? call : new ExecutorCallbackCall<>(executor, call);
}
};
}
}
// GsonConverterFactory类
public final class GsonConverterFactory extends Converter.Factory {
private final Gson gson;
@Override
public Converter<ResponseBody, ?> responseBodyConverter(Type type, Annotation[] annotations, Retrofit retrofit) {
// type是一个JavaBean类,就是请求网络返回的数据类型.
TypeAdapter<?> adapter = gson.getAdapter(TypeToken.get(type));
return new GsonResponseBodyConverter<>(gson, adapter);
}
}
// GsonResponseBodyConverter类
final class GsonResponseBodyConverter<T> implements Converter<ResponseBody, T> {
GsonResponseBodyConverter(Gson gson, TypeAdapter<T> adapter) {
this.gson = gson;
this.adapter = adapter;
}
// 该方法就是将ResponseBody 返回的数据转换为JavaBean类.
@Override
public T convert(ResponseBody value) throws IOException {
JsonReader jsonReader = gson.newJsonReader(value.charStream());
try {
T result = adapter.read(jsonReader);
if (jsonReader.peek() != JsonToken.END_DOCUMENT) {
throw new JsonIOException("JSON document was not fully consumed.");
}
return result;
} finally {
value.close();
}
}
}
new CallAdapted<>(requestFactory, callFactory, responseConverter, callAdapter);
abstract class HttpServiceMethod<ResponseT, ReturnT> extends ServiceMethod<ReturnT> {
static <ResponseT, ReturnT> HttpServiceMethod<ResponseT, ReturnT> parseAnnotations(Retrofit retrofit, Method method, RequestFactory requestFactory) {
// 获取API接口方法的返回值类型
Type adapterType = method.getGenericReturnType();
...
// 通过返回值类型,API接口方法信息等,创建一个呼叫适配器
CallAdapter<ResponseT, ReturnT> callAdapter =createCallAdapter(retrofit, method, adapterType, annotations);
// 获取响应数据类型
Type responseType = callAdapter.responseType();
...
// 通过响应数据类型,API接口方法信息等创建一个响应数据转换器
Converter<ResponseBody, ResponseT> responseConverter =createResponseConverter(retrofit, method, responseType);
// 这个是OkHttp对象
okhttp3.Call.Factory callFactory = retrofit.callFactory;
// 最后返回CallAdapted对象,这个不要与上面的callAdapter对象弄混淆了
//
return new CallAdapted<>(requestFactory, callFactory, responseConverter, callAdapter);
}
// 在Retrofit.create(GitHubService.class)会创建一个API接口的代理对象,当代理对象调用接口中方法时候,
// 最终就会调用代理对象中的invoke()方法, 该方法最终会返回一个Call对象.
// loadServiceMethod(method).invoke(args):这个invoke()方法就是此处的invoke().
@Override
final @Nullable ReturnT invoke(Object[] args) {
// loadServiceMethod(method)方法其实最终的类型为下面的HttpServiceMethod.CallAdapted类, 他实现了adapt()方法.
Call<ResponseT> call = new OkHttpCall<>(requestFactory, args, callFactory, responseConverter);
// 这里创建了了一个OkHttpCall对象.
// adapt(call, args)最终返回一个ExecutorCallbackCall类型的对象.
return adapt(call, args);
}
// 这个抽象方法最终由HttpServiceMethod.CallAdapted实现
protected abstract @Nullable ReturnT adapt(Call<ResponseT> call, Object[] args);
// CallAdapted类
static final class CallAdapted<ResponseT, ReturnT> extends HttpServiceMethod<ResponseT, ReturnT> {
private final CallAdapter<ResponseT, ReturnT> callAdapter;
@Override
protected ReturnT adapt(Call<ResponseT> call, Object[] args) {
// 假设callAdapter为DefaultCallAdapterFactory创建,看下DefaultCallAdapterFactory中的adapte().
// 这里特地说下call是OkHttpCall类型的对象.
// 下面分下到callAdapter.adapt(call)最终返回一个ExecutorCallbackCall类型的对象.
return callAdapter.adapt(call);
}
}
}
// DefaultCallAdapterFactory类
final class DefaultCallAdapterFactory extends CallAdapter.Factory {
// 这里再说明下, 这个get()方法其实在HttpServiceMethod.parseAnnotations()中创建呼叫适配器的时候已经执行过了.
// 他将get()中创建的CallAdapter对象返回了,被传递到了HttpServiceMethod.CallAdapted类中为callAdapter属性值.
@Override
public @Nullable CallAdapter<?, ?> get(Type returnType, Annotation[] annotations, Retrofit retrofit) {
...
return new CallAdapter<Object, Call<?>>() {
@Override
public Type responseType() {
return responseType;
}
// 该方法最终在HttpServiceMethod.CallAdapted.adapt()中被执行.
@Override
public Call<Object> adapt(Call<Object> call) {
return executor == null ? call : new ExecutorCallbackCall<>(executor, call);
}
};
}
}
ExecutorCallbackCall
final class DefaultCallAdapterFactory extends CallAdapter.Factory {
// ExecutorCallbackCall类
static final class ExecutorCallbackCall<T> implements Call<T> {
final Executor callbackExecutor;// 这个如果按照之前分析的就是MainThreadExecutor对象了,可以将回调发送到主线程中执行.
final Call<T> delegate;// 这个对象其实就是OkHttpCall对象了
ExecutorCallbackCall(Executor callbackExecutor, Call<T> delegate) {
this.callbackExecutor = callbackExecutor;
this.delegate = delegate;
}
}
}
正式开始网络请求
call.execute();
与call.enqueue()
service.listRepos("XXXX");
最终得到的对象为ExecutorCallbackCall类型,下面就开始调用网络了
final class DefaultCallAdapterFactory extends CallAdapter.Factory {
// ExecutorCallbackCall类
static final class ExecutorCallbackCall<T> implements Call<T> {
final Executor callbackExecutor;// 这个如果按照之前分析的就是MainThreadExecutor对象了,可以将回调发送到主线程中执行.
final Call<T> delegate;// 这个对象其实就是OkHttpCall对象了
ExecutorCallbackCall(Executor callbackExecutor, Call<T> delegate) {
this.callbackExecutor = callbackExecutor;
this.delegate = delegate;
}
// 同步调用
@Override
public Response<T> execute() throws IOException {
return delegate.execute();
}
// 异步调用
@Override
public void enqueue(final Callback<T> callback) {
Objects.requireNonNull(callback, "callback == null");
delegate.enqueue(
new Callback<T>() {
@Override
public void onResponse(Call<T> call, final Response<T> response) {
// 得到响应数据,就使用MainThreadExecutor类型对象将回调发送到主线程执行
callbackExecutor.execute(
() -> {
if (delegate.isCanceled()) {
// 这是客户端的取消回调,被发送到主线程执行
callback.onFailure(ExecutorCallbackCall.this, new IOException("Canceled"));
} else {
// 这是客户端的成功回调,也被发送到主线程执行
callback.onResponse(ExecutorCallbackCall.this, response);
}
});
}
@Override
public void onFailure(Call<T> call, final Throwable t) {
// 这是客户端的失败回调,被发送到主线程执行
callbackExecutor.execute(() -> callback.onFailure(ExecutorCallbackCall.this, t));
}
});
}
}
}
delegate.execute()
与delegate.enqueue()
final class OkHttpCall<T> implements Call<T> {
OkHttpCall(RequestFactory requestFactory,Object[] args,okhttp3.Call.Factory callFactory,Converter<ResponseBody, T> responseConverter) {
// 请求报文
this.requestFactory = requestFactory;
this.args = args;
// OkHttpClient
this.callFactory = callFactory;
// 响应数据转换器
this.responseConverter = responseConverter;
}
// 同步方法
@Override
public Response<T> execute() throws IOException {
okhttp3.Call call;
synchronized (this) {
executed = true;
// 看下这个,获取一个RealCall
call = getRawCall();
}
...
// call.execute() 这里就是通过RealCall对象执行同步方法了.
// 再看下parseResponse()
return parseResponse(call.execute());
}
// 异步方法
@Override
public void enqueue(final Callback<T> callback) {
...
try {
// 获取RealCall
call = rawCall = createRawCall();
}
...
// 这里就是像OkHttp中那样进行异步请求操作了
call.enqueue(
new okhttp3.Callback() {
@Override
public void onResponse(okhttp3.Call call, okhttp3.Response rawResponse) {
Response<T> response;
try {
// 解析异步请求的响应数据
response = parseResponse(rawResponse);
} ...
try {
// 回调onResponse(),到主线程执行
callback.onResponse(OkHttpCall.this, response);
} ...
}
@Override
public void onFailure(okhttp3.Call call, IOException e) {
callFailure(e);
}
private void callFailure(Throwable e) {
try {
// 回调onFailure(),到主线程执行
callback.onFailure(OkHttpCall.this, e);
} ...
}
});
}
// 获取RealCall方法
@GuardedBy("this")
private okhttp3.Call getRawCall() throws IOException {
okhttp3.Call call = rawCall;
...
try {
// 接着往下看 获取RealCall
return rawCall = createRawCall();
} catch (RuntimeException | Error | IOException e) {
...
}
}
// 到这里就能看清, 这里是获取一个RealCall
private okhttp3.Call createRawCall() throws IOException {
// callFactory就是一个OkHttpClient,OkHttpClient.newCall()返回的就是一个RealCall
okhttp3.Call call = callFactory.newCall(requestFactory.create(args));
...
return call;
}
// 解析网络请求的响应数据
Response<T> parseResponse(okhttp3.Response rawResponse) throws IOException {
ResponseBody rawBody = rawResponse.body();
...
ExceptionCatchingResponseBody catchingBody = new ExceptionCatchingResponseBody(rawBody);
try {
// 数据转换器,上面用的是GsonResponseBodyConverter来分析的,上面已经分析过这里就不说了.
T body = responseConverter.convert(catchingBody);
// 最后就是创建一个Response类型的数据返回了.
return Response.success(body, rawResponse);
}
}
// 写到最后真的不想写了...
}