MVP实战心得—封装Retrofit2.0+RxAndroid+RxBus

响应式编程框架,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上传表单[email protected]表示单个,@FieldMap表示集合.
需要添加上面的@FormUrlEncoded表示表单提交 ,
对应Content-Type:application/x-www-form-urlencoded
如:
@FormUrlEncoded
@POST("login的url")
Observable login(@Field("name") String name, @FieldMap Map params);
--------------------------------------------------分割线------------------------------------------------------------
@Part，@PartMap----post上传文件/数据[email protected]表示单个,@PartMap表示集合.
其中@Part MultipartBody.Part 类型代表文件，@Part("key") RequestBody类型代表参数
需要添加@Multipart表示支持文件上传的表单，Content-Type: multipart/form-data
@Multipart
@POST("update的url")
Observable update(@Part ("file") MultipartBody.Part file, @Part("key") RequestBody key,@PartMap Map 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> login(@QueryMap HashMap params);

其实所谓的Reretrofit+RxAndroid就是这么回事.

没有RxAndroid的Reretrofit请求接口是这样写的:

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

把Call换成了Observable而已.

(2)写一个接口类

/**
*所有的网络请求都可以写在这个接口类里面.
*/
public interface APIService {
     @GET("login地址")
     Observable<BaseResponse> login(@QueryMap HashMap 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()) //传入参数
       .subscribe(new Action1<BaseResponse>() {//简单的回调
            @Override
             public void call(BaseResponse loginDataBaseResponse) {
                //拿到数据,做处理
            }
    });

4.封装

有没有发现,设置泛型的是,包了一层BaseResponse 这么做是为了请求完成后对返回的数据进行统一处理.

先看BaseResponse:

public class BaseResponse {
    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>转化Observable,并处理BaseResponse
     *
     * @return 返回过滤后的Observable.
     */
    @SuppressWarnings("unchecked")
    public static  Observable compose(Observable<BaseResponse> observable) {
        return observable.compose(transformer);
    }

    /**
     * 这里就不细讲了,具体可以去看rxjava的使用.这个类的意义就是转换Observable.
     */
    private static class SimpleTransformer implements Observable.Transformer<BaseResponse, T> {
        //这里对Observable,进行一般的通用设置.不用每次用Observable都去设置线程以及重连设置
        @Override
        public Observable call(Observable<BaseResponse> observable) {
            return observable.subscribeOn(Schedulers.io())
                      .observeOn(AndroidSchedulers.mainThread())
                      .unsubscribeOn(Schedulers.io())
                      .timeout(5, TimeUnit.SECONDS)//重连间隔时间
                      .retry(5)//重连次数
                      .flatMap(new Func1<BaseResponse, Observable>() {
                          @Override
                          public Observable call(BaseResponse tBaseResponse) {
                              return flatResponse(tBaseResponse);
                          }
                      });
        }

        /**
         * 处理请求结果,BaseResponse
         * @param response 请求结果
         * @return 过滤处理, 返回只有data数据的Observable
         */
        private Observable flatResponse(final BaseResponse response) {
            return Observable.create(new Observable.OnSubscribe() {
                @Override
                public void call(Subscriber 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 extends Subscriber {

    @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()))
                .subscribe(new SimpleSubscriber() {
                    @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()))

这个转换我们应该放在Modle和ModleImpl中去写

public class LoginContract{
     ....//view接口省略
    public interface Model {
      /**
      * 获取登陆数据
      * @return Observable
      */
      Observable login(HashMap treeMap);
    }
    ....//prensent接口省略
}

public class LoginModelImpl implements LoginContract.Model {
   @Override
   public Observable login(HashMap 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()))
                .subscribe(new SimpleSubscriber() {
                    @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()))
                .subscribe(new SimpleSubscriber() {
                    @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 {
   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);
}

原文地址：https://www.cnblogs.com/Free-Thinker/p/9646396.html

时间： 2024-10-09 03:33:30

MVP实战心得—封装Retrofit2.0+RxAndroid+RxBus的相关文章

Android 基于ijkplayer+Rxjava+Rxandroid+Retrofit2.0+MVP+Material Design的android万能播放器aaa

MDPlayer万能播放器 MDPlayer,基于ijkplayer+Rxjava+Rxandroid+Retrofit2.0+MVP+Material Design的android万能播放器,可以播放本地和在线视频,可以浏览宅男杀手妹纸图片,UI设计遵循 Material Design. GitHub地址:https://github.com/Dawish/MDPlayer UI浏览:         1.UI设计: 列表使用RecyclerView,item为CardView并设置rippl

Retrofit2.0+RxJava+RxAndroid——强强联合的网络请求框架

最近看了很多关于Retrofit和Rxjava的文档介绍.终于在弄清Rxjava后顺利的弄懂了Retrofit. 网上有很多人都介绍了它们的联合使用,但是我看过之后理解不是太好.可能我太笨. 不过,今天写这篇博客的目的就是想来说说它们之间如何使用以及使用的时候遇到的坑. 这两者的关系并不大,但是联合在一起使用是非常简便的.Rxjava的响应式编程加上Retrofit的注解式请求用起来是非常爽的. 并且Retrofit内置的是Okhttp,所以这更加的让Retrofit变得强大. 如果在看这篇博客

Retrofit2.0+RxJava+MVP+Bmob的使用

本篇来总结一下学过的关于android方面的东西.梳理一下知识: 1.Retrofit2.0 Retrofit 是一个Square开发的类型安全的REST安卓客户端请求库.这个库为网络认证.API请求以及用OkHttp发送网络请求提供了强大的框架 . 2.RxJava/RxAndroid RxJava是一款响应式变成框架.RxAndroid在RxJava基础之上扩展了android线程调度.RxJava基本组成部分是Observables和Subscribers(事实上Observer才是最小的

Android 网络框架 Retrofit2.0介绍、使用和封装

前言 时至今日,Android的网络框架不再像之前那么到处都是,随着Google把 HttpClient直接删掉,似乎意味着Android越来越成熟.网络框架中的佼佼者Volley也不再那么光鲜,取而代之的是 Retrofit 和 okHttp. 感觉很像 OnePiece 中白胡子的离去象征着时代的变革,新时代的开始,多弗的垮台象征着七武海制度的取缔一样,不会使用Retrofit + okHttp + RxJava等一系列技术,就迈不进新时代的门槛,也不足以称为一个合格的开发者. 哈哈闲话不多

Android 使用Retrofit2.0+OkHttp3.0实现缓存处理+Cookie持久化第三方库

1.Retrofit+OkHttp的缓存机制 1.1.第一点 在响应请求之后在 data/data/<包名>/cache 下建立一个response 文件夹,保存缓存数据. 1.2.第二点 这样我们就可以在请求的时候,如果判断到没有网络,自动读取缓存的数据. 1.3.第三点 同样这也可以实现,在我们没有网络的情况下,重新打开App可以浏览的之前显示过的内容. 1.4.第四点 也就是:判断网络,有网络,则从网络获取,并保存到缓存中,无网络,则从缓存中获取. 1.5.github地址+参考文章 g

基于Retrofit2.0+RxJava+Dragger2实现不一样的Android网络构架搭建（转载）

转载请注明出处:http://blog.csdn.net/finddreams/article/details/50849385#0-qzone-1-61707-d020d2d2a4e8d1a374a433f596ad1440   一起分享,一起进步.finddreams:http://blog.csdn.net/finddreams/article/details/50849385 众所周知,手机APP的核心就在于调用后台接口,展示相关信息,方便我们在手机上就能和外界交互.所以APP中网络框架

Retrofit2.0 公共参数（固定参数）

请先阅读: Retrofit 动态参数(非固定参数.非必须参数)(Get.Post请求) 在实际项目中,对于有需要统一进行公共参数添加的网络请求,可以使用下面的代码来实现: RestAdapter restAdapter = new RestAdapter.Builder() .setEndpoint(ctx).setRequestInterceptor(new RequestInterceptor() { @Override public void intercept(RequestFacad

Retrofit2.0使用

随着Google对HttpClient 摒弃,和Volley的逐渐没落,OkHttp开始异军突起,而Retrofit则对okHttp进行了强制依赖. Retrofit是由Square公司出品的针对于Android和Java的类型安全的Http客户端, 如果看源码会发现其实质上就是对okHttp的封装,使用面向接口的方式进行网络请求,利用动态生成的代理类封装了网络接口请求的底层, 其将请求返回javaBean,对网络认证 REST API进行了很好对支持此,使用Retrofit将会极大的提高我们应

Retrofit2.0+ RxJava 优雅的取消重复避免并取消请求（十一）

Tamic/文 地址:http://blog.csdn.net/sk719887916/article/details/54575137 前几篇主要介绍了retrofit基本使用,结合rxJava的案列,以及RxJava结合retrofit的封装,包括公用参数,局部参数请求头添加,缓存,https, 文件上下传,结果解析,异常处理等,还有一些技巧,那么还有一个比较关键的是取消问题. 两者结合技巧可点击阅读:http://blog.csdn.net/sk719887916/article/deta