Android-RxJava(异步处理机制)

RxJava

观察者模式

Observer（观察者） --> OnclickListener
Observable(被观察者) --> button
subscribe(订阅) --> setOnclickListener
onNext(事件) --> onclick()

除了onNext之外还有两个事件
onCompleted() 和 onError()
这两个事件放在最后，而且运行了其中一个，不会再调用另一个

详解

• Observser/Subsrciber（观察者）

subsrciber和observer一样，但是subsrciber多了一个onStart()方法，会在subscribe(订阅)刚开始，事件还未发送之前被调用，可以用来做 数据的清零 或 重置 。
unsubscribe() 取消订阅，这个方法调用后，subscriber将不再接收事件

• Observable（被观察者）

Observable observable = Observable.create(new Observable.OnSubscribe<String>(){
    @Override
    public void call(Subscriber<? super String> subscriber){
    
    }
});

当observable被订阅时，就会自动调用 call() 方法

create() 方法是RxJava最基本的创造事件序列方法

还有两种

just() 方法：将传入的参数依次发送出来

比如：Observable observable = Observable.just("hello", "hi");
    相当于依次调用
    onNext("hello");
    onNext("hi");
    onCompleted();

from() 方法：将传入的数组或Iterable拆分成具体对象后，依次发送出来

比如：String[] words = {"hello", "hi"};
    Observable observable = Observable.from(words);

• Subscribe（订阅）
  创建了Observer和Observable之后，使用 subscribe() 联结

observable.subscribe(observer)
或者
observable.subscribe(subscriber)

subscribe支持不完整定义的回调，RxJava会自动创建出subscriber

Action1<String> onNextAction = new Action1<String>(){
    //相当于调用onNext方法
	@Override
	public void call(String s) {
    	Log.d(tag, s);
	}
}

Action0 onCompletedAction = new Action0(){
    //相当于调用onCompleted方法
	@Override
	public void call() {
    	Log.d(tag, s);
	}
}

//自动创建subscriber，并使用onNextAction来定义onNext()
observable.subscribe(onNextAction);
//自动创建subscriber，并使用onNextAction来定义onNext(),使用onCompletedAction来定义onCompleted()
observable.subscribe(onNextAction, onCompletedAction);

Action0和Action1是接口，只有一个方法call()
Action0可将onCompleted()内容打包（onCompleted方法无参数无返回值）
Action1可将onNext()和onError()内容打包（onNext和onError方法单参数无返回值）

例子

• 使用Action来完成一次RxJava

String[] names = ...;
Observable.from(names)	//创建observable
        .subscribe(new Action1<String>() {		//订阅并自动创建subscriber
        	@Override
       		public void call(String name) {		//相当于调用onNext()方法打印名字
        		Log.d(tag, name);
        	}
    	});

• 常规完成一次RxJava

int drawableRes = ...;
ImageView imageView = ...;
Observable.create(new OnSubscribe<Drawable>() {  //创建Observable
    		@Override
    		public void call(Subscriber<? super Drawable> subscriber) {
        		Drawable drawable = getTheme().getDrawable(drawableRes));
        		subscriber.onNext(drawable);	//调用subscriber的onNext()方法
        		subscriber.onCompleted();
    		}
	}).subscribe(new Observer<Drawable>() {	//订阅，然后调用Observable的call()方法
    		@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();
    		}
	});

Scheduler（线程控制）

Schedulers.immediate();		//直接在当前线程运行
Schedulers.newThread();	    //启用新线程，并在新线程中运行
Schedulers.io();			//读写文件，读写数据库，网络信息交互等
AndroidSchedulers.mainThread()	//指定的操作将在Android主线程运行

subscribeOn()指定subscribe()发生的线程，即订阅时运行的线程，就是call()方法运行的线程
（只能调用一次，而且是第一个才有用）

observeOn()指定subscriber运行的线程，即回调发生的线程，就是onNext()等方法运行的线程
（不限次数）

Scheduler的原理（变换）

第一种变换 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);
            }
        });

Func1和Action1类似，FuncX包装的是有返回值的方法
调用map()方法后，String对象转变成bitmap对象后返回

第二种变换 flatMap()

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		
        //激活observable对象
        public Observable<Course> call(Student student) {
            return Observable.from(student.getCourses());	//依次发送学生成绩，汇入同一个Observable，然后统一交给onNext()
        }
    }).subscribe(subscriber);

个人总结

Action0 无参数无返回值
Action1 有参数无返回值
Func1 有参数有返回值