开始使用Retrofit
- 首先先声明一个用于请求的接口
public interface GitHubService {
@GET("users/{user}/repos")//执行资源的地址后缀
Call<List<User>> listRepos(@Path("user") String user);
}```
2. 创建一个Retrofit对象，传入一些必要的参数
Converter.Factory factory = GsonConverterFactory.create();//使用Gson来进行数据的解析
Retrofit retrofit = new Retrofit.Builder().baseUrl("https://api.github.com/")
.addConverterFactory(factory)
.build();
3. 通过Retrofit对象通过动态代理的形式创建一个对象，发起一个请求。
GitHubService service = retrofit.create(GitHubService.class);
Call<List<User>> call = service.listRepos("zhaoyongchao");
call.enqueue(new Callback<List<User>>() {
@Override
public void onResponse(Call<List<User>> call, Response<List<User>> response) {
//成功后的回调
}
@Override
public void onFailure(Call<List<User>> call, Throwable t) {
//失败的回调
}
});
<!-- more -->
###分析具体的实现
- 在创建Retrofit对象的步骤就是一些赋值，在此只贴出build()的源码
public Retrofit build() {
//根路径的判断
if (baseUrl == null) {
throw new IllegalStateException("Base URL required.");
}
//如果不传入，则默认OKHttpClient为默认的请求工厂类
okhttp3.Call.Factory callFactory = this.callFactory;
if (callFactory == null) {
callFactory = new OkHttpClient();
}
// 使用副本，添加默认的适配器
List<CallAdapter.Factory> adapterFactories = new ArrayList<>(this.adapterFactories);
adapterFactories.add(Platform.get().defaultCallAdapterFactory(callbackExecutor));
// 创建一个用于类型转换的副本
List<Converter.Factory> converterFactories = new ArrayList<>(this.converterFactories);
return new Retrofit(callFactory, baseUrl, converterFactories, adapterFactories,
callbackExecutor, validateEagerly);
}
}
//区分当前运行的平台（Android）
static class Android extends Platform {
@Override CallAdapter.Factory defaultCallAdapterFactory(Executor callbackExecutor) {
if (callbackExecutor == null) {
callbackExecutor = new MainThreadExecutor();
}
return new ExecutorCallAdapterFactory(callbackExecutor);
}
static class MainThreadExecutor implements Executor {
//使用主线程的Looper来创建一个Handler，用来通信
private final Handler handler = new Handler(Looper.getMainLooper());
@Override public void execute(Runnable r) {
handler.post(r);
}
}
}
- 通过Retrofit的Create()方法来创建一个对象
public <T> T create(final Class<T> service) {
//判断是否为接口
Utils.validateServiceInterface(service);
if (validateEagerly) {
eagerlyValidateMethods(service);
}
//使用Proxy来创建动态创建一个代理对象，使用返回的对象调用接口的方法都会调用匿名内部类的invoke方法。
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, Object... args)
throws Throwable {
// 判断一下声明的类，如果是Object类，正常执行
if (method.getDeclaringClass() == Object.class) {
return method.invoke(this, args);
}
if (platform.isDefaultMethod(method)) {
return platform.invokeDefaultMethod(method, service, proxy, args);
}
return loadMethodHandler(method).invoke(args);
}
});
}
- 调用MethodHandler的creat()方法
static MethodHandler create(Retrofit retrofit, Method method) {
//根据方法的注解和返回类型创建具体的实现类，最终会到ExecutorCallAdapterFactory
CallAdapter<?> callAdapter = createCallAdapter(method, retrofit);
//得到泛型中的类型
Type responseType = callAdapter.responseType();
if (responseType == Response.class || responseType == okhttp3.Response.class) {
throw Utils.methodError(method, "'"
+ Types.getRawType(responseType).getName()
+ "' is not a valid response body type. Did you mean ResponseBody?");
}
//同样创建具体的转换类
Converter<ResponseBody, ?> responseConverter =
createResponseConverter(method, retrofit, responseType);
//根据请求类型和方法中的注解创建一个请求工厂类
RequestFactory requestFactory = RequestFactoryParser.parse(method, responseType, retrofit);
return new MethodHandler(retrofit.callFactory(), requestFactory, callAdapter,
responseConverter);
}
- createCallAdapter方法最终会调用到Retrofit中的nextCallAdapter方法
public CallAdapter<?> nextCallAdapter(CallAdapter.Factory skipPast, Type returnType,
Annotation[] annotations) {
checkNotNull(returnType, "returnType == null");
checkNotNull(annotations, "annotations == null");
//使用的是ExecutorCallAdapterFactory
int start = adapterFactories.indexOf(skipPast) + 1;
for (int i = start, count = adapterFactories.size(); i < count; i++) {
CallAdapter<?> adapter = adapterFactories.get(i).get(returnType, annotations, this);
if (adapter != null) {
return adapter;
}
}
throw new IllegalArgumentException(builder.toString());
}
- 继续分析一下ExecutorCallAdapterFactory中的get方法
public CallAdapter<Call<?>> get(Type returnType, Annotation[] annotations, Retrofit retrofit) {
//此适配器只能处理返回类型为Call<?>
if (getRawType(returnType) != Call.class) {
return null;
}
//得到Call<T>的泛型T的类型，作为相应体的返回类型
final Type responseType = Utils.getCallResponseType(returnType);
return new CallAdapter<Call<?>>() {
@Override public Type responseType() {
return responseType;
}
@Override public <R> Call<R> adapt(Call<R> call) {
//创建一个对象进行返回
return new ExecutorCallbackCall<>(callbackExecutor, call);
}
};
}
- createResponseConverter得过程和上述相同不做分析。
- 根据请求类型和方法中的注解创建一个请求工厂类，通过parseMethodAnnotations来解析注解、parsePathParameters来解析注解的值，为工厂类相应的字段赋值。
- 调用创建好的MethodHandler对象的invoke方法，根据上述生成的对象创建OKHttpCall对象也是委派对象,把生成的对象传入ExecutorCallAdapterFactory的adapt方法。
@Override public <R> Call<R> adapt(Call<R> call) {
return new ExecutorCallbackCall<>(callbackExecutor, call);
}
- 通过返回的Call对象的调用enqueue方法及ExecutorCallbackCall的enqueue方法
//MethodHandler中的方法
Object invoke(Object... args) {
return callAdapter.adapt(
new OkHttpCall<>(callFactory, requestFactory, args, responseConverter));
}
@Override public void enqueue(final Callback<T> callback) {
//调用及上述根据请求工厂、类型转换工厂和请求参数创建的OkHttpCall对象
delegate.enqueue(new Callback<T>() {
@Override public void onResponse(final Call<T> call, final Response<T> response) {
//通过handler把回调发送到主线程
callbackExecutor.execute(new Runnable() {
@Override public void run() {
if (delegate.isCanceled()) {
// Emulate OkHttp's behavior of throwing/delivering an IOException on cancelation
callback.onFailure(call, new IOException("Canceled"));
} else {
callback.onResponse(call, response);
}
}
});
}
@Override public void onFailure(final Call<T> call, final Throwable t) {
callbackExecutor.execute(new Runnable() {
@Override public void run() {
callback.onFailure(call, t);
}
});
}
});
}
- OkHttpCall中的enqueue方法
@Override public void enqueue(final Callback<T> callback) {
okhttp3.Call call;
Throwable failure;
synchronized (this) {
if (executed) throw new IllegalStateException("Already executed.");
executed = true;
call = rawCall;
failure = creationFailure;
if (call == null && failure == null) {
try {
//创建真是的请求
call = rawCall = createRawCall();
} catch (Throwable t) {
failure = creationFailure = t;
}
}
}
//添加失败回调
if (failure != null) {
callback.onFailure(this, failure);
return;
}
if (canceled) {
call.cancel();
}
//真实的发起请求
call.enqueue(new okhttp3.Callback() {
@Override public void onResponse(okhttp3.Call call, okhttp3.Response rawResponse)
throws IOException {
Response<T> response;
try {
//解析返回数据
response = parseResponse(rawResponse);
} catch (Throwable e) {
callFailure(e);
return;
}
callSuccess(response);
}
@Override public void onFailure(okhttp3.Call call, IOException e) {
try {
callback.onFailure(OkHttpCall.this, e);
} catch (Throwable t) {
t.printStackTrace();
}
}
private void callFailure(Throwable e) {
try {
callback.onFailure(OkHttpCall.this, e);
} catch (Throwable t) {
t.printStackTrace();
}
}
private void callSuccess(Response<T> response) {
try {
callback.onResponse(OkHttpCall.this, response);
} catch (Throwable t) {
t.printStackTrace();
}
}
});
}
- 到目前为止所有的注解和值已经解析，但是没有进行拼接。看一下RequestFactory的creat()方法
Request create(Object... args) throws IOException {
RequestBuilder requestBuilder =
new RequestBuilder(method, baseUrl.url(), relativeUrl, headers, contentType, hasBody,
isFormEncoded, isMultipart);
if (args != null) {
//从注解中解析的请求类型目前使用的是RequestAction.Path
RequestAction[] actions = requestActions;
if (actions.length != args.length) {
throw new IllegalArgumentException("Argument count ("
+ args.length
+ ") doesn't match action count ("
+ actions.length
+ ")");
}
for (int i = 0, count = args.length; i < count; i++) {
actions[i].perform(requestBuilder, args[i]);
}
}
return requestBuilder.build();
}
}
//RequestAction.Path类中重写的方法
@Override void perform(RequestBuilder builder, T value) throws IOException {
if (value == null) {
throw new IllegalArgumentException(
"Path parameter "" + name + "" value must not be null.");
}
builder.addPathParam(name, valueConverter.convert(value), encoded);
}
//进行完整路径的组合
void addPathParam(String name, String value, boolean encoded) {
if (relativeUrl == null) {
// The relative URL is cleared when the first query parameter is set.
throw new AssertionError();
}
relativeUrl = relativeUrl.replace("{" + name + "}", canonicalizeForPath(value, encoded));
}
//OKHttpClient中的 newCall转换为一个OkHttpCall的真正请求
@Override public Call newCall(Request request) {
return new RealCall(this, request);
}
- 最终的请求在RealCall中