回复
Android 搭建网络访问框架（上）
dmzhaoq1
发布于 2021-3-3 09:57
浏览
1收藏
OkHttp+Retrofit+RxJava搭建网络访问框架
前言
在实际开发APP中，网络访问是必不可少的，最开始访问网络是使用HttpURLConnection、而后面有了一些框架比如Volley、OkHttp、Retrofit等。那么你可能看到最多的是OkHttp，因为它很出名，Google也推荐你使用此框架进行网络访问。你可能会说Retrofit，Retrofit其实就是对OkHttp的二次封装。还有RxJava，这个又是用来干嘛的呢？为什么要将三者组合起来，组合有什么优势吗？带着这些问题看下去。
正文
创建一个名为NetworkFrameWorkDemo的项目。
点击Finish完成创建。
下面创建网络模块，点击导航栏 File→New→New Module…
选择Android Library，点击Next。
设置模块名称、模块包名等信息，点击Finish完成创建。
创建好之后如下图所示：
下面可以先不管这个app模块，把重点放到这个network模块中，等到要访问网络的时候再看app模块。
一、添加依赖
在network的build.gradle的dependencies{}闭包下添加如下依赖：
//retrofit2
api 'com.squareup.retrofit2:retrofit:2.4.0'
//这里用api 是为了让其他模块也可以使用gson
api 'com.squareup.retrofit2:converter-gson:2.4.0'
//日志拦截器
api 'com.squareup.okhttp3:logging-interceptor:3.9.0'
api 'com.squareup.retrofit2:adapter-rxjava2:2.4.0'
//rxjava
api 'io.reactivex.rxjava2:rxandroid:2.1.1'
api 'io.reactivex.rxjava2:rxjava:2.2.12'
api 'androidx.preference:preference:1.0.0'
//图片加载框架
api 'com.github.bumptech.glide:glide:4.11.0'
annotationProcessor 'com.github.bumptech.glide:compiler:4.11.0'
点击Sync进行同步依赖一下，这里你如果看到api觉得很奇怪的话，我这里解释一下，它和implementation其实差不多，只不过在依赖模块中你可以使用这个api。
在com.llw.network包下创建一个接口INetworkRequiredInfo，在里面写一些回调的方法，用于获取App的版本名、版本号、运行状态、全局上下文参数，里面代码如下：
/**
* App运行信息接口
* @author llw
*/
public interface INetworkRequiredInfo {
/**
* 获取App版本名
*/
String getAppVersionName();
/**
* 获取App版本号
*/
String getAppVersionCode();
/**
* 判断是否为Debug模式
*/
boolean isDebug();
/**
* 获取全局上下文参数
*/
Application getApplicationContext();
}
二、配置OkHttp
然后在这个包下建一个NetworkApi类，用于配置网络请求，首先是对OkHttp进行一些配置。
package com.llw.network;
import java.util.concurrent.TimeUnit;
import okhttp3.Cache;
import okhttp3.OkHttpClient;
import okhttp3.logging.HttpLoggingInterceptor;
/**
* 网络API
*
* @author llw
*/
public class NetworkApi {
//获取APP运行状态及版本信息，用于日志打印
private static INetworkRequiredInfo iNetworkRequiredInfo;
//OkHttp客户端
private static OkHttpClient okHttpClient;
/**
* 配置OkHttp
*
* @return OkHttpClient
*/
private static OkHttpClient getOkHttpClient() {
//不为空则说明已经配置过了，直接返回即可。
if (okHttpClient == null) {
//OkHttp构建器
OkHttpClient.Builder builder = new OkHttpClient.Builder();
//设置缓存大小
int cacheSize = 100 * 1024 * 1024;
//设置OkHttp网络缓存
builder.cache(new Cache(iNetworkRequiredInfo.getApplicationContext().getCacheDir(),cacheSize));
//设置网络请求超时时长，这里设置为6s
builder.connectTimeout(6, TimeUnit.SECONDS);
//在这里添加拦截器，通过拦截器可以知道一些信息，这对于开发中是有所帮助的，后面给加上。
// ...
//当程序在debug过程中则打印数据日志，方便调试用。
if (iNetworkRequiredInfo != null && iNetworkRequiredInfo.isDebug()){
//iNetworkRequiredInfo不为空且处于debug状态下则初始化日志拦截器
HttpLoggingInterceptor httpLoggingInterceptor = new HttpLoggingInterceptor();
//设置要打印日志的内容等级，BODY为主要内容，还有BASIC、HEADERS、NONE。
httpLoggingInterceptor.setLevel(HttpLoggingInterceptor.Level.BODY);
//将拦截器添加到OkHttp构建器中
builder.addInterceptor(httpLoggingInterceptor);
}
//OkHttp配置完成
okHttpClient = builder.build();
}
return okHttpClient;
}
}
在这里 getOkHttpClient() 方法中对OkHttp进行配置，注释已经写得很清楚了，我就也没有什么好说的。而这个里面其实还有两个日志拦截构造器没有配置上去，稍后写了之后，再添加上去。
三、配置Retrofit
在NetworkApi定义两个成员变量，分别用于状态API访问地址和Retrofit
//retrofitHashMap
private static HashMap<String, Retrofit> retrofitHashMap = new HashMap<>();
//API访问地址
private static String mBaseUrl;
下面写一个配置Retrofit的方法，里面的代码如下：
/**
* 配置Retrofit
*
* @param serviceClass 服务类
* @return Retrofit
*/
private static Retrofit getRetrofit(Class serviceClass) {
if (retrofitHashMap.get(mBaseUrl + serviceClass.getName()) != null) {
//刚才上面定义的Map中键是String，值是Retrofit，当键不为空时，必然有值，有值则直接返回。
return retrofitHashMap.get(mBaseUrl + serviceClass.getName());
}
//初始化Retrofit Retrofit是对OKHttp的封装，通常是对网络请求做处理，也可以处理返回数据。
//Retrofit构建器
Retrofit.Builder builder = new Retrofit.Builder();
//设置访问地址
builder.baseUrl(mBaseUrl);
//设置OkHttp客户端，传入上面写好的方法即可获得配置后的OkHttp客户端。
builder.client(getOkHttpClient());
//设置数据解析器 会自动把请求返回的结果（json字符串）通过Gson转化工厂自动转化成与其结构相符的实体Bean
builder.addConverterFactory(GsonConverterFactory.create());
//设置请求回调，使用RxJava 对网络返回进行处理
builder.addCallAdapterFactory(RxJava2CallAdapterFactory.create());
//retrofit配置完成
Retrofit retrofit = builder.build();
//放入Map中
retrofitHashMap.put(mBaseUrl + serviceClass.getName(), retrofit);
//最后返回即可
return retrofit;
}
四、配置RxJava
RxJava是对OkHttp的请求返回做处理，那么这个就涉及到线程的切换和异常的处理。因为在实际开发中很容易出现某一个接口请求返回500、400、404之类的异常，那么也可以在这个RxJava中做处理。
先在com.llw.network包下创建一个errorhandler包，该包下创建ExceptionHandle类，用来处理异常，里面的代码如下：
package com.llw.network.errorhandler;
import android.net.ParseException;
import com.google.gson.JsonParseException;
import org.apache.http.conn.ConnectTimeoutException;
import org.json.JSONException;
import java.net.ConnectException;
import retrofit2.HttpException;
/**
* 异常处理
* @author llw
*/
public class ExceptionHandle {
//未授权
private static final int UNAUTHORIZED = 401;
//禁止的
private static final int FORBIDDEN = 403;
//未找到
private static final int NOT_FOUND = 404;
//请求超时
private static final int REQUEST_TIMEOUT = 408;
//内部服务器错误
private static final int INTERNAL_SERVER_ERROR = 500;
//错误网关
private static final int BAD_GATEWAY = 502;
//暂停服务
private static final int SERVICE_UNAVAILABLE = 503;
//网关超时
private static final int GATEWAY_TIMEOUT = 504;
/**
* 处理异常
* @param throwable
* @return
*/
public static ResponseThrowable handleException(Throwable throwable) {
//返回时抛出异常
ResponseThrowable responseThrowable;
if (throwable instanceof HttpException) {
HttpException httpException = (HttpException) throwable;
responseThrowable = new ResponseThrowable(throwable, ERROR.HTTP_ERROR);
switch (httpException.code()) {
case UNAUTHORIZED:
case FORBIDDEN:
case NOT_FOUND:
case REQUEST_TIMEOUT:
case GATEWAY_TIMEOUT:
case INTERNAL_SERVER_ERROR:
case BAD_GATEWAY:
case SERVICE_UNAVAILABLE:
default:
responseThrowable.message = "网络错误";
break;
}
return responseThrowable;
} else if (throwable instanceof ServerException) {
//服务器异常
ServerException resultException = (ServerException) throwable;
responseThrowable = new ResponseThrowable(resultException, resultException.code);
responseThrowable.message = resultException.message;
return responseThrowable;
} else if (throwable instanceof JsonParseException
|| throwable instanceof JSONException
|| throwable instanceof ParseException) {
responseThrowable = new ResponseThrowable(throwable, ERROR.PARSE_ERROR);
responseThrowable.message = "解析错误";
return responseThrowable;
} else if (throwable instanceof ConnectException) {
responseThrowable = new ResponseThrowable(throwable, ERROR.NETWORK_ERROR);
responseThrowable.message = "连接失败";
return responseThrowable;
} else if (throwable instanceof javax.net.ssl.SSLHandshakeException) {
responseThrowable = new ResponseThrowable(throwable, ERROR.SSL_ERROR);
responseThrowable.message = "证书验证失败";
return responseThrowable;
} else if (throwable instanceof ConnectTimeoutException){
responseThrowable = new ResponseThrowable(throwable, ERROR.TIMEOUT_ERROR);
responseThrowable.message = "连接超时";
return responseThrowable;
} else if (throwable instanceof java.net.SocketTimeoutException) {
responseThrowable = new ResponseThrowable(throwable, ERROR.TIMEOUT_ERROR);
responseThrowable.message = "连接超时";
return responseThrowable;
}
else {
responseThrowable = new ResponseThrowable(throwable, ERROR.UNKNOWN);
responseThrowable.message = "未知错误";
return responseThrowable;
}
}
/**
* 约定异常
*/
public class ERROR {
/**
* 未知错误
*/
public static final int UNKNOWN = 1000;
/**
* 解析错误
*/
public static final int PARSE_ERROR = 1001;
/**
* 网络错误
*/
public static final int NETWORK_ERROR = 1002;
/**
* 协议出错
*/
public static final int HTTP_ERROR = 1003;
/**
* 证书出错
*/
public static final int SSL_ERROR = 1005;
/**
* 连接超时
*/
public static final int TIMEOUT_ERROR = 1006;
}
public static class ResponseThrowable extends Exception {
public int code;
public String message;
public ResponseThrowable(Throwable throwable, int code) {
super(throwable);
this.code = code;
}
}
public static class ServerException extends RuntimeException {
public int code;
public String message;
}
}
里面都是一些常规的错误，相信你可能碰到过一些。
然后再建一个HttpErrorHandler类，代码如下：
package com.llw.network.errorhandler;
import io.reactivex.Observable;
import io.reactivex.functions.Function;
/**
* 网络错误处理
*/
public class HttpErrorHandler<T> implements Function<Throwable, Observable<T>> {
/**
* 处理以下两类网络错误：
* 1、http请求相关的错误，例如：404，403，socket timeout等等；
* 2、应用数据的错误会抛RuntimeException，最后也会走到这个函数来统一处理；
*/
@Override
public Observable<T> apply(Throwable throwable) throws Exception {
//通过这个异常处理，得到用户可以知道的原因
return Observable.error(ExceptionHandle.handleException(throwable));
}
}
还需要写一个基础返回类，在com.llw.network下新建一个BaseResponse，代码如下：
package com.llw.network;
import com.google.gson.annotations.Expose;
import com.google.gson.annotations.SerializedName;
/**
* 基础返回类
* @author llw
*/
public class BaseResponse {
//返回码
@SerializedName("res_code")
@Expose
public Integer responseCode;
//返回的错误信息
@SerializedName("res_error")
@Expose
public String responseError;
}
现在准备工作都做好了，下面就要写这个RxJava的配置了，不过还有一步就是，在NetworkApi中写一个错误码的处理方法，代码如下：
/**
* 错误码处理
*/
protected static <T> Function<T, T> getAppErrorHandler() {
return new Function<T, T>() {
@Override
public T apply(T response) throws Exception {
//当response返回出现500之类的错误时
if (response instanceof BaseResponse && ((BaseResponse) response).responseCode >= 500) {
//通过这个异常处理，得到用户可以知道的原因
ExceptionHandle.ServerException exception = new ExceptionHandle.ServerException();
exception.code = ((BaseResponse) response).responseCode;
exception.message = ((BaseResponse) response).responseError != null ? ((BaseResponse) response).responseError : "";
throw exception;
}
return response;
}
};
}
下面终于到了这个RxJava的配置了
/**
* 配置RxJava 完成线程的切换，如果是Kotlin中完全可以直接使用协程
*
* @param observer 这个observer要注意不要使用lifecycle中的Observer
* @param <T> 泛型
* @return Observable
*/
public static <T> ObservableTransformer<T, T> applySchedulers(final Observer<T> observer) {
return new ObservableTransformer<T, T>() {
@Override
public ObservableSource<T> apply(Observable<T> upstream) {
Observable<T> observable = upstream
.subscribeOn(Schedulers.io())//线程订阅
.observeOn(AndroidSchedulers.mainThread())//观察Android主线程
.map(NetworkApi.<T>getAppErrorHandler())//判断有没有500的错误，有则进入getAppErrorHandler
.onErrorResumeNext(new HttpErrorHandler<T>());//判断有没有400的错误
//这里还少了对异常
//订阅观察者
observable.subscribe(observer);
return observable;
}
};
}
五、增加拦截器
拦截器中需要打印日志和时间转换，对此需要几个工具类，所以在com.llw.network下新建一个utils包，下面新建一个DateUitl
package com.llw.network.utils;
import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.util.Calendar;
import java.util.Date;
import java.util.GregorianCalendar;
import java.util.Locale;
public class DateUtil {
//获取当前完整的日期和时间
public static String getNowDateTime() {
SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
return sdf.format(new Date());
}
//获取当前日期
public static String getNowDate() {
SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd");
return sdf.format(new Date());
}
//前一天
public static String getYesterday(Date date) {
String tomorrow = "";
Calendar calendar = new GregorianCalendar();
calendar.setTime(date);
calendar.add(Calendar.DATE, -1);
date = calendar.getTime();
SimpleDateFormat formatter = new SimpleDateFormat("yyyy-MM-dd");
tomorrow = formatter.format(date);
return tomorrow;
}
//后一天
public static String getTomorrow(Date date) {
String tomorrow = "";
Calendar calendar = new GregorianCalendar();
calendar.setTime(date);
calendar.add(Calendar.DATE, +1);
date = calendar.getTime();
SimpleDateFormat formatter = new SimpleDateFormat("yyyy-MM-dd");
tomorrow = formatter.format(date);
return tomorrow;
}
//获取当前时间
public static String getNowTime() {
SimpleDateFormat sdf = new SimpleDateFormat("HH:mm:ss");
return sdf.format(new Date());
}
//获取当前日期(精确到毫秒)
public static String getNowTimeDetail() {
SimpleDateFormat sdf = new SimpleDateFormat("HH:mm:ss.SSS");
return sdf.format(new Date());
}
//获取今天是星期几
public static String getWeekOfDate(Date date) {
String[] weekDays = {"星期日", "星期一", "星期二", "星期三", "星期四", "星期五", "星期六"};
Calendar cal = Calendar.getInstance();
cal.setTime(date);
int w = cal.get(Calendar.DAY_OF_WEEK) - 1;
if (w < 0) {
}
w = 0;
return weekDays[w];
}
//计算星期几
private static int getDayOfWeek(String dateTime) {
Calendar cal = Calendar.getInstance();
if (dateTime.equals("")) {
cal.setTime(new Date(System.currentTimeMillis()));
} else {
SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd", Locale.getDefault());
Date date;
try {
date = sdf.parse(dateTime);
} catch (ParseException e) {
date = null;
e.printStackTrace();
}
if (date != null) {
cal.setTime(new Date(date.getTime()));
}
}
return cal.get(Calendar.DAY_OF_WEEK);
}
//根据年月日计算是星期几并与当前日期判断 非昨天、今天、明天 则以星期显示
public static String Week(String dateTime) {
String week = "";
String yesterday = "";
String today = "";
String tomorrow = "";
yesterday = getYesterday(new Date());
today = getNowDate();
tomorrow = getTomorrow(new Date());
if (dateTime.equals(yesterday)) {
week = "昨天";
} else if (dateTime.equals(today)) {
week = "今天";
} else if (dateTime.equals(tomorrow)) {
week = "明天";
} else {
switch (getDayOfWeek(dateTime)) {
case 1:
week = "星期日";
break;
case 2:
week = "星期一";
break;
case 3:
week = "星期二";
break;
case 4:
week = "星期三";
break;
case 5:
week = "星期四";
break;
case 6:
week = "星期五";
break;
case 7:
week = "星期六";
break;
}
}
return week;
}
//将时间戳转化为对应的时间(10位或者13位都可以)
public static String formatTime(long time) {
String times = null;
if (String.valueOf(time).length() > 10) {// 10位的秒级别的时间戳
times = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss").format(new Date(time * 1000));
} else {// 13位的秒级别的时间戳
times = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss").format(time);
}
return times;
}
//将时间字符串转为时间戳字符串
public static String getStringTimestamp(String time) {
String timestamp = null;
try {
SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
Long longTime = sdf.parse(time).getTime() / 1000;
timestamp = Long.toString(longTime);
} catch (ParseException e) {
e.printStackTrace();
}
return timestamp;
}
}
同样再建一个KLog类，用于日志打印。
package com.llw.network.utils;
import android.text.TextUtils;
import android.util.Log;
import org.json.JSONArray;
import org.json.JSONException;
import org.json.JSONObject;
/**
* 自定义日志类
*/
public final class KLog {
private static boolean IS_SHOW_LOG = true;
private static final String DEFAULT_MESSAGE = "execute";
private static final String LINE_SEPARATOR = System.getProperty("line.separator");
private static final int JSON_INDENT = 4;
private static final int V = 0x1;
private static final int D = 0x2;
private static final int I = 0x3;
private static final int W = 0x4;
private static final int E = 0x5;
private static final int A = 0x6;
private static final int JSON = 0x7;
public static void init(boolean isShowLog) {
IS_SHOW_LOG = isShowLog;
}
public static void v() {
printLog(V, null, DEFAULT_MESSAGE);
}
public static void v(String msg) {
printLog(V, null, msg);
}
public static void v(String tag, String msg) {
printLog(V, tag, msg);
}
public static void d() {
printLog(D, null, DEFAULT_MESSAGE);
}
public static void d(String msg) {
printLog(D, null, msg);
}
public static void d(String tag, String msg) {
printLog(D, tag, msg);
}
public static void i() {
printLog(I, null, DEFAULT_MESSAGE);
}
public static void i(String msg) {
printLog(I, null, msg);
}
public static void i(String tag, String msg) {
printLog(I, tag, msg);
}
public static void w() {
printLog(W, null, DEFAULT_MESSAGE);
}
public static void w(String msg) {
printLog(W, null, msg);
}
public static void w(String tag, String msg) {
printLog(W, tag, msg);
}
public static void e() {
printLog(E, null, DEFAULT_MESSAGE);
}
public static void e(String msg) {
printLog(E, null, msg);
}
public static void e(String tag, String msg) {
printLog(E, tag, msg);
}
public static void a() {
printLog(A, null, DEFAULT_MESSAGE);
}
public static void a(String msg) {
printLog(A, null, msg);
}
public static void a(String tag, String msg) {
printLog(A, tag, msg);
}
public static void json(String jsonFormat) {
printLog(JSON, null, jsonFormat);
}
public static void json(String tag, String jsonFormat) {
printLog(JSON, tag, jsonFormat);
}
private static void printLog(int type, String tagStr, String msg) {
if (!IS_SHOW_LOG) {
return;
}
StackTraceElement[] stackTrace = Thread.currentThread().getStackTrace();
int index = 4;
String className = stackTrace[index].getFileName();
String methodName = stackTrace[index].getMethodName();
int lineNumber = stackTrace[index].getLineNumber();
String tag = (tagStr == null ? className : tagStr);
methodName = methodName.substring(0, 1).toUpperCase() + methodName.substring(1);
StringBuilder stringBuilder = new StringBuilder();
stringBuilder.append("[ (").append(className).append(":").append(lineNumber).append(")#").append(methodName).append(" ] ");
if (msg != null && type != JSON) {
stringBuilder.append(msg);
}
String logStr = stringBuilder.toString();
switch (type) {
case V:
Log.v(tag, logStr);
break;
case D:
Log.d(tag, logStr);
break;
case I:
Log.i(tag, logStr);
break;
case W:
Log.w(tag, logStr);
break;
case E:
Log.e(tag, logStr);
break;
case A:
Log.wtf(tag, logStr);
break;
case JSON: {
if (TextUtils.isEmpty(msg)) {
Log.d(tag, "Empty or Null json content");
return;
}
String message = null;
try {
if (msg.startsWith("{")) {
JSONObject jsonObject = new JSONObject(msg);
message = jsonObject.toString(JSON_INDENT);
} else if (msg.startsWith("[")) {
JSONArray jsonArray = new JSONArray(msg);
message = jsonArray.toString(JSON_INDENT);
}
} catch (JSONException e) {
e(tag, e.getCause().getMessage() + "\n" + msg);
return;
}
printLine(tag, true);
message = logStr + LINE_SEPARATOR + message;
String[] lines = message.split(LINE_SEPARATOR);
StringBuilder jsonContent = new StringBuilder();
for (String line : lines) {
jsonContent.append("║ ").append(line).append(LINE_SEPARATOR);
}
Log.d(tag, jsonContent.toString());
printLine(tag, false);
}
break;
default:
break;
}
}
private static void printLine(String tag, boolean isTop) {
if (isTop) {
Log.d(tag, "╔═══════════════════════════════════════════════════════════════════════════════════════");
} else {
Log.d(tag, "╚═══════════════════════════════════════════════════════════════════════════════════════");
}
}
}
在com.llw.network下新建一个Interceptor包，包下新建一个RequestInterceptor类，这是一个请求拦截器，里面的代码如下：
package com.llw.network.interceptor;
import com.llw.network.INetworkRequiredInfo;
import com.llw.network.utils.DateUtil;
import java.io.IOException;
import okhttp3.Interceptor;
import okhttp3.Request;
import okhttp3.Response;
/**
* 请求拦截器
* @author llw
*/
public class RequestInterceptor implements Interceptor {
/**
* 网络请求信息
*/
private INetworkRequiredInfo iNetworkRequiredInfo;
public RequestInterceptor(INetworkRequiredInfo iNetworkRequiredInfo){
this.iNetworkRequiredInfo = iNetworkRequiredInfo;
}
/**
* 拦截
*/
@Override
public Response intercept(Chain chain) throws IOException {
String nowDateTime = DateUtil.getNowDateTime();
//构建器
Request.Builder builder = chain.request().newBuilder();
//添加使用环境
builder.addHeader("os","android");
//添加版本号
builder.addHeader("appVersionCode",this.iNetworkRequiredInfo.getAppVersionCode());
//添加版本名
builder.addHeader("appVersionName",this.iNetworkRequiredInfo.getAppVersionName());
//添加日期时间
builder.addHeader("datetime",nowDateTime);
//返回
return chain.proceed(builder.build());
}
}
还有一个返回拦截器或者说是响应拦截器。
package com.llw.network.interceptor;
import com.llw.network.utils.KLog;
import java.io.IOException;
import okhttp3.Interceptor;
import okhttp3.Response;
/**
* 返回拦截器(响应拦截器)
*
* @author llw
*/
public class ResponseInterceptor implements Interceptor {
private static final String TAG = "ResponseInterceptor";
/**
* 拦截
*/
@Override
public Response intercept(Chain chain) throws IOException {
long requestTime = System.currentTimeMillis();
Response response = chain.proceed(chain.request());
KLog.i(TAG, "requestSpendTime=" + (System.currentTimeMillis() - requestTime) + "ms");
return response;
}
}
这里面也很简单就是可记录当前这个接口的请求耗费时长，这个时间在网速正常的情况下自然是越短越好，当然这个就是后期的网络方面的优化了。
那么这两个拦截器有了，下面就他们放到OkHttp中，打开NetworkApi
现在这个拦截器就会在请求网络时生效了。
下一篇我们接着自定义Observer
————————————————
版权声明：本文为CSDN博主「初学者-Study」的原创文章，
分类
已于2021-3-3 09:57:05修改
赞
收藏 1
回复
相关推荐
