Error Handling

Error handling is crucial for creating robust and user-friendly applications. In Angular, the HTTPClient module provides methods to handle errors efficiently using RxJS operators.

Setting Up HTTPClientModule

First, import the HttpClientModule into your app module:

// app.module.ts
import { BrowserModule } from '@angular/platform-browser';
import { NgModule } from '@angular/core';
import { HttpClientModule } from '@angular/common/http';
import { AppComponent } from './app.component';
import { DataService } from './data.service';
import { HomeComponent } from './home/home.component';

@NgModule({
  declarations: [AppComponent, HomeComponent],
  imports: [BrowserModule, HttpClientModule],
  providers: [DataService],
  bootstrap: [AppComponent]
})
export class AppModule { }

Creating a Service

Next, create a service to manage HTTP requests using the Angular CLI command:

$ ng generate service data

This command generates a new service file named data.service.ts.

Implementing Error Handling

In the service file, inject the HttpClient and create methods to perform HTTP requests with error handling using the catchError operator:

// data.service.ts
import { Injectable } from '@angular/core';
import { HttpClient, HttpErrorResponse } from '@angular/common/http';
import { Observable, throwError } from 'rxjs';
import { catchError } from 'rxjs/operators';

@Injectable({
  providedIn: 'root'
})
export class DataService {
  private apiUrl = 'https://jsonplaceholder.typicode.com/posts';

  constructor(private http: HttpClient) { }

  getPosts(): Observable {
    return this.http.get(this.apiUrl).pipe(
      catchError(this.handleError)
    );
  }

  addPost(post: any): Observable {
    return this.http.post(this.apiUrl, post).pipe(
      catchError(this.handleError)
    );
  }

  updatePost(id: number, post: any): Observable {
    const url = `${this.apiUrl}/${id}`;
    return this.http.put(url, post).pipe(
      catchError(this.handleError)
    );
  }

  deletePost(id: number): Observable {
    const url = `${this.apiUrl}/${id}`;
    return this.http.delete(url).pipe(
      catchError(this.handleError)
    );
  }

  private handleError(error: HttpErrorResponse) {
    console.error('Server Error:', error);
    return throwError('Something went wrong with the request.');
  }
}

Using the Service in a Component

Inject the service into your component's constructor and use it to perform HTTP requests with error handling:

// home.component.ts
import { Component, OnInit } from '@angular/core';
import { DataService } from '../data.service';

@Component({
  selector: 'app-home',
  template: `
    
Posts
    

      
{{ post.title }}
    
    
{{ errorMessage }}
  `
})
export class HomeComponent implements OnInit {
  posts: any[] = [];
  errorMessage: string;

  constructor(private dataService: DataService) {}

  ngOnInit() {
    this.dataService.getPosts().subscribe(
      data => this.posts = data,
      error => this.errorMessage = error
    );
  }
}

Key Points

Conclusion

Error handling is essential for building reliable applications. By setting up the HTTPClientModule and using the HTTPClient with error handling, you can efficiently manage errors and provide a better user experience in your Angular applications. Happy coding!