Gestion de la Subscription ⚠️

👨🏻‍🍳 Nos Workshops ✉️Besoin d'aide ?🔍Code Review
Rechercher…
Dans les exemples ci-dessus, l'objet Subscription retourné par la méthode subscribe est simplement ignoré.
Il faut s'assurer que le composant unsubscribe de l'Observable avant sa destruction (et également si une nouvelle requête est déclenchée par exemple en cas de "refresh").
Dans le cas d'Observables infinis cela évite des fuites mémoire et surconsommation CPU.
Dans notre cas, cela évite la congestion des requêtes HTTP (dans le cas où le composant est détruit et reconstruit plusieurs fois rapidement par exemple ou encore lors de la navigation sur l'application via le Routing).
Unsubscribe dans ngOnDestroy
On profite généralement du "Lifecycle Hook" ngOnDestroy pour déclencher l'unsubscribe.
book-search.component.ts
1
private _bookListSubscription: Subscription;
2
​
3
constructor(private _bookRepository: BookRepository) {
4
}
5
​
6
ngOnInit() {
7
    this._bookListSubscription = this._bookRepository.getBookList()
8
        .subscribe(bookList => this.bookList = bookList);
9
}
10
​
11
ngOnDestroy() {
12
    this._bookListSubscription.unsubscribe();
13
}
Copied!
Et par précaution dans le cas où la subscription est créé plus tard.
book-search.component.ts
1
ngOnDestroy() {
2
    if (this._bookListSubscription != null) {
3
        this._bookListSubscription.unsubscribe();
4
    }
5
}
Copied!
L'inconvénient de cette approche est sa verbosité. Elle en devient "error-prone".
Unsubscribe avec l'opérateur takeUntil
book-search.component.ts
1
export class BookSearchComponent implements OnDestroy, OnInit {
2
​
3
    bookList: Book[];
4
​
5
    private _isDead$ = new Subject();
6
​
7
    constructor(private _bookRepository: BookRepository) {
8
    }
9
​
10
    ngOnInit() {
11
        this._bookRepository.getBookList()
12
            .pipe(takeUntil(this._isDead$))
13
            .subscribe(bookList => this.bookList = bookList);
14
    }
15
​
16
    ngOnDestroy() {
17
        this._isDead$.next();
18
    }
19
​
20
}
Copied!
Il existe une approche similaire avec l'opérateur takeWhile qui se base sur un valeur "boolean" plutôt qu'un Observable mais il est préférable de l'éviter.
Contrairement à l'approche takeUntil, takeWhile ne peut pas détecter en temps réel le changement de la variable "boolean" et la requête HTTP ne sera donc pas interrompue.
Exemple
​https://github.com/wishtack/wishtack-book-shop/tree/7-unsubscribe-using-take-until​
Wishtack - Wishtack Book Shop - StackBlitz
StackBlitz
Unsubscribe avec le Pipe async
Dans les cas les plus simples, cette approche est la plus adaptée car c'est la moins verbeuse est la plus réactive.
Le "pipe" async permet de préparer l'Observable dans le composant et laisser la vue subscribe quand elle en a besoin et si elle en a besoin.
book-search.component.ts
1
export class BookSearchComponent {
2
​
3
    bookList$: Observable<Book[]>;
4
​
5
    constructor(private _bookRepository: BookRepository) {
6
        this.bookList$ = this._bookRepository.getBookList();
7
    }
8
​
9
}
Copied!
Remarquez que l'on se permet de créer l'Observable directement dans le constructeur. En effet, tant que l'on ne subscribe pas, aucun traitement n'est déclenché.
A éviter
Il est possible d'utiliser la syntaxe perturbante ci-dessous mais il est préférable de l'éviter.
book-search.component.ts
1
export class BookSearchComponent {
2
​
3
    bookList$ = this._bookRepository.getBookList();
4
​
5
    constructor(private _bookRepository: BookRepository) {
6
    }
7
​
8
}
Copied!
Fonctionnement du "pipe" async
book-search.component.html
1
<wt-book-preview
2
        *ngFor="let book of bookList$ | async"
3
        [book]="book"></wt-book-preview>
Copied!
Le "pipe" async subscribe à l'Observable bookList$ et permet de mettre à jour la vue en conséquence.
A la destruction de l'élément (e.g. : "toggle" de la liste via *ngIf), le "pipe" async unsubscribe automagiquement.
Gotcha
En essayant d'afficher le nombre de "book" en créant un autre Observable :
book-search.component.ts
1
export class BookSearchComponent {
2
​
3
    bookCount$: Observable<number>;
4
    bookList$: Observable<Book[]>;
5
​
6
    constructor(private _bookRepository: BookRepository) {
7
        this.bookList$ = this._bookRepository.getBookList();
8
        this.bookCount$ = this.bookList$.pipe(map(bookList => bookList.length));
9
    }
10
​
11
}
Copied!
book-search.component.html
1
<div>{{ bookCount$ | async }}</div>
2
​
3
<wt-book-preview
4
        *ngFor="let book of bookList$ | async"
5
        [book]="book"></wt-book-preview>
Copied!
Cela "fonctionne" mais on peut remarquer que la requête HTTP a été exécutée deux fois.
L'Observable créé par le service HttpClient est de type "Cold" (c'est à dire Lazy).
Chaque "pipe" async appelle la méthode subscribe et déclenche donc la requête HTTP puis les traitements appliqués par les opérateurs (l'opérateur map dans notre cas).
shareReplay
Le comportement souhaité est le suivant :
Tant qu'il n'y a aucun appel à subscribe (explicite ou implicite via async), le traitement ne doit pas s'exécuter.
Au premier subscribe, le traitement doit être déclenché.
Les subscribes supplémentaires ne doivent pas redéclencher le traitement mais simplement attendre le résultat.
Les souscripteurs qui arrivent après la récupération du résultat doivent récupérer la dernière valeur obtenue.
L'intégralité de se traitement se fait simplement avec l'opérateur shareReplay en lui indiquant en paramètre la taille du buffer de mémorisation. Un buffer de taille 1 va mémoriser la dernière valeur.
Le problème décrit au paragraphe précédent est alors résolu ainsi :
1
export class BookSearchComponent {
2
​
3
    bookCount$: Observable<number>;
4
    bookList$: Observable<Book[]>;
5
​
6
    constructor(private _bookRepository: BookRepository) {
7
        this.bookList$ = this._bookRepository.getBookList()
8
            .pipe(shareReplay(1));
9
        this.bookCount$ = this.bookList$.pipe(map(bookList => bookList.length));
10
    }
11
​
12
}
Copied!
Gestion d'erreurs
Pour capturer les erreurs et détecter la fin du traitement (i.e. try / catch / finally), il suffit d'utiliser les opérateurs catchError et finalize.
EMPTY est une constante contenant un Observable vide. Vous êtes libres de retourner un Observable contenant des données (de secours) provenant d'une autre source (cache etc...).
book-search.component.ts
1
import { EMPTY, Observable } from 'rxjs';
2
import { catchError, finalize, map, shareReplay } from 'rxjs/operators';
3
​
4
this.bookList$ = this._bookRepository.getBookList()
5
    .pipe(
6
        catchError(error => {
7
            console.error(error);
8
            return EMPTY;
9
        }),
10
        finalize(() => {
11
            console.log('Done!');
12
        }),
13
        shareReplay(1)
14
    );
Copied!
Exemple
​https://github.com/wishtack/wishtack-book-shop/tree/8-unsubscribe-using-async-pipe​
Wishtack - Wishtack Book Shop - StackBlitz
StackBlitz
Observables ❤️async pipe ❤️retry
Pour reproduire l'erreur ci-dessus, vous pouvez bloquer le domaine de l'API sur Chrome via le menu décrit ci-dessous.
Chrome Block request
RxScavenger
​https://blog.wishtack.com/2018/05/30/handle-rxjs-subscriptions-properly-using-rx-scavenger/​
Handle RxJS Subscriptions Properly Using Rx-Scavenger
Wishtack