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
