前言 基于以下參考進行改良封裝
一益老、接入前準備沿彭，將下面的依賴導入工程里面
implementation 'io.reactivex.rxjava2:rxjava:2.1.0'
// 必要rxjava2依賴
implementation 'io.reactivex.rxjava2:rxandroid:2.0.1'
// 必要rxandrroid依賴，切線程時需要用到
implementation 'com.squareup.retrofit2:retrofit:2.3.0'
// 必要retrofit依賴
implementation 'com.squareup.retrofit2:adapter-rxjava2:2.3.0'
// 必要依賴朦佩，和Rxjava結合必須用到并思，
implementation 'com.squareup.retrofit2:converter-gson:2.3.0'
// 必要依賴，解析json字符所用
//非必要依賴语稠， log依賴宋彼，如果需要打印OkHttpLog需要添加
implementation 'com.squareup.okhttp3:logging-interceptor:3.8.1'
// gson轉換工廠
implementation 'com.google.code.gson:gson:2.8.5'
二、Retrofit使用講解（網上許多參考故略）
三仙畦、工程結構圖
結構圖
四输涕、封裝流程
1. 進行Retrofit的封裝
- 單例化Retrofit管理類
- 初始化okhttp
- 初始化retrofit
private static final String CACHE_PATH = "httpCache";
public static final long CACHE_SIZE = 1024 * 1024 * 100;
public static final int TIMEOUT = 15; //超時時間
private static volatile RetrofitManager mInstance;
private Retrofit mRetrofit; //retorfit對象
private OkHttpClient mOkhttpClient; //okhttp對象
private ServerApi api; //生成接口類
//單利化
public static ServerApi getServerApi() {
if (mInstance == null) {
synchronized (RetrofitManager.class) {
if (mInstance == null) {
mInstance = new RetrofitManager();
}
}
}
return mInstance.api;
}
/**
* 構造器中初始化okhttp和retrofit
*/
private RetrofitManager() {
initOkhttp();//初始化okhttp
initRetrofit(); //初始retrofit
}
/**
* 初始化retrofit
*/
private void initRetrofit() {
mRetrofit = new Retrofit.Builder()
.baseUrl(CommonConstant.BASE_URL)
.addConverterFactory(CustomGsonFactory.create())
.addCallAdapterFactory(RxJava2CallAdapterFactory.create())
.client(mOkhttpClient)
.build();
api = mRetrofit.create(ServerApi.class);
}
/**
* 初始化okhttp
*
* @return
*/
private void initOkhttp() {
//頭部參數攔截器
HeaderParamsInterceptor commonParamsInterceptor = new HeaderParamsInterceptor();
//日志參數攔截器
HttpLoggingInterceptor interceptor = new HttpLoggingInterceptor();
//關聯(lián)相應的攔截器
interceptor.setLevel(CommonConstant.IS_DEBUG ? HttpLoggingInterceptor.Level.BODY : HttpLoggingInterceptor.Level.NONE);
if (mOkhttpClient == null) {
synchronized ((RetrofitManager.class)) {
if (mOkhttpClient == null) {
//增加緩存
Cache cache = new Cache(new File(MyApplication.getInstance().getCacheDir(), CACHE_PATH), CACHE_SIZE);
mOkhttpClient = new OkHttpClient.Builder()
.cache(cache)
.addInterceptor(interceptor)
.addInterceptor(commonParamsInterceptor)
// .retryOnConnectionFailure(true)
.connectTimeout(TIMEOUT, TimeUnit.SECONDS)
.build();
}
}
}
}
/**
* 用于創(chuàng)建相關類
*
* @param clazz
* @param <T>
* @return
*/
public <T> T create(Class<T> clazz) {
if (mRetrofit != null) {
return mRetrofit.create(clazz);
}
return null;
}
2.根據要求封裝請求基類，響應基類慨畸，以及錯誤基類
- 請求基類莱坎，由于我們請求會將請求參數放在請求體中，然后通過json數據傳給服務器
public class BaseRequest<T> {
private T options;
public T getOptions() {
return options;
}
public void setOptions(T options) {
this.options = options;
}
}
- 響應基類寸士，一般情況會有msg ,code,data這三個字段
public class BaseResponse<T> {
@SerializedName(value = "code", alternate = "status")
private int code; //返回碼
private T data; //具體數據結果
private String msg; //返回信息
public int getCode() {
return code;
}
public void setCode(int code) {
this.code = code;
}
public T getData() {
return data;
}
public void setData(T data) {
this.data = data;
}
public String getMsg() {
return msg;
}
public void setMsg(String msg) {
this.msg = msg;
}
}
- 錯誤基類檐什，可以根據實際情況來碴卧，我們接口的請求放在errorbody中，故可以這樣處理乃正，但是如果放在response中通過這就需要靈活處理這個數據住册，防止類造型錯誤。
public class FailureBody {
private List data;
@SerializedName(value = "code",alternate = "status")
private int code;
private String msg;
public List getData() {
return data;
}
public void setData(List data) {
this.data = data;
}
public int getCode() {
return code;
}
public void setCode(int code) {
this.code = code;
}
public String getMsg() {
return msg;
}
public void setMsg(String msg) {
this.msg = msg;
}
}
3.Observable的生成
- 通過ObjectNetLoader這個類瓮具，簡化相應的線程切換
- 通過繼承的NetDataLoader這個類生成相應的Observable對象
public class ObjectLoader {
/**
* 用于封裝相關
* @param observable
* @param <T>
* @return
*/
protected <T> Observable<T> observer(Observable<T> observable){
return observable.subscribeOn(Schedulers.io())
.unsubscribeOn(Schedulers.io())
.observeOn(AndroidSchedulers.mainThread());
}
}
/**
* 用于對數據提前處理荧飞，同時也可用來對參數處理
* 例如合并，map ,zip或者flateMap這樣可以將不符合自己參數的數據轉換為自己想請求的參數
* 這一層是屬于module內名党，用于處理數據源区丑，供給presenter作為中間紐帶進行調用
*/
public class NetDataLoader extends ObjectLoader {
private ServerApi api;
private NetDataLoader() {
api = RetrofitManager.getServerApi();
}
public static NetDataLoader loader;
public static NetDataLoader get() {
if (loader == null) {
synchronized (NetDataLoader.class) {
if (loader == null) {
loader = new NetDataLoader();
}
}
}
return loader;
}
/*******************************請求數據*****************************************/
/************************************用戶**************************************/
//用用戶信息登錄
public Observable<BaseResponse<UserBean>> postUserLogin(ReqUserLogin bean) {
return observer(api.postUserLogin(getRequestBody(bean))); //請求參數的初步處理
}
/***********************請求數據modle類*************************************/
//用于對請求數據model修改為json數據
private <T> BaseRequest getRequestBody(T data) {
if (data == null)
return null;
BaseRequest<T> requestBody = new BaseRequest<>();
requestBody.setOptions(data);
return requestBody;
}
}
- observer的生成悍募，自定義Myobserver溪厘，既可以作為回調（供MVP中module回調接口）饰剥，也可以作為單獨使用。
/**
* @param <T>
*/
public abstract class MyObserver<T> implements io.reactivex.Observer<BaseResponse<T>> {
private Disposable d;
@Override
public void onSubscribe(Disposable d) {
SubscriptionManager.newStance().add(d);//提前添加相應的Disposable
this.d = d;
onDisposable(d);
}
@Override
public void onNext(BaseResponse<T> response) {
if (response.getCode() == 200) {//通過200說明請求成功
onSuccess(response);
}
SubscriptionManager.newStance().cancel(d);
}
@Override
public void onError(Throwable e) {
onFail(ExceptionHandle.handleException(e));
SubscriptionManager.newStance().cancel(d);
}
@Override
public void onComplete() {
onCompleted();
SubscriptionManager.newStance().cancel(d);
}
public abstract void onSuccess(BaseResponse<T> t);
public abstract void onFail(ExceptionHandle.ResponseThrowable throwable);
public abstract void onCompleted();
public abstract void onDisposable(Disposable d);
}
4.Rxjava相關管理蒋歌，防止發(fā)生內存泄漏
- 用于管理Rxjava帅掘，及時的取消訂閱，防止出現(xiàn)泄漏等情況（包括了Helper,以及管理類）
/**
* 訂閱監(jiān)聽器幫助類
* @param <T>
*/
public interface SubscriptionHelper<T> {
void add(Disposable disposable); //添加
void cancel(Disposable t); //取消
void cancelAll(); //取消所有訂閱
}
public class SubscriptionManager implements SubscriptionHelper<Object> {
public CompositeDisposable mDisposables;
private static SubscriptionManager manager;
private SubscriptionManager(){
if(mDisposables == null){
mDisposables = new CompositeDisposable();
}
}
public static SubscriptionManager newStance(){
if(manager == null){
synchronized (SubscriptionManager.class){
if(manager == null){
manager = new SubscriptionManager();
}
}
}
return manager;
}
@Override
public void add(Disposable disposable) {
if(disposable == null) return;
mDisposables.add(disposable);
}
@Override
public void cancel(Disposable t) {
if(null == t) return;
mDisposables.delete(t);
}
@Override
public void cancelAll() {
if(mDisposables != null && mDisposables.size() > 0){
if(!mDisposables.isDisposed())
mDisposables.dispose();
mDisposables.clear();
}
}
}
5.異常處理類
- 用于對錯誤和異常的同意處理堂油，通過在自定義observer中onError的回調中throwable的進行相關處理修档，從而統(tǒng)一回調給onFailure方法中，
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;
private static final int FAIL_QUEST = 406;//無法使用請求的內容特性來響應請求的網頁
private static final int BAD_REQUEST = 400;
private static ResponseBody body;
public static ResponseThrowable handleException(Throwable e) {
ResponseThrowable ex;
if (e instanceof HttpException) {
HttpException httpException = (HttpException) e;
ex = new ResponseThrowable(e, ERROR.HTTP_ERROR);
switch (httpException.code()) {
case UNAUTHORIZED:
body = ((HttpException) e).response().errorBody();
try {
String message = body.string();
FailureBody body = GsonUtil.GsonToBean(message, FailureBody.class);
ex.code = body.getCode();
ex.message = body.getMsg();
} catch (IOException e1) {
e1.printStackTrace();
}
break;
case FORBIDDEN:
ex.message = "服務器已經理解請求府框，但是拒絕執(zhí)行它";
break;
case NOT_FOUND:
body = ((HttpException) e).response().errorBody();
try {
String message = body.string();
FailureBody body = GsonUtil.GsonToBean(message, FailureBody.class);
ex.code = body.getCode();
ex.message = body.getMsg();
} catch (IOException e1) {
e1.printStackTrace();
}
break;
case REQUEST_TIMEOUT:
ex.message = "請求超時";
break;
case GATEWAY_TIMEOUT:
case INTERNAL_SERVER_ERROR:
ex.message = "服務器遇到了一個未曾預料的狀況吱窝，無法完成對請求的處理";
break;
case BAD_REQUEST:
body = ((HttpException) e).response().errorBody();
try {
String message = body.string();
FailureBody failureBody = GsonUtil.GsonToBean(message, FailureBody.class);
ex.message = failureBody.getMsg();
ex.code = failureBody.getCode();
} catch (IOException e1) {
e1.printStackTrace();
}
break;
case BAD_GATEWAY:
case SERVICE_UNAVAILABLE:
case FAIL_QUEST:
body = ((HttpException) e).response().errorBody();
try { //用于處理相關信息
String message = body.string();
Gson gson = new Gson();
// ErrorBodyDTO globalExceptionDTO = gson.fromJson(message, ErrorBodyDTO.class);
// if (globalExceptionDTO.getErrMsg() != null) {
// ex.message = globalExceptionDTO.getErrMsg();
// } else {
// ex.message = "";
// }
} catch (IOException e1) {
e1.printStackTrace();
}
break;
default:
ex.message = "網絡錯誤";
break;
}
return ex;
} else if (e instanceof ServerException) {
ServerException resultException = (ServerException) e;
ex = new ResponseThrowable(resultException, resultException.code);
ex.message = resultException.message;
return ex;
} else if (e instanceof JsonParseException
|| e instanceof JSONException
|| e instanceof ParseException) {
ex = new ResponseThrowable(e, ERROR.PARSE_ERROR);
ex.message = "解析錯誤";
return ex;
} else if (e instanceof ConnectException) {
ex = new ResponseThrowable(e, ERROR.NETWORD_ERROR);
ex.message = "連接失敗";
return ex;
} else if (e instanceof javax.net.ssl.SSLHandshakeException) {
ex = new ResponseThrowable(e, ERROR.SSL_ERROR);
ex.message = "證書驗證失敗";
return ex;
} else if (e instanceof java.net.SocketTimeoutException) {
ex = new ResponseThrowable(e, ERROR.TIMEOUT_ERROR);
//ex.message = "連接超時";
ex.message = "當前網絡連接不順暢，請稍后再試迫靖！";
return ex;
} else if (e instanceof java.net.UnknownHostException) {
ex = new ResponseThrowable(e, ERROR.TIMEOUT_ERROR);
ex.message = "網絡中斷院峡，請檢查網絡狀態(tài)！";
return ex;
} else if (e instanceof javax.net.ssl.SSLException) {
ex = new ResponseThrowable(e, ERROR.TIMEOUT_ERROR);
ex.message = "網絡中斷系宜，請檢查網絡狀態(tài)照激！";
return ex;
} else if (e instanceof java.io.EOFException) {
ex = new ResponseThrowable(e, ERROR.PARSE_EmptyERROR);
ex.message = "1007";
return ex;
} else if (e instanceof java.lang.NullPointerException) {
ex = new ResponseThrowable(e, ERROR.PARSE_EmptyERROR);
ex.message = "數據為空，顯示失敗";
return ex;
} else {
ex = new ResponseThrowable(e, ERROR.UNKNOWN);
ex.message = "未知錯誤";
return ex;
}
}
/**
* 約定異常
*/
public class ERROR {
/**
* 未知錯誤
*/
public static final int UNKNOWN = 1000;
/**
* 解析錯誤
*/
public static final int PARSE_ERROR = 1001;
/**
* 解析no content錯誤
*/
public static final int PARSE_EmptyERROR = 1007;
/**
* 網絡錯誤
*/
public static final int NETWORD_ERROR = 1002;
/**
* 協(xié)議出錯
*/
public static final int HTTP_ERROR = 1003;
/**
* 證書出錯
*/
public static final int SSL_ERROR = 1005;
/**
* 連接超時
*/
public static final int TIMEOUT_ERROR = 1006;
public static final int LOGIN_ERROR = -1000;
public static final int DATA_EMPTY = -2000;
}
public static class ResponseThrowable extends Exception {
public int code;
public String message;
public ResponseThrowable(Throwable throwable, int code) {
super(throwable);
this.code = code;
}
public ResponseThrowable(String message, int code) {
this.code = code;
this.message = message;
}
}
public class ServerException extends RuntimeException {
public int code;
public String message;
public ServerException(int code, String message) {
this.code = code;
this.message = message;
}
}
}
5.使用方法
NetDataLoader.get().postUserLogin(request).subscribe(new MyObserver<UserBean>() {
@Override
public void onSuccess(BaseResponse<UserBean> t) {
}
@Override
public void onFail(ExceptionHandle.ResponseThrowable throwable) {
}
@Override
public void onCompleted() {
}
@Override
public void onDisposable(Disposable d) {
}
});
