MVP+Rxjava笔记

最新推荐文章于 2024-03-30 11:44:30 发布

置顶 wfrs1651561

最新推荐文章于 2024-03-30 11:44:30 发布

阅读量317

点赞数 1

分类专栏： Android

本文链接：https://blog.csdn.net/wfrs1651561/article/details/52597777

版权

Android 专栏收录该内容

10 篇文章 0 订阅

订阅专栏

MVP区分于MVC模式总结：
(思想)1.将Activity，Fragment中的逻辑操作抽取成Presenter类，并建立两者间的通信机制;
2.Fragment或者Activity为了在特定时期获取Presenter的数据进行操作，需要抽取一些关于Presenter结果回调的method，组成IMVP接口，使特定的Fragment或者Activity在继承BaseFragment或者BaseActivity的同时实现IMVP类，复写这些方法，而这些方法的调用实际上是在 Presenter 里面调用的，
因为不同的Fragment对应不同的Presenter和IMVP，因此有必要抽取BasePresenter将Presenter和对应的IMVP关联起来(可以设置AttachMVP和detachMVP来关联两者);
具体实现：
1.首先例如：Fragment extends BaseFragment implement IMVP{}
2. 在Activity或者Fragment创建presenter对象，调用presenter.attachView(this);//使prensenter持有该Frament对象
3.Activity中调用presenter的业务逻辑处理方法，如：presenter.login(Params xxx);//这样Activity可以将数据传递给Presenter并通知Presenter进行相应操作
4.在Presenter.class:调用结果回调的方法：
如：Presenter.this.mMVP.showData(T t);//showData()最终调用的Activity的实现方法，这样Presenter可以将数据传递给Activity并通知Activity进行相应操作
RxJava流程分析(参考网站：http://gank.io/post/560e15be2dca930e00da1083 )：
一：创建Observable对象：
创建Observable对象的几种形式：

  1.Observable.just(o1,o2,o3)
  2.Observable.from(T[]); Observable.from(List<T>);  onNext(o1)-->onNext(o2)-->onNext(o3)-->onCompleted();
  3.Observable.create(new OnSubscribe<Drawable>() {
    @Override
    public void call(Subscriber<? super Drawable> subscriber) {
        Drawable drawable = getTheme().getDrawable(drawableRes));
        subscriber.onNext(drawable);
        subscriber.onCompleted();
    }
})
4.(不怎么常用)Observable.defer(new OnSubscribe<Drawable>() {
    @Override
    public void call(Subscriber<? super Drawable> subscriber) {
        Drawable drawable = getTheme().getDrawable(drawableRes));
        subscriber.onNext(drawable);
        subscriber.onCompleted();
    }
})

二：调用 observable.subscribe(参数为subscriber或者observer)方法
observable.subscribe(observer);
// 或者：
observable.subscribe(subscriber);//实际上就是在observable里调用observer的实现方法进行数据通信
三：创建Subscriber或者observer

1.直接new ： new Subscriber<File>() {
                            @Override
                            public void onCompleted() {
                            }
                            @Override
                            public void onError(Throwable e) {
                            }
                            @Override
                            public void onNext(File file) {
                            }
                        }

2.使用Action1,Action0:
observable.subscribe(onNextAction, onErrorAction, onCompletedAction);
Action1<Throwable> onErrorAction = new Action1<Throwable>() 
Action0 onCompletedAction = new Action0() 
//Subscriber(Action1：代表onNext或者onError;Action0:onCompleted)

简单示例：一+二+三：

1.String[] names = ...;
Observable.from(names)
    .subscribe(new Action1<String>() {
        @Override
        public void call(String name) {
            Log.d(tag, name);
        }
    });

2.通过这样可以区分线程进行UI更新操作

int drawableRes = ...;
ImageView imageView = ...;
Observable.create(new OnSubscribe<Drawable>() {
    @Override
    public void call(Subscriber<? super Drawable> subscriber) {
        Drawable drawable = getTheme().getDrawable(drawableRes));
        subscriber.onNext(drawable);
        subscriber.onCompleted();
    }
}).subscribe(new Observer<Drawable>() {
    @Override
    public void onNext(Drawable drawable) {
        imageView.setImageDrawable(drawable);
    }
    @Override
    public void onCompleted() {
    }
    @Override
    public void onError(Throwable e) {
        Toast.makeText(activity, "Error!", Toast.LENGTH_SHORT).show();
    }
});

四：线程控制函数：
举例：

int drawableRes = ...;
ImageView imageView = ...;
Observable.create(new OnSubscribe<Drawable>() {
    @Override
    public void call(Subscriber<? super Drawable> subscriber) {
    //IO线程
        Drawable drawable = getTheme().getDrawable(drawableRes));
        subscriber.onNext(drawable);
        subscriber.onCompleted();
    }
})
.subscribeOn(Schedulers.io()) 
// 指定 onSubscribe() 发生在 IO 线程  ！
.observeOn(AndroidSchedulers.mainThread()) 
// 指定 Subscriber 的回调内容发生在主线程！
.subscribe(new Observer<Drawable>() {
    @Override
    public void onNext(Drawable drawable) {//主线程  
        imageView.setImageDrawable(drawable);
    }

    @Override
    public void onCompleted() {//主线程
    }

    @Override
    public void onError(Throwable e) {//主线程 
        Toast.makeText(activity, "Error!", Toast.LENGTH_SHORT).show();
    }
});

五：对Observable的构造参数的变换
在just()和subscribe()中间多一步变换，即将传入参数进行一次变换，再传入subscriber里面！
1.map()讲解

Observable.just("images/logo.png") // 输入类型 String
    .map(new Func1<String, Bitmap>() {
        @Override
        public Bitmap call(String filePath) { // 参数类型 String
            return getBitmapFromPath(filePath); // 返回类型 Bitmap
        }
    })
    .subscribe(new Action1<Bitmap>() {
        @Override
        public void call(Bitmap bitmap) { // 参数类型 Bitmap
            showBitmap(bitmap);
        }
    });
//将传入参数进行一次变换string--->bitmap,这个时候用的是Func()：Func0(),Func1()(常用)函数与Action()对应！，再传入subscriber里面

2.flatMap()与map()不同，应用于一对多的情况:

Student[] students = ...;
Subscriber<Course> subscriber = new Subscriber<Course>() {
    @Override
    public void onNext(Course course) {
        Log.d(tag, course.getName());
    }
    ...
};
Observable.from(students)
    .flatMap(new Func1<Student, Observable<Course>>() {
        @Override
        public Observable<Course> call(Student student) {
            return Observable.from(student.getCourses());
        }
    })
    .subscribe(subscriber);

//flatMap() 中返回的是一个 Observable 对象，map()返回的是普通对象：
原理：1. 使用传入的事件对象创建一个 Observable 对象；2. 并不发送这个 Observable, 而是将它激活，于是它开始发送事件；3. 每一个创建出来的 Observable 发送的事件，都被汇入同一个 Observable ，而这个 Observable 负责将这些事件统一交给 Subscriber 的回调方法。这三个步骤，把事件拆成了两级，通过一组新创建的 Observable 将初始的对象『铺平』之后通过统一路径分发了下去

networkClient.token() // 返回 Observable<String>，在订阅时请求 token，并在响应后发送 token
    .flatMap(new Func1<String, Observable<Messages>>() {
        @Override
        public Observable<Messages> call(String token) {
            // 返回 Observable<Messages>，在订阅时请求消息列表，并在响应后发送请求到的消息列表
            return networkClient.messages();
        }
    })
    .subscribe(new Action1<Messages>() {
        @Override
        public void call(Messages messages) {
            // 处理显示消息列表
            showMessages(messages);
        }
    });

六.变换的原理：lift()：在 Observable 执行了 lift(Operator) 方法之后，会返回一个新的 Observable，这个新的 Observable 会像一个代理一样，负责接收原始的 Observable 发出的事件，并在处理后发送给 Subscriber。

七：对Observable自身对象的变换：compose();

public class LiftAllTransformer implements Observable.Transformer<Integer, String> {
    @Override
    public Observable<String> call(Observable<Integer> observable) {
        return observable
            .lift1()
            .lift2()
            .lift3()
            .lift4();
    }
}
...
Transformer liftAll = new LiftAllTransformer();
observable1.compose(liftAll).subscribe(subscriber1);
observable2.compose(liftAll).subscribe(subscriber2);
observable3.compose(liftAll).subscribe(subscriber3);
observable4.compose(liftAll).subscribe(subscriber4);

八：线程控制：Scheduler (二)

Observable.just(1, 2, 3, 4) // IO 线程，由 subscribeOn() 指定
    .subscribeOn(Schedulers.io())
    .observeOn(Schedulers.newThread())
    .map(mapOperator) // 新线程，由 observeOn() 指定
    .observeOn(Schedulers.io())
    .map(mapOperator2) // IO 线程，由 observeOn() 指定
    .observeOn(AndroidSchedulers.mainThread) 
    .subscribe(subscriber);  // Android 主线程，由 observeOn() 指定

九：其它常用操作符(即Observable类的一些方法)

1.doOnNext() (在onNext之前do)允许我们在每次输出一个元素之前做一些额外的事情，比如这里的保存标题
doOnSubscribe() doOnUnsubscribe()
2.避免内存泄漏 bindUntilEvent(RxlifeCycle里面的，Activity/Fragment需继承RxAppCompatActivity/RxFragment)
  Observable.interval(1, TimeUnit.SECONDS)
         .compose(this.bindUntilEvent(ActivityEvent.PAUSE))  
         .subscribe(mSub);
3.filter():过滤参数f中return false 的值！！！！！！
Observable.just(f)
                .filter(new Func1<File, Boolean>() {
                    @Override
                    public Boolean call(File file) {
                        return f.exists() && f.canRead() && FileUtils.isVideo(f);
                }
            }).take(5);
4.take(int i):输出最多指定数量的结果
5.timer(0,5,TimeUnit.SECONDS)(过时)与interval(0,5,TimeUnit.SECONDS)：间隔多少秒就执行一次：循环执行(计时器)
timer(5, TimeUnit.SECONDS) interval(0,5,TimeUnit.SECONDS)：延迟多少秒才执行
6.Observable.range(3,10)//产生从3开始，个数为10个的连续数字
7.repeat与repeatWhen

十：控制

/**利用CompositeSubscription来持有所有的Subscriptions，然后在onDestroy()或者onDestroyView()里取消所有的订阅。避免内存泄漏**/ 
    public void addSubscriberToCompositeSubscription(Subscription subscriber){
        if(subscriber != null){
            this.mCompositeSubscription.add(subscriber);
        }
    }

  @Override
    public void onCreate(Bundle arg0) {
        this.mCompositeSubscription = new CompositeSubscription();
    }

   @Override
    public void onDestroy() {
        /**取消Subscriber事件订阅**/
        this.mCompositeSubscription.unsubscribe();
        this.mCompositeSubscription = null;
    }

十一：总结：
常用：

1.networkClient.token() // 返回 Observable<String>，在订阅时请求 token，并在响应后发送 token
.subscribeOn(Schedulers.io()) // 指定 onSubscribe() 发生在 IO 线程  ！！！！！！！！！！！！！！！！！！！！！！！！
.observeOn(AndroidSchedulers.mainThread()) // 指定 Subscriber 的回调内容发生在主线程！！！！！！！！！！！！！！！！！
    .flatMap(new Func1<String, Observable<Messages>>() {
        @Override
        public Observable<Messages> call(String token) {
            // 返回 Observable<Messages>，在订阅时请求消息列表，并在响应后发送请求到的消息列表
            return networkClient.messages();
        }
    })
    .subscribe(new Action1<Messages>() {
        @Override
        public void call(Messages messages) {
            // 处理显示消息列表
            showMessages(messages);
        }
    });

2.Observable.just("images/logo.png") // 输入类型 String
.subscribeOn(Schedulers.io()) 
// 指定 onSubscribe() 发生在 IO 线程  
.observeOn(AndroidSchedulers.mainThread()) 
// 指定 Subscriber 的回调内容发生在主线程
    .map(new Func1<String, Bitmap>() {
        @Override
        public Bitmap call(String filePath) { // 参数类型 String
            return getBitmapFromPath(filePath); // 返回类型 Bitmap
        }
    })
    .subscribe(new Action1<Bitmap>() {
        @Override
        public void call(Bitmap bitmap) { // 参数类型 Bitmap
            showBitmap(bitmap);
        }
    });