A Deep Dive into Angular HttpClient

In modern web development, communicating with backend services is vital. If you're developing an Angular application, this usually involves working with APIs and performing HTTP operations such as GET, POST, PUT, and DELETE requests. Angular provides a powerful tool called HttpClient to make these operations easier and more intuitive. This blog post takes a comprehensive look at Angular's HttpClient, explaining what it is and how to use it effectively.

What is HttpClient?

link to this section

HttpClient is a built-in Angular module that simplifies HTTP calls in an Angular application. It provides a clean, flexible API for interacting with servers over HTTP, offering features such as typed requests and responses, interceptor support for middleware logic, and request and response transformations.

Setting up HttpClient

link to this section

To use HttpClient, you first need to import the HttpClientModule from @angular/common/http in your application's module, usually within app.module.ts .

import { HttpClientModule } from '@angular/common/http'; 
    declarations: [ AppComponent ], 
    imports: [ BrowserModule, HttpClientModule ], 
    providers: [], 
    bootstrap: [AppComponent] 

export class AppModule { } 

With the HttpClientModule imported, you can now inject the HttpClient service into your components or services.

import { HttpClient } from '@angular/common/http'; 
constructor(private http: HttpClient) { } 

Making HTTP Requests

link to this section

With the HttpClient injected, you can now make HTTP requests. Let's look at the basic operations.

GET Request

The get method retrieves data from a specified resource.

this.http.get('http://example.com/api/items').subscribe(data => { 

In the above example, we make a GET request to 'http://example.com/api/items' and subscribe to the returned Observable. This triggers the HTTP request, and the response data will be logged to the console when it arrives.

POST Request

The post method sends data to a server to create a new resource.

let item = { name: 'new item' }; 
this.http.post('http://example.com/api/items', item).subscribe(data => { 

In the above example, we make a POST request to 'http://example.com/api/items' , sending a new item as the request body.

PUT Request

The put method updates a specific resource with new data.

let updatedItem = { name: 'updated item' }; 
this.http.put('http://example.com/api/items/1', updatedItem).subscribe(data => { 

In this example, we make a PUT request to 'http://example.com/api/items/1' , sending the updated item as the request body.

DELETE Request

The delete method deletes a specific resource.

this.http.delete('http://example.com/api/items/1').subscribe(data => { 

In this example, we make a DELETE request to 'http://example.com/api/items/1' .

Error Handling

link to this section

To handle errors in HttpClient, you can use the catchError operator from RxJS. You provide a function to catchError that can handle the error.

import { catchError } from 'rxjs/operators'; 
import { throwError } from 'rxjs'; 

    catchError(error => {   
        console.error('An error occurred:', error); 
        return throwError('Something bad happened; please try again later.'); 
).subscribe(data => console.log(data)); 

In this example, if the GET request fails, the error will be logged to the console, and a new error will be emitted.


link to this section

HttpClient supports HTTP interceptors, allowing middleware logic to be inserted into the pipeline. Interceptors can handle a variety of cross-cutting concerns, such as authentication, logging, and error handling.

import { HttpInterceptor, HttpRequest, HttpHandler, HttpEvent } from '@angular/common/http'; 
import { Observable } from 'rxjs'; 

export class MyInterceptor implements HttpInterceptor { 
    intercept(req: HttpRequest<any>, next: HttpHandler): Observable<HttpEvent<any>> { 
        const modifiedReq = req.clone({ headers: req.headers.set('Authorization', 'some-token') }); 
        return next.handle(modifiedReq); 

In this example, the interceptor adds an 'Authorization' header to every outgoing HTTP request.

Request Headers

link to this section

You might need to send specific HTTP headers with your request, such as Content-Type or Authorization . You can do this by creating an instance of HttpHeaders .

import { HttpHeaders } from '@angular/common/http'; 
const headers = new HttpHeaders().set('Content-Type', 'application/json'); 
this.http.get('http://example.com/api/items', { headers }).subscribe(data => { 

In this example, we've created an HttpHeaders object and set the 'Content-Type' header to 'application/json'.

Request Parameters

link to this section

You can also send parameters with your HTTP request. This is common when making GET requests that need to include query parameters.

import { HttpParams } from '@angular/common/http'; 
let params = new HttpParams().set('name', 'value'); 
this.http.get('http://example.com/api/items', { params }).subscribe(data => { 

In this example, we've created an HttpParams object and set a 'name' parameter to 'value'.

Observables and RxJS Operators

link to this section

Angular HttpClient returns RxJS Observables from HTTP methods. These Observables can be manipulated using RxJS operators to transform the data, handle asynchronous actions, and more.

For instance, we might want to retry a failed HTTP request:

import { retry } from 'rxjs/operators'; 
    .subscribe(data => console.log(data), error => console.error(error)); 

In this example, the retry operator is used to automatically re-subscribe to the Observable up to 3 times if the request fails.

Reading the Full Response

link to this section

By default, HttpClient methods return the body of the response. But you can also read the full HTTP response, including headers and status code. To do this, you need to tell HttpClient that you want the full response with the observe option:

this.http.get('http://example.com/api/items', { observe: 'response' }).subscribe(response => { 

In this example, we've told HttpClient to give us the full response, and we're logging the status code and the 'Content-Type' header.

Testing HttpClient Requests

link to this section

Angular HttpClient provides testing capabilities through the HttpClientTestingModule and HttpTestingController . These utilities provide a way to mock HTTP requests in your unit tests:

import { TestBed } from '@angular/core/testing'; 
import { HttpClientTestingModule, HttpTestingController } from '@angular/common/http/testing'; 

let httpTestingController: HttpTestingController; 

beforeEach(() => { 
        imports: [ HttpClientTestingModule ] 
    httpTestingController = TestBed.inject(HttpTestingController); 

it('should make a GET request', () => { 
    const req = httpTestingController.expectOne('http://example.com/api/items'); 

In this example, we're creating a unit test that verifies our service makes a GET request to the correct URL.


link to this section

The HttpClient in Angular offers a powerful, easy-to-use model for handling HTTP operations. Its capabilities go beyond basic GET, POST, PUT, and DELETE operations, offering strong error handling features and support for HTTP interceptors. With HttpClient, you can write more maintainable code and build more robust applications. Mastering HttpClient is a critical skill in the toolbox of any Angular developer. Happy coding!