写在前面
之前基于OkHttp3封装了一个网络请求框架，本篇接着上一篇的内容继续对Retrofit作一个封装，所以首先基本的Retrofit的用法你要清楚，起码了解过它发起请求的一个完整过程。最近这些天我对这个网络请求库进行了简单的测试，因为处理的业务并不多，所以暂时还没有出现什么太大的问题，这篇文章在草稿箱里封存了这么久了，今天是2月12号了，年前事年前毕，明天就回家了，今天把它放出来了，如果大家发现了什么问题，欢迎给我留言。
一、项目地址
GitHub地址：https://github.com/square/retrofit
官网地址：http://square.github.io/retrofit/
个人封装Retrofit案例地址：https://github.com/JArchie/NetTest
二、封装思路讲解（这里是摘取核心代码说明封装思路，完整代码参见上面给出的案例地址）
（一）基本请求的实现
1、创建项目
首先我们新建一个工程，然后在该工程下New Module，选择Android Library，然后新建一个包名称为retrofit，我们所有封装的网络请求相关的类都放在这个包下面，主要用来进行RESTful请求的（一种软件的架构，推荐阮一峰大神的这篇文章：http://www.ruanyifeng.com/blog/2011/09/restful.html）。在具体代码实现之前，我们还必须要做的一步操作是，把retrofit相关的依赖都添加到build.gradle文件中，大家可以去项目主页上按步骤添加，这里我就直接从我的项目中复制了：
//网络库
compile 'com.squareup.okhttp3:okhttp:3.9.1'
compile 'com.squareup.retrofit2:retrofit:2.3.0'
compile 'com.google.code.gson:gson:2.8.0'
compile 'com.squareup.retrofit2:converter-gson:2.3.0'
compile 'com.squareup.retrofit2:converter-scalars:2.3.0'
compile 'com.squareup.okhttp3:logging-interceptor:3.8.1'为了使封装更加灵活，基于传入参数，并且无顺序要求的原则，建造者模式无疑是最佳的选择。
2、创建Service接口
首先Retrofit的使用必须要有一个接口，这里定义为RestService，里面定义一系列的方法，用来发起具体的请求，为了更好的理解我下面代码的含义，这里带大家先来了解一下几个注解的具体含义：
Http请求方法注解：
标记类注解：
参数类注解：
鉴于是通用的封装，所以这里不会传入具体的路由信息，这里参数均使用Map以键值对的形式定义，因为value不确定具体的类型，所以我们类型给它Object，然后每个方法的返回类型都是Retrofit2中的Call类型，如果你要使用RxJava，这里需要返回Observable类型，之后我们需要操作这个Call对象，来看本类的代码：
public interface RestService {
//Get请求
@GET
Call<String> get(@Url String url, @QueryMap Map<String, Object> params);
//Post请求
@FormUrlEncoded
@POST
Call<String> post(@Url String url, @FieldMap Map<String, Object> params);
//Post原始数据
@POST
Call<String> postRaw(@Url String url, @Body RequestBody body);
//Put请求
@FormUrlEncoded
@PUT
Call<String> put(@Url String url, @FieldMap Map<String, Object> params);
//Put原始数据
@PUT
Call<String> putRaw(@Url String url, @Body RequestBody body);
//Delete请求
@DELETE
Call<String> delete(@Url String url, @QueryMap Map<String, Object> params);
//文件下载
@Streaming
@GET
Call<ResponseBody> download(@Url String url, @QueryMap Map<String, Object> params);
//文件上传
@Multipart
@POST
Call<String> upload(@Url String url, @Part MultipartBody.Part file);
}3、创建请求方法类型管理类
新建一个类HttpMethod，这个类用来统一管理请求方法的类型，这个类其实是可有可无的，但是本着类多代码少的原则，类的数量多，类中代码少，这样整体的架构将会更加清晰，代码看着也更加整洁，这也是面向对象六大原则中单一职责原则（SRP）所推荐的（注意：这个尽量不要使用枚举类型，因为使用枚举内存会飙升，本人一开始就是定义的枚举类，后来Review代码时又改成常量类了），具体代码体现如下：
/**
* Created by Jarchie on 2017\12\7.
* 统一管理请求方法类型
*/
public final class HttpMethod {
public static final String GET = "GET";
public static final String POST = "POST";
public static final String POST_RAW = "POST_RAW";
public static final String PUT = "PUT";
public static final String PUT_RAW = "PUT_RAW";
public static final String DELETE = "DELETE";
public static final String UPLOAD = "UPLOAD";
}4、创建Retrofit的构建类
这里新建一个类RestCreator，这里面会使用到Java并发编程中推荐的单例模式的创建方式——内部类Holder，这里创建了一个静态内部类RetrofitHolder，用来构建全局的Retrofit对象，这里配置了Retrofit的baseUrl、client、并且添加了它的转换器，在配置client属性时，因为它需要一个OkHttpClient，所以我们这里又创建了一个静态内部类OkHttpHolder用来构建OkHttpClient对象，然后传入Retrofit的client属性中，通过写代码我们可以发现，Retrofit和OkHttp本身在设计的时候也是大量的使用了建造者模式，可见这种设计模式还是很受欢迎的，但是有一点比较烦，就是写起来比较累，很繁琐，后面在代码中会有详细的体现。又扯远了啊，继续说这个类，我们还在这个类中创建了OKHTTP的日志拦截器，这样我们在请求有响应时可以通过日志信息清楚的看到返回的数据，具体代码如下所示：
public final class RestCreator {
private static final class RetrofitHolder {
private static final String BASE_URL = Constant.BASE_URL;
private static final Retrofit RETROFIT_CLIENT = new Retrofit.Builder()
.baseUrl(BASE_URL)
.client(OKHttpHolder.OK_HTTP_CLIENT)
.addConverterFactory(ScalarsConverterFactory.create())
.build();
}
private static final class OKHttpHolder {
private static final int TIME_OUT = 20;
private static final OkHttpClient OK_HTTP_CLIENT = new OkHttpClient.Builder()
.connectTimeout(TIME_OUT, TimeUnit.SECONDS)
.addInterceptor(getLoggerInterceptor())
.build();
}
//创建OKHTTP的日志拦截器
private static HttpLoggingInterceptor getLoggerInterceptor() {
//日志显示级别
HttpLoggingInterceptor.Level level = HttpLoggingInterceptor.Level.BODY;
//新建log拦截器
HttpLoggingInterceptor loggingInterceptor = new HttpLoggingInterceptor(
new HttpLoggingInterceptor.Logger() {
@Override
public void log(@NonNull String message) {
Log.e("ResponseBody------->", message);
}
});
loggingInterceptor.setLevel(level);
return loggingInterceptor;
}
}5、请求回调的处理
这里我们新建一个包callback，在这个包下我们新建四个接口IRequest、ISuccess、IFailure、IError，相对应的分别用来处理请求开始结束、请求成功、请求失败、请求错误等几种状态下的回调。具体代码如下：
public interface IRequest {
//请求开始
void onRequestStart();
//请求结束
void onRequestEnd();
}public interface ISuccess {
//请求成功
void onSuccess(Object response);
}
public interface IFailure {
//请求失败
void onFailure();
}public interface IError {
//请求错误
void onError(int code, String msg);
}接着我们创建一个RequestCallbacks类，该类实现Retrofit2包下的Callback接口，这里注意别导错包了，这个类我们用来具体处理网络请求的回调过程，这个类中我创建了一个class字节码变量，在返回成功时使用Gson解析，将解析返回的结果就是一个数据实体对象返回到应用层中，在ISuccess接口中我们的参数类型定义为了Object，所以可以很灵活的强转成你自己的实体类型。如果你不想在框架层就解析成实体，比如有些业务情况返回的JSON数据比较简单，这里也做了一层处理，如果有实体对象就解析，没有就直接将原生JSON返回到应用层中去，做到了灵活处理。
public class RequestCallbacks implements Callback<String> {
private final IRequest REQUEST;
private final ISuccess SUCCESS;
private final IFailure FAILURE;
private final IError ERROR;
private final Class<?> CLASS;
public RequestCallbacks(IRequest request, ISuccess success, IFailure failure, IError error, Class<?> clazz) {
this.REQUEST = request;
this.SUCCESS = success;
this.FAILURE = failure;
this.ERROR = error;
this.CLASS = clazz;
}
@Override
public void onResponse(@NonNull Call<String> call, @NonNull Response<String> response) {
if (response.isSuccessful()) {
if (call.isExecuted()) {
if (SUCCESS != null) {
if (CLASS != null) {
Object object = new Gson().fromJson(response.body(), CLASS);
SUCCESS.onSuccess(object);
} else {
SUCCESS.onSuccess(response.body());
}
}
}
} else {
if (ERROR != null) {
ERROR.onError(response.code(), response.message());
}
}
DialogLoader.dismiss();
}
@Override
public void onFailure(@NonNull Call<String> call, @NonNull Throwable t) {
if (FAILURE != null) {
FAILURE.onFailure();
}
if (REQUEST != null) {
REQUEST.onRequestEnd();
}
DialogLoader.dismiss();
}
}
6、开启建造者模式
准备工作结束之后，我们来开始建造者的创建。这里首先创建一个宿主类RestClient，然后再创建一个建造者类RestClientBuilder，好了文件创建完成了先放着不要急着写，我们先来思考一下网络请求一般会有哪些参数？我们很容易想到的参数如下：URL、传入的值（请求参数）、回调、请求体（RequestBody这是OkHttp3中的内容）这些东西，别忘了定义我们上面准备好的字节码变量，用来控制数据解析的哦。我们的RestClient在每次Builder去build的时候，它都会生成一个全新的实例，这里面的参数是一次构建完毕，绝不允许更改的，所以我们在声明的时候使用final关键字来声明，这样能保证每一次传值的原子性，在多线程中也是一种比较安全的做法。用final声明的变量如果没有赋值的话，必须在构造方法中为其赋值，来看代码：
private final Context CONTEXT;
private final String URL;
private final HashMap<String, Object> PARAMS;
private final RequestBody BODY;
private final IRequest REQUEST;
private final ISuccess SUCCESS;
private final IFailure FAILURE;
private final IError ERROR;
private final Class<?> CLASS;
public RestClient(Context context, String url, HashMap<String, Object> params,
RequestBody body, IRequest request,
ISuccess success, IFailure failure, IError error,
Class<?> clazz) {
this.CONTEXT = context;
this.URL = url;
this.PARAMS = params;
this.BODY = body;
this.REQUEST = request;
this.SUCCESS = success;
this.FAILURE = failure;
this.ERROR = error;
this.CLASS = clazz;
}这样我们就可以创建我们的建造者了，代码如下：
public static RestClientBuilder Builder() {
return new RestClientBuilder();
}我们接着来看一下RestClientBuilder这个类里面有哪些方法？Builder里面就是一些传值的操作，所以我们需要把宿主类里面的参数都照搬过来，当然了这里不能再使用final关键字修饰了，否则我们不能为其依次赋值了，所以我们就按照普通的方式来声明了：
private Context mContext = null;
private String mUrl = null;
private HashMap<String, Object> PARAMS = new HashMap<>();
private RequestBody mBody = null;
private IRequest mIRequest = null;
private ISuccess mISuccess = null;
private IFailure mIFailure = null;
private IError mIError = null;
private Class<?> mClass = null;这里我们不允许外部的类去直接new它，只允许同包的RestClient去new它，所以这里在构造方法中做一个限制：
RestClientBuilder() {}接下来是一系列的具体构建上面声明的这些参数的方法，这里我们同样使用了final关键字修饰这些方法，不允许外部修改它，构建这些参数的代码其实都是很类似的，写了一个其它的直接复制粘贴，修修改改就OK了，来看具体代码：
public final RestClientBuilder context(Context context) {
this.mContext = context;
return this;
}
public final RestClientBuilder url(String url) {
this.mUrl = url;
return this;
}
public final RestClientBuilder params(HashMap<String, Object> params) {
PARAMS.putAll(params);
return this;
}
public final RestClientBuilder params(String key, Object value) {
PARAMS.put(key, value);
return this;
}
public final RestClientBuilder raw(String raw) {
this.mBody = RequestBody.create(MediaType.parse("application/json;charset=UTF-8"), raw);
return this;
}
public final RestClientBuilder onRequest(IRequest iRequest) {
this.mIRequest = iRequest;
return this;
}
public final RestClientBuilder listener(ISuccess iSuccess) {
this.mISuccess = iSuccess;
return this;
}
public final RestClientBuilder listener(IFailure iFailure) {
this.mIFailure = iFailure;
return this;
}
public final RestClientBuilder listener(IError iError) {
this.mIError = iError;
return this;
}
public final RestClientBuilder clazz(Class<?> clazz) {
this.mClass = clazz;
return this;
}好了，接着我们来build我们的RestClient，其实就是宿主的RestClient通过它自己的建造者RestClientBuilder去返回它本身的对象：
public final RestClient build() {
return new RestClient(mContext, mUrl, PARAMS, mBody, mIRequest,
mISuccess, mIFailure, mIError, mClass);
}7、发起网络请求
构建了RestClient对象之后，我们还没有调起网络请求的方法呢，不然写了这么多也是毫无卵用。
首先我们要拿到RestService接口的对象，这里为了方便，在RestCreator这个类中使用内部类Holder的模式去实现，然后对外提供一个返回RestService类对象的静态方法去获取：
public static RestService getRestService() {
return RestServiceHolder.REST_SERVICE;
}
private static final class RestServiceHolder {
private static final RestService REST_SERVICE =
RetrofitHolder.RETROFIT_CLIENT.create(RestService.class);
}拿到RestService之后，我们来接着写我们的实现请求的方法request(String method)方法，参数是区分各个请求类型的字符串，之前我们已经在HttpMethod类中定义好了，不知道大家还有印象吗？在这个方法中我们通过RestService类对象去调用内部定义好的通用的请求方法（get、post、put、Delete等等），然后返回一个Call对象，注意也是Retrofit2包下面的。调用完了具体的方法之后，我们最后去处理retrofit的回调，就是我们上面定义好的RequestCallbacks类中的内容，代码如下：
private void request(String method) {
final RestService service = RestCreator.getRestService();
Call<String> call = null;
if (REQUEST != null) {
REQUEST.onRequestStart();
}
//弹出加载框
DialogLoader.show(CONTEXT);
switch (method) { //调起Service中相对应的请求类型
case HttpMethod.GET: //GET请求
call = service.get(URL, PARAMS);
break;
case HttpMethod.POST: //POST请求
call = service.post(URL, PARAMS);
break;
case HttpMethod.POST_RAW: //POST原始数据
call = service.postRaw(URL, BODY);
break;
case HttpMethod.PUT: //PUT请求
call = service.put(URL, PARAMS);
break;
case HttpMethod.PUT_RAW: //PUT原始数据
call = service.putRaw(URL, BODY);
break;
case HttpMethod.DELETE: //DELETE请求
call = service.delete(URL, PARAMS);
break;
case HttpMethod.UPLOAD: //上传文件
final RequestBody requestBody =
RequestBody.create(MediaType.parse(MultipartBody.FORM.toString()), FILE);
final MultipartBody.Part body =
MultipartBody.Part.createFormData("file", FILE.getName(), requestBody);
call = service.upload(URL, body);
break;
default:
break;
}
if (call != null) {
call.enqueue(getRequestCallback());
}
}
//获取处理回调的方法
private Callback<String> getRequestCallback() {
return new RequestCallbacks(REQUEST, SUCCESS, FAILURE, ERROR, CLASS);
}最后我们再定义如下几个方法：get()、post()、put()、delete()、upload()，方法内部去调用request()方法，在建造者构建完成时调用，用来真正发起相对应的请求：
//GET请求
public final void get() {
request(HttpMethod.GET);
}
//POST请求
public final void post() {
if (BODY == null) {
request(HttpMethod.POST);
} else {
if (!PARAMS.isEmpty()) {
throw new RuntimeException("params must be null!");
}
request(HttpMethod.POST_RAW);
}
}
//PUT请求
public final void put() {
if (BODY == null) {
request(HttpMethod.PUT);
} else {
if (!PARAMS.isEmpty()) {
throw new RuntimeException("params must be null!");
}
request(HttpMethod.PUT_RAW);
}
}
//DELETE请求
public final void delete() {
request(HttpMethod.DELETE);
}
//上传文件
public final void upload() {
request(HttpMethod.UPLOAD);
}8、调用说明
在做完了以上这些工作之后，其实我们就已经把我们的RestClient的雏形构建出来了，链式调用结构清晰，让人看着神清气爽啊，发起请求的代码就写成了这个样子了：
RestClient.Builder()
.context(this)
.clazz(null)
.params("","")
.listener(new ISuccess() {
@Override
public void onSuccess(Object response) {
}
})
.listener(new IFailure() {
@Override
public void onFailure() {
}
})
.listener(new IError() {
@Override
public void onError(int code, String msg) {
}
})
.build()
.post();三、文件下载
文件下载其实就是个GET请求，这里需要注意大文件下载时一定要添加@Streaming注解，这是官方提到的一点，因为文件下载时是一次性读到内存中的，不加这个很容易造成内存溢出。下面我们就来具体的实现一下文件下载，其实过程都差不多。
1、处理耗时任务
因为文件下载是一个耗时的过程，所以我们不能直接在主线程中进行，需要在子线程中处理，然后将结果转发到主线程中。这里我们新建一个类SaveFileTask继承自AsyncTask类，第一个输入参数类型我们传入Object，第二个处理过程参数类型传入Void，第三个输出参数类型我们传入File类型，在doInBackground方法中，首先是拿到文件目录、后缀名、文件名、输入流这些内容，然后通过IO流进行文件写入的操作，在onPostExecute方法中，处理执行完的结果，此时是被主线程调用的，简单起见只处理成功的回调，通过SUCCESS.onSuccess()方法，参数传入文件路径，将下载的结果进行返回，如下所示：
public final class SaveFileTask extends AsyncTask<Object, Void, File> {
private final IRequest REQUEST;
private final ISuccess SUCCESS;
public SaveFileTask(IRequest request, ISuccess success) {
this.REQUEST = request;
this.SUCCESS = success;
}
@Override
protected File doInBackground(Object... params) {
String downloadDir = (String) params[0];
String extension = (String) params[1];
final ResponseBody body = (ResponseBody) params[2];
final String name = (String) params[3];
final InputStream is = body.byteStream(); //获得输入流
if (downloadDir == null || downloadDir.equals("")) {
downloadDir = "down_loads"; //下载的文件目录
}
if (extension == null || extension.equals("")) {
extension = "";
}
if (name == null) {
return FileUtil.writeToDisk(is, downloadDir, extension.toUpperCase(), extension);
} else {
return FileUtil.writeToDisk(is, downloadDir, name);
}
}
@Override
protected void onPostExecute(File file) {
super.onPostExecute(file);
if (SUCCESS != null) {
SUCCESS.onSuccess(file.getPath());
}
if (REQUEST != null) {
REQUEST.onRequestEnd();
}
autoInstallApk(file);
}
//下载apk文件下载完成时自动安装程序
private void autoInstallApk(File file) {
if (FileUtil.getExtension(file.getPath()).equals("apk")) {
final Intent install = new Intent();
install.addFlags(Intent.FLAG_ACTIVITY_NEW_TASK);
install.setAction(Intent.ACTION_VIEW);
install.setDataAndType(Uri.fromFile(file), "application/vnd.android.package-archive");
Contract.getContext().startActivity(install);
}
}
}
2、处理下载逻辑及回调
新建一个类DownloadHandler，然后定义好网络请求的URL、参数、文件目录、后缀名、文件名、相关回调接口，最后通过RestService调用内部定义的download方法，实现Callback，泛型传入ResponseBody，在重写的成功和失败的回调方法里进行具体的实现，成功的回调中通过我们上面定义的SaveFileTask类的对象去调用下载的执行方法进行真正的下载，这里调用的是executeOnExecutor方法，它通常和THREAD_POOL_EXECUTOR一起使用，允许多个任务在由AsyncTask管理的线程池中并行执行，代码如下：
public class DownloadHandler {
private final String URL;
private final HashMap<String, Object> PARAMS;
private final IRequest REQUEST;
private final String DOWNLOAD_DIR;
private final String EXTENSION;
private final String NAME;
private final ISuccess SUCCESS;
private final IFailure FAILURE;
private final IError ERROR;
public DownloadHandler(String url, HashMap<String, Object> params,
IRequest request, String downloadDir,
String extension, String name,
ISuccess success, IFailure failure,
IError error) {
this.URL = url;
this.PARAMS = params;
this.REQUEST = request;
this.DOWNLOAD_DIR = downloadDir;
this.EXTENSION = extension;
this.NAME = name;
this.SUCCESS = success;
this.FAILURE = failure;
this.ERROR = error;
}
//处理文件下载
public final void handleDownload() {
if (REQUEST != null) {
REQUEST.onRequestStart();
}
RestCreator.getRestService().download(URL, PARAMS)
.enqueue(new Callback<ResponseBody>() {
@Override
public void onResponse(@NonNull Call<ResponseBody> call, @NonNull Response<ResponseBody> response) {
if (response.isSuccessful()) { //成功时的回调
final ResponseBody responseBody = response.body();
final SaveFileTask task = new SaveFileTask(REQUEST, SUCCESS);
task.executeOnExecutor(AsyncTask.THREAD_POOL_EXECUTOR,
DOWNLOAD_DIR, EXTENSION, responseBody, NAME);
//这里一定要注意判断，否则文件下载不全
if (task.isCancelled()) {
if (REQUEST != null) {
REQUEST.onRequestEnd();
}
}
} else { //错误时的回调
ERROR.onError(response.code(), response.message());
}
}
@Override
public void onFailure(@NonNull Call<ResponseBody> call, @NonNull Throwable t) {
if (FAILURE != null)
FAILURE.onFailure();
}
});
}
}3、添加到构建者模式
我们通过和之前一样的方法，在RestClient类中新增下载文件的一些参数，并且在构造方法中补上：
private final File FILE; //文件
private final String DOWNLOAD_DIR; //文件目录
private final String EXTENSION; //后缀名
private final String NAME; //文件名还要提供一个下载的调用方法，内部实现直接构造一个DownloadHandler对象即可：
//下载文件
public final void download() {
new DownloadHandler(URL, PARAMS, REQUEST, DOWNLOAD_DIR,
EXTENSION, NAME, SUCCESS, FAILURE, ERROR)
.handleDownload();
}并且在RestClientBuilder类中提供相对应的构建方法：
public final RestClientBuilder file(File file) {
this.mFile = file;
return this;
}
public final RestClientBuilder file(String filePath) {
this.mFile = new File(filePath);
return this;
}
public final RestClientBuilder dir(String dir) {
this.mDownloadDir = dir;
return this;
}
public final RestClientBuilder extension(String extension) {
this.mExtension = extension;
return this;
}
public final RestClientBuilder name(String name) {
this.mName = name;
return this;
}好了到这里，我们的整个框架就已经封装完成了，不过还是有很多需要完善的地方，我只能日后再说了！
四、编写测试案例
下面在应用层写一个测试案例，来测试框架是否能够正常使用，这里我就只贴实现的核心代码了（文章太长估计都没耐心看了）：
接口地址（猫眼电影（非官方））：http://m.maoyan.com/movie/list.json?type=hot&offset=0&limit=10
请求代码如下：
RestClient.Builder()
.context(this)
.url("movie/list.json?type=hot")
.params("offset", 0)
.params("limit", 10)
.clazz(MovieBean.class)
.listener(new ISuccess() {
@Override
public void onSuccess(Object response) {
MovieBean bean = (MovieBean) response;
mList.addAll(bean.getData().getMovies());
recyclerView.setLayoutManager(new LinearLayoutManager(MainActivity.this));
recyclerView.setAdapter(new IndexListAdapter(MainActivity.this, mList));
}
})
.listener(new IError() {
@Override
public void onError(int code, String msg) {
Log.e("onError: ", msg);
}
})
.listener(new IFailure() {
@Override
public void onFailure() {
Log.e("onFailure: ", "请求失败");
}
})
.build()
.get();最终实现的效果图如下图所示：
好了，写到这里就要结束了，最后再甩一遍本项目的地址：https://github.com/JArchie/NetTest
最后祝大家新年快乐，阖家幸福！
