Iniciación rx java

Reactive para Android
Elisa de Gregorio

¿Que es reactive?
- Se basa en que las apps son flujos de datos finitos o infinitos asíncronos.
- Nos abstrae
- Threading de bajo nivel
- Sincronización
- Estructuras de datos concurrentes
- Gestión de Errores *
- Nos permite concatenar transformaciones, componer datos de diferentes
fuentes de manera sencilla*
- Reactive- RXJava, RXJs, RX.NET, RXScala, RXPy …
- RXJava creado por Netflix

Ok show me now!
Time
Observer Observable
Subscribe
On Next *
OnError |
OnComplete

Ok show me now!
String adventure="Time";
Observable.just(adventure)
.subscribe(new Subscriber<String>() {
@Override
public void onCompleted() {
Log.d("Test", "COMPLETE");
}
@Override
public void onError(Throwable e) {
Log.e("Test", "ERROR");
}
@Override
public void onNext(String s) {
Log.d("Test", s);
}
});

Ok show me now!
@Override
}
@Override
}
@Override
Log.d("Test", s);
}
});
Crear el Observable
“Flujo de datos”

Ok show me now!
@Override
}
@Override
}
@Override
Log.d("Test", s);
}
});
Te suscribes para
recoger los datos
LOG:
Time
Complete

Que Evita RXJava
Callbacks:
public class User{
String name;
String surname;
String fullName;
}

Que Evita RXJava
Callbacks:
public void changeName(final User user,final String
name,final Callback<User> callback ){
Handler handler = new Handler();
handler.postDelayed(new Runnable() {
@Override
public void run() {
user.setName(name);
callback.onSuccess(user);
}
}, SERVICE_LATENCY_IN_MILLIS);
}
public class User{
String name;
String surname;
String fullName;
}

Que Evita RXJava
Callbacks: User user = new User();
userRepository.changeName(user,
"Name", new Callback<User>() {
@Override
public void onSuccess(User item) {
//:D
}
@Override
public void onError() {
//D:
}
});
public void changeName(final User user,final String
name,final Callback<User> callback ){
Handler handler = new Handler();
handler.postDelayed(new Runnable() {
@Override
public void run() {
user.setName(name);
callback.onSuccess(user);
}
}, SERVICE_LATENCY_IN_MILLIS);
}
public class User{
String name;
String surname;
String fullName;
}

Que Evita RXJava
Callbacks: userRepository.changeName(user, "Name", new Callback<User>() {
@Override
userRepository.changeSurname(item, "Surname", new Callback<User>() {
@Override
//:D
}
@Override
public void onError() { //D: }
});
}
@Override
public void onError() { //D: }
});
public class User{
String name;
String surname;
String fullName;
}

Que Evita RXJava
Callbacks: userRepository.changeName(user, "Name", new Callback<User>() {
@Override
@Override
userRepository.changeFullname(item, item.getName(), item.getSurmane(),
new Callback<User>() {
@Override
//Finish!
}
@Override
public void onError() {//D:
}
});
}
@Override
}
});
}
@Override
}
});
public class User{
String name;
String surname;
String fullName;
}

Que Evita RXJava
Callbacks:
public class User{
String name;
String surname;
String fullName;
}
CALLBACK HELL!
userRepository.changeName(user, "Name", new Callback<User>() {
@Override
@Override
userRepository.changeFullname(item, item.getName(), item.getSurmane(),
new Callback<User>() {
@Override
//Finish!
}
@Override
}
});
}
@Override
}
});
}
@Override
}
});

y en RXJava ...
Callbacks:
public Observable<User> changeName(final User user,final String name) {
return Observable.fromCallable(new Callable<User>() {
@Override
public User call() throws Exception {
user.setName(name);
return user;
}
});
}
public class User{
String name;
String surname;
String fullName;
}

y en RXJava ...
Callbacks:
public class User{
String name;
String surname;
String fullName;
}
Observable.just(new User())
.flatMap(new Func1<User, Observable<User>>() {
@Override
public Observable<User> call(User user) {
return userRepository.changeName(user, "name");
}
}).flatMap(new Func1<User, Observable<User>>() {
@Override
return userRepository.changeSurname(user, "surname");
}
}).flatMap(new Func1<User, Observable<User>>() {
@Override
return userRepository.changeFullName(user, user.getName(), user.getSurmane());
}
}).subscribe(new Subscriber<User>() {
@Override
public void onCompleted() {//Finish
}
@Override
public void onError(Throwable e) { //D:
}
@Override
public void onNext(User user) { // :D
log(user);
}
});

en RXJava y retrolambda...o Kotlin ! :D
Callbacks:
Observable.just(new User())
.flatMap(user -> userRepository.changeName(user, "name"))
.flatMap(user -> userRepository.changeSurname(user, "surname"))
.flatMap(user ->
userRepository.changeFullName(user, user.getName(), user.getSurmane()))
.subscribe(user ->log(user));
public class User{
String name;
String surname;
String fullName;
}

RXJava
● Se compone:
○ Set de clases para representar streams de datos - Observables
○ Set de clases para escuchar las fuentes de datos - Subscribers
○ Set de clases para modificar y componer los datos
TimeObserver/subscriber Observable
Subscribe
On Next *
OrError |
OnComplete

RxJava Observable types
● Observable<T>
○ Emite 0-n items, termina con error, o completo
● Flowable<T> -RXJava2
○ Emite 0-n items, termina con error, o completo
○ Soporta BackPressure
● Single<T>
○ Emite exactamente 1 item or error
● Maybe<T>
○ Emite 0 items o 1 item o error
● Completable
○ Emite 0 items, solo una señal de completado o error

Flowable vs Observable
BackPessure: poder controlar la velocidad con la que source emite datos
RXJava 1:
● Solo estaban los Observables (implementaban BackPressure)
● MissingBackpressureException D:
○ Hay formas de evitarlo https://github.com/ReactiveX/RxJava/wiki/Backpressure
RXJava 2:
● Flowables
● Observable (No backPressure) - Flowables (Con backPressure)

Subscriptions
Subscribe un observer a un
observable:
Subscription subscribe()
Subscription subscribe(Action1<? super T> onNext)
Subscription subscribe(Observer<? super T> observer)
Subscription subscribe(Subscriber<? super T> subscriber)
Subscription subscribe(Action1<? super T> onNext,
Action1<java.lang.Throwable> onError)
Subscription subscribe(Action1<? super T> onNext,
Action1<java.lang.Throwable> onError, Action0 onComplete)
.subscribeOn(Schedulers.computation())
.observeOn(AndroidSchedulers.mainThread())
@Override
}
@Override
}
@Override
Log.d("Test", s);
}
});

Subscriptions con memory leaks!
Sin problemas potenciales
Observable.just(1).subscribe(... this.something());
Memory Leak!!
Observable.interval(1, TimeUnit.SECONDS).subscribe(... this.something());

Subscriptions con memory leaks!
Sin problemas potenciales
Observable.just(1).subscribe(... this.something());
Memory Leak!!
Observable.interval(1, TimeUnit.SECONDS).subscribe(... this.something());
Solución:
RXJava1: Unsubscribe() RXJava2: Dispose()
RXJava1:CompositeSubscription RXJava2:CompositeDisposable

Schedulers String adventure="Time";
@Override
}
@Override
}
@Override
Log.d("Test", s);
}
});
Indican en qué hilo deben
ejecutarse las operaciones

Schedulers
ejecutarse las operaciones:
● Scheduler.immediate()
Crea un Scheduler que ejecuta
inmediatamente el trabajo en el
hilo actual
.subscribeOn(Schedulers.inmediate())
@Override
}
@Override
}
@Override
Log.d("Test", s);
}
});

Schedulers
● Scheduler.trampoline()
Crea un Scheduler que coloca
el trabajo, en la cola del hilo
actual.
.subscribeOn(Schedulers.trampoline())
@Override
}
@Override
}
@Override
Log.d("Test", s);
}
});

Schedulers
● Scheduler.newThread()
Crea un Scheduler que crea un
nuevo hilo para realizar el
trabajo.
.subscribeOn(Schedulers.newThead())
@Override
}
@Override
}
@Override
Log.d("Test", s);
}
});

Schedulers
● Scheduler.computation()
Crea un Scheduler para trabajo
computacional, tiene tantos
hilos como CPU tenga el
dispositivo.
@Override
}
@Override
}
@Override
Log.d("Test", s);
}
});

Schedulers
● Scheduler.computation()
● Scheduler.io()
Crea un Scheduler para
realizar llamadas I/O. Tiene un
thread-pool que crece a
demanda
.subscribeOn(Schedulers.io())
@Override
}
@Override
}
@Override
Log.d("Test", s);
}
});

Reactive operations
http://reactivex.io/documentation/operators.html
● Crear Observables: Create, Defer, From, Interval, Just ...
● Transformar Observables: Buffer, FlatMap, Map, Scan ...
● Filtrar Observables: First, ElementAt, Distinct, Take …
● Combinar Observables: Join, CombineLatest, Zip…
● Errores: Catch, Retry
● Condicionales: All, Amb, Contains, DefaultIfEmpty…
● Matemáticos: Average, Concat, Count, Max, Reduce…
● BackPressure: Buffer, Sample, Window…

Crear Observables
RxJava tiene varios métodos para crear observables
● Observable.just("Hello")
● Observable.fromIterable()
● Observable.fromArray()
● Observable.fromCallable()
● Observable.fromFuture()
● Observable.interval()

Crear Observables
@Override
public void onCompleted() {}
@Override
public void onError(Throwable e) {}
@Override
Log.d("Test", s);
}
});
Log : Time
String[] adventureTime={"what","time","is","it?"};
Observable.just(adventureTime)
.subscribe(new Subscriber<String[]>() {
@Override
@Override
@Override
public void onNext(String[] s) {
Log.d("Test", s);
}
});
Log : Time [what,time, is,it]

Crear Observables
Log : Time what
time
is
it
String[] adventureTime={"what","time","is","it?"};
Observable.from(adventureTime)
@Override
@Override
@Override
Log.d("Test", s);
}
});
@Override
@Override
@Override
Log.d("Test", s);
}
});

FlatMap
http://reactivex.io/documentation/operators/flatmap.html

FlatMap- Map-Zip
http://reactivex.io/documentation/operators/map.html | http://rxmarbles.com/#map

FlatMap- Map-Zip
http://reactivex.io/documentation/operators/zip.html | http://rxmarbles.com/#zip

Ejemplo Operaciones
Lista de usuarios de la charla
searchQuery(query)
.flatMap(new Func1<List<Users>, Observable<Users>>() {
@Override
public Observable<Users> call(List<Users> userList) {
return Observable.from(userList);
}
});

Ejemplo Operaciones
Lista de perfiles de usuarios de la charla
searchQuery(query)
@Override
}
}).flatMap(new Func1<Users, Observable<LinkedINData>>() {
@Override
public Observable<LinkedINData> call(Users user) {
return linkedINQuery(user.getURL());
}
});

Ejemplo Operaciones
Lista de perfiles de usuarios de la charla que trabajan en Android
searchQuery(query)
@Override
}
@Override
}).filter(new Func1<LinkedINData, Boolean>() {
@Override
public Boolean call(LinkedINData linkedINData) {
return linkedINData.worksInAndroid();
}
});

Ejemplo Operaciones
5 usuarios de la charla que trabajan en Android
searchQuery(query)
@Override
}
@Override
}).filter(new Func1<LinkedINData, Boolean>() {
@Override
public Boolean call(LinkedINData linkedINData) {
return linkedINData.worksInAndroid();
}
}).take(5);

RXJava en la práctica
Data Domain View

Data
Repositorio
BD/API/... public interface GithubService {
String SERVICE_ENDPOINT = "https://api.github.com";
@GET("/users/{login}")
Observable<GithubEntity> getUser(@Path("login") String login);
}
Datasources
Retrofit y Realm

Data
Repositorio
BD/API/...
public Observable<Github> getGithubUser(String login){
return dataStoreFactory.getUser(login)
//Map the Api object to the Domain object
.flatMap(new Function<GithubEntity, Observable<Github>>() {
@Override
public Observable<Github> apply
(@NonNull GithubEntity githubEntity) throws Exception {
return userResponseMapper.responseToModel(githubEntity);
}
});
}
Datasources

Domain
Casos de uso
public Observable<Github> getGithubUser(String login){
return mGithubRepository.getUser(login);
}
Interactor

View
Activity/fragment
Presenter
Model
mGetUserUseCase.execute(“user_login”)
.subscribeOn(Schedulers.newThread())
.subscribe(new Subscriber<Github>() {
@Override
Log.d(TAG, "onCompleted");
}
@Override
Log.e(TAG, "onError");
}
@Override
public void onNext(Github user) {
render(user);
}
});

RXTesting- Test Unitario- Dominio
@Before
public void setUp() throws Exception {
githubRepositoryMock = mock(GithubRepositoy.class);
mGetUserUseCase =new GetUserUseCaseImpl(githubRepositoryMock);
}
@Test
public void GetUserUseCase_Execute_GetGithubUser() throws Exception {
// Arrange
Github expectedGithub = new Github();
// Act
when(githubRepositoryMock.getUser("characterTest", 0)).thenReturn(Observable.just(expectedGithub));
Observable<Github> realGithubObj = mGetUserUseCase.execute("characterTest", 0);
TestSubscriber<Github> testSubscriber = new TestSubscriber<>();
realGithubObj.subscribe( testSubscriber);
// Assert
testSubscriber.assertNoErrors();
testSubscriber.assertValue(expectedGithub);
}

Iniciación rx java

More Related Content

Similar to Iniciación rx java

Recently uploaded

Iniciación rx java