Отлов ошибок в Angular HttpClient

115

У меня есть служба данных, которая выглядит так:

@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 Error: Uncaught (in prom ): [object Object] из core.es5.js Как мне справиться с этим в моем случае?

Последний трибунал
источник

Ответы:

231

У вас есть несколько вариантов, в зависимости от ваших потребностей. Если вы хотите обрабатывать ошибки для каждого запроса, добавьте catchв свой запрос. Если вы хотите добавить глобальное решение, используйтеHttpInterceptor .

Откройте здесь рабочий демонстрационный плункер для решений ниже.

tl; dr

В простейшем случае вам просто нужно добавить a .catch()или a .subscribe(), например:

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)
      );

Но об этом подробнее см. Ниже.


Метод (локальное) решение: записать ошибку и вернуть отклик

Если вам нужно обрабатывать ошибки только в одном месте, вы можете использовать catchи вернуть значение по умолчанию (или пустой ответ) вместо полного отказа. Вам также не нужно .mapпросто преобразовывать, вы можете использовать универсальную функцию. Источник: Angular.io - Получение сведений об ошибке .

Итак, общий .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 {}

Примечание: если у вас есть и перехватчик ошибок, и некоторая локальная обработка ошибок, естественно, вероятно, что локальная обработка ошибок никогда не будет запущена, поскольку ошибка всегда будет обрабатываться перехватчиком до того, она достигнет локальной обработки ошибок.

Запустите рабочий демонстрационный плункер здесь .

acdcjunior
источник
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
1
Это не компилируется: return Observable.of({my: "default value..."}); выдает ошибку «| ...» не может быть присвоено типу «HttpEvent <any>».
Яков Файн
1
@YakovFain Если вы хотите значение по умолчанию в перехватчик, он должен быть HttpEvent, например , как HttpResponse. Так, например, вы можете использовать: return Observable.of(new HttpResponse({body: [{name: "Default value..."}]}));. Я обновил ответ, чтобы прояснить этот момент. Кроме того, я создал рабочий демонстрационный плункер, чтобы показать, что все работает: plnkr.co/edit/ulFGp4VMzrbaDJeGqc6q?p=preview
acdcjunior
1
@acdcjunior, ты подарок, который продолжает дарить :)
LastTribunal
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;
      })
    );
  }
}
MegaCasper
источник
11
Это должно получить больше голосов. Ответ acdcjunior на сегодняшний день нельзя использовать
Пол Крюгер,
48

С появлением HTTPClientAPI был не только Httpзаменен API, но и добавлен новый - HttpInterceptorAPI.

AFAIK одна из его целей - добавить поведение по умолчанию ко всем исходящим запросам и входящим ответам 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 - еще одно плохое решение.

И дополнительный совет: если вы используете TYPE сценарий , начните использовать его часть типа. Вы теряете одно из самых больших преимуществ языка: знание типа значения, с которым вы имеете дело.

Если вам нужен, на мой взгляд, хороший пример Angular-сервиса, обратите внимание на следующую суть .

Jota.Toledo
источник
Комментарии не подлежат расширенному обсуждению; этот разговор был перемещен в чат .
deceze
Я полагаю, это должно быть this.http.get()и т. Д., А не this.get()т. Д. DataService?
displayname
Выбранный ответ теперь кажется более полным.
Крис Хейнс
9

Довольно просто (по сравнению с тем, как это было сделано в предыдущем 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!');
    }
  );
Томер
источник
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.');
  }
}

Дополнительные сведения см. В Руководстве по Angular для Http.

Удит Индракантха
источник
1
Это единственный ответ, который у меня сработал. Остальные выдают ошибку: «Тип 'Observable <unknown>' не может быть назначен типу 'Observable <HttpEvent <any>>».
Король Артур Третий,
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)));
}
солнце sreng
источник
0

Если вы не можете обнаружить ошибки ни с одним из предложенных здесь решений, возможно, сервер не обрабатывает запросы CORS.

В этом случае Javascript, а тем более Angular, может получить доступ к информации об ошибке.

Ищите предупреждения в консоли, которые включают 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");
        }
      }
    });
  }
}

Вы можете предпочесть этот блог .. приведенный простой пример.

Прашант М Бхавсар
источник