基於RxJava2+Retrofit2簡單易用的網絡請求實現

代碼地址如下：
http://www.demodashi.com/demo/13473.html

簡介

基於RxJava2+Retrofit2實現簡單易用的網絡請求，結合android平台特性的網絡封裝庫,采用api鏈式調用一點到底,集成cookie管理,多種緩存模式,極簡https配置,上傳下載進度顯示,請求錯誤自動重試,請求攜帶token、時間戳、簽名sign動態配置,自動登錄成功后請求重發功能,3種層次的參數設置默認全局局部,默認標准ApiResult同時可以支持自定義的數據結構，已經能滿足現在的大部分網絡請求。

特點

• 比Retrofit使用更簡單、更易用。
• 采用鏈式調用一點到底
• 加入基礎ApiService，減少Api冗余
• 支持動態配置和自定義底層框架Okhttpclient、Retrofit.
• 支持多種方式訪問網絡GET、POST、PUT、DELETE等請求協議
• 支持網絡緩存,八種緩存策略可選,涵蓋大多數業務場景
• 支持固定添加header和動態添加header
• 支持添加全局參數和動態添加局部參數
• 支持文件下載、多文件上傳和表單提交數據
• 支持文件請求、上傳、下載的進度回調、錯誤回調，也可以自定義回調
• 支持默認、全局、局部三個層次的配置功能
• 支持任意數據結構的自動解析
• 支持添加動態參數例如timeStamp時間戳、token、簽名sign
• 支持自定義的擴展API
• 支持多個請求合並
• 支持Cookie管理
• 支持異步、同步請求
• 支持Https、自簽名網站Https的訪問、雙向驗證
• 支持失敗重試機制，可以指定重試次數、重試間隔時間
• 支持根據ky刪除網絡緩存和清空網絡緩存
• 提供默認的標准ApiResult解析和回調，並且可自定義ApiResult
• 支持取消數據請求，取消訂閱，帶有對話框的請求不需要手動取消請求，對話框消失會自動取消請求
• 支持請求數據結果采用回調和訂閱兩種方式
• api設計上結合http協議和android平台特點來實現,loading對話框,實時進度條顯示
• 返回結果和異常統一處理
• 結合RxJava2，線程智能控制

演示

全局配置

一般在 Aplication，或者基類中，只需要調用一次即可，可以配置調試開關，全局的超時時間，公共的請求頭和請求參數等信息
初始化需要一個Context，最好在Application#onCreate()中初始化，記得在manifest.xml中注冊Application。

Application:

public class MyApplication extends Application {
    @Override
    public void onCreate() {
        super.onCreate();
    }
}

manifest.xml：

...

<application
    android:name=".MyApplication"
    ...
 />

默認初始化

如果使用默認始化后，一切采用默認設置。如果你需要配置全局超時時間、緩存、Cookie、底層為OkHttp的話，請看高級初始化。

public class MyApplication extends Application {

    @Override
    public void onCreate() {
        super.onCreate();
        EasyHttp.init(this);//默認初始化
    }
}

高級初始化

可以進行超時配置、網絡緩存配置、okhttp相關參數配置、retrofit相關參數配置、cookie配置等，這些參數可以選擇性的根據業務需要配置。

public class MyApplication extends Application {

    @Override
    public void onCreate() {
        super.onCreate();
        EasyHttp.init(this);//默認初始化,必須調用

        //全局設置請求頭
        HttpHeaders headers = new HttpHeaders();
        headers.put("User-Agent", SystemInfoUtils.getUserAgent(this, AppConstant.APPID));
        //全局設置請求參數
        HttpParams params = new HttpParams();
        params.put("appId", AppConstant.APPID);

        //以下設置的所有參數是全局參數,同樣的參數可以在請求的時候再設置一遍,那么對於該請求來講,請求中的參數會覆蓋全局參數
        EasyHttp.getInstance()
        
                //可以全局統一設置全局URL
                .setBaseUrl(Url)//設置全局URL  url只能是域名 或者域名+端口號 

                // 打開該調試開關並設置TAG,不需要就不要加入該行
                // 最后的true表示是否打印內部異常，一般打開方便調試錯誤
                .debug("EasyHttp", true)
                
                //如果使用默認的60秒,以下三行也不需要設置
                .setReadTimeOut(60 * 1000)
                .setWriteTimeOut(60 * 100)
                .setConnectTimeout(60 * 100)
                
                //可以全局統一設置超時重連次數,默認為3次,那么最差的情況會請求4次(一次原始請求,三次重連請求),
                //不需要可以設置為0
                .setRetryCount(3)//網絡不好自動重試3次
                //可以全局統一設置超時重試間隔時間,默認為500ms,不需要可以設置為0
                .setRetryDelay(500)//每次延時500ms重試
                //可以全局統一設置超時重試間隔疊加時間,默認為0ms不疊加
                .setRetryIncreaseDelay(500)//每次延時疊加500ms
                
                //可以全局統一設置緩存模式,默認是不使用緩存,可以不傳,具體請看CacheMode
                .setCacheMode(CacheMode.NO_CACHE)
                //可以全局統一設置緩存時間,默認永不過期
                .setCacheTime(-1)//-1表示永久緩存,單位:秒 ，Okhttp和自定義RxCache緩存都起作用
                //全局設置自定義緩存保存轉換器，主要針對自定義RxCache緩存
                .setCacheDiskConverter(new SerializableDiskConverter())//默認緩存使用序列化轉化
                //全局設置自定義緩存大小，默認50M
                .setCacheMaxSize(100 * 1024 * 1024)//設置緩存大小為100M
                //設置緩存版本，如果緩存有變化，修改版本后，緩存就不會被加載。特別是用於版本重大升級時緩存不能使用的情況
                .setCacheVersion(1)//緩存版本為1
                //.setHttpCache(new Cache())//設置Okhttp緩存，在緩存模式為DEFAULT才起作用
                
                //可以設置https的證書,以下幾種方案根據需要自己設置
                .setCertificates()                                  //方法一：信任所有證書,不安全有風險
                //.setCertificates(new SafeTrustManager())            //方法二：自定義信任規則，校驗服務端證書
                //配置https的域名匹配規則，不需要就不要加入，使用不當會導致https握手失敗
                //.setHostnameVerifier(new SafeHostnameVerifier())
                //.addConverterFactory(GsonConverterFactory.create(gson))//本框架沒有采用Retrofit的Gson轉化，所以不用配置
                .addCommonHeaders(headers)//設置全局公共頭
                .addCommonParams(params)//設置全局公共參數
                //.addNetworkInterceptor(new NoCacheInterceptor())//設置網絡攔截器
                //.setCallFactory()//局設置Retrofit對象Factory
                //.setCookieStore()//設置cookie
                //.setOkproxy()//設置全局代理
                //.setOkconnectionPool()//設置請求連接池
                //.setCallbackExecutor()//全局設置Retrofit callbackExecutor
                //可以添加全局攔截器，不需要就不要加入，錯誤寫法直接導致任何回調不執行
                //.addInterceptor(new GzipRequestInterceptor())//開啟post數據進行gzip后發送給服務器
                .addInterceptor(new CustomSignInterceptor());//添加參數簽名攔截器
    }
}

請求數據

網絡請求，采用鏈式調用，支持一點到底。

入口方法

  /**
     * get請求
     */
    public static GetRequest get(String url);

    /**
     * post請求和文件上傳
     */
    public static PostRequest post(String url);

    /**
     * delete請求
     */
    public static DeleteRequest delete(String url) ;

    /**
     * 自定義請求
     */
    public static CustomRequest custom();

    /**
     * 文件下載
     */
    public static DownloadRequest downLoad(String url) ;

    /**
     * put請求
     */
    public static PutRequest put(String url);

通用功能配置

1.包含一次普通請求所有能配置的參數，真實使用時不需要配置這么多，按自己的需要選擇性的使用即可

2.以下配置全部是單次請求配置，不會影響全局配置，沒有配置的仍然是使用全局參數。

3.為單個請求設置超時，比如涉及到文件的需要設置讀寫等待時間多一點。

完整參數GET示例：

EasyHttp.get("/v1/app/chairdressing/skinAnalyzePower/skinTestResult")
                .baseUrl("http://www.xxxx.com")//設置url
                .writeTimeOut(30*1000)//局部寫超時30s,單位毫秒
                .readTimeOut(30*1000)//局部讀超時30s,單位毫秒
                .connectTimeout(30*1000)//局部連接超時30s,單位毫秒
                .headers(new HttpHeaders("header1","header1Value"))//添加請求頭參數
                .headers("header2","header2Value")//支持添加多個請求頭同時添加
                .headers("header3","header3Value")//支持添加多個請求頭同時添加
                .params("param1","param1Value")//支持添加多個參數同時添加
                .params("param2","param2Value")//支持添加多個參數同時添加
                //.addCookie(new CookieManger(this).addCookies())//支持添加Cookie
                .cacheTime(300)//緩存300s 單位s
                .cacheKey("cachekey")//緩存key
                .cacheMode(CacheMode.CACHEANDREMOTE)//設置請求緩存模式
                //.okCache()//使用模式緩存模式時，走Okhttp緩存
                .cacheDiskConverter(new GsonDiskConverter())//GSON-數據轉換器
                //.certificates()添加證書
                .retryCount(5)//本次請求重試次數
                .retryDelay(500)//本次請求重試延遲時間500ms
                .addInterceptor(Interceptor)//添加攔截器
                .okproxy()//設置代理
                .removeHeader("header2")//移除頭部header2
                .removeAllHeaders()//移除全部請求頭
                .removeParam("param1")
                .accessToken(true)//本次請求是否追加token
                .timeStamp(false)//本次請求是否攜帶時間戳
                .sign(false)//本次請求是否需要簽名
                .syncRequest(true)//是否是同步請求，默認異步請求。true:同步請求
                .execute(new CallBack<SkinTestResult>() {
                    @Override
                    public void onStart() {
                        //開始請求
                    }

                    @Override
                    public void onCompleted() {
                       //請求完成
                    }

                    @Override
                    public void onError(ApiException e) {
                      //請求錯誤
                    }

                    @Override
                    public void onSuccess(SkinTestResult response) {
                      //請求成功
                    }
                });

url

Url可以通過初始化配置的時候傳入EasyHttp.getInstance().setBaseUrl("http://www.xxx.com");
入口方法傳入： EasyHttp.get("/v1/app/chairdressing/skinAnalyzePower/skinTestResult").baseUrl("http://www.xxxx.com")
如果入口方法中傳入的url含有http或者https,則不會拼接初始化設置的baseUrl.
例如：EasyHttp.get("http://www.xxx.com/v1/app/chairdressing/skinAnalyzePower/skinTestResult")則setBaseUrl()和baseUrl()傳入的baseurl都不會被拼接。
注:EasyHttp.get/post/put/等采用拼接的用法時請注意，url要用/斜杠開頭，例如：EasyHttp.get("/v1/login") 正確 EasyHttp.get("v1/login") 錯誤

http請求參數

兩種設置方式
.params(HttpParams params)
.params("param1","param1Value")//添加參數鍵值對

HttpParams params = new HttpParams();
params.put("appId", AppConstant.APPID);
.addCommonParams(params)//設置全局公共參數

http請求頭

.headers(HttpHeaders headers)
.headers("header2","header2Value")//添加參數鍵值對

.addCommonHeaders(headers)//設置全局公共頭

普通網絡請求

支持get/post/delete/put等
鏈式調用的終點請求的執行方式有：execute(Class clazz) 、execute(Type type)、execute(CallBack callBack)三種方式，都是針對標准的ApiResult

execute(CallBack callBack)

1.EasyHttp（推薦）
示例：

方式一：
 //EasyHttp.post("/v1/app/chairdressing/skinAnalyzePower/skinTestResult")
 EasyHttp.get("/v1/app/chairdressing/skinAnalyzePower/skinTestResult")
                .readTimeOut(30 * 1000)//局部定義讀超時
                .writeTimeOut(30 * 1000)
                .connectTimeout(30 * 1000)
                .params("name","張三")
                .timeStamp(true)
                .execute(new SimpleCallBack<SkinTestResult>() {
                    @Override
                    public void onError(ApiException e) {
                        showToast(e.getMessage());
                    }

                    @Override
                    public void onSuccess(SkinTestResult response) {
                        if (response != null) showToast(response.toString());
                    }
                });

2.手動創建請求對象

 //GetRequest 、PostRequest、DeleteRequest、PutRequest
 GetRequest request = new GetRequest("/v1/app/chairdressing/skinAnalyzePower/skinTestResult");
        request.readTimeOut(30 * 1000)//局部定義讀超時
                .params("param1", "param1Value1")
                .execute(new SimpleCallBack<SkinTestResult>() {
                    @Override
                    public void onError(ApiException e) {

                    }

                    @Override
                    public void onSuccess(SkinTestResult response) {

                    }
                });

execute(Class clazz)和execute(Type type)

execute(Class clazz)和execute(Type type)功能基本一樣，execute(Type type)主要是針對集合不能直接傳遞Class

EasyHttp.get(url)
                .params("param1", "paramValue1")
                .execute(SkinTestResult.class)//非常簡單直接傳目標class
                //.execute(new TypeToken<List<SectionItem>>() {}.getType())//Type類型
                .subscribe(new BaseSubscriber<SkinTestResult>() {
                    @Override
                    public void onError(ApiException e) {
                        showToast(e.getMessage());
                    }

                    @Override
                    public void onNext(SkinTestResult skinTestResult) {
                        showToast(skinTestResult.toString());
                    }
                });

請求返回Disposable

網絡請求會返回Disposable對象，方便取消網絡請求

Disposable disposable = EasyHttp.get("/v1/app/chairdressing/skinAnalyzePower/skinTestResult")
                .params("param1", "paramValue1")
                .execute(new SimpleCallBack<SkinTestResult>() {
                    @Override
                    public void onError(ApiException e) {
                        showToast(e.getMessage());
                    }

                    @Override
                    public void onSuccess(SkinTestResult response) {
                        showToast(response.toString());
                    }
                });

        //在需要取消網絡請求的地方調用,一般在onDestroy()中
        //EasyHttp.cancelSubscription(disposable);

帶有進度框的請求

帶有進度框的請求，可以設置對話框消失是否自動取消網絡和自定義對話框功能，具體參數作用請看請求回調講解

方式一：ProgressDialogCallBack

ProgressDialogCallBack帶有進度框的請求，可以設置對話框消失是否自動取消網絡和自定義對話框功能，具體參數作用請看自定義CallBack講解

 IProgressDialog mProgressDialog = new IProgressDialog() {
            @Override
            public Dialog getDialog() {
                ProgressDialog dialog = new ProgressDialog(MainActivity.this);
                dialog.setMessage("請稍候...");
                return dialog;
            }
        };
        EasyHttp.get("/v1/app/chairdressing/")
                .params("param1", "paramValue1")
                .execute(new ProgressDialogCallBack<SkinTestResult>(mProgressDialog, true, true) {
                    @Override
                    public void onError(ApiException e) {
                        super.onError(e);//super.onError(e)必須寫不能刪掉或者忘記了
                        //請求失敗
                    }

                    @Override
                    public void onSuccess(SkinTestResult response) {
                       //請求成功
                    }
                });

注：錯誤回調 super.onError(e);必須寫

方式二：ProgressSubscriber

IProgressDialog mProgressDialog = new IProgressDialog() {
            @Override
            public Dialog getDialog() {
                ProgressDialog dialog = new ProgressDialog(MainActivity.this);
                dialog.setMessage("請稍候...");
                return dialog;
            }
        };
 EasyHttp.get(URL)
                .timeStamp(true)
                .execute(SkinTestResult.class)
                .subscribe(new ProgressSubscriber<SkinTestResult>(this, mProgressDialog) {
                    @Override
                    public void onError(ApiException e) {
                        super.onError(e);
                        showToast(e.getMessage());
                    }

                    @Override
                    public void onNext(SkinTestResult skinTestResult) {
                        showToast(skinTestResult.toString());
                    }
                });

請求返回Observable

通過網絡請求可以返回Observable，這樣就可以很好的通過Rxjava與其它場景業務結合處理，甚至可以通過Rxjava的connect()操作符處理多個網絡請求。例如：在一個頁面有多個網絡請求，如何在多個請求都訪問成功后再顯示頁面呢？這也是Rxjava強大之處。
注：目前通過execute(Class clazz)方式只支持標注的ApiResult結構，不支持自定義的ApiResult
示例：

Observable<SkinTestResult> observable = EasyHttp.get(url)
                .params("param1", "paramValue1")
                .execute(SkinTestResult.class);

        observable.subscribe(new BaseSubscriber<SkinTestResult>() {
            @Override
            public void onError(ApiException e) {
                showToast(e.getMessage());
            }

            @Override
            public void onNext(SkinTestResult skinTestResult) {
                showToast(skinTestResult.toString());
            }
        });

文件下載

本庫提供的文件下載非常簡單，沒有提供復雜的下載方式例如：下載管理器、斷點續傳、多線程下載等，因為不想把本庫做重。如果復雜的下載方式，還請考慮其它下載方案。
文件目錄如果不指定,默認下載的目錄為/storage/emulated/0/Android/data/包名/files
文件名如果不指定,則按照以下規則命名:

1.首先檢查用戶是否傳入了文件名,如果傳入,將以用戶傳入的文件名命名
2.如果沒有傳入文件名，默認名字是時間戳生成的。
3.如果傳入了文件名但是沒有后綴，程序會自動解析類型追加后綴名

示例：

 String url = "http://61.144.207.146:8081/b8154d3d-4166-4561-ad8d-7188a96eb195/2005/07/6c/076ce42f-3a78-4b5b-9aae-3c2959b7b1ba/kfid/2475751/qqlite_3.5.0.660_android_r108360_GuanWang_537047121_release_10000484.apk";
        EasyHttp.downLoad(url)
                .savePath("/sdcard/test/QQ")
                .saveName("release_10000484.apk")//不設置默認名字是時間戳生成的
                .execute(new DownloadProgressCallBack<String>() {
                    @Override
                    public void update(long bytesRead, long contentLength, boolean done) {
                        int progress = (int) (bytesRead * 100 / contentLength);
                        HttpLog.e(progress + "% ");
                        dialog.setProgress(progress);
                        if (done) {//下載完成
                        }
                        ...
                    }

                    @Override
                    public void onStart() {
                       //開始下載
                    }

                    @Override
                    public void onComplete(String path) {
                       //下載完成，path：下載文件保存的完整路徑
                    }

                    @Override
                    public void onError(ApiException e) {
                        //下載失敗
                    }
                });

POST請求，上傳String、json、object、body、byte[]

一般此種用法用於與服務器約定的數據格式，當使用該方法時，params中的參數設置是無效的，所有參數均需要通過需要上傳的文本中指定，此外，額外指定的header參數仍然保持有效。

• .upString("這是要上傳的長文本數據！")//默認類型是：MediaType.parse("text/plain")
• 如果你對請求頭有自己的要求，可以使用這個重載的形式，傳入自定義的content-type文本
  upString("這是要上傳的長文本數據！", "application/xml") // 比如上傳xml數據，這里就可以自己指定請求頭
• upJson該方法與upString沒有本質區別，只是數據格式是json,通常需要自己創建一個實體bean或者一個map，把需要的參數設置進去，然后通過三方的Gson或者 fastjson轉換成json字符串，最后直接使用該方法提交到服務器。
  .upJson(jsonObject.toString())//上傳json
• .upBytes(new byte[]{})//上傳byte[]
• .requestBody(body)//上傳自定義RequestBody
• .upObject(object)//上傳對象object 必須要增加.addConverterFactory(GsonConverterFactory.create())設置

1.upString、upJson、requestBody、upBytes、upObject五個方法不能同時使用，當前只能選用一個
2.使用upJson、upObject時候params、sign(true/false)、accessToken（true/false）、攔截器都不會起作用

示例：

HashMap<String, String> params = new HashMap<>();
params.put("key1", "value1");
params.put("key2", "這里是需要提交的json格式數據");
params.put("key3", "也可以使用三方工具將對象轉成json字符串");
JSONObject jsonObject = new JSONObject(params);

RequestBody body=RequestBody.create(MediaType.parse("xxx/xx"),"內容");
EasyHttp.post("v1/app/chairdressing/news/favorite")
                //.params("param1", "paramValue1")//不能使用params，upString 與 params 是互斥的，只有 upString 的數據會被上傳
                .upString("這里是要上傳的文本！")//默認類型是：MediaType.parse("text/plain")
                //.upString("這是要上傳的長文本數據！", "application/xml") // 比如上傳xml數據，這里就可以自己指定請求頭
                
                 //.upJson(jsonObject.toString())
                 //.requestBody(body)
                 //.upBytes(new byte[]{})
                 //.upObject(object)
                .execute(new SimpleCallBack<String>() {
                    @Override
                    public void onError(ApiException e) {
                        showToast(e.getMessage());
                    }

                    @Override
                    public void onSuccess(String response) {
                        showToast(response);
                    }
                });

上傳圖片或者文件

支持單文件上傳、多文件上傳、混合上傳，同時支持進度回調，
暫不實現多線程上傳/分片上傳/斷點續傳等高級功能

上傳文件支持文件與參數一起同時上傳，也支持一個key上傳多個文件，以下方式可以任選
上傳文件支持兩種進度回調：ProgressResponseCallBack(線程中回調)和UIProgressResponseCallBack（可以刷新UI）

final UIProgressResponseCallBack listener = new UIProgressResponseCallBack() {
            @Override
            public void onUIResponseProgress(long bytesRead, long contentLength, boolean done) {
                int progress = (int) (bytesRead * 100 / contentLength);
                if (done) {//完成
                }
                ...
            }
        };
        EasyHttp.post("/v1/user/uploadAvatar")
                //支持上傳新增的參數
                //.params(String key, File file, ProgressResponseCallBack responseCallBack)
                //.params(String key, InputStream stream, String fileName, ProgressResponseCallBack responseCallBack)
                //.params(String key, byte[] bytes, String fileName, ProgressResponseCallBack responseCallBack) 
                //.addFileParams(String key, List<File> files, ProgressResponseCallBack responseCallBack)
                //.addFileWrapperParams(String key, List<HttpParams.FileWrapper> fileWrappers)
                //.params(String key, File file, String fileName, ProgressResponseCallBack responseCallBack)
                //.params(String key, T file, String fileName, MediaType contentType, ProgressResponseCallBack responseCallBack)
                
                //方式一：文件上傳
                File file = new File("/sdcard/1.jpg");
                //如果有文件名字可以不用再傳Type,會自動解析到是image/*
                .params("avatar", file, file.getName(), listener)
                //.params("avatar", file, file.getName(),MediaType.parse("image/*"), listener)

                //方式二：InputStream上傳
               final InputStream inputStream = getResources().getAssets().open("1.jpg");
                .params("avatar", inputStream, "test.png", listener)
                
                //方式三：byte[]上傳
                Bitmap bitmap = BitmapFactory.decodeResource(getResources(), R.mipmap.test);
                ByteArrayOutputStream baos = new ByteArrayOutputStream();
                bitmap.compress(Bitmap.CompressFormat.PNG, 100, baos);
                final byte[] bytes = baos.toByteArray();
                //.params("avatar",bytes,"streamfile.png",MediaType.parse("image/*"),listener)
                //如果有文件名字可以不用再傳Type,會自動解析到是image/*
                .params("avatar", bytes, "streamfile.png", listener)
        
                .params("file1", new File("filepath1"))   // 可以添加文件上傳
	            .params("file2", new File("filepath2")) 	// 支持多文件同時添加上傳
	            .addFileParams("key", List<File> files)	// 這里支持一個key傳多個文件
                .params("param1", "paramValue1") 		// 這里可以上傳參數
                .accessToken(true)
                .timeStamp(true)
                .execute(new ProgressDialogCallBack<String>(mProgressDialog, true, true) {
                    @Override
                    public void onError(ApiException e) {
                        super.onError(e);
                        showToast(e.getMessage());
                    }

                    @Override
                    public void onSuccess(String response) {
                        showToast(response);
                    }
                });

取消請求

通過Disposable取消

每個請求前都會返回一個Disposable，取消訂閱就可以取消網絡請求，如果是帶有進度框的網絡請求，則不需要手動取消網絡請求，會自動取消。

 Disposable mSubscription = EasyHttp.get(url).execute(callback);
  ...
  @Override
    protected void onDestroy() {
        super.onDestroy();
        EasyHttp.cancelSubscription(mSubscription);
    }

通過dialog取消

自動取消使用ProgressDialogCallBack回調或者使用ProgressSubscriber,就不用再手動調用cancelSubscription();
ProgressDialogCallBack:

EasyHttp.get(url).execute(new ProgressDialogCallBack());

ProgressSubscriber

EasyHttp.get(url).execute(SkinTestResult.class).subscribe(new ProgressSubscriber<SkinTestResult>(this, mProgressDialog) {
            @Override
            public void onError(ApiException e) {
                super.onError(e);
                showToast(e.getMessage());
            }

            @Override
            public void onNext(SkinTestResult skinTestResult) {
                showToast(skinTestResult.toString());
            }
        })

同步請求

同步請求只需要設置syncRequest()方法

 EasyHttp.get("/v1/app/chairdressing/skinAnalyzePower/skinTestResult")
                ...
                .syncRequest(true)//設置同步請求
                .execute(new CallBack<SkinTestResult>() {});

請求回調CallBack支持的類型

//支持回調的類型可以是Bean、String、CacheResult<Bean>、CacheResult<String>、List<Bean>
new SimpleCallBack<CacheResult<Bean>>()//支持緩存的回調，請看緩存講解
new SimpleCallBack<CacheResult<String>>()//支持緩存的回調，請看緩存講解
new SimpleCallBack<Bean>()//返回Bean
new SimpleCallBack<String>()//返回字符串
new SimpleCallBack<List<Bean>()//返回集合

注：其它回調同理

cookie使用

cookie的內容主要包括：名字，值，過期時間，路徑和域。路徑與域一起構成cookie的作用范圍,關於cookie的作用這里就不再科普，自己可以去了解
cookie設置：

EasyHttp.getInstance()
   				 ...
                  //如果不想讓本庫管理cookie,以下不需要
                .setCookieStore(new CookieManger(this)) //cookie持久化存儲，如果cookie不過期，則一直有效
                 ...

• 查看url所對應的cookie

HttpUrl httpUrl = HttpUrl.parse("http://www.xxx.com/test");
CookieManger cookieManger = getCookieJar();
List<Cookie> cookies =  cookieManger.loadForRequest(httpUrl);

• 查看CookieManger所有cookie

PersistentCookieStore cookieStore= getCookieJar().getCookieStore();
List<Cookie> cookies1= cookieStore.getCookies();

• 添加cookie

Cookie.Builder builder = new Cookie.Builder();
Cookie cookie = builder.name("mCookieKey1").value("mCookieValue1").domain(httpUrl.host()).build();
CookieManger cookieManger = getCookieJar();
cookieManger.saveFromResponse(httpUrl, cookie);
//cookieStore.saveFromResponse(httpUrl, cookieList);//添加cookie集合

• 移除cookie

HttpUrl httpUrl = HttpUrl.parse("http://www.xxx.com/test");
CookieManger cookieManger = EasyHttp.getCookieJar();
Cookie cookie = builder.name("mCookieKey1").value("mCookieValue1").domain(httpUrl.host()).build();
cookieManger.remove(httpUrl,cookie);

• 清空cookie

CookieManger cookieManger = EasyHttp.getCookieJar();
cookieManger.removeAll();

自定義call()請求

提供了用戶自定義ApiService的接口，您只需調用call方法即可.
示例：

public interface LoginService {
    @POST("{path}")
    @FormUrlEncoded
    Observable<ApiResult<AuthModel>> login(@Path("path") String path, @FieldMap Map<String, String> map);
}

final CustomRequest request = EasyHttp.custom()
                .addConverterFactory(GsonConverterFactory.create(new Gson()))//自定義的可以設置GsonConverterFactory
                .params("param1", "paramValue1")
                .build();

        LoginService mLoginService = request.create(LoginService.class);
        LoginService mLoginService = request.create(LoginService.class);
        Observable<ApiResult<AuthModel>> observable = request.call(mLoginService.login("v1/account/login", request.getParams().urlParamsMap));
        Disposable subscription = observable.subscribe(new Action1<ApiResult<AuthModel>>() {
            @Override
            public void call(ApiResult<AuthModel> result) {
                //請求成功
            }
        }, new Action1<Throwable>() {
            @Override
            public void call(Throwable throwable) {
                //請求失敗
            }
        });

自定義apiCall()請求

提供默認的支持ApiResult結構，數據返回不需要帶ApiResult,直接返回目標.
示例：

Observable<AuthModel> observable = request.apiCall(mLoginService.login("v1/account/login", request.getParams().urlParamsMap));

請求回調和訂閱

請求回調本庫提供兩種方式Callback和Subscriber

回調方式

此種方式主要針對execute(CallBack callBack)，目前內部提供的回調包含CallBack, SimpleCallBack ,ProgressDialogCallBack ,DownloadProgressCallBack 可以根據自己的需求去自定義Callback

• CallBack所有回調的基類，抽象類
• SimpleCallBack簡單回調，只有成功和失敗
• ProgressDialogCallBack帶有進度框的回調，可以自定義進度框、支持是否可以取消對話框、對話框消失自動取消網絡請求等參數設置
• DownloadProgressCallBack如果要做文件下載，則必須使用該回調，內部封裝了關於文件下載進度回調的方法，如果使用其他回調也可以，但是沒有進度通知

該網絡框架的核心使用方法即為Callback的繼承使用，因為不同的項目需求，會有個性化的回調請自定義

CallBack回調

new CallBack<T>() {
                    @Override
                    public void onStart() {
                       //請求開始
                    }

                    @Override
                    public void onCompleted() {
                       //請求完成
                    }

                    @Override
                    public void onError(ApiException e) {
                       //請求失敗
                    }

                    @Override
                    public void onSuccess(T t) {
                       //請求成功
                    }
                }

SimpleCallBack回調

new SimpleCallBack<T>() {
                    @Override
                    public void onError(ApiException e) {
                         //請求失敗
                    }

                    @Override
                    public void onSuccess(T t) {
                        //請求成功
                    }
                }

ProgressDialogCallBack回調

可以自定義帶有加載進度框的回調，取消對話框會自動取消掉網絡請求

提供兩個構造

public ProgressDialogCallBack(IProgressDialog progressDialog);//默認不能取消對話框
public ProgressDialogCallBack(IProgressDialog progressDialog, boolean isShowProgress, boolean isCancel);//自定義加載進度框,可以設置是否顯示彈出框，是否可以取消 progressDialog: dialog對象接口 isShowProgress：對話框消失是否取消網絡請求 isCancel：是否可以取消對話框對應Dialog的setCancelable(isCancel)方法;

自定義ProgressDialog對話框

 private IProgressDialog mProgressDialog = new IProgressDialog() {
        @Override
        public Dialog getDialog() {
            ProgressDialog dialog = new ProgressDialog(MainActivity.this);
            dialog.setMessage("請稍候...");
            return dialog;
        }
    };

DownloadProgressCallBack回調

此回調只用於文件下載，具體請看文件下載講解

自定義CallBack回調

如果對回調有特殊需求，支持可以繼承CallBack自己擴展功能

訂閱方式

此種方式主要是針對execute(Class clazz)和execute(Type type)，目前內部提供的Subscriber包含BaseSubscriber、DownloadSubscriber、ProgressSubscriber，可以根據自己的需求去自定義Subscriber

• BaseSubscriber所有訂閱者的基類，抽象類
• DownloadSubscriber下載的訂閱者，上層不需要關注
• ProgressSubscriber帶有進度框的訂閱，可以自定義進度框、支持是否可以取消對話框、對話框消失自動取消網絡請求等參數設置

new BaseSubscriber<T>() {
            @Override
            public void onError(ApiException e) {
               //請求失敗
            }

            @Override
            public void onNext(T t) {
                //請求成功
            }
        }

new ProgressSubscriber<T>(this, mProgressDialog) {
                    @Override
                    public void onError(ApiException e) {
                        super.onError(e);
                        //請求失敗
                    }

                    @Override
                    public void onNext(T t) {
                         //請求成功
                    }
                }

自定義Subscriber

如果對Subscriber有特殊需求，支持可以繼承BaseSubscriber自己擴展訂閱者

緩存使用

緩存介紹

本庫的緩存主要分okhttp的Cache緩存和自定義的RxCache緩存,大家有疑問okhttp有緩存，retrofit也是支持通過header來設置緩存，為什么還要自定義一個緩存機制呢？通過自定義RxCache緩存使用更簡單，更符合我們常用的業務需求(常用的緩存策略也不會太復雜)， retrofit的緩存借助於okhttp通過攔截器interceptor實現或者通過@Headers("Cache-Control: public, max-age=3600)具體用法這里不做詳細描述，有興趣的可以自己去了解。動態修改緩存時間不方便，例如：同一個接口，不同時間段請求的內容緩存的時間不一樣，需要動態修改。

對於DEFAULT模式是okhttp的Cache緩存。因為該模式是完全遵循標准的http協議的,緩存時間是依靠服務端響應頭來控制，也可以通過攔截器自己處理

對於RxCache的緩存支持多種存儲方式，提供IDiskConverter轉換器接口目前支持SerializableDiskConverter和GsonDiskConverter兩種方式，也可以自定義Parcelable、fastjson、xml、kryo等轉換器
SerializableDiskConverter
使用緩存前，必須讓緩存的數據所有javaBean對象實現Serializable接口，否則會報NotSerializableException。 因為緩存的原理是將對象序列化后保存，如果不實現Serializable接口，會導致對象無法序列化，進而無法保存，也就達不到緩存的效果。
優點：存儲和讀取都不用再轉化直接就是需要的對象速度快
缺點：如果javabean里面還有javabean且層級比較多，也必須每個都要實現Serializable接口，比較麻煩
GsonDiskConverter
此種方式就是以json字符串的方式存儲
優點：相對於SerializableDiskConverter轉換器，存儲的對象不需要進行序列化
缺點：就是存儲和讀取都要使用Gson進行轉換，object->String->Object的給一個過程，相對來說每次都要轉換性能略低，但是性能基本忽略不計

目前提供了八種CacheMode緩存模式,每種緩存模式都可以指定對應的CacheTime,將復雜常用的業務場景封裝在里面，讓你不用關心緩存的具體實現，而專注於數據的處理

• NO_CACHE：不使用緩存,該模式下,cacheKey,cacheTime 等參數均無效
• DEFAULT：按照HTTP協議的默認緩存規則，走OKhttp的Cache緩存
• FIRSTREMOTE：先請求網絡，請求網絡失敗后再加載緩存
• FIRSTCACHE：先加載緩存，緩存沒有再去請求網絡
• ONLYREMOTE：僅加載網絡，但數據依然會被緩存
• ONLYCACHE：只讀取緩存，緩存沒有會返回null
• CACHEANDREMOTE:先使用緩存，不管是否存在，仍然請求網絡，CallBack會回調兩次.
• CACHEANDREMOTEDISTINCT:先使用緩存，不管是否存在，仍然請求網絡，CallBack回調不一定是兩次，如果發現請求的網絡數據和緩存數據是一樣的，就不會再返回網絡的回調,既回調一次。否則不相同仍然會回調兩次。（目的是為了防止數據沒有發生變化，也需要回調兩次導致界面無用的重復刷新）,此種模式緩存的對象bean一定要重寫tostring()方法

注：無論對於哪種緩存模式，都可以指定一個cacheKey，建議針對不同需要緩存的頁面設置不同的cacheKey，如果相同，會導致數據覆蓋。

緩存設置

緩存設置有兩種方式
方式一：全局設置，所有請求都會默認使用此模式

 EasyHttp.getInstance()
 				...
                .setCacheMode(CacheMode.CACHEANDREMOTE)//不設置默認是NO_CACHE模式
                ...

方式二：單個請求設置緩存模式

 EasyHttp.get(URL)
 				...
                .cacheMode(CacheMode.FIRSTREMOTE)
                ...

設置轉換器

方式一：全局設置，所有請求都會默認使用此存儲轉換器

EasyHttp.getInstance().setCacheDiskConverter(new SerializableDiskConverter())//默認緩存使用序列化轉化

方式二：單個請求設置存儲轉換器

EasyHttp.get(URL).cacheDiskConverter(new GsonDiskConverter());

注：一個請求就選用一種轉換器，切記不要使用SerializableDiskConverter來緩存，又用GsonDiskConverter來讀會報錯

自定義轉換器

如果你想擁有自己的轉換器請實現IDiskConverter接口。
示例：

public class CustomDiskConverter implements IDiskConverter {
    @Override
    public <T> T load(InputStream source, Type type) {
        //實現讀功能
        return null;
    }

    @Override
    public boolean writer(OutputStream sink, Object data) {
        //實現寫功能
        return false;
    }
}

緩存回調

對具有緩存的回調CallBack，如果你想知道當前的緩存是來自本地還是網絡，只需要回調中加入CacheResult，其它和普通的網絡請求方式一模一樣。CacheResult中的isFromCache可以知道是否來自緩存，true：來自緩存，false：來自網絡。請使用new SimpleCallBack<CacheResult<T>>() 也就是在你原有的T上包含一層CacheResult就可以了。如果不想用到isFromCache就不需要用CacheResult，直接使用new SimpleCallBack<T>()
帶有CacheResult回調示例：

 EasyHttp.get(url)
                .readTimeOut(30 * 1000)//測試局部讀超時30s
                .cacheMode(cacheMode)
                .cacheKey(this.getClass().getSimpleName())//緩存key
                .retryCount(5)//重試次數
                .cacheTime(5 * 60)//緩存時間300s，默認-1永久緩存  okhttp和自定義緩存都起作用
                //.okCache(new Cache());//okhttp緩存，模式為默認模式（CacheMode.DEFAULT）才生效
                //.cacheDiskConverter(new GsonDiskConverter())//默認使用的是 new SerializableDiskConverter();
                .cacheDiskConverter(new SerializableDiskConverter())//默認使用的是 new SerializableDiskConverter();
                .timeStamp(true)
                .execute(new SimpleCallBack<CacheResult<SkinTestResult>>() {

                    @Override
                    public void onError(ApiException e) {
                       //請求失敗
                    }

                    @Override
                    public void onSuccess(CacheResult<SkinTestResult> cacheResult) {
                        HttpLog.i(cacheResult.toString());
                        String from = "";
                        if (cacheResult.isFromCache) {
                            from = "我來自緩存";
                        } else {
                            from = "我來自遠程網絡";
                        }
                       ....
                    }
                });

移除緩存

支持根據緩存key移除緩存，主要是針對RxCache才能起作用

EasyHttp.removeCache("cachekey");

清空緩存

EasyHttp.clearCache();

RxCache

RxCache是自己封裝的一個本地緩存功能庫，采用Rxjava+DiskLruCache來實現，線程安全內部采用ReadWriteLock機制防止頻繁讀寫緩存造成的異常，可以獨立使用，單獨用RxCache來存儲數據。采用transformer與網絡請求結合，可以實現網絡緩存功能,本地硬緩存，具有緩存讀寫功能（異步）、緩存是否存在、根據key刪除緩存、清空緩存（異步）、緩存Key會自動進行MD5加密、可以設置緩存磁盤大小、緩存key、緩存時間、緩存存儲的轉換器、緩存目錄、緩存Version等功能本庫不作為重點介紹。后期會將此代碼獨立開源一個庫，作為一分鍾讓你自己的網絡庫也具有緩存功能，敬請期待！！！

動態參數

動態參數就是像我們的token、時間戳timeStamp、簽名sign等，這些參數不能是全局參數因為是變化的，設置成局部參數又太麻煩，每次都要獲取。token是有有效時間的或者異地登錄等都會變化重新獲取，時間戳一般是根據系統的時間，sign是根據請求的url和參數進行加密簽名一般都有自己的簽名規則。有的接口需要這些參數有的接口不需要，本庫很好的解決這個問題。

1.在請求的時候可以設置下面三個參數

.accessToken(true)//本次請求是否追加token
.timeStamp(false)//本次請求是否攜帶時間戳
.sign(false)//本次請求是否需要簽名

2.需要繼承庫中提供的動態攔截器BaseDynamicInterceptor

繼承BaseDynamicInterceptor后就可以獲取到參數的設置值，請詳細看CustomSignInterceptor的注釋講解，也可以查看Demo示例
示例:

/**
 * <p>描述：對參數進行簽名、添加token、時間戳處理的攔截器</p>
 * 主要功能說明：<br>
 * 因為參數簽名沒辦法統一，簽名的規則不一樣，簽名加密的方式也不同有MD5、BASE64等等，只提供自己能夠擴展的能力。<br>
 * 作者： zhouyou<br>
 * 日期： 2017/5/4 15:21 <br>
 * 版本： v1.0<br>
 */
public class CustomSignInterceptor extends BaseDynamicInterceptor<CustomSignInterceptor> {
    @Override
    public TreeMap<String, String> dynamic(TreeMap<String, String> dynamicMap) {
        //dynamicMap:是原有的全局參數+局部參數
        //你不必關心當前是get/post/上傳文件/混合上傳等，庫中會自動幫你處理。
        //根據需要自己處理，如果你只用到token則不必處理isTimeStamp()、isSign()
        if (isTimeStamp()) {//是否添加時間戳，因為你的字段key可能不是timestamp,這種動態的自己處理
            dynamicMap.put(ComParamContact.Common.TIMESTAMP, String.valueOf(System.currentTimeMillis()));
        }
        if (isSign()) {是否簽名
            //1.因為你的字段key可能不是sign，這種需要動態的自己處理
            //2.因為你的簽名的規則不一樣，簽名加密方式也不一樣，只提供自己能夠擴展的能力
            dynamicMap.put(ComParamContact.Common.SIGN, sign(dynamicMap));
        }
        if (isAccessToken()) {//是否添加token
            String acccess = TokenManager.getInstance().getAuthModel().getAccessToken();
            dynamicMap.put(ComParamContact.Common.ACCESSTOKEN, acccess);
        }
        //Logc.i("dynamicMap:" + dynamicMap.toString());
        return dynamicMap;//dynamicMap:是原有的全局參數+局部參數+新增的動態參數
    }

    //示例->簽名規則：POST+url+參數的拼裝+secret
    private String sign(TreeMap<String, String> dynamicMap) {
        String url = getHttpUrl().url().toString();
        url = url.replaceAll("%2F", "/");
        StringBuilder sb = new StringBuilder("POST");
        sb.append(url);
        for (Map.Entry<String, String> entry : dynamicMap.entrySet()) {
            sb.append(entry.getKey()).append("=").append(entry.getValue()).append("&");
        }

        sb.append(AppConstant.APP_SECRET);
        HttpLog.i(sb.toString());
        return MD5.encode(sb.toString());
    }
}

3.設置自定義的動態攔截器

最好通過全局的方式設置，因為一般很多接口都會使用到

 EasyHttp.getInstance()
                 ...
                .addInterceptor(new CustomSignInterceptor())//添加動態參數（簽名、token、時間戳）攔截器
                 ...

自定義ApiResult

本庫中默認提供的是標准ApiResult.內部是靠ApiResult進行解析的，如果你的數據結構跟ApiResult不同，你可以在你的項目中繼承ApiResult，然后重寫getCode()、getData()、getMsg()和isOk()等方法來實現自己的需求。
本庫中ApiResult如下：

public class ApiResult<T> {
    private int code;
    private String msg;
    private T 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;
    }

    public T getData() {
        return data;
    }

    public void setData(T data) {
        this.data = data;
    }

    public boolean isOk() {//請求成功的判斷方法
        return code == 0 ? true : false;
    }
}

json格式類似:

{
"code": 100010101,
"data": 內容,
"msg": "請求成功"
}

假如你的數據結構是這樣的：

{
"error_code": 0,
"result": 內容,
"reason": "請求成功"
}

那么你的basebean可以寫成這樣

public class CustomApiResult<T> extends ApiResult<T> {
    String reason;
    int error_code;
    //int resultcode;
    T result;
    @Override
    public int getCode() {
        return error_code;
    }
    @Override
    public void setCode(int code) {
        error_code = code;
    }
    @Override
    public String getMsg() {
        return reason;
    }
    @Override
    public void setMsg(String msg) {
        reason = msg;
    }
    @Override
    public T getData() {
        return result;
    }
    @Override
    public void setData(T data) {
        result = data;
    }
   /* @Override
    public boolean isOk() {
        return error_code==200;//如果不是0表示成功，請重寫isOk()方法。
    }*/
}

那么你的網絡請求可以這樣寫

自定義ApiResult回調方式（通過CallBackProxy代理）

EasyHttp.get(url)
                .readTimeOut(30 * 1000)//局部定義讀超時
                .writeTimeOut(30 * 1000)
                .connectTimeout(30 * 1000)
                //.cacheKey(this.getClass().getSimpleName()+"11")
                //.cacheMode(CacheMode.CACHEANDREMOTE)
                //.cacheMode(CacheMode.ONLYREMOTE)
                //.headers("","")//設置頭參數
                //.params("name","張三")//設置參數
                //.addInterceptor()
                //.addConverterFactory()
                //.addCookie()
                //.timeStamp(true)
                .baseUrl("http://apis.juhe.cn")
                .params("phone", "手機號")
                .params("dtype", "json")
                .params("key", "5682c1f44a7f486e40f9720d6c97ffe4")
                .execute(new CallBackProxy<CustomApiResult<ResultBean>, ResultBean>(new SimpleCallBack<ResultBean>() {
                    @Override
                    public void onError(ApiException e) {
                        //請求錯誤
                    }

                    @Override
                    public void onSuccess(ResultBean response) {
                        //請求成功
                    }
                }) {
                });

這種寫法會覺得有點長，CallBackProxy的泛型參數每次都需要填寫，其中CustomApiResult是繼承ApiResult的，CustomApiResult相當於項目的basebean,對於一個實際項目來講，basebean是固定的，所以我們可以繼續封裝這個方法，根據需要一般只需要封裝get和post請求就可以了。

 public static <T> Disposable customExecute(CallBack<T> callBack) {
        return execute(new CallBackProxy<CustomApiResult<T>, T>(callBack) {
        });
    }

通過以上改造，再次調用時直接使用CallBack，不用再關注CallBackProxy，是不是明顯簡單很多了，具體請看代碼Demo!!!

自定義ApiResult訂閱方式（通過CallClazzProxy代理）

Observable<ResultBean> observable = EasyHttp.get("/mobile/get")
                .readTimeOut(30 * 1000)//局部定義讀超時
                .writeTimeOut(30 * 1000)
                .baseUrl("http://apis.juhe.cn")
                .params("phone", "18688994275")
                .params("dtype", "json")
                .params("key", "5682c1f44a7f486e40f9720d6c97ffe4")
                .execute(new CallClazzProxy<CustomApiResult<ResultBean>, ResultBean>(ResultBean.class) {
                });
        observable.subscribe(new ProgressSubscriber<ResultBean>(this, mProgressDialog) {
            @Override
            public void onError(ApiException e) {
                super.onError(e);
                showToast(e.getMessage());
            }

            @Override
            public void onNext(ResultBean result) {
                showToast(result.toString());
            }
        });

調試模式

一個好的庫，一定有比較人性化的調試模式，為了方便開發者查看請求過程和請求日志，本庫提供詳細的日志打印，最好在開發階段，請打開調試模式輸出優雅的Log.
調試模式的控制在初始化配置時就可以直接設置。

public class MyApplication extends Application {
        @Override
        public void onCreate() {
            super.onCreate();
            ...
            EasyHttp.getInstance()
            		...
                    // 打開該調試開關並設置TAG,不需要就不要加入該行
                    // 最后的true表示是否打印內部異常，一般打開方便調試錯誤
                    .debug("EasyHttp", true);
        }
    }

Log預覽說明

這里一個成功請求的例子：

上方的Log打印了一個Request完整的聲明周期，一個請求的Log有以下特點：
1.開頭和結尾打了-->http is start和 -->http is Complete分割請求，完整的生命周期的內容都會打印在開頭和結尾的里面。
2.request請求和response響應分割，分別是

-------------------------------request-------------------------------

-------------------------------response-------------------------------

3.在---request---之后會打印請求的url、當前請求的類型GET/POST... -->GET/POST開頭 -->END GET/POST結尾。如果是GET、HEAD請求方式添加的參數將會在這里完整的以url?key=value&key=value的形式打印。
4.在----response----之后會打印（在服務器響應后被打印），包含響應碼、響應狀態、響應頭、cookie,body等以<--200(響應碼)開頭，<--END HTTP結尾
5.loadCache key=如果設置了緩存，會看到緩存的key，開啟了網絡緩存功能才會輸出。
6.loadCache result=從緩存里讀取的結果，開啟了網絡緩存功能才會輸出。
7.save status => true保存緩存的狀態

混淆

#okhttp
-dontwarn com.squareup.okhttp3.**
-keep class com.squareup.okhttp3.** { *;}
-dontwarn okio.**

# Retrofit
-dontwarn retrofit2.**
-keep class retrofit2.** { *; }
-keepattributes Exceptions

# Retrolambda
-dontwarn java.lang.invoke.*

# RxJava RxAndroid
-dontwarn sun.misc.**
-keepclassmembers class rx.internal.util.unsafe.*ArrayQueue*Field* {
    long producerIndex;
    long consumerIndex;
}
-keepclassmembers class rx.internal.util.unsafe.BaseLinkedQueueProducerNodeRef {
    rx.internal.util.atomic.LinkedQueueNode producerNode;
}
-keepclassmembers class rx.internal.util.unsafe.BaseLinkedQueueConsumerNodeRef {
    rx.internal.util.atomic.LinkedQueueNode consumerNode;
}
###rxandroid-1.2.1
-keepclassmembers class rx.android.**{*;}

# Gson
-keep class com.google.gson.stream.** { *; }
-keepattributes EnclosingMethod
-keep class org.xz_sale.entity.**{*;}
-keep class com.google.gson.** {*;}
-keep class com.google.**{*;}
-keep class sun.misc.Unsafe { *; }
-keep class com.google.gson.stream.** { *; }
-keep class com.google.gson.examples.android.model.** { *; }

#RxEasyHttp
-keep class com.zhouyou.http.model.** {*;}
-keep class com.zhouyou.http.cache.model.** {*;}
-keep class com.zhouyou.http.cache.stategy.**{*;}

項目程序結構目錄截圖

項目程序結構目錄截圖如下：

基於RxJava2+Retrofit2簡單易用的網絡請求實現

代碼地址如下：
http://www.demodashi.com/demo/13473.html

注：本文著作權歸作者，由demo大師代發，拒絕轉載，轉載需要作者授權