宇不语
宇不语

RxJava 2.0有什么不同(译)

为什么翻译这篇文章

ReactiveX 于2016.10.29 发布了正式版RxJava 2.0.0，但到我写本文章为止，还没有发现谁完整的翻译了官方的这篇文档 What’s-different-in-2.0。

秉着旧事物迟早被新事物替代的想法，于是我用我没过6级的英语咬牙翻译下这篇文章，希望能帮助年轻的司机。但鉴于本人水平有限，翻译得不好，如果各位大神发现哪里写错了，欢迎发邮件通知我，我会在第一时间改正，本人邮箱:[email protected]

关于我们

作者: 宇不语
个人网站: www.ittianyu.com
个人博客: blog.csdn.net/qq_35064774
Github: github.com/ittianyu
本文地址:点这里

开始

RxJava 2.0 已经按照Reactive-Streams specification规范完全的重写了。2.0 已经独立于RxJava 1.x而存在。

因为Reactive-Streams有一个不同的构架，它改变了一些以往RxJava的用法。这份文档尝试去总结所发生的变化，并描述如何把1.x的代码改写成符合2.x规则的代码。

这个页面是为本库用户写的，这将会有一个分界页面，专门留给为RxJava库开发者以及那些希望为2.x版本开发自定义操作符的用户

Maven 地址和基础包

为了让 RxJava 1.x 和 RxJava 2.x 相互独立，我们把RxJava 2.x 被放在了maven io.reactivex.rxjava2:rxjava:2.x.y 下，类放在了 io.reactivex 包下

用户从 1.x 切换到 2.x 时需要导入的相应的包，但注意不要把1.x和2.x混淆了。

Javadoc

Java 文档

官方2.x的 Java 文档 http://reactivex.io/RxJava/2.x/javadoc/

Nulls

RxJava 2x 不再支持 null 值，如果传入一个null会抛出 NullPointerException

Observable.just(null);

Single.just(null);

Observable.fromCallable(() -> null)
    .subscribe(System.out::println, Throwable::printStackTrace);

Observable.just(1).map(v -> null)
    .subscribe(System.out::println, Throwable::printStackTrace);

这意味着 Observable 不再发射任何值，而只是正常结束或者抛出异常。API 设计者可以定义 Observable 这样的观察者， 因为并不确定具体是什么类型的 Object。例如，如果你需要一个 signaller-like ，你可以定义一个共享的枚举类型，它是一个单独的实例onNext‘d:

enum Irrelevant { INSTANCE; }

Observable source = Observable.create((ObservableEmitter emitter) -> {
   System.out.println("Side-effect 1");
   emitter.onNext(Irrelevant.INSTANCE);

   System.out.println("Side-effect 2");
   emitter.onNext(Irrelevant.INSTANCE);

   System.out.println("Side-effect 3");
   emitter.onNext(Irrelevant.INSTANCE);
});

source.subscribe(e -> { /* Ignored. */ }, Throwable::printStackTrace); 
  
Observable 和 Flowable
 
  
在RxJava 0.x中关于介绍backpressure部分有一个小小的遗憾，那就是没有用一个单独的类，而是使用了Observable。 主要的背压问题是有很多很火的代码，像UI events，不能合理的背压，导致了无法意料的 MissingBackpressureException。
 
  
我们试图在 2.x 中纠正这个问题。因此我们把io.reactivex.Observable 设计成非背压的，并增加一个新的io.reactivex.Flowable 去支持背压。
 
  
好消息是操作符的名字几乎没有改动。坏消息是当你执行’organize imports’时必须要格外的小心，它可能无意的给你选择一个非背压的io.reactivex.Observable 。
 
  
Single
 
  
2.x 的Single类可以发射一个单独onSuccess 或 onError消息。它现在按照Reactive-Streams规范被重新设计，SingleObserver改成了如下的接口。
 
  
interface SingleObserver {
    void onSubscribe(Disposable d);
    void onSuccess(T value);
    void onError(Throwable error);
}
 
  
并遵循协议 onSubscribe (onSuccess | onError)?.
 
  
Completable
 
  
Completable大部分和以前的一样。因为它在1.x的时候就是按照Reactive-Streams的规范进行设计的。
 
  
命名上有些变化， 
 rx.Completable.CompletableSubscriber 变成了 io.reactivex.CompletableObserver 和 onSubscribe(Disposable):
 
  
interface CompletableObserver {
    void onSubscribe(Disposable d);
    void onComplete();
    void onError(Throwable error);
}
 
  
并且仍然遵循协议 onSubscribe (onComplete | onError)?.
 
  
Maybe
 
  
RxJava 2.0.0-RC2 介绍了一个新的类型 Maybe 。从概念上来说，它是Single 和 Completable 的结合体。它可以发射0个或1个通知或错误的信号。
 
  
Maybe类结合了MaybeSource, MaybeObserver作为信号接收接口，同样遵循协议onSubscribe (onSuccess | onError | onComplete)?。因为最多有一个元素被发射，Maybe没有背压的概念。
 
  
这意味着调用onSubscribe(Disposable)请求可能还会触发其他 onXXX方法。和Flowable不同，如果那有一个单独的值要发射，那么只有onSuccess被调用，onComplete不被调用。
 
  
这个新的类,实际上和其他Flowable的子类操作符一样可以发射0个或1个序列。
 
  
Maybe.just(1)
.map(v -> v + 1)
.filter(v -> v == 1)
.defaultIfEmpty(2)
.test()
.assertResult(2);
 
  
Base reactive interfaces
 
  
基础reactive接口
 
  
按照Reactive-Streams风格的Flowable实现了 Publisher接口，其他基础类也实现了类似的基础接口
 
  
interface ObservableSource {
    void subscribe(Observersuper T> observer);
}

interface SingleSource {
    void subscribe(SingleObserversuper T> observer);
}

interface CompletableSource {
    void subscribe(CompletableObserver observer);
}

interface MaybeSource {
    void subscribe(MaybeObserversuper T> observer);
}
 
  
因此，很多操作符需要从用户接收Publisher 和 XSource的一些基础的类型。
 
  
Flowable flatMap(Functionsuper T, ? extends Publisher> mapper);

Observable flatMap(Functionsuper T, ? extends ObservableSource> mapper);
 
  
通过Publisher作为输入，你可以组合其他的遵从Reactive-Streams规范的库，而不需要包裹或把它们转换成Flowable。
 
  
如果一个操作符必须要提供一个基础类，那么用户将会收到一个完整的基础类。
 
  
Flowable> windows = source.window(5);

source.compose((Flowable flowable) -> 
    flowable
    .subscribeOn(Schedulers.io())
    .observeOn(AndroidSchedulers.mainThread()));
 
  
Subjects 和 Processors
 
  
在Reactive-Streams规范中，Subject类似于行为，即消费者和提供者的事件在同一时间发生。随着Observable/Flowable的分离，支持背压的类都是遵从Reactive-Streams规范的FlowableProcessor的子类。一个关于Subject重要的变化是它们不再支持T -> R这样的转换。
 
  
在 2.x 中， io.reactivex.subjects.AsyncSubject, io.reactivex.subjects.BehaviorSubject, io.reactivex.subjects.PublishSubject, io.reactivex.subjects.ReplaySubject 和 io.reactivex.subjects.UnicastSubject 不支持背压。
 
  
io.reactivex.processors.AsyncProcessor, io.reactivex.processors.BehaviorProcessor, io.reactivex.processors.PublishProcessor, io.reactivex.processors.ReplayProcessor 和io.reactivex.processors.UnicastProcessor 支持背压。 BehaviorProcessor 和 PublishProcessor 不能协同请求下级的订阅者，如果下游不能保存，则会发射一个MissingBackpressureException异常。其他XProcessor类支持对下游订阅者背压，但是当被订阅源时，它们会无限制的消费。
 
  
其他类
 
  
rx.observables.ConnectableObservable 现在是io.reactivex.observables.ConnectableObservable 和 io.reactivex.flowables.ConnectableFlowable。
 
  
GroupedObservable
 
  
rx.observables.GroupedObservable 现在是io.reactivex.observables.GroupedObservable 和io.reactivex.flowables.GroupedFlowable.
 
  
在1.x中，你可以用GroupedObservable.from()创建一个实例。在2.x中，所有实例都直接继承了GroupedObservable，因此这个工厂方法不再可用； 现在整个类都是抽象的。
 
  
不过你可以继承类然后添加你自定义的subscribeActual行为来达到1.x中相似的功能。
 
  
class MyGroup extends GroupedObservable {
    final K key;

    final Subject subject;

    public MyGroup(K key) {
        this.key = key;
        this.subject = PublishSubject.create();
    }

    @Override
    public T getKey() {
        return key;
    }

    @Override
    protected void subscribeActual(Observersuper T> observer) {
        subject.subscribe(observer);
    }
}
 
  
功能接口
 
  
1.x 和 2.x 是跑在Java 6以上的虚拟机的，所以我们不能使用Java8的功能接口(functional interfaces)，比如java.util.function.Function。但我们可以按照这个例子来定义自己的功能接口(functional interfaces)。
 
  
一个值得注意的区别是所有的功能接口(functional interfaces)都定义了throws Exception。这对于consumers 和 mappers 来说是一个巨大的便利，你不需要用try-catch捕获异常。
 
  
Flowable.just("file.txt")
.map(name -> Files.readLines(name))
.subscribe(lines -> System.out.println(lines.size()), Throwable::printStackTrace);
 
  
如果文件不存在或者不可读，结尾的consumer会直接输出IOException。你可以直接调用Files.readLines(name)而不需要捕获异常。
 
  
Actions
 
  
为了减少组件数量，2.x中没有定义Action3-Action9和ActionN。
 
  
保留的action接口按照Java 8 functional风格命名。 无参数的Action0 被操作符io.reactivex.functions.Action和Scheduler代替。Action1被重命名为Consumer。Action2 被重命名为BiConsumer。 ActionN 被Consumer 代替。
 
  
Functions
 
  
我们按照Java 8的命名风格定义了io.reactivex.functions.Function 和io.reactivex.functions.BiFunction, 把Func3 - Func9 分别改成了 Function3 - Function9 。FuncN被Function代替。
 
  
此外，操作符不再使用Func1但原始返回类型为Predicate。
 
  
io.reactivex.functions.Functions类提供了常见的转换功能Function
 
  
Subscriber
 
  
Reactive-Streams规范有自己的Subscriber。这个接口是轻量级的，并且把请求管理和取消机制整合进了一个单独的接口org.reactivestreams.Subscription，而不是分别用rx.Producer 和 rx.Subscription。这就可以用比1.x中rx.Subscriber更少的内部状态来创建一个stream consumers。
 
  
Flowable.range(1, 10).subscribe(new Subscriber() {
    @Override
    public void onSubscribe(Subscription s) {
        s.request(Long.MAX_VALUE);
    }

    @Override
    public void onNext(Integer t) {
        System.out.println(t);
    }

    @Override
    public void onError(Throwable t) {
        t.printStackTrace();
    }

    @Override
    public void onComplete() {
        System.out.println("Done");
    }
});
 
  
由于命名冲突，把rx 包改成org.reactivestreams。此外org.reactivestreams.Subscriber 不能从外面添加、取消或请求。
 
  
为了弥补这一空缺，我们为Flowable定义了抽象类DefaultSubscriber, ResourceSubscriber 和 DisposableSubscriber 分别提供了类似于rx.Subscriber的资源跟踪支持，并且可以从外面取消 dispose():
 
  
ResourceSubscriber subscriber = new ResourceSubscriber() {
    @Override
    public void onStart() {
        request(Long.MAX_VALUE);
    }

    @Override
    public void onNext(Integer t) {
        System.out.println(t);
    }

    @Override
    public void onError(Throwable t) {
        t.printStackTrace();
    }

    @Override
    public void onComplete() {
        System.out.println("Done");
    }
};

Flowable.range(1, 10).delay(1, TimeUnit.SECONDS).subscribe(subscriber);

subscriber.dispose();
 
  
注意，由于Reactive-Streams的兼容性，方法onCompleted被重命名为onComplete。
 
  
因为1.x中，Observable.subscribe(Subscriber)返回Subscription，用户经常添加Subscription到CompositeSubscription中，例如:
 
  
CompositeSubscription composite = new CompositeSubscription();

composite.add(Observable.range(1, 5).subscribe(new TestSubscriber()));
 
  
由于Reactive-Streams规范，Publisher.subscribe无返回值。为了弥补这一点，我们增加了E subscribeWith(E subscriber)方法。因为在2.x中ResourceSubscriber 直接实现了Disposable，所以代码可以这样写。
 
  
CompositeDisposable composite2 = new CompositeDisposable();

composite2.add(Flowable.range(1, 5).subscribeWith(subscriber));
 
  
在onSubscribe/onStart中调用request
 
  
注意，在Subscriber.onSubscribe或ResourceSubscriber.onStart中调用request(n)将会立即调用onNext，实例代码如下：
 
  
Flowable.range(1, 3).subscribe(new Subscriber() {

    @Override
    public void onSubscribe(Subscription s) {
        System.out.println("OnSubscribe start");
        s.request(Long.MAX_VALUE);
        System.out.println("OnSubscribe end");
    }

    @Override
    public void onNext(Integer v) {
        System.out.println(v);
    }

    @Override
    public void onError(Throwable e) {
        e.printStackTrace();
    }

    @Override
    public void onComplete() {
        System.out.println("Done");
    }
});
 
  
This will print: 
 将会打印:
 
  
OnSubscribe start
1
2
3
Done
OnSubscribe end
 
  
当你在onSubscribe/onStart中做了一些初始化的工作，而这些工作是在request后面时，会出现一些问题，在onNext执行时，你的初始化工作的那部分代码还没有执行。为了避免这种情况，请确保你调用request时，已经把所有初始化工作做完了。
 
  
这个行为不同于1.x中的 request要经过延迟的逻辑直到上游的Producer到达时。在2.x中，总是Subscription先传递下来，90%的情况下没有延迟请求的必要。
 
  
Subscription
 
  
在RxJava 1.x中，接口rx.Subscription负责流和资源的生命周期管理，即退订和释放资源，例如scheduled tasks。Reactive-Streams规范用这个名称指定source和consumer之间的关系: org.reactivestreams.Subscription 允许从上游请求一个正数，并支持取消。
 
  
为了避免名字冲突，1.x的rx.Subscription被改成了 io.reactivex.Disposable。
 
  
因为Reactive-Streams的基础接口org.reactivestreams.Publisher 定义subscribe()为无返回值，Flowable.subscribe(Subscriber)不再返回任何Subscription。其他的基础类型也遵循这种规律。
 
  
在2.x中其他的subscribe的重载方法返回Disposable。
 
  
原始的Subscription容器类型已经被重命名和修改。
 
  
     
   
  • CompositeSubscription 改成 CompositeDisposable，
    •  
   
  • SerialSubscription 和MultipleAssignmentSubscription 被合并到了 SerialDisposable。 set() 方法取消了旧值，而replace()方法没有。
    •  
   
  • RefCountSubscription 已被删除。
    •  
  
 
  
背压
 
  
Reactive-Streams规范的操作符支持背压，特别是当它们不发送请求时，它们不会溢出。新的操作符Flowable被设计成适合下游请求，然而这个不意味着MissingBackpressureException不会出现。这个异常仍然存在。但这一次，onNext会抛出这个异常。
 
  
作为替代，在2.x中Observable完全不支持背压，但可以被替换。
 
  
Reactive-Streams compliance
 
  
Flowable-based sources和operators是遵从Reactive-Streams 1.0.0规范的，除了一个规则§3.9和解释的规则§1.3:
 
  
 
   
§3.9: While the Subscription is not cancelled, Subscription.request(long n) MUST signal onError with a java.lang.IllegalArgumentException if the argument is <= 0. The cause message MUST include a reference to this rule and/or quote the full rule.
 
  
 
  
Rule §3.9 requires excessive overhead to handle (half-serializer on every operator dealing with request()) for a bug-case. RxJava 2 (and Reactor 3 in fact) reports the IllegalArgumentException to RxJavaPlugins.onError and ignores it otherwise. RxJava 2 passes the Test Compatibility Kit (TCK) by applying a custom operator that routes the IllegalArgumentException into the Subscriber.onError in an async-safe manner. All major Reactive-Streams libraries are free of such zero requests; Reactor 3 ignores it as we do and Akka-Stream uses a converter (to interact with other RS sources and consumers) which has (probably) a similar routing behavior as our TCK operator. 
 
  
 
   
§1.3: onSubscribe, onNext, onError and onComplete signaled to a Subscriber MUST be signaled sequentially (no concurrent notifications).
 
  
 
  
TCK 允许同步但限制onSubscribe 和 onNext之间往返。也就是说在onSubscribe中，调用request(1)后将会调用onNext，在onNext返回后request(1)才会返回。虽然大部分操作符都是这样的，但操作符observeOn会异步的调用onNext，因此onSubscribe会和onNext同时被调用。这就是由TCK来检测，我们使用another operator来延迟下游请求直到onSubscribe返回。再次声明，这种异步行为不是RxJava 2的一个问题，因为在Reactor 3中操作符是线程安全的执行onSubscribe。Akka-Stream的转换类似于延迟请求。
 
  
因为这两个影响inter-library的行为，我们考虑在以后给Flowable增加了一个标准的操作符，把这两种行为改到一个单独的方法。
 
  
Runtime hooks
 
  
2.x 中重新设计了RxJavaPlugins类，现在支持运行时改变回调。测试需要重写schedulers，生命周期方法可以通过回调函数。
 
  
RxJavaObservableHook和友类现在都取消了，RxJavaHooks功能被加入到了RxJavaPlugins。
 
  
Schedulers
 
  
在2.x的API中仍然支持主要的默认scheduler: computation, io, newThread 和 trampoline，可以通过io.reactivex.schedulers.Schedulers这个实用的工具类来调度。
 
  
2.x中不存在immediate 调度器。 它被频繁的误用，并没有正常的实现 Scheduler 规范；它包含用于延迟动作的阻塞睡眠，并且不支持递归调度。你可以使用Schedulers.trampoline()来代替它。
 
  
Schedulers.test()已经被移除，这样避免了默认调度器休息的概念差异。那些返回一个”global”的调度器实例是鉴于test()总是返回一个新的TestScheduler实例。现在我们鼓励测试人员使用这样简单的代码new TestScheduler()。
 
  
io.reactivex.Scheduler抽象类现在支持直接调度任务，不需要先创建然后通过Worker调度。
 
  
public abstract class Scheduler {

    public Disposable scheduleDirect(Runnable task) { ... }

    public Disposable scheduleDirect(Runnable task, long delay, TimeUnit unit) { ... }

    public Disposable scheduleDirectPeriodically(Runnable task, long initialDelay, 
        long period, TimeUnit unit) { ... }

    public long now(TimeUnit unit) { ... }

    // ... rest is the same: lifecycle methods, worker creation
}
 
  
主要的目的是为了避免跟踪Worker的开销。方法有一个默认的实现，你可以直接复用 createWorker ，但如果有需要，你也可以重写它来实现更强大的功能。
 
  
这些方法返回了当前时间调度器的概念， now()被改成接受一个用于指定单位量的TimeUnit的方法。
 
  
进入reactive的世界
 
  
RxJava 1.x的设计缺陷之一是暴露了rx.Observable.create()方法，该方法虽然很强大，但导致了你很少使用内置典型的操作符。不幸的是，有太多的代码依赖于这个库，所以我们不能删除或重命名它。
 
  
2.x是一个新的开始，我们不会再犯这个错误了。每一个基础类Flowable, Observable, Single, Maybe 和 Completable 都有安全的create操作符去支持背压和取消。
 
  
Flowable.create((FlowableEmitter emitter) -> {
    emitter.onNext(1);
    emitter.onNext(2);
    emitter.onComplete();
}, BackpressureStrategy.BUFFER);
 
  
实际上，1.x中fromEmitter已经被重命名为Flowable.create。其他基础类型也有类似的create方法。
 
  
离开reactive的世界
 
  
除了subscribing 各自的consumers(Subscriber, Observer, SingleObserver, MaybeObserver 和 CompletableObserver) 以及functional-interface 基础consumers(例如 subscribe(Consumer, Consumer, Action))，以前在1.x中独立的BlockingObservable 已经集成了主要的基础类型。现在你可以直接调用blockingX来阻塞等待结果:
 
  
List list = Flowable.range(1, 100).toList().blockingGet(); // toList() returns Single

Integer i = Flowable.range(100, 100).blockingLast();
 
  
在2.x中另外一个关于rx.Subscriber 和org.reactivestreams.Subscriber重要的区别是，你的Subscriber和Observer不允许抛出任何致命的异常。这意味着下面这样的代码不再是合法的:
 
  
Subscriber subscriber = new Subscriber() {
    @Override
    public void onSubscribe(Subscription s) {
        s.request(Long.MAX_VALUE);
    }

    public void onNext(Integer t) {
        if (t == 1) {
            throw new IllegalArgumentException();
        }
    }

    public void onError(Throwable e) {
        if (e instanceof IllegalArgumentException) {
            throw new UnsupportedOperationException();
        }
    }

    public void onComplete() {
        throw new NoSuchElementException();
    }
};

Flowable.just(1).subscribe(subscriber);
 
  
这样的规则同样适用于Observer, SingleObserver, MaybeObserver 和 CompletableObserver。
 
  
由于很多现有基于1.x的代码做了类似的事情，我们设计了safeSubscribe方法来帮助你处理这样的代码。
 
  
当然你也可以使用subscribe(Consumer, Consumer, Action)方法来提供一个回调。
 
  
Flowable.just(1)
.subscribe(
    subscriber::onNext, 
    subscriber::onError, 
    subscriber::onComplete, 
    subscriber::onSubscribe
);
 
  
Testing
 
  
测试RxJava 2.x和1.x中一样，Flowable可以用io.reactivex.subscribers.TestSubscriber测试，而非背压的Observable, Single, Maybe 和 Completable可以用io.reactivex.observers.TestObserver测试。
 
  
test() “operator”
 
  
为了支持我们内部测试，所有的基础类都有 test() 方法，返回TestSubscriber 或 TestObserver:
 
  
TestSubscriber ts = Flowable.range(1, 5).test();

TestObserver to = Observable.range(1, 5).test();

TestObserver tso = Single.just(1).test();

TestObserver tmo = Maybe.just(1).test();

TestObserver tco = Completable.complete().test();
 
  
第二个便利之处在于，大部分TestSubscriber/TestObserver方法返回自身实例，这让我们可以链式调用各种assertX方法。第三个便利是，你可以流畅的测试你的代码而不需要去创建或者引入TestSubscriber/TestObserver实例。
 
  
Flowable.range(1, 5)
.test()
.assertResult(1, 2, 3, 4, 5)
;
 
  
值得注意的新的断言方法
 
  
     
   
  • assertResult(T... items): 断言在onComplete中将会按指定顺序收到给定的值，并且没有错误。
    •  
   
  • assertFailure(Class clazz, T... items): 断言将会收到指定的异常。
    •  
   
  • assertFailureAndMessage(Class clazz, String message, T... items): 和assertFailure一样，但还会验证 getMessage() 中包含的值。
    •  
   
  • awaitDone(long time, TimeUnit unit) 等待一个终结事件，如果超时了，将会取消该事件。
    •  
   
  • assertOf(Consumer> consumer) 组成一些断言到流式链中。
    •  
  
 
  
其中一个好处是，把Flowable改为Observable，所以测试代码不需要改变，内部的已经把TestSubscriber改成了TestObserver。
 
  
提前取消和请求
 
  
TestObserver中的test()方法有一个 test(boolean cancel) 重载，它能在订阅前取消TestSubscriber/TestObserver:
 
  
PublishSubject pp = PublishSubject.create();

// nobody subscribed yet
assertFalse(pp.hasSubscribers());

pp.test(true);

// nobody remained subscribed
assertFalse(pp.hasSubscribers());
 
  
TestSubscriber 有 test(long initialRequest) 和 test(long initialRequest, boolean cancel) 重载，用于指定初始请求数量以及TestSubscriber是否应该立即被取消。如果initialRequest被给定，TestSubscriber 实例通常需要被捕获以便访问request()方法:
 
  
PublishProcessor pp = PublishProcessor.create();

TestSubscriber ts = pp.test(0L);

ts.request(1);

pp.onNext(1);
pp.onNext(2);

ts.assertFailure(MissingBackpressureException.class, 1);
 
  
测试异步代码
 
  
对于给定的异步代码，流畅的阻塞终端事件是可能的:
 
  
Flowable.just(1)
.subscribeOn(Schedulers.single())
.test()
.awaitDone(5, TimeUnit.SECONDS)
.assertResult(1);
 
  
Mockito & TestSubscriber
 
  
那些在1.x中正在使用Mockito和Observer的用户需要去使用Subscriber.onSubscribe方法去提出初始的请求，否则序列化将会挂起或者失败:
 
  
@SuppressWarnings("unchecked")
public static  Subscriber mockSubscriber() {
    Subscriber w = mock(Subscriber.class);

    Mockito.doAnswer(new Answer() {
        @Override
        public Object answer(InvocationOnMock a) throws Throwable {
            Subscription s = a.getArgumentAt(0, Subscription.class);
            s.request(Long.MAX_VALUE);
            return null;
        }
    }).when(w).onSubscribe((Subscription)any());

    return w;
} 
  
操作符的差别
 
  
2.x中大部分操作符仍然被保留，实际上大部分行为和1.x一样。下面的列表中列出了每一个基础类的在1.x和2.x的区别
 
  
通常来说，很多操作符提供了重载，允许指定运行上游的内部缓冲区的大小或者预先分配的数量。
 
  
一些操作符重载已经被重命名为了后缀风格，比如 fromArray, fromIterable。这么做的原因是，当用Java 8编译时，javac往往不能区分功能接口类型。
 
  
在1.x中被标记为@Beta 或 @Experimental的操作符已经成为正式操作符了。
 
  
1.x Observable 到 2.x Flowable
 
  
工厂方法:
 
  
 
    
    
 
     1.x 
     2.x 
    
 
    
    
    
 
     amb 
     添加 amb(ObservableSource...) 重载, 2-9 参数被删除 
    
 
    
 
     RxRingBuffer.SIZE 
     bufferSize() 
    
 
    
 
     combineLatest 
     增加条目重载, 增加 带bufferSize 参数的重载, combineLatest(List) 被删除 
    
 
    
 
     concat 
     增加带 prefetch 参数的重载, 5-9 重载被删除 , 使用 concatArray 代替 
    
 
    
 
     N/A 
     增加 concatArray 和 concatArrayDelayError 
    
 
    
 
     N/A 
     增加 concatArrayEager 和 concatArrayEagerDelayError 
    
 
    
 
     concatDelayError 
     增加带延时的重载 
    
 
    
 
     concatEagerDelayError 
     增加带延时的重载 
    
 
    
 
     create(SyncOnSubscribe) 
     被 generate + 重载代替 
    
 
    
 
     create(AsnycOnSubscribe) 
     不存在 
    
 
    
 
     create(OnSubscribe) 
     使用安全的 create(FlowableOnSubscribe, BackpressureStrategy), 支持 unsafeCreate() 
    
 
    
 
     from 
     拆分成 fromArray, fromIterable, fromFuture 
    
 
    
 
     N/A 
     增加 fromPublisher 
    
 
    
 
     fromAsync 
     重命名为 create() 
    
 
    
 
     N/A 
     增加 intervalRange() 
    
 
    
 
     limit 
     被删除, 使用 take 
    
 
    
 
     merge 
     增加带 prefetch的重载 
    
 
    
 
     mergeDelayError 
     增加带 prefetch的重载 
    
 
    
 
     sequenceEqual 
     增加带 bufferSize的重载 
    
 
    
 
     switchOnNext 
     增加带 prefetch的重载 
    
 
    
 
     switchOnNextDelayError 
     增加带 prefetch的重载 
    
 
    
 
     timer 
     被废弃 
    
 
    
 
     zip 
     增加带 bufferSize 和 delayErrors 的重载, 拆分成了 zipArray 和 zipIterable 
    
 
    
  
 
  
实例方法:
 
  
 
    
    
 
     1.x 
     2.x 
    
 
    
    
    
 
     all 
     RC3 返回 Single 
    
 
    
 
     any 
     RC3 返回 Single 
    
 
    
 
     asObservable 
     重命名为 hide(), 隐藏所有的身份 
    
 
    
 
     buffer 
     重载自定义的 Collection 提供者 
    
 
    
 
     cache(int) 
     被废弃 
    
 
    
 
     collect 
     RC3 返回 Single 
    
 
    
 
     collect(U, Action2) 
     改成 collectInto 和 RC3 返回 Single 
    
 
    
 
     concatMap 
     增加带 prefetch 的重载 
    
 
    
 
     concatMapDelayError 
     增加带 prefetch的重载, 支持延时 
    
 
    
 
     concatMapEager 
     增加带 prefetch的重载 
    
 
    
 
     concatMapEagerDelayError 
     增加带 prefetch的重载, 支持延时 
    
 
    
 
     count 
     RC3 返回 Single 
    
 
    
 
     countLong 
     被删除, 使用 count 
    
 
    
 
     distinct 
     重载自定义的 Collection 提供者. 
    
 
    
 
     doOnCompleted 
     重命名为 doOnComplete 
    
 
    
 
     doOnUnsubscribe 
     重命名为 Flowable.doOnCancel 和 doOnDispose , additional info 
    
 
    
 
     N/A 
     增加 doOnLifecylce 来处理 onSubscribe, request 和 cancel 
    
 
    
 
     elementAt(int) 
     RC3 不再发射 NoSuchElementException 如果源比索引更小 
    
 
    
 
     elementAt(Func1, int) 
     被删除, 使用 filter(predicate).elementAt(int) 代替 
    
 
    
 
     elementAtOrDefault(int, T) 
     重命名为 elementAt(int, T) 和 RC3 返回 Single 
    
 
    
 
     elementAtOrDefault(Func1, int, T) 
     被删除, 使用 filter(predicate).elementAt(int, T) 代替 
    
 
    
 
     first() 
     RC3 重命名为 firstElement 返回 Maybe 
    
 
    
 
     first(Func1) 
     被删除, 使用 filter(predicate).first()代替 
    
 
    
 
     firstOrDefault(T) 
     重命名为 first(T) RC3 返回 Single 
    
 
    
 
     firstOrDefault(Func1, T) 
     被删除, 使用 filter(predicate).first(T)代替 
    
 
    
 
     flatMap 
     增加带 prefetch的重载 
    
 
    
 
     N/A 
     增加 forEachWhile(Predicate, [Consumer, [Action]]) 用于有条件停止 consumption 
    
 
    
 
     groupBy 
     增加带 bufferSize和 delayError的重载， 支持 支持内部自定义map，RC1中没有 
    
 
    
 
     ignoreElements 
     RC3 返回 Completable 
    
 
    
 
     isEmpty 
     RC3 返回 Single 
    
 
    
 
     last() 
     RC3 重命名为 lastElement 返回 Maybe 
    
 
    
 
     last(Func1) 
     被删除, 使用 filter(predicate).last()代替 
    
 
    
 
     lastOrDefault(T) 
     重命名为 last(T) RC3 返回 Single 
    
 
    
 
     lastOrDefault(Func1, T) 
     被删除, 使用 filter(predicate).last(T)代替 
    
 
    
 
     nest 
     被删除, 使用 just代替 
    
 
    
 
     publish(Func1) 
     增加带 prefetch的重载 
    
 
    
 
     reduce(Func2) 
     RC3 返回 Maybe 
    
 
    
 
     N/A 
     增加 reduceWith(Callable, BiFunction) 为了减少自定义Subscriber, 返回 Single 
    
 
    
 
     N/A 
     增加 repeatUntil(BooleanSupplier) 
    
 
    
 
     repeatWhen(Func1, Scheduler) 
     删除了重载, 使用 subscribeOn(Scheduler).repeatWhen(Function) 代替 
    
 
    
 
     retry 
     增加 retry(Predicate), retry(int, Predicate) 
    
 
    
 
     N/A 
     增加 retryUntil(BooleanSupplier) 
    
 
    
 
     retryWhen(Func1, Scheduler) 
     删除了重载, 使用 subscribeOn(Scheduler).retryWhen(Function) 代替 
    
 
    
 
     N/A 
     增加 sampleWith(Callable, BiFunction) 去扫描自定义的Subscriber方式 
    
 
    
 
     single() 
     RC3 重命名为 singleElement 返回 Maybe 
    
 
    
 
     single(Func1) 
     被删除，使用 filter(predicate).single()代替 
    
 
    
 
     singleOrDefault(T) 
     重命名为 single(T) RC3 返回 Single 
    
 
    
 
     singleOrDefault(Func1, T) 
     被删除，使用 filter(predicate).single(T)代替 
    
 
    
 
     skipLast 
     增加带 bufferSize 和 delayError 的重载 
    
 
    
 
     startWith 
     2-9 参数的被删除了, 使用 startWithArray 代替 
    
 
    
 
     N/A 
     增加 startWithArray 来减少二义性 
    
 
    
 
     N/A 
     增加 subscribeWith 返回输入的订阅对象 
    
 
    
 
     switchMap 
     增加带 prefetch 的重载 
    
 
    
 
     switchMapDelayError 
     增加带 prefetch 的重载 
    
 
    
 
     takeLastBuffer 
     被删除 
    
 
    
 
     N/A 
     增加 test() 
    
 
    
 
     timeout(Func0, ...) 
     方法签名改成了 timeout(Publisher, ...) 删除了方法, 如果有需要，使用 defer(Callable>) 
    
 
    
 
     toBlocking().y 
     内联 blockingY() 操作符, 除了 toFuture 
    
 
    
 
     toCompletable 
     RC3 被删除, 使用 ignoreElements代替 
    
 
    
 
     toList 
     RC3 返回 Single> 
    
 
    
 
     toMap 
     RC3 返回 Single> 
    
 
    
 
     toMultimap 
     RC3 返回 Single>> 
    
 
    
 
     N/A 
     增加 toFuture 
    
 
    
 
     N/A 
     增加 toObservable 
    
 
    
 
     toSingle 
     RC3 被删除, 使用 single(T)代替 
    
 
    
 
     toSortedList 
     RC3 增加 Single> 
    
 
    
 
     withLatestFrom 
     5-9 个参数的重载被删除 
    
 
    
 
     zipWith 
     增加带 prefetch 和 delayErrors 的重载 
    
 
    
  
 
  
不同的返回类型
 
  
2.x中一些的操作符产生确切的一个值或者一个错误时，返回Single。
 
  
 
    
    
 
     操作符 
     旧返回值 
     新返回值 
     备注 
    
 
    
    
    
 
     all(Predicate) 
     Observable 
     Single 
     如果所有的元素都匹配，则发射true 
    
 
    
 
     any(Predicate) 
     Observable 
     Single 
     如果所有的元素都匹配，则发射true 
    
 
    
 
     count() 
     Observable 
     Single 
     计算序列中元素的数量 
    
 
    
 
     elementAt(int) 
     Observable 
     Maybe 
     Emits 给定位置处的元素或完成的元素 
    
 
    
 
     elementAt(int, T) 
     Observable 
     Single 
     发射指定位置的元素或默认元素 
    
 
    
 
     first(T) 
     Observable 
     Single 
     发射第一个元素或者抛出 NoSuchElementException 
    
 
    
 
     firstElement() 
     Observable 
     Maybe 
     发射第一个元素或者结束 
    
 
    
 
     ignoreElements() 
     Observable 
     Completable 
     忽略所有非终端事件 
    
 
    
 
     isEmpty() 
     Observable 
     Single 
     如果源为空，则发射true 
    
 
    
 
     last(T) 
     Observable 
     Single 
     发射最后一个元素或默认值 
    
 
    
 
     lastElement() 
     Observable 
     Maybe 
     发射最后一个元素或结束 
    
 
    
 
     reduce(BiFunction) 
     Observable 
     Maybe 
     发射减少的值或者结束 
    
 
    
 
     reduce(Callable, BiFunction) 
     Observable 
     Single 
     发射减少的值或者初始的值 
    
 
    
 
     reduceWith(U, BiFunction) 
     Observable 
     Single 
     发射减少的值或者初始的值 
    
 
    
 
     single(T) 
     Observable 
     Single 
     发射唯一的元素或默认值 
    
 
    
 
     singleElement() 
     Observable 
     Maybe 
     发射唯一的元素或结束 
    
 
    
 
     toList() 
     Observable> 
     Single> 
     将所有元素放到 List 
    
 
    
 
     toMap() 
     Observable> 
     Single> 
     将所有元素放到 Map 
    
 
    
 
     toMultimap() 
     Observable>> 
     Single>> 
     将所有元素包装到Collection后放到 Map 
    
 
    
 
     toSortedList() 
     Observable> 
     Single> 
     将所有元素放到 List 并排序 
    
 
    
  
 
  
移除
 
  
为了保证最终的2.0API尽可能干净，我们删除了一些候选的方法和组件。
 
  
 
    
    
 
     删除时的版本 
     组件 
     备注 
    
 
    
    
    
 
     RC3 
     Flowable.toCompletable() 
     使用 Flowable.ignoreElements()代替 
    
 
    
 
     RC3 
     Flowable.toSingle() 
     使用 Flowable.single(T)代替 
    
 
    
 
     RC3 
     Flowable.toMaybe() 
     使用 Flowable.singleElement()代替 
    
 
    
 
     RC3 
     Observable.toCompletable() 
     使用 Observable.ignoreElements()代替 
    
 
    
 
     RC3 
     Observable.toSingle() 
     使用 Observable.single(T)代替 
    
 
    
 
     RC3 
     Observable.toMaybe() 
     使用 Observable.singleElement()代替 
    
 
    
  
 
  
其他改变
 
  
doOnCancel/doOnDispose/unsubscribeOn
 
  
在1.x中，doOnUnsubscribe总是执行终端事件，因为SafeSubscriber调用了unsubscribe。这实际上是没有必要的。Reactive-Streams规范中，一个终端事件到达Subscriber，上游的Subscription会取消，因此调用 cancel()是一个空操作。
 
  
由于同样的原因unsubscribeOn也没被在终端路径上调用，但只有实际在链上调用cancel时，才会调用unsubscribeOn。
 
  
因此，下面的序列不会被调用 
 doOnCancel:
 
  
Flowable.just(1, 2, 3)
.doOnCancel(() -> System.out.println("Cancelled!"))
.subscribe(System.out::println);
 
  
然而，下面将会调用take操作符在传送过程中取消onNext
 
  
Flowable.just(1, 2, 3)
.doOnCancel(() -> System.out.println("Cancelled!"))
.take(2)
.subscribe(System.out::println);
 
  
如果你需要在终端或者取消时执行清理，考虑使用using操作符代替。
 
  

                            
                        
                    
                    
                    

                    
                    
                    

                
                

                    
                

            
        
    
    

        
你可能感兴趣的:(RxJava)

        

            

                
    
                    
  • Android JetPack架构——结合记事本Demo一篇打通对Sqlite的增删改查结合常用jetpack架构应用
                        erhtre
程序员androidjetpack架构sqlite
                        
    为什么要用Jetpack?========================================================================关于为什么要用Jetpack，我参考了许多的博客和官方文档，开阔了我对Android生态圈的理解和认识，在Jetpack推出前出现的许许多多强大的第三方框架与语言，典型代表无疑是强大的RxJava在Jetpack仍然有许多粉丝在一
    
                    
    • 
                    
  • Rxjava2你应该懂的源码，其实并不难（二）
                        kwbsky

                        
    接上篇继续。一、线程切换observeOnObservable.just("1").subscribeOn(Schedulers.io()).observeOn(AndroidSchedulers.mainThread()).subscribe(observer)我们知道，当调用observeOn之后，后面执行的代码都将切换到他指定的线程，除非再次调用observeOn切换其他线程。上源码：@Ch
    
                    
    • 
                    
  • Android视频开发进阶-关于视频的那些术语，android软件开发计算器
                        wa32saa
程序员架构移动开发android
                        
    原文出处：jianshu正文说到安卓的视频开发，大多数朋友们都是用着开源的播放器，或者安卓自带的nativemediaplayer，拿来主义居多，我曾经也是。。。最近这半年因为开始着手重构公司的播放器,也开始学习了很多视频音频开发的相关知识，抱着独乐乐不如众乐乐的想法，开始写一些值得分享的东西。这次的连载和之前的RxJava分享一样，会分开不容的章节。第一次我打算分享一下视频开发中常见的一些知识点
    
                    
    • 
                    
  • 2024最新Android大厂面试真题大全（附答案）
                        imtokenmax合约众筹
2024年程序员面试android面试职场和发展
                        
    五、架构设计和设计模式1.谈谈你对Android设计模式的理解2.MVCMVPMVVM原理和区别3.你所知道的设计模式有哪些？4.项目中常用的设计模式5.手写生产者/消费者模式6.写出观察者模式的代码7.适配器模式，装饰者模式，外观模式的异同？8.用到的一些开源框架，介绍一个看过源码的，内部实现过程。9.谈谈对RxJava的理解10.Rxjava发送事件步骤11.RxJava的作用，与平时使用的异
    
                    
    • 
                    
  • Android从零开始搭建MVVM架构（6）
                        m0_66070459
程序员面试移动开发android
                        
    //加载项目build.gradle的anroid标签下dataBinding{enabled=true}添加相关依赖//okhttp、retrofit、rxjavaimplementation‘com.squareup.okhttp3:okhttp:3.8.0’implementation‘com.squareup.retrofit2:retrofit:2.3.0’implementation‘
    
                    
    • 
                    
  • okhttp，retrofit,rxjava 是如何配合工作的 作用分别是什么
                        追梦的鱼儿
okhttpretrofitrxjava
                        
    目录OkHttp作用基本使用Retrofit作用基本使用RxJava作用优势基本使用三者的配合工作OkHttp、Retrofit和RxJava是Android开发中常用的三种库，它们各自有不同的作用，并且可以很好地配合工作来实现网络请求和响应的处理。OkHttp作用OkHttp是一个高效的HTTP客户端，用于发起网络请求和处理响应。它支持同步和异步请求、连接池、缓存、重定向、超时设置等功能。基本使
    
                    
    • 
                    
  • Retrofit+Rxjava-以自己的方式重头开始-入门篇
                        MonkeyLei

                        
    之前小萌新直接上项目，然后立马就用上了Rretrofit和Rxjava来做，没有特别去学习，然后直接就干了。看了看别人的用法。后面也根据个人请求数据结果进行了封装，总共封装了两两次，基本实现了通用请求，一个请求方法就搞定所有请求，返回不同的对象或者对象列表MonkeyLei：Android-Retrofit2+Rxjava2之网络通用请求-初步封装-相关关键类MonkeyLei：Android-R
    
                    
    • 
                    
  • idea: 基于 http 的双向通信
                        weixin_33939380
开发工具java前端ViewUI
                        
    纯http上的双向通信最近大概看了下rxJava的订阅者模式，然后突发奇想有没有可能用类似的思路实现纯http上的双向通信A是传统的http服务器B是普通的客户端，假设我们能够在B上启动一个简易的httpserver并且有办法实现公网访问然后通过类似事件订阅的方式实现双向通信。例：要实现的功能：B是美团外卖商家端，当有用户下单时，B能够收到推送A是美团服务器，当用户下单时，给B发请求通知B实现思路
    
                    
    • 
                    
  • RxJava2+Retrofit2+RxLifecycle3+OkHttp3网络请求封装（动态演示）
                        2301_82241819
程序员网络php开发语言
                        
    ArrayMapmap=newArrayMap{NbaService.getInstance().getNBAInfo(“6949e822e6844ae6453fca0cf83379d3”).subscribeOn(Schedulers.io()).observeOn(AndroidSchedulers.mainThread()).compose(this.bindToLifecycle()).s
    
                    
    • 
                    
  • RxJava学习笔记
                        ztzt123

                        
    之前有过一次学习笔记，发现长时间不经常用Rx的一些操作已经忘得差不多了，经常的复习是多么的重要啊，这次会在上一次不足的部分补充一下。上一次的学习笔记：http://wiki.sankuai.com/pages/viewpage.action?pageId=405485429Rx操作符补充flatMap使用flatMap时将原本发送的数据进行转换，再返回转换后数据的Observable，flatMa
    
                    
    • 
                    
  • Rxjava Transtorming Observables
                        shiyuzhe

                        
    OperatorsthattransformitemsthatareemittedbyanObservable.Buffer—periodicallygatheritemsfromanObservableintobundlesandemitthesebundlesratherthanemittingtheitemsoneatatimeFlatMap—transformtheitemsemitted
    
                    
    • 
                    
  • LiveData 迁移到 Kotlin Flow详解
                        
kotlin
                        
    LiveData，是Android2017推出的一个东西，配合MVVM使用。观察者模式，的确简化了我们的工作方式，但RxJava等选项，对于当时的初学者来说实在是太复杂了。因此ArchitectureComponents团队创建了LiveData：这是个非常“有主见的”可观察数据持有者类，并且是专门为Android设计的。它保持简单明了，这让它易于上手，建议是将RxJava用于更复杂的响应流案例，
    
                    
    • 
                    
  • retrofit+rxjava+okhttp网络框架之二次封装
                        nade_s

                        
    retrofit+rxjava的是这几年很流行的一种网络框架，开发者也提供了丰富的方法。之所以进行二次封装，就是因为retrofit+rxjava的链式调用太方便了，不符合单一性原则，管理起来比较麻烦。主要目的是二次封装后，和项目有很高的契合度更高。说一下封装思路，由于其本身调用方便，具体方法就不做封装了。第一retrofit对象封装。第二封装okhttp拦截器，用于添加头参数，拦截错误日志。第三
    
                    
    • 
                    
  • RxJava常用的操作符
                        emmmmsuperdan
rxjavaandroidjava
                        
    ZipZip:把两个流返回结果一起调用；Zip(a,b,newFunction(b的类型，结合结果的返回类型));
    
                    
    • 
                    
  • Android混淆-基本混淆模板+自定义混淆类NotProguard
                        MonkeyLei

                        
    proguard-rules.pro-第三方就增加了一个glide+rxjava+retrofit，别的按需添加即可#AddprojectspecificProGuardruleshere.#Youcancontrolthesetofappliedconfigurationfilesusingthe#proguardFilessettinginbuild.gradle.##Formoredetai
    
                    
    • 
                    
  • RxJava-使用详解与背压原理2
                        Laughing_G

                        
    一、RxJava1与RxJava2的区别前提：RxJava是响应式编程，基于事件流开发。区别：1.RxJava2不再支持null值，如果传入一个null会抛出NullPointerException；2.Observable.just(null)不支持；3.RxJava2所有的函数接口（Function、Action、Consumer）均设计为可抛出Exception，同时支持自己去解决编译异常需
    
                    
    • 
                    
  • MVP步骤
                        I_Am_Legend

                        
    T-MVP步骤：1.添加依赖implementation'com.squareup.okhttp3:okhttp:3.8.1'implementation'com.squareup.okhttp3:logging-interceptor:3.4.1'implementation'io.reactivex:rxjava:1.1.6'//Retrofit的rx解析库implementation'com
    
                    
    • 
                    
  • 手把手带你入门神秘的RxJava
                        可以写但没有必要

                        
    近两年来国内的技术圈子中越来越多的开始提及RxJava，越来越多的应用和面试中都会有RxJava，而就目前的情况，Android的网络库基本被Retrofit+OkHttp一统天下了，而配合上响应式编程RxJava可谓如鱼得水。什么是RxJava•Rx是ReactiveExtensions的简写，翻译为响应的扩展。也就是通过由一方发出信息，另一方响应信息并作出处理的核心框架代码。•该框架由微软的架
    
                    
    • 
                    
  • Hystrix系列之执行原理分析
                        美团Java

                        
    上文中介绍了Hystrix的由来，本文会深入分析Hystrix的执行过程。Hystrix的大部分逻辑基于RxJava，其实现让很热多人望而却步，停留在了仅仅使用的地步，从一个简单的HelloWorld开始。publicclassCommandHelloWorldextendsHystrixCommand{privatefinalStringname;publicCommandHelloWorld(
    
                    
    • 
                    
  • RxJava之concatMap系列转换操作符源码介绍
                        103style

                        
    转载请以链接形式标明出处：本文出自:103style的博客转换相关的操作符以及官方介绍RxJava之concatMap系列转换操作符官方介绍：TransformingObservablesconcatMapconcatMapCompletableconcatMapCompletableDelayErrorconcatMapDelayErrorconcatMapEagerconcatMapEager
    
                    
    • 
                    
  • Coroutines和Rxjava异步编程对比之二
                        小菜鸟程序媛

                        
    原文地址：https://medium.com/@manuelvicnt/coroutines-and-rxjava-an-asynchronicity-comparison-part-2-cancelling-execution-199485cdf068在Android开发中，取消RxJava或Coroutines的执行时很重要的，因为在View即将被销毁的时候，取消网络请求或者对象的创建是必须
    
                    
    • 
                    
  • Rxjava2019-03-26
                        NullPointe_8e82

                        
    每隔一秒执行list集合中的一条数据//ObservablelistObservable=Observable.fromIterable(Catetorys);////interval定时器，间隔1秒发射一次//ObservabletimerObservable=Observable.interval(1000,TimeUnit.MILLISECONDS);////使用zip操作符合并两个Obse
    
                    
    • 
                    
  • 【Android】RxJava系列01-基本概述和基本用法
                        Rose J
RxJavaandroidrxjava
                        
    少年啊，要永远相信美好的事情即将发生【Android】RxJava系列01-基本概述和基本用法1.RxJava的概述2.RxJava的作用3.观察者和被观察者4.背压5.RxJava的基本用法步骤一，创建Observer（观察者）步骤二，创建Observable（被观察者）步骤三，Subscribe（订阅）1.RxJava的概述RxJava是什么？是ReactiveX的一种Java实现。那，Rea
    
                    
    • 
                    
  • RxSwift的使用详解
                        adaodao3056

                        
    RxSwift的使用详解一.RxSwift简介推荐:RxSwift官方文档中文:RxSwift官方文档的中文翻译RxSwift是Swift函数响应式编程的一个开源库，由Github的ReactiveX组织开发、维护其他语言像C#,Java和JS也有，Rx.Net、RxJava、rxjsRxSwift的目的是让数据/事件流和异步任务能够更方便的序列化处理，能够使用Swift进行响应式编程1.RxSw
    
                    
    • 
                    
  • Retrofit2
                        穷极_d8f1

                        
    Retrofit2的好处超级解耦解耦？解什么耦？我们在请求接口数据的时候，API接口定义和API接口使用总是相互影响，什么传参、回调等，耦合在一块。有时候我们会考虑一下怎么封装我们的代码让这两个东西不那么耦合，这个就是Retrofit的解耦目标，也是它的最大的特点。可以配置不同HttpClient来实现网络请求，如OkHttp、HttpClient...支持同步、异步和RxJava可以配置不同的反
    
                    
    • 
                    
  • Android应用开发进阶，flutter页面跳转防止页面重复刷新
                        m0_64604842
程序员面试android移动开发
                        
    第三章通过Google官方的架构示例项目To-Do，详细介绍了Android的应用架构，包括MVP，MVP-Clean，MVP-Dagger，MVP-RxJava，MVVM-DataBinding，MVVM-Live。第四章介绍了实战项目AndroidPlus，AndroidPlus是一个专注于Andriod领域的知识问答与分享平台，遵循MaterialDesign，使用了MVP-Dagger架构
    
                    
    • 
                    
  • LiveData 迁移到 Kotlin Flow详解
                        xiangzhihong8
深入Android应用开发kotlin开发语言android
                        
    LiveData，是Android2017推出的一个东西，配合MVVM使用。观察者模式，的确简化了我们的工作方式，但RxJava等选项，对于当时的初学者来说实在是太复杂了。因此ArchitectureComponents团队创建了LiveData：这是个非常“有主见的”可观察数据持有者类，并且是专门为Android设计的。它保持简单明了，这让它易于上手，建议是将RxJava用于更复杂的响应流案例，
    
                    
    • 
                    
  • Android Kotlin 基于RxJava的简单封装
                        水天滑稽天照八野滑稽石

                        
    前言使用RxJava无非就是为了开异步任务，所以这儿简单按照个人使用习惯封装了下使用方法单个任务的异步valtask=Task.singleTask{//需要异步进行的任务}.success{//成功回调（这里是UI线程了）}.error{//失败回调（这里是UI线程了）}.interrupted{//被打断回调（这里是UI线程了）}.start()task.cancel()带有进度条的异步val
    
                    
    • 
                    
  • 关于 RxJava2CallAdapterFactory
                        Gubr

                        
    今天在看谷歌最新的框架的时候发现有一段有些疑问的代码publicLiveData>loadUser(Stringlogin){returnnewNetworkBoundResource(appExecutors){//...@NonNull@OverrideprotectedLiveData>createCall(){//这里直接返回并没有像我们常写的那样需要拼接以下代码//subscribeOn
    
                    
    • 
                    
  • Rxjava3文档级教程链接
                        logan.gan
android
                        
    许进进的博客地址：https://blog.csdn.net/LucasXu01Rxjava3文档级教程一：介绍和基本使用https://blog.csdn.net/LucasXu01/article/details/105279367Rxjava3文档级教程二：操作符全解https://blog.csdn.net/LucasXu01/article/details/105312731Rxjava
    
                    
    • 
                                
  • Nginx负载均衡
                                    510888780
nginx应用服务器
                                    
    Nginx负载均衡一些基础知识: 
 
nginx 的 upstream目前支持 4 种方式的分配 
1)、轮询（默认） 
      每个请求按时间顺序逐一分配到不同的后端服务器，如果后端服务器down掉，能自动剔除。 
2)、weight 
      指定轮询几率，weight和访问比率成正比
    
                                
    • 
                                
  • RedHat 6.4 安装 rabbitmq
                                    bylijinnan
erlangrabbitmqredhat
                                    
    在 linux 下安装软件就是折腾，首先是测试机不能上外网要找运维开通，开通后发现测试机的 yum 不能使用于是又要配置 yum 源，最后安装 rabbitmq 时也尝试了两种方法最后才安装成功 
 
机器版本： 
 
[root@redhat1 rabbitmq]# lsb_release
LSB Version:    :base-4.0-amd64:base-4.0-noarch:core
    
                                
    • 
                                
  • FilenameUtils工具类
                                    eksliang
FilenameUtilscommon-io
                                    
    转载请出自出处：http://eksliang.iteye.com/blog/2217081 一、概述 
这是一个Java操作文件的常用库，是Apache对java的IO包的封装，这里面有两个非常核心的类FilenameUtils跟FileUtils，其中FilenameUtils是对文件名操作的封装;FileUtils是文件封装，开发中对文件的操作，几乎都可以在这个框架里面找到。 非常的好用。 
    
                                
    • 
                                
  • xml文件解析SAX
                                    不懂事的小屁孩
xml
                                    
    xml文件解析:xml文件解析有四种方式， 
1.DOM生成和解析XML文档(SAX是基于事件流的解析) 
2.SAX生成和解析XML文档(基于XML文档树结构的解析) 
3.DOM4J生成和解析XML文档 
4.JDOM生成和解析XML  
本文章用第一种方法进行解析，使用android常用的DefaultHandler 
 
 
import org.xml.sax.Attributes;

    
                                
    • 
                                
  • 通过定时任务执行mysql的定期删除和新建分区，此处是按日分区
                                    酷的飞上天空
mysql
                                    
    使用python脚本作为命令脚本，linux的定时任务来每天定时执行 
  
#!/usr/bin/python
# -*- coding: utf8 -*-
import pymysql
import datetime
import calendar

#要分区的表
table_name = 'my_table'
#连接数据库的信息
host,user,passwd,db = 
    
                                
    • 
                                
  • 如何搭建数据湖架构？听听专家的意见
                                    蓝儿唯美
架构
                                    
    Edo Interactive在几年前遇到一个大问题：公司使用交易数据来帮助零售商和餐馆进行个性化促销，但其数据仓库没有足够时间去处理所有的信用卡和借记卡交易数据 
 “我们要花费27小时来处理每日的数据量，”Edo主管基础设施和信息系统的高级副总裁Tim Garnto说道：“所以在2013年，我们放弃了现有的基于PostgreSQL的关系型数据库系统，使用了Hadoop集群作为公司的数
    
                                
    • 
                                
  • spring学习——控制反转与依赖注入
                                    a-john
spring
                                    
           控制反转（Inversion of Control，英文缩写为IoC）是一个重要的面向对象编程的法则来削减计算机程序的耦合问题，也是轻量级的Spring框架的核心。 控制反转一般分为两种类型，依赖注入（Dependency Injection，简称DI）和依赖查找（Dependency Lookup）。依赖注入应用比较广泛。 
  

    
                                
    • 
                                
  • 用spool+unixshell生成文本文件的方法
                                    aijuans
xshell
                                    
    例如我们把scott.dept表生成文本文件的语句写成dept.sql,内容如下:  
　　set pages 50000; 
　　set lines 200; 
　　set trims on; 
　　set heading off; 
　　spool /oracle_backup/log/test/dept.lst; 
　　select deptno||','||dname||','||loc 
    
                                
    • 
                                
  • 1、基础--名词解析(OOA/OOD/OOP)
                                    asia007
学习基础知识
                                    
    OOA:Object-Oriented Analysis（面向对象分析方法） 
是在一个系统的开发过程中进行了系统业务调查以后，按照面向对象的思想来分析问题。OOA与结构化分析有较大的区别。OOA所强调的是在系统调查资料的基础上，针对OO方法所需要的素材进行的归类分析和整理，而不是对管理业务现状和方法的分析。 
　　OOA（面向对象的分析）模型由5个层次（主题层、对象类层、结构层、属性层和服务层）
    
                                
    • 
                                
  • 浅谈java转成json编码格式技术
                                    百合不是茶
json编码java转成json编码
                                    
    json编码;是一个轻量级的数据存储和传输的语言 
   
   在java中需要引入json相关的包,引包方式在工程的lib下就可以了 
  
JSON与JAVA数据的转换（JSON 即 JavaScript Object Natation，它是一种轻量级的数据交换格式，非 
  
常适合于服务器与 JavaScript 之间的数据的交
    
                                
    • 
                                
  • web.xml之Spring配置(基于Spring+Struts+Ibatis)
                                    bijian1013
javaweb.xmlSSIspring配置
                                    
    指定Spring配置文件位置 
<context-param>
		<param-name>contextConfigLocation</param-name>
		<param-value>
			/WEB-INF/spring-dao-bean.xml,/WEB-INF/spring-resources.xml,
			/WEB-INF/
    
                                
    • 
                                
  • Installing SonarQube（Fail to download libraries from server）
                                    sunjing
InstallSonar
                                    
    1.  Download and unzip the SonarQube distribution  
2.  Starting the Web Server 
The default port is "9000" and the context path is "/". These values can be changed in &l
    
                                
    • 
                                
  • 【MongoDB学习笔记十一】Mongo副本集基本的增删查
                                    bit1129
mongodb
                                    
    一、创建复本集 
  
假设mongod,mongo已经配置在系统路径变量上，启动三个命令行窗口，分别执行如下命令： 
  
mongod --port 27017 --dbpath  data1 --replSet rs0

mongod --port 27018 --dbpath  data2 --replSet rs0

mongod --port 27019 -
    
                                
    • 
                                
  • Anychart图表系列二之执行Flash和HTML5渲染
                                    白糖_
Flash
                                    
    今天介绍Anychart的Flash和HTML5渲染功能 
  
 
 HTML5 
 
Anychart从6.0第一个版本起，已经逐渐开始支持各种图的HTML5渲染效果了，也就是说即使你没有安装Flash插件，只要浏览器支持HTML5，也能看到Anychart的图形（不过这些是需要做一些配置的）。 
这里要提醒下大家，Anychart6.0版本对HTML5的支持还不算很成熟，目前还处于
    
                                
    • 
                                
  • Laravel版本更新异常4.2.8-> 4.2.9 Declaration of ... CompilerEngine ... should be compa
                                    bozch
laravel
                                    
    昨天在为了把laravel升级到最新的版本，突然之间就出现了如下错误： 
ErrorException thrown with message "Declaration of Illuminate\View\Engines\CompilerEngine::handleViewException() should be compatible with Illuminate\View\Eng
    
                                
    • 
                                
  • 编程之美-NIM游戏分析-石头总数为奇数时如何保证先动手者必胜
                                    bylijinnan
编程之美
                                    
    


import java.util.Arrays;
import java.util.Random;

public class Nim {

	/**编程之美 NIM游戏分析
问题：
有N块石头和两个玩家A和B，玩家A先将石头随机分成若干堆，然后按照BABA...的顺序不断轮流取石头，
能将剩下的石头一次取光的玩家获胜，每次取石头时，每个玩家只能从若干堆石头中任选一堆，
    
                                
    • 
                                
  • lunce创建索引及简单查询
                                    chengxuyuancsdn
查询创建索引lunce
                                    
    import java.io.File;
import java.io.IOException;

import org.apache.lucene.analysis.Analyzer;
import org.apache.lucene.analysis.standard.StandardAnalyzer;
import org.apache.lucene.document.Docume
    
                                
    • 
                                
  • [IT与投资]坚持独立自主的研究核心技术
                                    comsci
it
                                    
     
 
       和别人合作开发某项产品....如果互相之间的技术水平不同,那么这种合作很难进行,一般都会成为强者控制弱者的方法和手段..... 
 
 
       所以弱者,在遇到技术难题的时候,最好不要一开始就去寻求强者的帮助,因为在我们这颗星球上,生物都有一种控制其
    
                                
    • 
                                
  • flashback transaction闪回事务查询
                                    daizj
oraclesql闪回事务
                                    
       
闪回事务查询有别于闪回查询的特点有以下3个： 
 
（1）其正常工作不但需要利用撤销数据，还需要事先启用最小补充日志。 
 
（2）返回的结果不是以前的“旧”数据，而是能够将当前数据修改为以前的样子的撤销SQL（Undo SQL）语句。 
 
（3）集中地在名为flashback_transaction_query表上查询，而不是在各个表上通过“as of”或“vers
    
                                
    • 
                                
  • Java I/O之FilenameFilter类列举出指定路径下某个扩展名的文件
                                    游其是你
FilenameFilter
                                    
    这是一个FilenameFilter类用法的例子，实现的列举出“c:\\folder“路径下所有以“.jpg”扩展名的文件。        1   2   3   4   5   6   7   8   9   10   11   12   13   14   15   16   17   18   19   20   21   22   23   24   25   26   27   28  
    
                                
    • 
                                
  • C语言学习五函数，函数的前置声明以及如何在软件开发中合理的设计函数来解决实际问题
                                    dcj3sjt126com
c
                                    
    # include <stdio.h>

int f(void)		//括号中的void表示该函数不能接受数据，int表示返回的类型为int类型
{
	return 10;	//向主调函数返回10
}

void g(void)	//函数名前面的void表示该函数没有返回值
{
	//return 10;	//error 与第8行行首的void相矛盾
}

in
    
                                
    • 
                                
  • 今天在测试环境使用yum安装，遇到一个问题： Error: Cannot retrieve metalink for repository: epel. Pl
                                    dcj3sjt126com
centos
                                    
    今天在测试环境使用yum安装，遇到一个问题： 
Error: Cannot retrieve metalink for repository: epel. Please verify its path and try again 
  
处理很简单，修改文件“/etc/yum.repos.d/epel.repo”， 将baseurl的注释取消， mirrorlist注释掉。即可。 
&n
    
                                
    • 
                                
  • 单例模式
                                    shuizhaosi888
单例模式
                                    
    单例模式        懒汉式 
public class RunMain {

	/**
	 * 私有构造
	 */
	private RunMain() {
	}
	
    /**
     * 内部类，用于占位，只有
     */
	private static class SingletonRunMain {
		priv
    
                                
    • 
                                
  • Spring Security（09）——Filter
                                    234390216
Spring Security
                                    
    Filter 
目录 
1.1     Filter顺序 
1.2     添加Filter到FilterChain 
1.3     DelegatingFilterProxy 
1.4     FilterChainProxy 
1.5
    
                                
    • 
                                
  • 公司项目NODEJS实践0.1
                                    逐行分析JS源代码
mongodbnginxubuntunodejs
                                    
      
一、前言 
        前端如何独立用nodeJs实现一个简单的注册、登录功能，是不是只用nodejs+sql就可以了？其实是可以实现，但离实际应用还有距离，那要怎么做才是实际可用的。 
        网上有很多nod
    
                                
    • 
                                
  • java.lang.Math
                                    liuhaibo_ljf
javaMathlang
                                    
    System.out.println(Math.PI); 
System.out.println(Math.abs(1.2)); 
System.out.println(Math.abs(1.2)); 
System.out.println(Math.abs(1)); 
System.out.println(Math.abs(111111111)); 
System.out.println(Mat
    
                                
    • 
                                
  • linux下时间同步
                                    nonobaba
ntp
                                    
    今天在linux下做hbase集群的时候，发现hmaster启动成功了，但是用hbase命令进入shell的时候报了一个错误  PleaseHoldException: Master is initializing，查看了日志，大致意思是说master和slave时间不同步，没办法，只好找一种手动同步一下，后来发现一共部署了10来台机器，手动同步偏差又比较大，所以还是从网上找现成的解决方
    
                                
    • 
                                
  • ZooKeeper3.4.6的集群部署
                                    roadrunners
zookeeper集群部署
                                    
    ZooKeeper是Apache的一个开源项目，在分布式服务中应用比较广泛。它主要用来解决分布式应用中经常遇到的一些数据管理问题，如：统一命名服务、状态同步、集群管理、配置文件管理、同步锁、队列等。这里主要讲集群中ZooKeeper的部署。 
  
1、准备工作 
我们准备3台机器做ZooKeeper集群，分别在3台机器上创建ZooKeeper需要的目录。 
  
数据存储目录
    
                                
    • 
                                
  • Java高效读取大文件
                                    tomcat_oracle
java
                                    
    　　读取文件行的标准方式是在内存中读取，Guava 和Apache Commons IO都提供了如下所示快速读取文件行的方法：   　　Files.readLines(new File(path), Charsets.UTF_8);   　　FileUtils.readLines(new File(path));   　　这种方法带来的问题是文件的所有行都被存放在内存中，当文件足够大时很快就会导致
    
                                
    • 
                                
  • 微信支付api返回的xml转换为Map的方法
                                    xu3508620
xmlmap微信api
                                    
    举例如下： 
<xml> 
   <return_code><![CDATA[SUCCESS]]></return_code> 
   <return_msg><![CDATA[OK]]></return_msg> 
   <appid><
    
                                
    •