facebook

Blog

Resta aggiornato

Chiamate HTTP più semplici e Interceptor per centralizzare tutto
Il nuovo HttpClient in Angular
mercoledì 24 Ottobre 2018

A partire dalla versione 5 di Angular, il modulo @angular/http è stato deprecato in favore del nuovo modulo @angular/common/http. Quindi abbiamo un nuovo oggetto per chiamare il nostro backend, che sostanzialmente introduce un tipo generico sul risultato che ci permette di omettere il classico .map(res:Response => res.json()).

L’importazione del modulo cambia come segue:

import { BrowserModule } from '@angular/platform-browser'; 
import { NgModule } from '@angular/core'; 
import { HttpClientModule } from '@angular/common/http'; 
import { AppComponent } from './app.component'; 
 
@NgModule({ 
    declarations: [ AppComponent ], 
    imports: [ BrowserModule, HttpClientModule ], 
    providers: [], 
    bootstrap: [AppComponent] 
}) 
export class AppModule { }

Un servizio di integrazione del backend può quindi essere scritto in questo modo:

import { Injectable } from '@angular/core'; 
import { HttpClient } from '@angular/common/http'; 
import { Event } from '../events/events.model'; 
 
@Injectable() 
export class BackendService { 
 
    constructor(private httpClient: HttpClient) {}
 
    getData() { 
        return this.httpClient.get< Event[] >('http://localhost:3000/api/');
    } 
}

La sintassi è veramente concisa e molto espressiva, grande! Ma la feature più interessante è la possibilità di inserire il proprio codice nella pipeline della richiesta: adesso è possibile fare qualcosa prima e dopo l’effettiva chiamata HTTP con uno o più interceptors. Quindi, è possibile creare la propria pipeline di richiesta HTTP e le possibilità sono infinite. Per fare alcuni esempi:

  • Aggiungere qualcosa all’header della richiesta prima dell’invocazione HTTP, per esempio l’authentication token o qualsiasi cosa vogliate;
  • Trasformare la response come si vuole dopo l’invocazione HTTP;
  • Loggare le attività HTTP;
  • Centralizzare la gestione degli errori HTTP;
  • Fare un redirect alla login se si riceve un errore 401, oppure ritentare l’operazione.

Il limite è la propria fantasia o, meglio, i propri requisiti.

Grazie a Typescript è veramente semplice creare un Interceptor:

  • Creare una classe che implementa l’interfaccia Interceptor;
  • Implementare il metodo intercept per fare quello che si vuole;
  • Registrare la classe nella sezione providers del modulo.

Se usate Visual Studio Code e avete installato gli snippet per Angular di John Papa, avete degli snippet per creare degli interceptor:

import { Injectable } from '@angular/core';
import { HttpInterceptor, HttpEvent, HttpHandler, HttpRequest } from '@angular/common/http';
import { Observable } from 'rxjs/Observable';
 
@Injectable()
export class MyFirstInterceptor implements HttpInterceptor {
 
  intercept(req: HttpRequest, next: HttpHandler): Observable> {
    return next.handle(req);
  }
 
}

Potete aggiungere tutti gli interceptor di cui avete bisogno, saranno valutati nell’ordine in cui sono registrati:

import { BrowserModule } from '@angular/platform-browser'; 
import { NgModule } from '@angular/core'; 
import { HttpClientModule, HTTP_INTERCEPTORS } from '@angular/common/http'; 
import { AppComponent } from './app.component';
​import { MyFirstInterceptor } from './shared/myfirstinterceptor'; 
​import { MySecondInterceptor } from './shared/mysecondinterceptor';
@NgModule({ 
    declarations: [ AppComponent ], 
    imports: [ BrowserModule, HttpClientModule ], 
    providers: [
        {
            provide: HTTP_INTERCEPTORS,
            useClass: MyFirstInterceptor,
            multi: true,
        },
        {
            provide: HTTP_INTERCEPTORS,
            useClass: MySecondInterceptor,
            multi: true,
        }], 
    bootstrap: [AppComponent] 
}) 
export class AppModule { }

Nel nostro Raptor Framework, usiamo interceptor per molte attività. Una di queste è la gestione dell’errore di autenticazione: se ricevo un errore HTTP 401, l’utente viene redirezionato alla login:

import { Injectable } from '@angular/core'; 
import { HttpEvent, HttpInterceptor, HttpHandler, HttpRequest, HttpResponse, HttpErrorResponse } from '@angular/common/http'; 
import { Observable } from 'rxjs/Observable'; 
import { Router, ActivatedRoute } from '@angular/router'; 
import 'rxjs/add/operator/do'; 
 
@Injectable()
export class RaptorInterceptor implements HttpInterceptor { 
    constructor( private router: Router) { }
 
    intercept(req: HttpRequest, next: HttpHandler): Observable> { 
        return next.handle(req)
            .do((event: HttpEvent) => { 
                if (event instanceof HttpResponse) {
                    // TODO: logging 
                }
            }, (err: any) => { 
                if (err instanceof HttpErrorResponse) { 
                    if (err.status === 401) { 
                        this.router.navigate(['login']); 
                    }
                }
             }); 
     } 
} 

Vi mostrerò questo caso nella mia sessione sul Raptor Framework, il 29 Novembre a WPC 2017, non perdetevelo!

A presto