1.基本使用
参照官方网站实例：
(1) 创建一个java接口用来作为http请求
public interface GitHubService {
@GET("users/{user}/repos")
Call<List<Repo>> listRepos(@Path("user") String user);
}
(2) Retrofit类会自动实现这个GitHubService接口
Retrofit retrofit = new Retrofit.Builder()
.baseUrl("https://api.github.com/")
.build();
GitHubService service = retrofit.create(GitHubService.class);
(3) 返回的GitHubService是一个retrofit所实现的代理对象，然后调用此方法来包装了一个对于http的请求
Call<List<Repo>> repos = service.listRepos("octocat");
此Call对象即可对于网络请求做同步或者异步请求操作。
2.源码解析
(1) 查看Reftrofit的源码目录树，查看代码，所包含的类很少，http子目录下都是定义接口时的注解信息，如常用的@GET,@POST等，查看它的代码是添加了注解，具体对于注解相关理解可以请看注解介绍。
/** Make a GET request. */
@Documented
@Target(METHOD)//用来修饰方法
@Retention(RUNTIME)//运行时保留
public @interface GET {
/**
* A relative or absolute path, or full URL of the endpoint. This value is optional if the first
* parameter of the method is annotated with {@link Url @Url}.
* <p>
* See {@linkplain retrofit2.Retrofit.Builder#baseUrl(HttpUrl) base URL} for details of how
* this is resolved against a base URL to create the full endpoint URL.
*/
String value() default "";
}
(2) 从上面的基本操作上我们可以查看一下Retrofit的源码，先从retrofit.create来看，如何声明了一个接口，转化成了一个可以访问http请求的操作。
Retrofit可以看成一个适配类，它是通过注解将一个java接口返回成一个http调用。Retrofit类先通过一个Builder模式定义一个Retrofit实例，然后调用Retrofit.create()方法：
@SuppressWarnings("unchecked") // Single-interface proxy creation guarded by parameter safety.
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, 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.callAdapter.adapt(okHttpCall);
}
});
}
关键点为:Proxy.newProxyInstance()方法，我们自己通过建立一个Interface,然后由Proxy为我们生成一个代理对象，会调用InvocationHandler类中的invode()方法，然后会调用此方法去做一些统一操作，真正的操作在serviceMethod.callAdapter.adapt(okHttpCall)此行代码中。
(3)接下来查看ServiceMethod类，分析callAdapter.adapt()此方法具体干了什么事情。
通过此类的描述即可知道，它就是真正的适配器，将接口转化成http的调用。
Adapts an invocation of an interface method into an HTTP call.
内部也是使用Builder来实例化对象，具体查看callAdapter，在createCallAdapter()方法中，
return (CallAdapter<T, R>) retrofit.callAdapter(returnType, annotations);
还是在retrofit类中创建的
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;
}
}
是从adapterFactories列表中获取的，查看此列表的初始化为：
public Builder addCallAdapterFactory(CallAdapter.Factory factory) {
adapterFactories.add(checkNotNull(factory, "factory == null"));
return this;
}
这个我们就清楚理如果在Retrofit.Builder中设置了addCallAdapterFactory()此方法，那么就用此的adapt来实现接口的具体操作，例如我们可以使用RxJavaCallAdapterFactory.create()，那么返回的就是一个Observable了，而不是默认的Call类类，我们直接查看默认的Call类是如果来实现adapt()方法的.
adapterFactories.add(platform.defaultCallAdapterFactory(callbackExecutor));
所有的adapterFactory都要实现CallAdapter.Factory接口，它其中就定义了在retrofit中调用的adapt方法，它有两个实现类为DefaultCallAdapterFactory.java和ExecutorCallAdapterFactory.java，我们直接查看DefaultCallAdapterFactory.java这个简单的类即可：
@Override public Call<Object> adapt(Call<Object> call) {
return call;
}
ServiceMethod<Object, Object> serviceMethod =
(ServiceMethod<Object, Object>) loadServiceMethod(method);
OkHttpCall<Object> okHttpCall = new OkHttpCall<>(serviceMethod, args);
return serviceMethod.callAdapter.adapt(okHttpCall);
它就是返回了Call这个类，从最开始Retrofit中的方法,我们可以知道它所返回的就是OkHttpCall这个类，那么看这个OkHttpCall的同步和异步的网络请求即可，这个流程，我们从锁定定义的Interface类，然后Retrofit类的create方法，通过ServiceMethod的一系列转化，最后变成了CallAdapter这个接口的具体实现类，所传递的参数为OkHttpCall类，它是对于OkHttp的Call类的封装，所返回的就是一个http请求。
(4) 我们接下来查看ServiceMethod还做了哪些工作
主要的操作在Builder.build()中
responseType:从一个http的响应部分转化成为一个java对象，它就是Call<Repo>中的Repo.
responseConverter:它是通过Retrofit.addConverterFactory()来用于解析为一个java对象，我们一般都是在http请求JSON对象，转化成为java类，那么就可以传入GsonConverterFactory.create()
methodAnnotations: 注解方法，它是通过parseMethodAnnotation来进行解析，不同的注解传输不同的值，同意调用parseHttpMethodAndPath来拼接请求url，用来网络请求。
parameterHandlers：用来解析在API定义方法是后的参数。parseParameterAnnotation()方法用来解析没一个参数的注解，例如@Query,@Path。
(5) 接下来查看http请求操作
具体的接口为retrofit2.Call类，具体的实现类为OkHttpCall.java,我们直接查看我们所常用的enqueue异步方法：
okhttp3.Call call;
...
...
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();
}
}
});
这一段代码，就可以明显的看出，上述的OkHttpCall就是对于okhttp3.Call类的封装，然后通过我们自己索要实现的Callback接口来完成onResponse等操作。
以上代码的分析就是一个从创建Retrofit类到最后http异步请求完成的流程。
(5) 接下来是看它如何解析http请求的，直接看异步操作了，同步操作同理
private okhttp3.Call createRawCall() throws IOException {
Request request = serviceMethod.toRequest(args);
okhttp3.Call call = serviceMethod.callFactory.newCall(request);
if (call == null) {
throw new NullPointerException("Call.Factory returned null.");
}
return call;
}
异步操作中Call的生成，Request定义的为一个http的请求，它的产生要去ServiceMethod.toRequest()方法中去看，
RequestBuilder requestBuilder = new RequestBuilder(httpMethod, baseUrl, relativeUrl, headers,
contentType, hasBody, isFormEncoded, isMultipart);
利用ServiceMethod中的方法配置来（就是我们新建Retrofit.Builder的配置）配置Request
ParameterHandler<Object>[] handlers = (ParameterHandler<Object>[]) parameterHandlers;
...
...
for (int p = 0; p < argumentCount; p++) {
handlers[p].apply(requestBuilder, args[p]);
}
最后是由ParameterHandler来操作的，查看此类就可以发现它是对于我们所自己定义的接口方法中的参数的处理，例如：
@Path，@Query的处理，这个就是将我们之前在ServiceMethod中所对于方法和参数的解析，在此使用了。然后调用了
serviceMethod.callFactory.newCall()此方法来返回一个Call对象。callFactory是从retrofit类中来的，就是我们在Builder.client()中所调用的方法，这个就是OkHttpClient。Request类中就是我们的http的请求信息，然后用个OkHttpClient来做具体的请求。parseResponse是用来解析相应的方法,最后会调用ServiceMethod.toResponse(),就是通过配置的responseConverter类解析相应的信息的，用GsonConverterFactory.create()就是将JSON转化成了java类对象。
这就是使用默认一般操作的从请求到响应的代码流程.
网友评论