Reactive Programming with RxJava-Chapter4:Applying Reactive Programming to Existing Application(1)

From Collections to Observables

BlockingObservable:Exiting the Reactive World

List<Person> people = personDao
            .listPeople()
            .toList()
            .toBlocking()
            .single()

Embracing laziness

public Observable<Person> listPeople(){
    return Observable.defer(() ->
        Observable.from(query("SELECT * FROM PEOPLE")));
}

void bestBookFor(Person person){
    recommend(person)
            .onErrorResumeNext(bestSeller())
            .map(Book::getTitle)
            .subscribe(this::display);
}

Composing Observables()

Lazy paging and concatenation

Obsevabel<Person> people=Observable
            .range(0,Integer.Max_VALUE)
            .map(this::listPeople)
            .takeWhile(list->!list.isEmpty())
            .concatMap(Observable::from);

Imperative Concurrency

Where to Subscribe
Pay attention to where you see subscribe() in domain code.Often your business logic is just composing Observables all the way down and returning then to some sort of framewoik or scaffolding layer.The actual subscription happens behind the scenes in a web framework or some glue code.It`s not a bad practice to call subscribe() yourself,but try to push it out as far as possible.

Whenever you see double-wrapped type(for example Optional

Observabel<Ticket> ticket= flight
        .zipWith(passenger,this::rxBookTicket)
        .flatMap(obs->obs);

You might perceive flatmap() as merely a syntactic trick to avoid a nested Observable< Observable<…> > problem,but it`s much more fundamental than this.

flatMap() as Asynchronous Chaining Operator

List<Ticket> failures = Observable.from(tickets)
    .flatMap(ticket ->
        rxSendEmail(ticket)
            .ingoreElements()
            //.flatMap(response -> Observable.<Ticket>empty())
            .doOnError(e -> log.warn("Failed to send {}",ticket,e))
            .onErrorRetrun(err -> ticket)
    .toList()
    .toBlocking()
    .single()

Attention
Remember that Observables are synchronous by default;however,we can easily change that and apply concurrency in places where it was least expected.This is especially valuable in existing legacy applications,which you can optimize without much hassle.

Wrapping up if you are implementing Obsrvables from scratch,making them asynchronous by default is more idiomatic.

最后，安利一款自己写的基于MVP的Android开发框架

https://github.com/sxenon/Pure
欢迎大家拍砖，如果觉得好，麻烦多多star