MVP實戰心得(三)---封裝Retrofit2.0+RxAndroid+RxBus

轉載請標明出處：http://www.lxweimin.com/p/2a2464938b47
本文出自:Jlanglang

介紹:

Retrofit:

對okhttp的封裝,可以更方便的使用okhttp

RxAndroid

響應式編程框架,rxjava的擴展,很爽的鏈式編程
魅力在于對數據的處理,與線程切換的靈活性.
用來處理異步操作(Lambda表達式不會用.用Lambda表達式代碼會更少,但不會的人會看不懂代碼.不是很推薦)

RxBus

用RxJava實現的EventBus

說說為什么要配合起來用

Retrofit負責鏈接網絡,請求網絡.
RxAndroid負責處理請求的結果.異步操作
RxBus可以很方便的進行各組件之間的通信.
我之前是用asynchttpclient做網絡請求的,各種代碼縮進,if套if,各種回調,慘不忍睹啊.
用了Retrofit+RxAndroid我就徹底放棄asynchttpclient了.

使用

1.RxJava

傳送門:RxJava---------這個作為入門學習rxjava非常好

2.Retrofit

這個寫點基本的用法吧..

首先看用的包:

//retrofit2--看名字就知道是啥了
compile 'com.squareup.retrofit2:retrofit:2.1.0'
//CallAdapterFactory的Rx依賴包---導這個包才能配合rxAndroid使用
compile 'com.squareup.retrofit2:adapter-rxjava:2.1.0'
//ConverterFactory的String依賴包----這個是解析數據的工廠.用來格式化數據的,配置編碼啊,gson解析啊.
compile 'com.squareup.retrofit2:converter-scalars:2.1.0'

然后是retrofit注解：(使用retrofit,注解是很重要的)

方法注解 : 包含@GET、@POST、@PUT、@DELETE、@PATCH、@HEAD、@OPTIONS、@HTTP。

這個不多講.一般用的就是@GET、@POST,很明顯,一個是get請求,一個是post請求

標記注解 : 包含@FormUrlEncoded、@Multipart、@Streaming。
這個得和參數注解一起說

參數注解 : 包含@Query,@QueryMap、@Body、@Field，@FieldMap、@Part，@PartMap。

@Get---------用的參數注解就@Query,@QueryMap,

@Post--------則會用到 @Body、@Field，@FieldMap、@Part，@PartMap。

@Body-------將數據轉化成Json,然后post.具體轉化根據設置的解析工廠(下面有講)
---------------------------------------------------分割線----------------------------------------------------------
@Field，@FieldMap------post上傳表單.@Field表示單個,@FieldMap表示集合.
需要添加上面的@FormUrlEncoded表示表單提交 ,
對應Content-Type:application/x-www-form-urlencoded
如:
@FormUrlEncoded
@POST("login的url")
Observable<User> login(@Field("name") String name, @FieldMap Map params);
--------------------------------------------------分割線------------------------------------------------------------
@Part，@PartMap----post上傳文件/數據.@Part表示單個,@PartMap表示集合.
其中@Part MultipartBody.Part 類型代表文件，@Part(“key”) RequestBody類型代表參數 
需要添加@Multipart表示支持文件上傳的表單，Content-Type: multipart/form-data
@Multipart
@POST("update的url")
Observable<User> update(@Part ("file") MultipartBody.Part file, @Part(“key”) RequestBody key,
                               @PartMap Map<String,RequestBody> files);
如果參數較少,使用@Part ("file")就可以解決了,如果參數較多,那就需要使用@PartMap了.

其他注解 : @Path、@Header,@Headers、@Url
這幾個用處挺大的,這里就不細說了,并不是必用的,我用的不多.

Retrofit 配置代碼.

//這個是處理網絡請求的log信息的,可以實現Interceptor接口來自定義.
 HttpLoggingInterceptor interceptor = new HttpLoggingInterceptor(new HttpLoggingInterceptor.Logger() {
            @Override
            public void log(String message) {
                HLog.i("RxJava", message);
            }
        });

OkHttpClient client = new OkHttpClient.Builder()
                .addInterceptor(interceptor)
                .build();
Retrofit retrofit = new Retrofit.Builder()
                .client(client)//Retrofit需要配置一個OkHttpClient實例.
                .baseUrl(API_HOST)//需要指定一個baseUrl,一般就是服務器的域名
                .addConverterFactory(FastjsonConverterFactory.create())//這個是數據解析工廠,我用的是fastjson
                .addCallAdapterFactory(RxJavaCallAdapterFactory.create())//支持rxJava,在第二個jar包里面
                .build();

下面是完整代碼:

/**
* 寫成單例模式,因為并不需要多個Retrofit存在.
*/
public class RetrofitUtil {
    /**
     * 服務器地址
     */
    private static final String API_HOST ="你的BaseUrl";
    private RetrofitUtil() {

    }
    public static Retrofit getRetrofit() {
        return Instanace.retrofit;
    }
    //靜態內部類,保證單例并在調用getRetrofit方法的時候才去創建.
    private static class Instanace {
        private static final Retrofit retrofit = getInstanace();
        private static Retrofit getInstanace() {
            HttpLoggingInterceptor interceptor = new HttpLoggingInterceptor(new HttpLoggingInterceptor.Logger(){
                @Override
                public void log(String message) {
                    HLog.i("RxJava", message);
                }
            });
            OkHttpClient client = new OkHttpClient.Builder()
                    .addInterceptor(interceptor)
                    .build();
            Reretrofit = new Retrofit.Builder()
                    .client(client)
                    .baseUrl(API_HOST)
                    .addConverterFactory(FastjsonConverterFactory.create())
                    .addCallAdapterFactory(RxJavaCallAdapterFactory.create())
                    .build();
            return retrofit;
        }
    }
}

json解析工廠,代碼太多,,具體可以見demo

3.RxAndroid

如果沒接觸的話,可以看前面的Rxjava鏈接.

(1).首先看Reretrofit+RxAndroid是怎么使用的
@GET("login地址")
Observable<BaseResponse<LoginData>> login(@QueryMap HashMap<String, Object> params);

其實所謂的Reretrofit+RxAndroid就是這么回事.

沒有RxAndroid的Reretrofit請求接口是這樣寫的:

@GET("login地址")
Call<BaseResponse<LoginData>> login(@QueryMap HashMap<String, Object> params);

把Call換成了Observable而已.

(2)寫一個接口類
/**
*所有的網絡請求都可以寫在這個接口類里面.
*/
public interface APIService {
     @GET("login地址")
     Observable<BaseResponse<LoginData>> login(@QueryMap HashMap<String, Object> params);
     ......
}
(3)接口類的實現
/**
 * 請求生成類。Retrofit一次生成,并作為單例.
 */
public class ApiServcieImpl {
    private ApiServcieImpl() {

    }
    public static APIService getInstance() {
        return createAPIService.apiService;
    }

    /**
     * Retrofit生成接口對象.
     */
    private static class createAPIService {
        //Retrofit會根據傳入的接口類.生成實例對象.
        private static final APIService apiService = RetrofitUtil.getRetrofit().create(APIService.class);
    }
}

然后就可以通過ApiServcieImpl.getInstance()去調用APIService里面寫的接口了.
如:

ApiServcieImpl.getInstance().login(new HashMap<String, Object>()) //傳入參數
       .subscribe(new Action1<BaseResponse<LoginData>>() {//簡單的回調
            @Override 
             public void call(BaseResponse<LoginData> loginDataBaseResponse) { 
                //拿到數據,做處理
            }
    });

4.封裝

有沒有發現,設置泛型的是<BaseResponse<LoginData>>,包了一層BaseResponse
這么做是為了請求完成后對返回的數據進行統一處理.

先看BaseResponse:

public class BaseResponse<T> {
    private boolean success;//請求是否成功
    private int resultCode;//狀態嗎
    private String msg;//返回的提示消息
    private T data;//主要內容,因為不知道返回的會是什么類型,所以用泛型來表示
    //get set方法就不貼了.
}

怎么處理.

 /**
 * @author jlanglang  2016/11/15 16:14
 */
public class ModelFilteredFactory {
    private final static Observable.Transformer transformer = new SimpleTransformer();

    /**
     * 將Observable<BaseResponse<T>>轉化Observable<T>,并處理BaseResponse
     *
     * @return 返回過濾后的Observable.
     */
    @SuppressWarnings("unchecked")
    public static <T> Observable<T> compose(Observable<BaseResponse<T>> observable) {
        return observable.compose(transformer);
    }

    /**
     * 這里就不細講了,具體可以去看rxjava的使用.這個類的意義就是轉換Observable.
     */
    private static class SimpleTransformer<T> implements Observable.Transformer<BaseResponse<T>, T> {
        //這里對Observable,進行一般的通用設置.不用每次用Observable都去設置線程以及重連設置
        @Override
        public Observable<T> call(Observable<BaseResponse<T>> observable) {
            return observable.subscribeOn(Schedulers.io())
                      .observeOn(AndroidSchedulers.mainThread())
                      .unsubscribeOn(Schedulers.io())
                      .timeout(5, TimeUnit.SECONDS)//重連間隔時間
                      .retry(5)//重連次數
                      .flatMap(new Func1<BaseResponse<T>, Observable<T>>() {
                          @Override
                          public Observable<T> call(BaseResponse<T> tBaseResponse) {
                              return flatResponse(tBaseResponse);
                          }
                      });
        }

        /**
         * 處理請求結果,BaseResponse
         * @param response 請求結果
         * @return 過濾處理, 返回只有data數據的Observable
         */
        private Observable<T> flatResponse(final BaseResponse<T> response) {
            return Observable.create(new Observable.OnSubscribe<T>() {
                @Override
                public void call(Subscriber<? super T> subscriber) {
                    if (response.isSuccess()) {//請求成功
                        if (!subscriber.isUnsubscribed()) {
                            subscriber.onNext(response.getData());
                        }
                    } else {//請求失敗
                        int resultCode = response.getResultCode();
                        if (!subscriber.isUnsubscribed()) {
                            //這里拋出自定義的一個異常.可以處理服務器返回的錯誤.
                            subscriber.onError(new APIException(response.getResultCode(), response.getMsg()));
                        }
                        return;
                    }
                    if (!subscriber.isUnsubscribed()) {//請求完成
                        subscriber.onCompleted();
                    }
                }
            });
        }
    }
}

僅僅只有上面那些了么?接著看.

/**
 * @author jlanglang  2016/11/14 17:32
  * Subscriber,這個是用來處理Observable的結果的.
 */
public abstract class SimpleSubscriber<T> extends Subscriber<T> {
 
    @Override
    public void onCompleted() {//這個是請求完成時調用.如果走了onError()就不會走這個方法.
       
    }

    @Override
    public void onError(Throwable e) {//這里通常就處理異常
        if (e instanceof APIException) {
            APIException exception = (APIException) e;
            ToastUtil.showToast( exception.message);
        } else if (e instanceof UnknownHostException) {
            ToastUtil.showToast("請打開網絡");
        } else if (e instanceof SocketTimeoutException) {
            ToastUtil.showToast( "請求超時");
        } else if (e instanceof ConnectException) {
            ToastUtil.showToast("連接失敗");
        } else if (e instanceof HttpException) {
            ToastUtil.showToast("請求超時");
        }else {
            ToastUtil.showToast("請求失敗");
        }
        e.printStackTrace();
    }

    @Override
    public void onNext(T t) {//這里的是獲得了數據,方法意思很明顯,下一步干啥
        if (t != null) {//這里最好判斷一下是否為null.
            call(t);
        } else {
            ToastUtil.showToast("連接失敗");
        }
    }
    /**
    *因為具體的處理這里無法得知,所以抽象.
    */
    public abstract void call(T t);
}

好了,看看現在的具體使用吧:

ModelFilteredFactory.compose(ApiServcieImpl.getInstance().login(new HashMap<String, Object>()))
                .subscribe(new SimpleSubscriber<LoginData>() {
                    @Override
                    public void call(LoginData loginData) {
                  
                    }
                });
 看起來之前用起來差不多,但是卻做了很多的處理:
1.對Observable做了通用設置.網絡重連次數,線程設置,重連時間.
2.做了對服務器返回結果的統一處理.比如根據resultcode,處理登陸過期啊啥的.
3.判斷了data是否為null,不會在call()里面擔心loginData是否為null
4.統一處理了請求的各種異常.

5.用到MVP中.

你以為上面那些就完了嗎?NO!
如果我們在Presenter中這樣調用其實是很不科學的.
ModelFilteredFactory.compose(ApiServcieImpl.getInstance().login(new HashMap<String, Object>()))
這個轉換我們應該放在Modle和ModleImpl中去寫
public class LoginContract{
     ....//view接口省略
    public interface Model {  
      /**   
      * 獲取登陸數據  
      * @return Observable<LoginData> 
      */  
      Observable<LoginData> login(HashMap<String, Object> treeMap);
    }
    ....//prensent接口省略
}

public class LoginModelImpl implements LoginContract.Model { 
   @Override 
   public Observable<LoginData> login(HashMap<String, Object> hashMap) {     
       return ModelFilteredFactory.compose(ApiServcieImpl.getInstance().login(hashMap));   
 }}
那么我們在presenter中調用就可以這樣:
public class LoginPresenterImpl exdents BasePresenter implements LoginContract.Presenter{
     .....
     private  LoginModelImpl  loginModelImpl;
     public void onCreate(){
       loginModelImpl = new LoginModelImpl();//創建modle實例
     }
     public void login(){
        //通過modle請求接口
        loginModelImpl.login(new HashMap<String, Object>()))
                .subscribe(new SimpleSubscriber<LoginData>() {
                    @Override
                    public void call(LoginData loginData) {
                          //處理請求的數據,綁定視圖 
                    }
                });
        }
    ....
}

6.管理Observable的生命周期,也就是網絡請求的生命周期.

Observable是不是很高大上,然而如果你不進行處理,可是會內存泄漏的
RxAndroid也不會自動的根據Activity/frgament的生命周期結束異步請求.
但處理其實很簡單.

使用CompositeSubscription

只需要將Observable,異步處理到最后返回的subscribe添加到CompositeSubscription實例里就行了.

  public void login(){
    Subscription subscribe = loginModelImpl.login(new HashMap<String, Object>()))
                .subscribe(new SimpleSubscriber<LoginData>() {
                    @Override
                    public void call(LoginData loginData) {
                          //處理請求的數據,綁定視圖 
                    }
                });
      compositeSubscription.add(subscribe);//添加訂閱
  }
  //在銷毀的時候,結束訂閱事件.
  public void onDestroy() {
    compositeSubscription.unsubscribe();//結束所有add的subscribe事件
 }

那么,實戰心得(二)中的BasePresenter就可以進行改進了,具體見:

傳送門:實戰心得(二)

/**
 * @author jlanglang  2016/11/11 15:10
 */
public abstract class BasePresenter<T extends BaseView> {
   protected T mView;
   protected CompositeSubscription compositeSubscription;
    /**
     * 綁定View
     */
    public void onAttch(T view) {
        this.mView = view;
        compositeSubscription = new CompositeSubscription ();
    }
    /**
     * 做初始化的操作,需要在V的視圖初始化完成之后才能調用
     * presenter進行初始化.
     */
    public abstract void onCreate();
    /** 
    * 在這里結束異步操作
    */
    public void onDestroy(){
        compositeSubscription.unsubscribe();//結束異步請求.
    }
    /**
     * 在V銷毀的時候調用,解除綁定
    */
    public void onDetach() {  
       mView = null;
    }
    /**
    * 容易被回收掉時保存數據
    */
    public abstract void onSaveInstanceState(Bundle outState);
}

7 RxBus

沒什么特別值得提的,用法自行搜索,哈哈,個人在項目中用的也不是很多,某些情況會用一下,但真心好用.

再附上githubdemo地址,還未更新到最新.

mvpDemo

您的喜歡與回復是我最大的動力－＿－

最后編輯于 ：
?著作權歸作者所有,轉載或內容合作請聯系作者
平臺聲明：文章內容（如有圖片或視頻亦包括在內）由作者上傳并發布，文章內容僅代表作者本人觀點，簡書系信息發布平臺，僅提供信息存儲服務。

推薦閱讀更多精彩內容

  • Android 自定義View的各種姿勢1 Activity的顯示之ViewRootImpl詳解 Activity...
    passiontim閱讀 173,242評論 25贊 708
  • 文章轉自：http://gank.io/post/560e15be2dca930e00da1083作者：扔物線在正...
    xpengb閱讀 7,061評論 9贊 73
  • 我從去年開始使用 RxJava ，到現在一年多了。今年加入了 Flipboard 后，看到 Flipboard 的...
    Jason_andy閱讀 5,570評論 7贊 62
  • Git是一個很強大的分布式版本控制系統。它不但適用于管理大型開源軟件的源代碼，管理私人的文檔和源代碼也有很多優勢。...
    Mr_不靠譜_先森閱讀 364評論 0贊 1
  • 留在身邊的人越來越少，也越來越重要 上周新世相搞了一個48小時交換活動——你與他（她）相遇那天，發生了什么事？有一...
    六月醬閱讀 356評論 7贊 10