Angular HttpClientでエラーをキャッチする


114

次のようなデータサービスがあります。

@Injectable()
export class DataService {
    baseUrl = 'http://localhost'
        constructor(
        private httpClient: HttpClient) {
    }
    get(url, params): Promise<Object> {

        return this.sendRequest(this.baseUrl + url, 'get', null, params)
            .map((res) => {
                return res as Object
            })
            .toPromise();
    }
    post(url, body): Promise<Object> {
        return this.sendRequest(this.baseUrl + url, 'post', body)
            .map((res) => {
                return res as Object
            })
            .toPromise();
    }
    patch(url, body): Promise<Object> {
        return this.sendRequest(this.baseUrl + url, 'patch', body)
            .map((res) => {
                return res as Object
            })
            .toPromise();
    }
    sendRequest(url, type, body, params = null): Observable<any> {
        return this.httpClient[type](url, { params: params }, body)
    }
}

私は、HTTPエラー(すなわち404)を取得する場合、私は厄介なコンソールメッセージが表示されます。 ERRORエラー:(約束で)キャッチされない:[オブジェクトのオブジェクト]からcore.es5.js 私は私の場合、それを処理するにはどうすればよいですか?

回答:


231

ニーズに応じて、いくつかのオプションがあります。リクエストごとにエラーを処理する場合は、リクエストにを追加catchします。グローバルソリューションを追加する場合は、を使用しますHttpInterceptor

以下のソリューションのデモプランカーを開きます。

tl; dr

最も単純なケースで.catch().subscribe()、次のようにa またはを追加するだけです。

import 'rxjs/add/operator/catch'; // don't forget this, or you'll get a runtime error
this.httpClient
      .get("data-url")
      .catch((err: HttpErrorResponse) => {
        // simple logging, but you can do a lot more, see below
        console.error('An error occurred:', err.error);
      });

// or
this.httpClient
      .get("data-url")
      .subscribe(
        data => console.log('success', data),
        error => console.log('oops', error)
      );

しかし、これにはさらに詳細があります。以下を参照してください。


メソッド(ローカル)ソリューション:エラーをログに記録し、フォールバック応答を返す

1か所のみでエラーを処理する必要がある場合は、catch完全に失敗するのではなく、デフォルト値(または空の応答)を使用して返すことができます。また.map、キャストする必要はありません。ジェネリック関数を使用できます。出典:Angular.io-Getting Error Details

したがって、ジェネリック.get()メソッドは次のようになります。

import { Injectable } from '@angular/core';
import { HttpClient, HttpErrorResponse } from "@angular/common/http";
import { Observable } from 'rxjs/Observable';
import 'rxjs/add/operator/catch';
import 'rxjs/add/observable/of';
import 'rxjs/add/observable/empty';
import 'rxjs/add/operator/retry'; // don't forget the imports

@Injectable()
export class DataService {
    baseUrl = 'http://localhost';
    constructor(private httpClient: HttpClient) { }

    // notice the <T>, making the method generic
    get<T>(url, params): Observable<T> {
      return this.httpClient
          .get<T>(this.baseUrl + url, {params})
          .retry(3) // optionally add the retry
          .catch((err: HttpErrorResponse) => {

            if (err.error instanceof Error) {
              // A client-side or network error occurred. Handle it accordingly.
              console.error('An error occurred:', err.error.message);
            } else {
              // The backend returned an unsuccessful response code.
              // The response body may contain clues as to what went wrong,
              console.error(`Backend returned code ${err.status}, body was: ${err.error}`);
            }

            // ...optionally return a default fallback value so app can continue (pick one)
            // which could be a default value
            // return Observable.of<any>({my: "default value..."});
            // or simply an empty observable
            return Observable.empty<T>();
          });
     }
}

エラーを処理することで、URLのサービスの状態が悪い場合でもアプリを続行できます。

このリクエストごとのソリューションは、ほとんどの場合、各メソッドに特定のデフォルトの応答を返したい場合に適しています。ただし、エラーの表示のみに関心がある場合(またはグローバルなデフォルトの応答がある場合)は、以下で説明するように、インターセプターを使用することをお勧めします。

ここで動作するデモプランカーを実行します


高度な使用法:すべての要求または応答のインターセプト

もう一度、Angular.ioガイドは示しています:

の主な機能@angular/common/httpはインターセプト、つまりアプリケーションとバックエンドの間にあるインターセプターを宣言する機能です。アプリケーションがリクエストを行うと、インターセプターはそれをサーバーに送信する前に変換します。インターセプターは、アプリケーションがそれを認識する前に、途中でレスポンスを変換できます。これは、認証からロギングまですべてに役立ちます。

もちろん、これは非常に簡単な方法でエラーを処理するために使用できます(デモプランカーはこちら):

import { Injectable } from '@angular/core';
import { HttpEvent, HttpInterceptor, HttpHandler, HttpRequest, HttpResponse,
         HttpErrorResponse } from '@angular/common/http';
import { Observable } from 'rxjs/Observable';
import 'rxjs/add/operator/catch';
import 'rxjs/add/observable/of';
import 'rxjs/add/observable/empty';
import 'rxjs/add/operator/retry'; // don't forget the imports

@Injectable()
export class HttpErrorInterceptor implements HttpInterceptor {
  intercept(request: HttpRequest<any>, next: HttpHandler): Observable<HttpEvent<any>> {
    return next.handle(request)
      .catch((err: HttpErrorResponse) => {

        if (err.error instanceof Error) {
          // A client-side or network error occurred. Handle it accordingly.
          console.error('An error occurred:', err.error.message);
        } else {
          // The backend returned an unsuccessful response code.
          // The response body may contain clues as to what went wrong,
          console.error(`Backend returned code ${err.status}, body was: ${err.error}`);
        }

        // ...optionally return a default fallback value so app can continue (pick one)
        // which could be a default value (which has to be a HttpResponse here)
        // return Observable.of(new HttpResponse({body: [{name: "Default value..."}]}));
        // or simply an empty observable
        return Observable.empty<HttpEvent<any>>();
      });
  }
}

インターセプターを提供する:HttpErrorInterceptor上記を宣言するだけでは、アプリはそれを使用しません。次のように、インターセプターとして提供することで、アプリモジュール接続する必要があります。

import { NgModule } from '@angular/core';
import { HTTP_INTERCEPTORS } from '@angular/common/http';
import { HttpErrorInterceptor } from './path/http-error.interceptor';

@NgModule({
  ...
  providers: [{
    provide: HTTP_INTERCEPTORS,
    useClass: HttpErrorInterceptor,
    multi: true,
  }],
  ...
})
export class AppModule {}

注:エラーインターセプターと一部のローカルエラー処理の両方がある場合、当然、エラーはローカルエラー処理に到達するにインターセプターによって常に処理されるため、ローカルエラー処理はトリガーされない可能性があります。

ここで動作するデモプランカーを実行します


2
まあ、彼が完全に派手になりたいのなら、彼は自分の奉仕を完全に明確にしておくだろう:return this.httpClient.get<type>(...)。そして、catch...彼が実際にそれを消費するサービスのどこかにそれがあるのは、それが彼がオブザーバブルを構築する場所であり、それが流れを最もよく処理できるからです。
dee zg

1
おそらく、最適なソリューションは、Promise<Object>のクライアント(DataServiceのメソッドの呼び出し元)にエラーを処理させることです。例:this.dataService.post('url', {...}).then(...).catch((e) => console.log('handle error here instead', e));。あなたとあなたのサービスのユーザーにとってより明確なものを選択してください。
acdcjunior 2017

1
これはコンパイルさreturn Observable.of({my: "default value..."}); れません:「| ...」はタイプ「HttpEvent <any>」に割り当てられません」というエラーが発生します。
Yakov Fain 2017

1
@YakovFainインターセプターにデフォルト値が必要な場合はHttpEvent、などのである必要がありますHttpResponse。したがって、たとえば、次のように使用できますreturn Observable.of(new HttpResponse({body: [{name: "Default value..."}]}));。この点を明確にするために、回答を更新しました。また、すべての機能を示すデモプランカーを作成しました。plnkr.co
edit

1
@acdcjunior、あなたは贈り続ける贈り物です:)
LastTribunal 2018

67

私は更新してくださいしてみましょうacdcjunior使用についての答えをHttpInterceptor最新RxJs機能(V.6)で。

import { Injectable } from '@angular/core';
import {
  HttpInterceptor,
  HttpRequest,
  HttpErrorResponse,
  HttpHandler,
  HttpEvent,
  HttpResponse
} from '@angular/common/http';

import { Observable, EMPTY, throwError, of } from 'rxjs';
import { catchError } from 'rxjs/operators';

@Injectable()
export class HttpErrorInterceptor implements HttpInterceptor {
  intercept(request: HttpRequest<any>, next: HttpHandler): Observable<HttpEvent<any>> {

    return next.handle(request).pipe(
      catchError((error: HttpErrorResponse) => {
        if (error.error instanceof Error) {
          // A client-side or network error occurred. Handle it accordingly.
          console.error('An error occurred:', error.error.message);
        } else {
          // The backend returned an unsuccessful response code.
          // The response body may contain clues as to what went wrong,
          console.error(`Backend returned code ${error.status}, body was: ${error.error}`);
        }

        // If you want to return a new response:
        //return of(new HttpResponse({body: [{name: "Default value..."}]}));

        // If you want to return the error on the upper level:
        //return throwError(error);

        // or just return nothing:
        return EMPTY;
      })
    );
  }
}

11
これはもっと賛成する必要があります。acdcjuniorの回答は今日現在使用できません
ポールクルーガー

48

HTTPClientAPI の登場により、API Httpが置き換えられただけでなく、新しいHttpInterceptorAPI が追加されました。

AFAIKの目標の1つは、すべてのHTTP送信要求と受信応答にデフォルトの動作を追加することです。

したがって、デフォルトのエラー処理動作を追加する場合.catch()、可能なすべてのhttp.get / post / etcメソッドに追加することは、途方もなく保守が困難です。

これは、例として次のように使用できますHttpInterceptor

import { Injectable } from '@angular/core';
import { HttpEvent, HttpInterceptor, HttpHandler, HttpRequest, HttpErrorResponse, HTTP_INTERCEPTORS } from '@angular/common/http';
import { Observable } from 'rxjs/Observable';
import { _throw } from 'rxjs/observable/throw';
import 'rxjs/add/operator/catch';

/**
 * Intercepts the HTTP responses, and in case that an error/exception is thrown, handles it
 * and extract the relevant information of it.
 */
@Injectable()
export class ErrorInterceptor implements HttpInterceptor {
    /**
     * Intercepts an outgoing HTTP request, executes it and handles any error that could be triggered in execution.
     * @see HttpInterceptor
     * @param req the outgoing HTTP request
     * @param next a HTTP request handler
     */
    intercept(req: HttpRequest<any>, next: HttpHandler): Observable<HttpEvent<any>> {
        return next.handle(req)
            .catch(errorResponse => {
                let errMsg: string;
                if (errorResponse instanceof HttpErrorResponse) {
                    const err = errorResponse.message || JSON.stringify(errorResponse.error);
                    errMsg = `${errorResponse.status} - ${errorResponse.statusText || ''} Details: ${err}`;
                } else {
                    errMsg = errorResponse.message ? errorResponse.message : errorResponse.toString();
                }
                return _throw(errMsg);
            });
    }
}

/**
 * Provider POJO for the interceptor
 */
export const ErrorInterceptorProvider = {
    provide: HTTP_INTERCEPTORS,
    useClass: ErrorInterceptor,
    multi: true,
};

// app.module.ts

import { ErrorInterceptorProvider } from 'somewhere/in/your/src/folder';

@NgModule({
   ...
   providers: [
    ...
    ErrorInterceptorProvider,
    ....
   ],
   ...
})
export class AppModule {}

OPに関する追加情報:強い型なしでhttp.get / post / etcを呼び出すことは、APIの最適な使用法ではありません。サービスは次のようになります。

// These interfaces could be somewhere else in your src folder, not necessarily in your service file
export interface FooPost {
 // Define the form of the object in JSON format that your 
 // expect from the backend on post
}

export interface FooPatch {
 // Define the form of the object in JSON format that your 
 // expect from the backend on patch
}

export interface FooGet {
 // Define the form of the object in JSON format that your 
 // expect from the backend on get
}

@Injectable()
export class DataService {
    baseUrl = 'http://localhost'
    constructor(
        private http: HttpClient) {
    }

    get(url, params): Observable<FooGet> {

        return this.http.get<FooGet>(this.baseUrl + url, params);
    }

    post(url, body): Observable<FooPost> {
        return this.http.post<FooPost>(this.baseUrl + url, body);
    }

    patch(url, body): Observable<FooPatch> {
        return this.http.patch<FooPatch>(this.baseUrl + url, body);
    }
}

Promises代わりにサービスメソッドから戻ることObservablesは、別の悪い決定です。

そして、もう1つアドバイスがあります。TYPEスクリプトを使用している場合は、タイプの部分の使用を開始してください。言語の最大の利点の1つを失う:あなたが扱っている価値のタイプを知ること。

私の意見では、角張ったサービスの良い例が必要な場合は、次の要点をご覧ください


コメントは、詳細な議論のためのものではありません。この会話はチャットに移動さました
だます

私はこれがあるべきと仮定this.http.get()などといないthis.get()などでDataService
displayname

選択した回答がより完全になりました。
Chris Haines

9

Angular 6+の場合、.catchはObservableと直接連動しません。あなたが使用する必要があります

.pipe(catchError(this.errorHandler))

コードの下:

import { IEmployee } from './interfaces/employee';
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 EmployeeService {

  private url = '/assets/data/employee.json';

  constructor(private http: HttpClient) { }

  getEmployees(): Observable<IEmployee[]> {
    return this.http.get<IEmployee[]>(this.url)
                    .pipe(catchError(this.errorHandler));  // catch error
  }

  /** Error Handling method */

  errorHandler(error: HttpErrorResponse) {
    if (error.error instanceof ErrorEvent) {
      // A client-side or network error occurred. Handle it accordingly.
      console.error('An error occurred:', error.error.message);
    } else {
      // The backend returned an unsuccessful response code.
      // The response body may contain clues as to what went wrong,
      console.error(
        `Backend returned code ${error.status}, ` +
        `body was: ${error.error}`);
    }
    // return an observable with a user-facing error message
    return throwError(
      'Something bad happened; please try again later.');
  }
}

詳細については、HttpのAngularガイドを参照してください。


1
これが私にとってうまくいった唯一の答えです。他のユーザーは「タイプ 'Observable <unknown>'はタイプ 'Observable <HttpEvent <any >> "に割り当てられない」というエラーを出します。
アーサー王

8

かなり単純です(以前のAPIでの方法と比較して)。

Angular公式ガイドのソース(コピーして貼り付け)

 http
  .get<ItemsResponse>('/api/items')
  .subscribe(
    // Successful responses call the first callback.
    data => {...},
    // Errors will call this callback instead:
    err => {
      console.log('Something went wrong!');
    }
  );

5

Angular 8 HttpClientエラー処理サービスの

ここに画像の説明を入力してください

api.service.ts

    import { Injectable } from '@angular/core';
    import { HttpClient, HttpHeaders, HttpErrorResponse } from '@angular/common/http';
    import { Student } from '../model/student';
    import { Observable, throwError } from 'rxjs';
    import { retry, catchError } from 'rxjs/operators';

    @Injectable({
      providedIn: 'root'
    })
    export class ApiService {

      // API path
      base_path = 'http://localhost:3000/students';

      constructor(private http: HttpClient) { }

      // Http Options
      httpOptions = {
        headers: new HttpHeaders({
          'Content-Type': 'application/json'
        })
      }

      // Handle API errors
      handleError(error: HttpErrorResponse) {
        if (error.error instanceof ErrorEvent) {
          // A client-side or network error occurred. Handle it accordingly.
          console.error('An error occurred:', error.error.message);
        } else {
          // The backend returned an unsuccessful response code.
          // The response body may contain clues as to what went wrong,
          console.error(
            `Backend returned code ${error.status}, ` +
            `body was: ${error.error}`);
        }
        // return an observable with a user-facing error message
        return throwError(
          'Something bad happened; please try again later.');
      };


      // Create a new item
      createItem(item): Observable<Student> {
        return this.http
          .post<Student>(this.base_path, JSON.stringify(item), this.httpOptions)
          .pipe(
            retry(2),
            catchError(this.handleError)
          )
      }

     ........
     ........

    }

2

あなたはおそらく次のようなものを持ちたいでしょう:

this.sendRequest(...)
.map(...)
.catch((err) => {
//handle your error here
})

サービスの使い方にも大きく依存しますが、これが基本的なケースです。


1

@acdcjuniorの回答に続き、これは私がそれを実装した方法です

サービス:

  get(url, params): Promise<Object> {

            return this.sendRequest(this.baseUrl + url, 'get', null, params)
                .map((res) => {
                    return res as Object
                }).catch((e) => {
                    return Observable.of(e);
                })
                .toPromise();
        }

発信者:

this.dataService.get(baseUrl, params)
            .then((object) => {
                if(object['name'] === 'HttpErrorResponse') {
                            this.error = true;
                           //or any handle
                } else {
                    this.myObj = object as MyClass 
                }
           });

1

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

const PASSENGER_API = 'api/passengers';

getPassengers(): Observable<Passenger[]> {
  return this.http
    .get<Passenger[]>(PASSENGER_API)
    .pipe(catchError((error: HttpErrorResponse) => throwError(error)));
}

0

ここで提供されるソリューションのいずれかでエラーをキャッチできない場合は、サーバーがCORSリクエストを処理していない可能性があります。

その場合、Angularよりはるかに少ないJavaScriptがエラー情報にアクセスできます。

CORBまたはを含むコンソールの警告を探しますCross-Origin Read Blocking

また、エラーを処理するために構文が変更されました(他のすべての回答で説明されています)。次のように、パイプ可能な演算子を使用します。

this.service.requestsMyInfo(payload).pipe(
    catcheError(err => {
        // handle the error here.
    })
);

0

Interceptorを使用すると、エラーをキャッチできます。以下はコードです:

@Injectable()
export class ResponseInterceptor implements HttpInterceptor {
  intercept(req: HttpRequest<any>, next: HttpHandler): Observable<HttpEvent<any>> {
    //Get Auth Token from Service which we want to pass thr service call
    const authToken: any = `Bearer ${sessionStorage.getItem('jwtToken')}`
    // Clone the service request and alter original headers with auth token.
    const authReq = req.clone({
      headers: req.headers.set('Content-Type', 'application/json').set('Authorization', authToken)
    });

    const authReq = req.clone({ setHeaders: { 'Authorization': authToken, 'Content-Type': 'application/json'} });

    // Send cloned request with header to the next handler.
    return next.handle(authReq).do((event: HttpEvent<any>) => {
      if (event instanceof HttpResponse) {
        console.log("Service Response thr Interceptor");
      }
    }, (err: any) => {
      if (err instanceof HttpErrorResponse) {
        console.log("err.status", err);
        if (err.status === 401 || err.status === 403) {
          location.href = '/login';
          console.log("Unauthorized Request - In case of Auth Token Expired");
        }
      }
    });
  }
}

あなたはこのブログを好むことができます。

弊社のサイトを使用することにより、あなたは弊社のクッキーポリシーおよびプライバシーポリシーを読み、理解したものとみなされます。
Licensed under cc by-sa 3.0 with attribution required.