Convert the service and components to use Angular's HTTP service.
In this page, you'll make the following improvements.
Get the hero data from a server.
Let users add, edit, and delete hero names.
Save the changes to the server.
You'll teach the app to make corresponding HTTP calls to a remote server's web API.
When you're done with this page, the app should look like this .
Where you left off
In the previous page, you learned to navigate between the dashboard and the fixed heroes list,
editing a selected hero along the way.
That's the starting point for this page.
Keep the app transpiling and running
Enter the following command in the terminal window:
npm start
This command runs the TypeScript compiler in "watch mode", recompiling automatically when the code changes.
The command simultaneously launches the app in a browser and refreshes the browser when the code changes.
You can keep building the Tour of Heroes without pausing to recompile or refresh the browser.
Providing HTTP Services
The HttpModule is not a core Angular module.
HttpModule is Angular's optional approach to web access. It exists as a separate add-on module called @angular/http
and is shipped in a separate script file as part of the Angular npm package.
You're ready to import from @angular/http because systemjs.config configured SystemJS to load that library when you need it.
Register for HTTP services
The app will depend on the Angular http service, which itself depends on other supporting services.
The HttpModule from the @angular/http library holds providers for a complete set of HTTP services.
To allow access to these services from anywhere in the app,
add HttpModule to the imports list of the AppModule.
src/app/app.module.ts (v1)
import { NgModule } from '@angular/core';
import { BrowserModule } from '@angular/platform-browser';
import { FormsModule } from '@angular/forms';
import { HttpModule } from '@angular/http';
import { AppRoutingModule } from './app-routing.module';
import { AppComponent } from './app.component';
import { DashboardComponent } from './dashboard.component';
import { HeroesComponent } from './heroes.component';
import { HeroDetailComponent } from './hero-detail.component';
import { HeroService } from './hero.service';
@NgModule({
imports: [
BrowserModule,
FormsModule,
HttpModule,
AppRoutingModule
],
declarations: [
AppComponent,
DashboardComponent,
HeroDetailComponent,
HeroesComponent,
],
providers: [ HeroService ],
bootstrap: [ AppComponent ]
})
export class AppModule { }
Notice that you also supply HttpModule as part of the imports array in root NgModule AppModule.
Simulate the web API
We recommend registering app-wide services in the root
AppModuleproviders. Here you're
registering in main for a special reason.
Until you have a web server that can handle requests for hero data,
the HTTP client will fetch and save data from
a mock service, the in-memory web API.
The app itself doesn't need to know
about this, so you can slip the in-memory web API into the
configuration above the AppComponent.
Update src/app/app.module.ts with this version, which uses the mock service:
src/app/app.module.ts (v2)
import { NgModule } from '@angular/core';
import { BrowserModule } from '@angular/platform-browser';
import { FormsModule } from '@angular/forms';
import { HttpModule } from '@angular/http';
import { AppRoutingModule } from './app-routing.module';
// Imports for loading & configuring the in-memory web api
import { InMemoryWebApiModule } from 'angular-in-memory-web-api';
import { InMemoryDataService } from './in-memory-data.service';
import { AppComponent } from './app.component';
import { DashboardComponent } from './dashboard.component';
import { HeroesComponent } from './heroes.component';
import { HeroDetailComponent } from './hero-detail.component';
import { HeroService } from './hero.service';
@NgModule({
imports: [
BrowserModule,
FormsModule,
HttpModule,
InMemoryWebApiModule.forRoot(InMemoryDataService),
AppRoutingModule
],
declarations: [
AppComponent,
DashboardComponent,
HeroDetailComponent,
HeroesComponent,
],
providers: [ HeroService ],
bootstrap: [ AppComponent ]
})
export class AppModule { }
Rather than require a real API server, this example simulates communication with the remote server by adding the
InMemoryWebApiModule
to the module imports, effectively replacing the Http client's XHR backend service with an in-memory alternative.
The forRoot() configuration method takes an InMemoryDataService class
that primes the in-memory database.
Add the file in-memory-data.service.ts in app with the following content:
This file replaces mock-heroes.ts, which is now safe to delete.
The in-memory web API is only useful in the early stages of development and for demonstrations such as this Tour of Heroes.
Don't worry about the details of this backend substitution; you can
skip it when you have a real web API server.
This was implemented in anticipation of ultimately
fetching heroes with an HTTP client, which must be an asynchronous operation.
Now convert getHeroes() to use HTTP.
src/app/hero.service.ts (updated getHeroes and new class members)
private heroesUrl = 'api/heroes'; // URL to web api
constructor(private http: Http) { }
getHeroes(): Promise<Hero[]> {
return this.http.get(this.heroesUrl)
.toPromise()
.then(response => response.json().data as Hero[])
.catch(this.handleError);
}
private handleError(error: any): Promise<any> {
console.error('An error occurred', error); // for demo purposes only
return Promise.reject(error.message || error);
}
Update the import statements as follows:
src/app/hero.service.ts (updated imports)
import { Injectable } from '@angular/core';
import { Headers, Http } from '@angular/http';
import 'rxjs/add/operator/toPromise';
import { Hero } from './hero';
Refresh the browser. The hero data should successfully load from the
mock server.
HTTP Promise
The Angular http.get returns an RxJS Observable.
Observables are a powerful way to manage asynchronous data flows.
You'll read about Observables later in this page.
For now, you've converted the Observable to a Promise using the toPromise operator.
.toPromise()
The Angular Observable doesn't have a toPromise operator out of the box.
There are many operators like toPromise that extend Observable with useful capabilities.
To use those capabilities, you have to add the operators themselves.
That's as easy as importing them from the RxJS library like this:
In the Promise's then() callback, you call the json method of the HTTP Response to extract the
data within the response.
.then(response => response.json().data as Hero[])
The response JSON has a single data property, which
holds the array of heroes that the caller wants.
So you grab that array and return it as the resolved Promise value.
Note the shape of the data that the server returns.
This particular in-memory web API example returns an object with a data property.
Your API might return something else. Adjust the code to match your web API.
The caller is unaware that you fetched the heroes from the (mock) server.
It receives a Promise of heroes just as it did before.
Error Handling
At the end of getHeroes(), you catch server failures and pass them to an error handler.
.catch(this.handleError);
This is a critical step.
You must anticipate HTTP failures, as they happen frequently for reasons beyond your control.
private handleError(error: any): Promise<any> {
console.error('An error occurred', error); // for demo purposes only
return Promise.reject(error.message || error);
}
In this demo service, you log the error to the console; in real life,
you would handle the error in code. For a demo, this works.
The code also includes an error to
the caller in a rejected promise, so that the caller can display a proper error message to the user.
Get hero by id
When the HeroDetailComponent asks the HeroService to fetch a hero,
the HeroService currently fetches all heroes and
filters for the one with the matching id.
That's fine for a simulation, but it's wasteful to ask a real server for all heroes when you only want one.
Most web APIs support a get-by-id request in the form api/hero/:id (such as api/hero/11).
Update the HeroService.getHero method to make a get-by-id request:
This request is almost the same as getHeroes.
The hero id in the URL identifies which hero the server should update.
Also, the data in the response is a single hero object rather than an array.
Unchanged getHeroes API
Although you made significant internal changes to getHeroes() and getHero(),
the public signatures didn't change.
You still return a Promise from both methods.
You won't have to update any of the components that call them.
Now it's time to add the ability to create and delete heroes.
Updating hero details
Try editing a hero's name in the hero detail view.
As you type, the hero name is updated in the view heading.
But if you click the Back button, the changes are lost.
Updates weren't lost before. What changed?
When the app used a list of mock heroes, updates were applied directly to the
hero objects within the single, app-wide, shared list. Now that you're fetching data
from a server, if you want changes to persist, you must write them back to
the server.
Add the ability to save hero details
At the end of the hero detail template, add a save button with a click event
binding that invokes a new component method named save.
src/app/hero-detail.component.html (save)
<button (click)="save()">Save</button>
Add the following save method, which persists hero name changes using the hero service
update method and then navigates back to the previous view.
To identify which hero the server should update, the hero id is encoded in
the URL. The put() body is the JSON string encoding of the hero, obtained by
calling JSON.stringify. The body content type
(application/json) is identified in the request header.
Refresh the browser, change a hero name, save your change,
and click the browser Back button. Changes should now persist.
Add the ability to add heroes
To add a hero, the app needs the hero's name. You can use an input
element paired with an add button.
Insert the following into the heroes component HTML, just after
the heading:
In addition to calling the component's delete() method, the delete button's
click handler code stops the propagation of the click event—you
don't want the <li> click handler to be triggered because doing so would
select the hero that the user will delete.
The logic of the delete() handler is a bit trickier:
Of course you delegate hero deletion to the hero service, but the component
is still responsible for updating the display: it removes the deleted hero
from the array and resets the selected hero, if necessary.
To place the delete button at the far right of the hero entry,
add this additional CSS:
Refresh the browser and try the new delete functionality.
Observables
Each Http service method returns an Observable of HTTP Response objects.
The HeroService converts that Observable into a Promise and returns the promise to the caller.
This section shows you how, when, and why to return the Observable directly.
Background
An Observable is a stream of events that you can process with array-like operators.
Angular core has basic support for observables.
Developers augment that support with operators and extensions from the
RxJS library.
You'll see how shortly.
Recall that the HeroService chained the toPromise operator to the Observable result of http.get().
That operator converted the Observable into a Promise and you passed that promise back to the caller.
Converting to a Promise is often a good choice. You typically ask http.get() to fetch a single chunk of data.
When you receive the data, you're done.
The calling component can easily consume a single result in the form of a Promise.
But requests aren't always done only once.
You may start one request,
cancel it, and make a different request before the server has responded to the first request.
A request-cancel-new-request sequence is difficult to implement with function Promise() { [native code] }s, but
easy with s.
Add the ability to search by name
You're going to add a hero search feature to the Tour of Heroes.
As the user types a name into a search box, you'll make repeated HTTP requests for heroes filtered by that name.
Start by creating HeroSearchService that sends search queries to the server's web API.
src/app/hero-search.service.ts
import { Injectable } from '@angular/core';
import { Http } from '@angular/http';
import { Observable } from 'rxjs/Observable';
import 'rxjs/add/operator/map';
import { Hero } from './hero';
@Injectable()
export class HeroSearchService {
constructor(private http: Http) {}
search(term: string): Observable<Hero[]> {
return this.http
.get(`app/heroes/?name=${term}`)
.map(response => response.json().data as Hero[]);
}
}
The http.get() call in HeroSearchService is similar to the one
in the HeroService, although the URL now has a query string.
More importantly, you no longer call toPromise().
Instead you return the Observable from the the htttp.get(),
after chaining it to another RxJS operator, map(),
to extract heroes from the response data.
As the user types in the search box, a keyup event binding calls the component's search()
method with the new search box value.
As expected, the *ngFor repeats hero objects from the component's heroes property.
But as you'll soon see, the heroes property is now an Observable of hero arrays, rather than just a hero array.
The *ngFor can't do anything with an Observable until you route it through the async pipe (AsyncPipe).
The async pipe subscribes to the Observable and produces the array of heroes to *ngFor.
Create the HeroSearchComponent class and metadata.
src/app/hero-search.component.ts
import { Component, OnInit } from '@angular/core';
import { Router } from '@angular/router';
import { Observable } from 'rxjs/Observable';
import { Subject } from 'rxjs/Subject';
// Observable class extensions
import 'rxjs/add/observable/of';
// Observable operators
import 'rxjs/add/operator/catch';
import 'rxjs/add/operator/debounceTime';
import 'rxjs/add/operator/distinctUntilChanged';
import { HeroSearchService } from './hero-search.service';
import { Hero } from './hero';
@Component({
selector: 'hero-search',
templateUrl: './hero-search.component.html',
styleUrls: [ './hero-search.component.css' ],
providers: [HeroSearchService]
})
export class HeroSearchComponent implements OnInit {
heroes: Observable<Hero[]>;
private searchTerms = new Subject<string>();
constructor(
private heroSearchService: HeroSearchService,
private router: Router) {}
// Push a search term into the observable stream.
search(term: string): void {
this.searchTerms.next(term);
}
ngOnInit(): void {
this.heroes = this.searchTerms
.debounceTime(300) // wait 300ms after each keystroke before considering the term
.distinctUntilChanged() // ignore if next search term is same as previous
.switchMap(term => term // switch to new observable each time the term changes
// return the http search observable
? this.heroSearchService.search(term)
// or the observable of empty heroes if there was no search term
: Observable.of<Hero[]>([]))
.catch(error => {
// TODO: add real error handling
console.log(error);
return Observable.of<Hero[]>([]);
});
}
gotoDetail(hero: Hero): void {
let link = ['/detail', hero.id];
this.router.navigate(link);
}
}
Search terms
Focus on the searchTerms:
private searchTerms = new Subject<string>();
// Push a search term into the observable stream.
search(term: string): void {
this.searchTerms.next(term);
}
A Subject is a producer of an observable event stream;
searchTerms produces an Observable of strings, the filter criteria for the name search.
Each call to search() puts a new string into this subject's observable stream by calling next().
Initialize the heroes property (ngOnInit)
A Subject is also an Observable.
You can turn the stream
of search terms into a stream of Hero arrays and assign the result to the heroes property.
heroes: Observable<Hero[]>;
ngOnInit(): void {
this.heroes = this.searchTerms
.debounceTime(300) // wait 300ms after each keystroke before considering the term
.distinctUntilChanged() // ignore if next search term is same as previous
.switchMap(term => term // switch to new observable each time the term changes
// return the http search observable
? this.heroSearchService.search(term)
// or the observable of empty heroes if there was no search term
: Observable.of<Hero[]>([]))
.catch(error => {
// TODO: add real error handling
console.log(error);
return Observable.of<Hero[]>([]);
});
}
Passing every user keystroke directly to the HeroSearchService would create an excessive amount of HTTP requests,
taxing server resources and burning through the cellular network data plan.
Instead, you can chain Observable operators that reduce the request flow to the string Observable.
You'll make fewer calls to the HeroSearchService and still get timely results. Here's how:
debounceTime(300) waits until the flow of new string events pauses for 300 milliseconds
before passing along the latest string. You'll never make requests more frequently than 300ms.
distinctUntilChanged ensures that a request is sent only if the filter text changed.
switchMap() calls the search service for each search term that makes it through debounce and distinctUntilChanged.
It cancels and discards previous search observables, returning only the latest search service observable.
With the switchMap operator
(formerly known as flatMapLatest),
every qualifying key event can trigger an http() method call.
Even with a 300ms pause between requests, you could have multiple HTTP requests in flight
and they may not return in the order sent.
switchMap() preserves the original request order while returning
only the observable from the most recent http method call.
Results from prior calls are canceled and discarded.
If the search text is empty, the http() method call is also short circuited
and an observable containing an empty array is returned.
Note that until the service supports that feature, canceling the HeroSearchService Observable
doesn't actually abort a pending HTTP request.
For now, unwanted results are discarded.
catch intercepts a failed observable.
The simple example prints the error to the console; a real life app would do better.
Then to clear the search result, you return an observable containing an empty array.
Import RxJS operators
Most RxJS operators are not included in Angular's base Observable implementation.
The base implementation includes only what Angular itself requires.
When you need more RxJS features, extend Observable by importing the libraries in which they are defined.
Here are all the RxJS imports that this component needs:
src/app/hero-search.component.ts (rxjs imports)
import { Observable } from 'rxjs/Observable';
import { Subject } from 'rxjs/Subject';
// Observable class extensions
import 'rxjs/add/observable/of';
// Observable operators
import 'rxjs/add/operator/catch';
import 'rxjs/add/operator/debounceTime';
import 'rxjs/add/operator/distinctUntilChanged';
The import 'rxjs/add/...' syntax may be unfamiliar.
It's missing the usual list of symbols between the braces: {...}.
You don't need the operator symbols themselves.
In each case, the mere act of importing the library
loads and executes the library's script file which, in turn, adds the operator to the Observable class.
Add the search component to the dashboard
Add the hero search HTML element to the bottom of the DashboardComponent template.
Run the app again. In the Dashboard, enter some text in the search box.
If you enter characters that match any existing hero names, you'll see something like this.
App structure and code
Review the sample source code in the for this page.
Verify that you have the following structure:
angular-tour-of-heroes
src
app
app.component.ts
app.component.css
app.module.ts
app-routing.module.ts
dashboard.component.css
dashboard.component.html
dashboard.component.ts
hero.ts
hero-detail.component.css
hero-detail.component.html
hero-detail.component.ts
hero-search.component.html (new)
hero-search.component.css (new)
hero-search.component.ts (new)
hero-search.service.ts (new)
hero.service.ts
heroes.component.css
heroes.component.html
heroes.component.ts
in-memory-data.service.ts (new)
main.ts
index.html
styles.css
systemjs.config.js
tsconfig.json
node_modules ...
package.json
Home Stretch
You're at the end of your journey, and you've accomplished a lot.
You added the necessary dependencies to use HTTP in the app.
You refactored HeroService to load heroes from a web API.
You extended HeroService to support post(), put(), and delete() methods.
You updated the components to allow adding, editing, and deleting of heroes.
You configured an in-memory web API.
You learned how to use Observables.
Here are the files you added or changed in this page.
