La dernière fois, j'ai parlé de la création d'un exemple d'application dans l'article suivant. RxJava (RxAndroid) + RxBus + Data Binding + échantillon de salle (basé sur Java 1.7) sur Android.
Cette fois, j'expliquerai l'implémentation qui utilise RxJava pour acquérir des données de manière asynchrone à partir de l'API. Veuillez vous référer à l'article précédent ci-dessus pour l'environnement d'exploitation.
Lorsque vous essayez d'obtenir des données à partir d'une API qui existe sur le Web Le traitement peut prendre un certain temps en fonction de l'état de la communication et de la quantité de données. Pendant ce temps, si les opérations sur l'écran (annulation, etc.) ne sont pas acceptées, l'UX se détériorera, donc Le traitement qui peut prendre du temps est généralement effectué de manière asynchrone.
Il existe plusieurs bibliothèques sur Android qui permettent ce processus asynchrone.
J'ai utilisé RxJava cette fois, Vous pouvez envisager d'utiliser d'autres bibliothèques telles que LiveData. Au fait, la raison pour laquelle j'ai choisi RxJava est Je pensais qu'il y avait de nombreux exemples d'utilisation et de nombreux cas, C'est parce que je pensais qu'il était "flétri" par rapport à LiveData.
Cette fois, je n'expliquerai pas la programmation réactive ou RxJava. Pour plus de détails, si vous google, vous obtiendrez divers hits, alors là ...
Aussi, pour le moment, seule l'explication minimale nécessaire est donnée pour bouger, donc Lorsque vous l'utilisez à des fins professionnelles, assurez-vous de le vérifier **.
Vous pouvez consulter la source des explications ici.
La source correspondante est ici
Observable.create(new ObservableOnSubscribe<GithubRepositoryApiResponseEntity>() {
@Override
public void subscribe(ObservableEmitter<GithubRepositoryApiResponseEntity> emitter) throws Exception {
//Traitement asynchrone
Request request = new Request.Builder()
.url(url)
.get()
.build();
OkHttpClient client = new OkHttpClient();
try {
Response res = client.newCall(request).execute();
String responseBodyStr = res.body().string();
//Objectize json avec GSON
Gson gson = new Gson();
GithubRepositoryApiResponseEntity responceData = (GithubRepositoryApiResponseEntity) gson.fromJson(responseBodyStr, GithubRepositoryApiResponseEntity.class);
emitter.onNext(responceData);
emitter.onComplete();
} catch (Exception e) {
e.printStackTrace();
emitter.onError(e);
} finally {
loading = false;
}
}
})
.observeOn(Schedulers.newThread()) //après observer(réponse)Faites-le dans un nouveau fil
.subscribeOn(Schedulers.newThread()) //Faites-le de manière asynchrone dans un nouveau thread
.subscribe(observer); //Exécuter
Passez une classe anonyme de type ObservableOnSubscribe
Dans emitter.onNext, spécifiez le flux (résultat reçu par Observer).
N'oubliez pas d'appeler ʻemitter.onComplete (); . Le système anormal est ʻemitter.onError (Exception); .
Passez le résultat de Observable.create à observeOn et
Spécifie le thread à traiter.
ʻSi vous spécifiez AndroidSchedulers.mainThread () , il fonctionnera sur le thread principal. Si vous spécifiez Schedulers. newThread ()`, il fonctionnera sur un nouveau thread (qui n'interfère pas avec le thread principal).
Enfin, spécifiez l'observateur dans la méthode subscribe et inscrivez-vous.
La source correspondante est ici
private Observer observer = new Observer<GithubRepositoryApiResponseEntity>() {
GithubRepositoryApiCompleteEventEntity eventResult = new GithubRepositoryApiCompleteEventEntity();
@Override
public void onSubscribe(Disposable d) {
}
@Override
public void onNext(GithubRepositoryApiResponseEntity response) {
eventResult.setResult(false);
List<GithubRepositoryApiResponseEntity.Repository> repositoryList = response.getItems();
ArrayList<GithubRepositoryListItemEntity> data = new ArrayList<>();
for (GithubRepositoryApiResponseEntity.Repository repository : repositoryList) {
GithubRepositoryListItemEntity listItem = new GithubRepositoryListItemEntity();
listItem.setFullName(repository.getFull_name());
data.add(listItem);
}
eventResult.setListItems(data);
if (response.getItems() != null && response.getItems().size() > 0) {
eventResult.setResult(true);
}
//Appeler un événement
RxBus.getInstance().send(eventResult);
}
@Override
public void onError(Throwable e) {
//Appeler un événement
RxBus.getInstance().send(eventResult);
}
@Override
public void onComplete() {
}
};
Tout d'abord, j'expliquerai le RxBus suivant la prochaine fois. RxBus.getInstance().send(eventResult);
Définissez d'abord une instance de type Observer
onSubscribe est une méthode qui est exécutée lorsque la préparation des données est terminée. La notification peut être annulée à l'aide de l'argument Jetable (On ne sait pas s'il est significatif de sortir à ce moment ...)
onNext est une méthode qui est exécutée lorsque les données circulent. Cette fois, vous ne recevez le résultat de l'API qu'une seule fois. Dans cet exemple, il est remplacé par la classe Entity pour l'affichage, Je pense qu'il n'est pas nécessaire que Gson et Data Binding puissent être définis comme un ensemble. (Je pensais que ce n'était pas si fatal, alors je l'ai laissé tel quel)
onError est une méthode appelée lorsqu'une erreur se produit. Je ne l'ai pas traité dans cet exemple, donc Faites quelque chose si vous en avez besoin.
onComplete est une méthode qui est exécutée lorsque le flux de données est terminé.
C'était comme ça.
ViewModel est persistant (contient une instance dans une sous-classe d'Application), donc En gros, je ne pense pas qu'il y ait d'impact du cycle de vie. Cependant, cela a un effet lorsque la vue (activité et fragment) est impliquée.
C'est pourquoi il s'agissait d'une brève explication du traitement asynchrone par RxJava. Il semble difficile d'utiliser RxJava pour diverses choses. Pour le moment, à partir du code hérité actuel Il semble possible de remplacer le traitement asynchrone.
La prochaine fois, je voudrais expliquer la notification d'événements par RxBus.
Recommended Posts