RxJava implements this operator as create.

It is good practice to check the observer’s isUnsubscribed state from within the function you pass tocreate so that your Observable can stop emitting items or doing expensive calculations when there is no longer an interested observer.

创建的这个流,会产生三个值(事件),值可以用户自己定义。
Observable.create(xxxx),返回一个流

  

XXXX方法,是用户自定义的。要实现一个自定义的call方法。
Observable.OnSubscribe<?>,?指定了流产生的事件的值类型,一个事件包含了值的信息。
在流里面,检查外部是否有观察者(observer),如果没有就不用产生事件了。这样可以避免,在没有观察者处理产生的事件时,依然在发出事件。
 
在下述代码里面,流它做的事情是,用红色代码表示,产生4个onNext事件;然后,产生一个onCompleted事件。
然后,观察者,订阅流发出的事件,对流发出的事件做响应,用蓝色代码表示。 
下述代码的事件流:
--onNext---onNext---onNext---onNext---onCompleted--
订阅者对事件进行处理
Observable.create(new Observable.OnSubscribe<Integer>() {
@Override
public void call(Subscriber<? super Integer> observer) {
try {
if (!observer.isUnsubscribed()) {
for (int i = 1; i < 5; i++) {
observer.onNext(i);
}
observer.onCompleted();
}
} catch (Exception e) {
observer.onError(e);
}
}
} ).subscribe(new Subscriber<Integer>() {
@Override
public void onNext(Integer item) {
System.out.println("Next: " + item);
} @Override
public void onError(Throwable error) {
System.err.println("Error: " + error.getMessage());
} @Override
public void onCompleted() {
System.out.println("Sequence complete.");
}
});

结果:

Next: 1
Next: 2
Next: 3
Next: 4
Sequence complete.

Scheduler

If you want to introduce multithreading into your cascade of Observable operators, you can do so by instructing those operators (or particular Observables) to operate on particular Schedulers.
 
Scheduler用来定义,流中产生值的操作,在哪个线程工作;订阅者,在哪个线程工作。
 
Some ReactiveX Observable operators have variants that take a Scheduler as a parameter. These instruct the operator to do some or all of its work on a particular Scheduler.
可以指定流的操作是在哪个线程中执行的,通过传入一个Scheduler参数。
 
You can make an Observable act on a particular Scheduler by means of the ObserveOn or SubscribeOn operators. ObserveOn instructs an Observable to call its observer’s onNextonError, and onCompletedmethods on a particular Scheduler; SubscribeOn takes this a step further and instructs the Observable to do all of its processing (including the sending of items and notifications to observers) on a particular Scheduler.
 
你可以让一个流,在某个Scheduler中执行,通过给流的方法ObserveOn,SubscribeOn提供参数Scheduler。
ObserveOn方法,指定流(Observable)在哪个线程中调用观察者(observer)的onNext,onError,onCompleted方法。
SubscribeOn指定流的所有处理,生成事件和值的执行操作,是在哪个线程中执行的。
 

Varieties of Scheduler

You obtain a Scheduler from the factory methods described in the Schedulers class. The following table shows the varieties of Scheduler that are available to you by means of these methods in RxJava:

可以通过Scheduler的工厂方法,取得一个scheduler实例。
根据使用场景,选择合适的Scheduler实例。
 
Scheduler purpose
Schedulers.computation( ) meant for computational work such as event-loops and callback processing; do not use this scheduler for I/O (use Schedulers.io( )instead); the number of threads, by default, is equal to the number of processors
Schedulers.from(executor) uses the specified Executor as a Scheduler
Schedulers.immediate( ) schedules work to begin immediately in the current thread
Schedulers.io( ) meant for I/O-bound work such as asynchronous performance of blocking I/O, this scheduler is backed by a thread-pool that will grow as needed; for ordinary computational work, switch toSchedulers.computation( )
Schedulers.newThread( ) creates a new thread for each unit of work
Schedulers.trampoline( ) queues work to begin on the current thread after any already-queued work
---------------------------------------
完整例子代码
 
1.回调方法执行先后顺序
------->onCreateView------>onActivityCreated---->onDestroy
 
2.执行界面元素注入,初始化界面操作。
 
3.然后,监听点击事件。每次点击的时候,就专门生成一个事件流(Observable),并且生成一个观察者Observer专门订阅事件流发出的事件。
Observer处理发出的事件是在UI线程中进行,事件流调用方法observeOn(AndroidSchedulers.mainThread())来达到。
事件流,产生事件和执行后台操作,则是在一个非线程中执行,调用方法subscribeOn(Schedulers.io())。
 
4.界面销毁的时候
则不再订阅事件流。
 
下述例子,一个事件流的过程:
首先_doSomeLongOperation_thatBlocksCurrentThread执行该操作,然后,依次发出
--onNext--onCompleted--
 
相应的,订阅者,则对发出的事件进行处理。

public class ConcurrencyWithSchedulersDemoFragment extends BaseFragment {

    @InjectView(R.id.progress_operation_running) ProgressBar _progress;
@InjectView(R.id.list_threading_log) ListView _logsList; private LogAdapter _adapter;
private List<String> _logs;
private Subscription _subscription; @Override
public void onDestroy() {
super.onDestroy();
if (_subscription != null) {
_subscription.unsubscribe();
}
} @Override
public void onActivityCreated(@Nullable Bundle savedInstanceState) {
super.onActivityCreated(savedInstanceState);
_setupLogger();
} @Override
public View onCreateView(LayoutInflater inflater,
@Nullable ViewGroup container,
@Nullable Bundle savedInstanceState) {
View layout = inflater.inflate(R.layout.fragment_concurrency_schedulers, container, false);
ButterKnife.inject(this, layout);
return layout;
} @OnClick(R.id.btn_start_operation)
public void startLongOperation() { _progress.setVisibility(View.VISIBLE);
_log("Button Clicked"); _subscription = AppObservable.bindFragment(this, _getObservable()) // Observable,相当于是stream,流
.subscribeOn(Schedulers.io())
.observeOn(AndroidSchedulers.mainThread())
.subscribe(_getObserver()); // Observer
} private Observable<Boolean> _getObservable() {
return Observable.create(new Observable.OnSubscribe<Boolean>() { @Override
public void call(Subscriber<? super Boolean> observer) { if(!observer.isUnsubscribed())
{
_log("Within Observable"); _doSomeLongOperation_thatBlocksCurrentThread();
observer.onNext(true);
observer.onCompleted();
} }
});
} /**
* Observer that handles the result List<Integer> from Observable
* through the 3 important actions:
*
* 1. onCompleted
* 2. onError
* 3. onNext
*/
private Observer<Boolean> _getObserver() {
return new Observer<Boolean>() { @Override
public void onCompleted() {
_log("On complete");
_progress.setVisibility(View.INVISIBLE);
} @Override
public void onError(Throwable e) {
Timber.e(e, "Error in RxJava Demo concurrency");
_log(String.format("Boo Error %s", e.getMessage()));
_progress.setVisibility(View.INVISIBLE);
} @Override
public void onNext(Boolean aBoolean) {
_log(String.format("onNext with return value \"%b\"", aBoolean));
}
};
} // -----------------------------------------------------------------------------------
// Method that help wiring up the example (irrelevant to RxJava) private void _doSomeLongOperation_thatBlocksCurrentThread() {
_log("performing long operation"); try {
Thread.sleep(3000); } catch (InterruptedException e) {
Timber.d("Operation was interrupted");
}
} private void _log(String logMsg) { if (_isCurrentlyOnMainThread()) {
_logs.add(0, logMsg + " (main thread) ");
_adapter.clear();
_adapter.addAll(_logs);
} else {
_logs.add(0, logMsg + " (NOT main thread) "); // You can only do below stuff on main thread.
new Handler(Looper.getMainLooper()).post(new Runnable() { @Override
public void run() {
_adapter.clear();
_adapter.addAll(_logs);
}
});
}
} private void _setupLogger() {
_logs = new ArrayList<String>();
_adapter = new LogAdapter(getActivity(), new ArrayList<String>());
_logsList.setAdapter(_adapter);
} private boolean _isCurrentlyOnMainThread() {
return Looper.myLooper() == Looper.getMainLooper();
} private class LogAdapter
extends ArrayAdapter<String> { public LogAdapter(Context context, List<String> logs) {
super(context, R.layout.item_log, R.id.item_log, logs);
}
}
}

  

参考资料:http://reactivex.io/documentation/operators/create.html
https://github.com/ReactiveX/RxJava/wiki/The-RxJava-Android-Module

函数式编程--响应式编程 ---android应用例子的更多相关文章

  1. iOS-函数式编程 && 响应式编程概念

    作为一个iOS developer,那么你一定用过Masnory / SnapKit: Masonry是一个OC开发中,非常好用的自动布局的第三方框架: SnapKit是Masonry团队打造的swi ...

  2. 函数式响应式编程 - Functional Reactive Programming

    我们略过概念,直接看函数式响应式编程解决了什么问题. 从下面这个例子展开: 两个密码输入框,一个提交按钮. 密码.确认密码都填写并一致,允许提交:不一致提示错误. HTML 如下: <input ...

  3. 深入浅出-iOS函数式编程的实现 && 响应式编程概念

    简介 本篇主要回顾一下--iOS函数式编程 && 响应式编程概念 ,如何一步步实现函数式编程的过程,对阅读Masonry && SnapKit源码有一定的帮助. 配图 ...

  4. [HMLY]11.iOS函数式编程的实现&&响应式编程概念

    简介 本篇主要回顾一下--iOS函数式编程 && 响应式编程概念 ,如何一步步实现函数式编程的过程,对阅读Masonry && SnapKit源码有一定的帮助. 作为一 ...

  5. RxJava(一):响应式编程与Rx

    一,响应式编程 响应式编程是一种关注于数据流(data streams)和变化传递(propagation of change)的异步编程方式. 1.1 异步编程 传统的编程方式是顺序执行的,必须在完 ...

  6. 使用Reactor响应式编程

    介绍 响应式编程 响应式编程不同于我们熟悉的命令式编程,我们熟悉的命令式编程即代码就是一行接一行的指令,按照它们的顺序一次一条地出现.一个任务被执行,程序就需要等到它执行完了,才能执行下一个任务.每一 ...

  7. 07-Spring5 WebFlux响应式编程

    SpringWebFlux介绍 简介 SpringWebFlux是Spring5添加的新模块,用于Web开发,功能和SpringMvc类似的,WebFlux使用当前一种比较流行的响应式编程框架 使用传 ...

  8. 【响应式编程的思维艺术】 (1)Rxjs专题学习计划

    目录 一. 响应式编程 二. 学习路径规划 一. 响应式编程 响应式编程,也称为流式编程,对于非前端工程师来说,可能并不是一个陌生的名词,它是函数式编程在软件开发中应用的延伸,如果你对函数式编程还没有 ...

  9. 函数响应式编程(FRP)思想-Callback风格

    序 ReactiveCocoa是IOS广为使用的技术框架,而ReactiveCocoa的核心思想就FRP.FRP不同于JAVA的object-oriented和AOP,FRP能让你的代码像数学一样简洁 ...

随机推荐

  1. java多线程三之线程协作与通信实例

    多线程的难点主要就是多线程通信协作这一块了,前面笔记二中提到了常见的同步方法,这里主要是进行实例学习了,今天总结了一下3个实例: 1.银行存款与提款多线程实现,使用Lock锁和条件Condition. ...

  2. EasyJSWebView原理分析

    概述 在iOS6之前,native只能调用webiew里的js代码,官方没有提供js调用native方法的接口.到了iOS7,官方提供了JSContext用来与js交互,native和js可以双向调用 ...

  3. Java中的 toString 方法

    1. Object 类中定义有 public String toString() 方法,其返回值是 String 类型,描述当前对象的有关信息: 2. 在进行 String 与其它类型数据的连接操作时 ...

  4. iOS AVAudioPlayer播放音频时声音太小

    iOS AVAudioPlayer播放音频时声音太小 //引入AVFoundation类库,设置播放模式就可以了 do { try AVAudioSession.sharedInstance().ov ...

  5. nginx的平滑升级,不间断服务

    nginx的平滑升级,不间断服务   Nginx更新真的很快,最近nginx的1.0.5稳定版,nginx的0.8.55和nginx的0.7.69旧的稳定版本已经发布.我一项比较喜欢使用新版本的软件, ...

  6. 修改CSV中的某些值

    file.csv文件如下,然后对其中某些值进行变换操作,刚学Powershell的时候操作起来很麻烦,现在看来其实就是对于哈希表的操作. col1,col2,col3,col4 text1,text2 ...

  7. 内存交换空间(swap)的构建

    一.使用物理分区构建swap 1.先进行分区的行为. [root@iZ255cppmtxZ ~]# fdisk /dev/xvdb Welcome to fdisk (util-linux ). Ch ...

  8. ExtremeComponents源码解析(一)

    一.前言 因参与公司框架改造,在负责前端table组件选型时,原本选了jqGrid和Bootstraptable作为备选方案,评审会上,武哥提了EXtremeComponents,让我也去了解下,看下 ...

  9. BZOJ4771 七彩树(dfs序+树上差分+主席树)

    考虑没有深度限制怎么做.显然的做法是直接转成dfs序上主席树,但如果拓展到二维变成矩形数颜色数肯定没法做到一个log. 另一种做法是利用树上差分.对于同种颜色的点,在每个点处+1,dfs序相邻点的lc ...

  10. 转 :hlda文献学习笔记

    David M.BLEI nCR文献学习笔记(基本完成了)  http://yhbys.blog.sohu.com/238343705.html 题目:The Nested Chinese Resta ...