Building a reactive mindset

@FMuntenescu
Florina Muntenescu
@FMuntenescu
Building a
Reactive Mindset

@FMuntenescu
Donald
Duck’s Burger
Joint

@FMuntenescu
filter(meat -> isMeatFresh(meat))
map(meat -> cook(meat))
Dewey

@FMuntenescu
zip
STREAMS OF DATA

@FMuntenescu
Consumer
Observable
Subscriber

@FMuntenescu
operators

@FMuntenescu
for(Meat meat: meatList){
if(!isMeatFresh(meat)){
meatList.remove(meat);
}
}

@FMuntenescu
Observable.from(meatSource)
.filter(meat ->
isMeatFresh(meat))

@FMuntenescu
for(Meat meat: meatList){
meat = cook(meat);
}

@FMuntenescu
Observable.from(meatSource)
.filter(meat ->
isMeatGoneBad(meat))
.map(meat -> cook(meat));

@FMuntenescu
Observable<Burger> burgerObservable =
Observable.zip(bunObservable,
meatObservable,
tomatoObservable,
(bun, meat, tomato) ->
makeBurger(bun, meat, tomato))
bunObservable
meatObservable
tomatoObservable
burgerObservable

@FMuntenescu
Consumer
Observable
Subscriber
.subscribe

@FMuntenescu
Subscriber
burgerObservable
.subscribe(mickeySubscriber);

@FMuntenescu
Subscriber
onNext(Burger burger)
onCompleted()
burgerObservable
.subscribe(
burger -> eatBurger(burger),
error -> complain(error),
() -> leaveBurgerJoint());
// onNext
//onError
//onCompleted
onError(Throwable error)

@FMuntenescu
meatObservable,
tomatoObservable,
.subscribe(burger -> eatBurger(burger),
error -> complain(error));
// dining area
// dining area

@FMuntenescu
// kitchen
meatObservable,
tomatoObservable,
// dining area

@FMuntenescu
// kitchen
// dining area
meatObservable,
tomatoObservable,
.subscribeOn(kitchen)
.observeOn(dining area)

@FMuntenescu
meatObservable,
tomatoObservable,
.subscribeOn(Schedulers.computation())
.observeOn(AndroidSchedulers.mainThread())
// kitchen
// dining area

@FMuntenescu
Stream of data
Observable
Subscriber
Operators
Threads

@FMuntenescu
Creating
Observables

@FMuntenescu
Creating
Observables
From a
List

@FMuntenescu
List<Burger> burgers = new ArrayList<>();
burgers.add(new Burger());
Observable.from(burgers);

@FMuntenescu
1 2

@FMuntenescu
burgerObservable.subscribe(new Subscriber<Burger>() {
@Override
public void onNext(final Burger burger) {
}
@Override
public void onCompleted() {
}
@Override
public void onError(final Throwable e) {
}
});

@FMuntenescu
Observable<Burger> burgerObservable = Observable.from(burgers);
@Override
// handle burger 1
}
@Override
}
@Override
}
});
1

@FMuntenescu
@Override
// handle burger 2
}
@Override
}
@Override
}
});
1 2

@FMuntenescu
@Override
}
@Override
// no more burgers!
}
@Override
}
});
1 2

@FMuntenescu
Observable<List<Burger>>
burgerObservable =
Observable.just(burgers);

@FMuntenescu
1
Observable<List<Burger>> burgerObservable
=

@FMuntenescu
Observable<List<Burger>> burgerObservable =
burgerObservable.subscribe(
new Subscriber<List<Burger>>() {
@Override
public void onNext(final List<Burger> burgers) {
}
@Override
}
@Override
}
});

@FMuntenescu
@Override
public void onNext(
final List<Burger> burgers) {
// handle the list of burgers
}
@Override
}
@Override
}
});
1

@FMuntenescu
@Override
public void onNext(
final List<Burger> burgers) {
// handle the list of burgers
}
@Override
// no more burgers!
}
@Override
}
});
1

@FMuntenescu
Creating
Observables
From
Click
Events

@FMuntenescu
[click!] [click!] [click!]

@FMuntenescu
???.subscribe(new Subscriber<String>() {
@Override
public void onNext(final String s) {
// called on every click
}
@Override
}
@Override
}
});

@FMuntenescu
[click!] [click!] [click!]
???.onNext(…) ???.onNext(…) ???.onNext(…)

@FMuntenescu
burgerButton.setOnClickListener(new View.OnClickListener() {
@Override
public void onClick(final View view) {
}
});
PublishSubject<String> burgerRequestedSubject =
PublishSubject.create();

@FMuntenescu
burgerButton.setOnClickListener(new View.OnClickListener() {
@Override
public void onClick(final View view) {
burgerRequestedSubject.onNext(…);
}
});
PublishSubject<String> burgerRequestedSubject =
PublishSubject.create();

@FMuntenescu
burgerRequestedSubject.subscribe(new Subscriber<String>() {
@Override
public void onNext(final String s) {
// called on every click
}
@Override
// will never be called for click events
}
@Override
}
});

@FMuntenescu
Creating
Observables
From
Declarativ
e Code

@FMuntenescu
public Burger cook(){
// cooking is time consuming
return burger;
}
Observable.fromCallable(this::cook);

@FMuntenescu
Thread t = new Thread(new Runnable() {
@Override
public void run() {
cook();
}
});

@FMuntenescu
Thread t = new Thread(new Runnable() {
@Override
public void run() {
try{
cook();
} catch(Exception e) {
// handle exception
}
}
});

@FMuntenescu
getMeatObservable()
.filter(meat -> isMeatFresh(meat))
.map(meat -> cook(meat))
.subscribeOn(
meat -> doSomething(),

@FMuntenescu
public Observable<Meat> getCookedMeat() {
return getMeatObservable()
.filter(meat -> isMeatFresh(meat))
.map(meat -> cook(meat));
}
Observable.zip(getBun(),
getCookedMeat(),
getTomatoSlice(),
.subscribeOn(
burger -> eatBurger(burger),

@FMuntenescu
Start using
RxJava

@FMuntenescu
public Burger cook(){
// cooking is time consuming
// make sure it’s on a background thread
return burger;
}
Observable.fromCallable(this::cook)
.subscribeOn(Schedulers.computation())
.observeOn(AndroidSchedulers.mainThread())

@FMuntenescu
@GET(“repos”)
Call<List<Burger>> repoBurgers();
@GET(“repos”)
Observable<List<Burger>> repoBurgers();

@FMuntenescu@FMuntenescu
jobs@updudes.net
Building a Reactive Mindset
https://upday.github.io/blog/reactive_mindset_burgers
Reactive Burgers – Code Example
https://github.com/florina-muntenescu/ReactiveBurgers
Building a
Burger
Reactive
Mindset

Building a reactive mindset

Recommended

Recommended

More Related Content

Recently uploaded

Recently uploaded (20)

Featured

Featured (20)

Building a reactive mindset

Editor's Notes