Retrofit基本使用及原理+源码解析（入门级）
前言：本篇博文主要对Retrofit做一个基本介绍，了解Retrofit基本使用以及部分源码解析，让读者对Retrofit框架有一个基本了解，主要参考文章：https://www.jianshu.com/p/07f7eb4aa9ae
目录
1-Retrofit实例的创建：它是通过内部类Builder的build()方法创建的，build()方法代码如下：
2-接口实例及Call对象的创建：Retrofit的create方法：
3-获得了Call(OKhhttpCall)对象后，调用其enqueue方法，将网络请求放入到队列中，等待响应：
一、概述
Retrofit是一个Android网络框架。是一个对OKhttp框架的封装，所以其内部实现原理实际上是基于OKhttp。Retrofit采用注解方式开发。通过注解构建不同的请求和请求参数，省去了创建大量类似的请求和函数重载。实际上这些参数最终都会在OKhttp中组合成一个完整的Http请求，并通过OKhttp框架进行发送。
二、基本使用
1-导入Retrofit框架：
在AS项目中build.gradle中的dependencies中添加引用项，如下所示：引用retrofit2.2的jar包
compile 'com.squareup.retrofit2:retrofit:2.2.0'
//Configuration 'compile' is obsolete and has been replaced with 'implementation' and 'api'.引用成功后在retrofit2文件夹下可以看到如下Retrofit中的类：
上图为Retrofit包所包含的类，其中http中包含了有关注解的定义。包括Body、DELETE、Field、FieldMap、FormUrlEncoded、GET、HEAD、Header、HeaderMap、Headers、HTTP、Multipart、OPTIONS、Part、PartMap、PATCH、Path、POST、PUT、Query、QueryMap、QueryName、Streaming、Url。其中较为常用的有GET、POST、Url、Streaming、Header等。后面将会谈到这些注释的用法，暂时可看成是一种声明，这种声明可以针对方法，也可以针对方法中的参数。
2-使用Retrofit框架：
需求：要从一个Url指定的地址中下载一个文件
1.首先，要创建一个接口，接口名称取为IGetFileService（可随便取），并且定义一个接口方法，这个方法有几个地方需要注意：方法上方的注解@Streaming，@GET；方法的返回值Call，还有这个泛型的实例类型ResponseBody。
package com.example.retrofitapplication;
import okhttp3.ResponseBody;
import retrofit2.Call;
import retrofit2.http.GET;
import retrofit2.http.Streaming;
public interface IGetFileServer {
@Streaming
@GET("file/test.txt")
Call<ResponseBody> downloadFile();
}
2.然后创建了接口之后，就可以创建Retrofit实例：
Retrofit的创建与接口方法的返回值有关，Retrofit.Builder()可调用addCallAdapterFactory方法和addCoverterFactory方法，都是针对返回值的一些转换。所以现在这个Retrofit的创建是最简单的一种形式。其他形式在后面会再作介绍。
package com.example.retrofitapplication;
import androidx.appcompat.app.AppCompatActivity;
import retrofit2.Retrofit;
import android.os.Bundle;
public class MainActivity extends AppCompatActivity {
@Override
protected void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.activity_main);
//创建Retrofit实例
Retrofit retrofit = new Retrofit.Builder()
.baseUrl("https://api.git.com/")
.build();
}
}值得注意的是baseUrl这个方法。其参数是一个Url字符串，而且必须以“/”作为结尾，这个字符串与上面@GET注解的参数“file/test.txt”共同组成一个完整的URL，downloaFile()方法将要访问的就是“https://api.git.com/file/test.txt”这个URL。Retrofit的这种设定将网络文件的域和文件在域中的路径作了分离，对同一个域中的多个文件访问有一种比较统一的形式。
但对于动态获得的URL访问则会存在一点问题，因为baseUrl不能以完整的URL作为参数传入，必须只传一个域（因为必须以”/”作为结尾，不然报错）。幸好Retrofit还提供了一个注解@URL。只要在方法中声明一个参数，并加上@URL注解，就可以动态地将完整的URL作为请求的参数。如下所示：这样，无论BaseUrl传入什么参数，都不起作用，而是用downloadFile的参数fileUrl作为请求的URL。
package com.example.retrofitapplication;
import ...
public interface IGetFileServer {
@Streaming
@GET("file/test.txt")
Call<ResponseBody> downloadFile(@Url String fileUrl);//用@Url修饰参数
}3.通过Retrofit实例获得接口实例，通过接口实例获得Call实例：
package com.example.retrofitapplication;
import ...
public class MainActivity extends AppCompatActivity {
@Override
protected void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.activity_main);
//获得Retrofit实例
Retrofit retrofit = new Retrofit.Builder()
.baseUrl("https://api.git.com/")
.build();
//获得接口实例
IGetFileServer iGetFileServer = retrofit.create(IGetFileServer.class);
//获得call对象
Call<ResponseBody> responseBodyCall = iGetFileServer.downloadFile();
}
}4.获得了这个call对象就可以开始访问网络了。
responseBodyCall.enqueue(new Callback<ResponseBody>() {
@Override
public void onResponse(Call<ResponseBody> call, Response<ResponseBody> response) {
ResponseBody body = response.body();
//获得输入流
InputStream inputStream = body.byteStream();
//TODO SOMETHING
}
@Override
public void onFailure(Call<ResponseBody> call, Throwable t) {
}
});总结一下这个流程：
- 创建一个接口，以及接口的方法，使用注解标识该方法的请求参数。
- 创建Retrofit实例。
- 通过retrofit实例创建接口实例，调用接口实例的接口方法，获得call对象。
- 调用call对象的enqueue方法，并且传入Callback参数，实现onResponse方法和onFailure方法，表示请求成功和失败时候的回调。
三、Retrofit内部的实现
上面的例子的疑惑点：
- 创建的接口IGetFileServer怎么使用Retrofit的create方法就可以创建一个IGetFileServer的实例？
- 可以调用其没有经过我们具体实现的方法downloadFile实现网络请求呢？
这里使用了反射和代理的设计模式，IGetFileServer的实例实际上Retrofit创建的一个代理，而接口方法downloadFile的实现其实是经过Retrofit内部特殊处理的，这个downloadFile可以看成是一个标识，是Retrofit内部一段逻辑的调用接口，其方法参数都需要添加注解，因此不是随意的想要添加任意参数都可以的。这个接口IGetFileServer看起来是我们自己创建的，连接口方法也是我们定义的，实际上，它只是为了声明我们对网络请求的一个简化形式，这需要跟以往创建接口并自己实现的思路区分开来。这个接口的方法不需要我们实现，它已经在Retrofit内实现好了，我们只需要添加参数，就可以调用网络请求。下面先来看这个代理和方法是怎样实现的。
1-Retrofit实例的创建：它是通过内部类Builder的build()方法创建的，build()方法代码如下：
public Retrofit build() {
if (baseUrl == null) {
throw new IllegalStateException("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();
}
// Make a defensive copy of the adapters and add the default Call adapter.
List<CallAdapter.Factory> adapterFactories = new ArrayList<>(this.adapterFactories);
adapterFactories.add(platform.defaultCallAdapterFactory(callbackExecutor));
// Make a defensive copy of the converters.
List<Converter.Factory> converterFactories = new ArrayList<>(this.converterFactories);
return new Retrofit(callFactory, baseUrl, converterFactories, adapterFactories,
callbackExecutor, validateEagerly);
}Retrofit的构造方法如下：
Retrofit(okhttp3.Call.Factory callFactory, HttpUrl baseUrl,
List<Converter.Factory> converterFactories, List<CallAdapter.Factory> adapterFactories,
Executor callbackExecutor, boolean validateEagerly) {
this.callFactory = callFactory;
this.baseUrl = baseUrl;
this.converterFactories = unmodifiableList(converterFactories); // Defensive copy at call site.
this.adapterFactories = unmodifiableList(adapterFactories); // Defensive copy at call site.
this.callbackExecutor = callbackExecutor;
this.validateEagerly = validateEagerly;
}2-接口实例及Call对象的创建：Retrofit的create方法：
public <T> T create(final Class<T> service) {
//判断参数是否是接口
Utils.validateServiceInterface(service);
//默认为false
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);
}
});
}联系上面的例子，接口方法是需要返回Call对象的。而OkHttpCall则是Call的实现类。注意到返回的是callAdapter.adapt(okHttpCall)，而当我们没有添加callAdapter的时候，使用Retrofit默认的callAdapter，而这个默认的callAdapter==传入的okHttpCall。因此，方法最后返回的即创建的okHttpCall，callAdapter就是对返回的Call对象的一个转化类，在后面会谈到RxJava和Retrofit的结合使用，就需要将这个okHttpCall转换成Rxjava的Observable，这个时候就需要使用RxJava的callAdapter，对call进行转化。
loadServiceMethod会对method（即我们定义的接口方法）进行处理，构成ServiceMethod对象。这个对象在OkHttpCall进行网络请求时会用到。Retrofit使用serviceMethodCache这个表缓存serviceMethod，如果从serviceMethodCache中没有method对应的serviceMethod，则会通过ServiceMethod的Buidler创建一个。证明如下：
ServiceMethod<?, ?> loadServiceMethod(Method method) {
ServiceMethod<?, ?> result = serviceMethodCache.get(method);
if (result != null) return result;
synchronized (serviceMethodCache) {
result = serviceMethodCache.get(method);
if (result == null) {
result = new ServiceMethod.Builder<>(this, method).build();
serviceMethodCache.put(method, result);
}
}
return result;
}3-获得了Call(OKhhttpCall)对象后，调用其enqueue方法，将网络请求放入到队列中，等待响应：
@Override public void enqueue(final Callback<T> callback) {
if (callback == null) throw new NullPointerException("callback == null");
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对象实际上是OKhttp中的RealCall对象-->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();
}
}
});
}从enqueue方法可知，我们得到的OkHttpCall实际上是对OKHttp请求的封装，实际的网络实现还是要通过OKHttp中的相关类来实现。这里体现了Retrofit的思想，即对OkHttp的封装，以及简化其使用。
四、总结Retrofit内部实现步骤
- Retrofit实例的构造，填充一些参数，比如将在后面谈到的callAdapterFactory、convertFactory，以及baseUrl，callFactory（与callAdapterFactory作区分，若不指定，则为一个默认的OkHttpClient，可以根据需要创建一个OkHttpClient，然后对这个OkHttpClient添加对应的属性，以实现不同的网络处理机制）。
- Retrofit调用create创建一个接口的代理实体，而代理关键部分在于创建一个ServiceMethod，ServiceMethod收集接口方法的参数类型以及对应的注解，组成一个有关网络请求的参数类型集合。
- ServiceMethod与接口方法传入的参数共同作用传入OkHttpCall，构成一个Call对象，经过CallAdapterFactory的适配返回。因此接口方法可以理解为最后获得这个Call对象（真实来说应该是OkHttpCall）。
- Call对象调用enqueue实际使用的是OkHttp的RealCall的enqueue方法，因此Retrofit的Call对象可以看成是OkHttp的Call的一个封装。当然，这不是一个简单的封装，在网络请求获得响应后，OkHttpCall还会对返回的信息进行转置，根据ConvertFactory定义的转置模式进行转换。
扫一扫
1106
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
