J'ai une méthode qui retourne un Observable<ArrayList<Long>>
, qui sont les identifiants de certains éléments. J'aimerais parcourir cette liste et télécharger chaque élément à l'aide d'une autre méthode qui renvoie Observable<Item>
.
Comment pourrais-je faire cela en utilisant des opérateurs RxJava?
Voici un petit exemple autonome
public class Example {
public static class Item {
int id;
}
public static void main(String[] args) {
getIds()
.flatMapIterable(ids -> ids) // Converts your list of ids into an Observable which emits every item in the list
.flatMap(Example::getItemObservable) // Calls the method which returns a new Observable<Item>
.subscribe(item -> System.out.println("item: " + item.id));
}
// Simple representation of getting your ids.
// Replace the content of this method with yours
private static Observable<List<Integer>> getIds() {
return Observable.just(Arrays.<Integer>asList(1, 2, 3));
}
// Replace the content of this method with yours
private static Observable<Item> getItemObservable(Integer id) {
Item item = new Item();
item.id = id;
return Observable.just(item);
}
}
Veuillez noter que Observable.just(Arrays.<Integer>asList(1, 2, 3))
est une simple représentation de Observable<ArrayList<Long>>
De votre question. Vous pouvez le remplacer par votre propre observable dans votre code.
Cela devrait vous donner la base de ce dont vous avez besoin.
p/s: Utilisez la méthode flatMapIterable
pour ce cas car il appartient à Iterable
comme expliqué ci-dessous:
/**
* Implementing this interface allows an object to be the target of
* the "for-each loop" statement. See
* <strong>
* <a href="{@docRoot}openjdk-redirect.html?v=8&path=/technotes/guides /language/foreach.html">For-each Loop</a>
* </strong>
*
* @param <T> the type of elements returned by the iterator
*
* @since 1.5
* @jls 14.14.2 The enhanced for statement
*/
public interface Iterable<T>
Au lieu de flatMapIterable
, vous pouvez le faire avec flatMap
:
Observable.just(Arrays.asList(1, 2, 3)) //we create an Observable that emits a single array
.flatMap(numberList -> Observable.fromIterable(numberList)) //map the list to an Observable that emits every item as an observable
.flatMap(number -> downloadFoo(number)) //download smth on every number in the array
.subscribe(...);
private ObservableSource<? extends Integer> downloadFoo(Integer number) {
//TODO
}
Personnellement, je pense que .flatMap(numberList -> Observable.fromIterable(numberList))
est plus facile à lire et à comprendre que .flatMapIterable(numberList -> numberList )
.
La différence semble être l'ordre (RxJava2):
En utilisant des références de méthodes, cela ressemble à:
Observable.just(Arrays.asList(1, 2, 3))
.flatMap(Observable::fromIterable)
.flatMap(this::downloadFoo)
Utilisez un Transformer qui modifie l’observable source en appelant un flatMap
avec une fonction. Vous pouvez considérer cela comme un processus en deux étapes:
Iterable<T>
) et le réémet comme un Observable<T>
flatMap
prend chacune de ces émises Observable<T>
objets et les fusionne en un seul Observable<T>
Le transformateur ressemble à ceci:
public class FlattenTransform<T> implements Observable.Transformer<Iterable<T>, T> {
@Override
public Observable<? extends T> call(Observable<? extends Iterable<T>> source) {
return source.flatMap(new Func1<Iterable<T>, Observable<T>>() {
@Override
public Observable<T> call(Iterable<T> values) {
return Observable.from(values);
}
});
}
}
Une fois votre Transformer créé, vous pouvez utiliser compose
pour appliquer la transformation à la source observable:
public class Example {
private static final ArrayList<Long> sourceList = new ArrayList<>(Arrays.asList(new Long[] {1L,2L,3L}));
private static final Observable<ArrayList<Long>> listObservable = Observable.just(sourceList);
private static final FlattenTransform<Long> flattenList = new FlattenTransform<Long>();
public static void main(String[] args) {
listObservable.compose(flattenList).subscribe(printItem);
}
private static Action1<Long> printItem = new Action1<Long>() {
@Override
public void call(Long item) {
System.out.println("item: " + item);
}
};
}
L’avantage d’utiliser un compose
avec un Transformer
au lieu d’un flatMap
avec un Func1
_ est-ce que si à l'avenir, si vous avez besoin d'aplatir une nouvelle liste, vous n'aurez même pas à penser à l'opérateur à utiliser (map? flatMap? concatMap?). En d'autres termes, l'opération flatmap est intégrée à la classe FlattenTransform et ce détail est extrait par résumé.
Les transformateurs présentent également d'autres avantages, tels que la possibilité d'enchaîner plusieurs opérations.
En Kotlin, utilisez flattenAsFlowable
:
repository.getFlowableData(id)
.subscribeOn(Schedulers.io())
.observeOn(Schedulers.computation())
.toList()
.flattenAsFlowable { it }
.map { someMethod(it) }
.observeOn(AndroidSchedulers.mainThread())
.subscribe({ },
{ onError(it) })