কৌণিক এইচটিপিপিলেটতে ত্রুটিগুলি ধরা


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

যদি আমি এইচটিটিপি ত্রুটি পাই (যেমন 404), আমি একটি বাজে কনসোল বার্তা পেয়েছি : ত্রুটি ত্রুটি: আনকচড (প্রতিশ্রুতিতে): [অবজেক্ট অবজেক্ট] কোর.es5.js থেকে আমি কীভাবে এটি পরিচালনা করব?

উত্তর:


231

আপনার প্রয়োজনের উপর নির্ভর করে আপনার কাছে কিছু বিকল্প রয়েছে। আপনি যদি প্রতি অনুরোধের ভিত্তিতে ত্রুটিগুলি পরিচালনা করতে চান তবে catchআপনার অনুরোধটিতে একটি যুক্ত করুন । আপনি যদি বিশ্বব্যাপী সমাধান যুক্ত করতে চান তবে ব্যবহার করুন HttpInterceptor

নীচের সমাধানগুলির জন্য এখানে ওয়ার্কিং ডেমো প্লঙ্কারটি খুলুন ।

TL; ড

সবচেয়ে সহজ ক্ষেত্রে, আপনাকে কেবল একটি .catch()বা একটি যুক্ত করতে হবে .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>();
          });
     }
}

ত্রুটিটি পরিচালনা করা আপনাকে ইউআরএল-এ থাকা পরিষেবাটি খারাপ অবস্থায় থাকলেও অ্যাপটি চালিয়ে যাওয়ার অনুমতি দেবে।

প্রতি-অনুরোধ সমাধানটি বেশিরভাগ ক্ষেত্রেই ভাল যখন আপনি প্রতিটি পদ্ধতির একটি নির্দিষ্ট ডিফল্ট প্রতিক্রিয়া ফিরিয়ে দিতে চান। তবে আপনি যদি কেবল ত্রুটি প্রদর্শনের বিষয়ে চিন্তা করেন (বা বিশ্বব্যাপী ডিফল্ট প্রতিক্রিয়া রয়েছে), তবে নীচের বর্ণিত হিসাবে একটি ইন্টারসেপ্টর ব্যবহার করা আরও ভাল সমাধান।

এখানে ওয়ার্কিং ডেমো প্লাঙ্কার চালান ।


উন্নত ব্যবহার: সমস্ত অনুরোধ বা প্রতিক্রিয়াগুলিতে বাধা দেওয়া

আবার, 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...সেখান থেকে অন্য কোথাও আসবে যেখানে তিনি এটি সত্যই গ্রাস করেন কারণ সেখানে তিনি পর্যবেক্ষণযোগ্য প্রবাহ তৈরি করবেন এবং এটি সর্বোত্তমভাবে পরিচালনা করতে পারবেন।
ডি 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..."}); এটি একটি ত্রুটি দেয় "| ... '' এইচটিপিএভেন্ট <নতুন> 'টাইপ করার যোগ্য নয়" "
ইয়াকভ ফেইন

1
@YakovFain আপনি আটককারী একটি ডিফল্ট মান চান, এটি একটি হওয়া আবশ্যক HttpEventযেমন একটি হিসাবে, HttpResponse। সুতরাং, উদাহরণস্বরূপ, আপনি ব্যবহার করতে পারে: return Observable.of(new HttpResponse({body: [{name: "Default value..."}]}));। আমি এই বিষয়টি পরিষ্কার করার জন্য উত্তর আপডেট করেছি। এছাড়াও, আমি সমস্ত কাজ করে দেখানোর জন্য একটি ওয়ার্কিং ডেমো প্লাঙ্কার তৈরি করেছি: plnkr.co/edit/ulFGp4VMzrbaDJeGqc6q?p= পূর্বরূপ
acdcjunior

1
@ অ্যাকডজিনিয়র, আপনি এমন উপহার যা চালিয়ে যান :)
লাস্টটিবুনাল

67

আমাকে দয়া করে সর্বশেষতম RxJs বৈশিষ্ট্যগুলি (v.6) এর সাথে HTTPInterceptor ব্যবহার সম্পর্কে acdcjunior এর উত্তর আপডেট করুন ।

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
এটি আরও upvated করা প্রয়োজন। এসিডকিউনিয়ারের উত্তরটি আজ অব্যবহার্য
পল ক্রুগার

48

HTTPClientএপিআই আসার পরে , কেবল Httpএপিআই প্রতিস্থাপন করা হয়নি, তবে একটি নতুন যুক্ত করা হয়েছিল, HttpInterceptorএপিআই।

এএফআইকে এর অন্যতম লক্ষ্য হ'ল সমস্ত এইচটিটিপি আউটগোয়িং অনুরোধ এবং আগত প্রতিক্রিয়াগুলিতে ডিফল্ট আচরণ যুক্ত করা।

সুতরাং ধরে নিই যে আপনি নিজের সম্ভাব্য সমস্ত http.get / post / ইত্যাদি পদ্ধতিতে যুক্ত করে একটি ডিফল্ট ত্রুটি পরিচালনার আচরণ যুক্ত .catch()করতে চান তা হাস্যকরভাবে বজায় রাখা শক্ত।

এটি নিম্নলিখিত পদ্ধতিতে ব্যবহার করে উদাহরণস্বরূপ 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 {}

ওপির জন্য কিছু অতিরিক্ত তথ্য: কোনও শক্তিশালী প্রকার ছাড়াই http.get / post / ইত্যাদি কল করা কোনও API এর অনুকূল ব্যবহার নয় isn't আপনার পরিষেবাটি দেখতে এইরকম হওয়া উচিত:

// 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অন্য একটি খারাপ সিদ্ধান্ত।

এবং অতিরিক্ত পরামর্শের অংশ: আপনি যদি টিওয়াইপি স্ক্রিপ্টটি ব্যবহার করে থাকেন তবে এর ধরণের অংশটি ব্যবহার শুরু করুন। আপনি ভাষার বৃহত্তম সুবিধাগুলির মধ্যে একটি হারাবেন: আপনি যে মানটির সাথে লেনদেন করছেন তার ধরণটি জানতে।

আপনি যদি একটি, আমার মতে, কৌণিক পরিষেবাটির ভাল উদাহরণ চান তবে নীচের টুকরোটি একবার দেখুন


মন্তব্যগুলি বর্ধিত আলোচনার জন্য নয়; এই কথোপকথন চ্যাটে সরানো হয়েছে ।
ছদ্মবেশ

আমি ধরে নিই যে এটি হওয়া উচিত this.http.get()ইত্যাদি এবং না this.get()ইত্যাদিতে DataService?
displayname

নির্বাচিত উত্তরটি এখন আরও সম্পূর্ণ বলে মনে হচ্ছে।
ক্রিস হেইনেস

9

মোটামুটি সোজা (পূর্ববর্তী API এর সাথে এটি কীভাবে করা হয়েছিল তার তুলনায়)।

কৌনিক অফিসিয়াল গাইড (অনুলিপি এবং আটকানো) থেকে উত্স

 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

কৌণিক 6+ এর জন্য .ক্যাচটি পর্যবেক্ষণযোগ্যের সাথে সরাসরি কাজ করে না। আপনি ব্যবহার করতে হবে

.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.');
  }
}

আরও তথ্যের জন্য, এইচটিটিপি জন্য কৌণিক নির্দেশিকা দেখুন


1
এটি আমার পক্ষে কাজ করা একমাত্র উত্তর। অন্যরা একটি ত্রুটি দেয়: "টাইপ 'পর্যবেক্ষণযোগ্য <অজ্ঞাত>' টাইপ করার জন্য 'পর্যবেক্ষণযোগ্য <HttpEvent <any>> টাইপযোগ্য নয়'।
কিং আর্থার তৃতীয়

5

কৌণিক 8 এইচটিটিপি ক্লায়েন্ট ত্রুটি পরিচালনা করার পরিষেবা উদাহরণ Example

এখানে চিত্র বর্ণনা লিখুন

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 অনুরোধগুলি পরিচালনা করছে না।

সেই ইভেন্টে জাভাস্ক্রিপ্ট, অনেক কম কৌনিক, ত্রুটির তথ্য অ্যাক্সেস করতে পারে।

আপনার কনসোলে সতর্কবার্তা যে অন্তর্ভুক্ত দেখুন CORBবা Cross-Origin Read Blocking

এছাড়াও, সিনট্যাক্সগুলি ত্রুটিগুলি পরিচালনা করার জন্য পরিবর্তিত হয়েছে (প্রতিটি অন্যান্য উত্তরে বর্ণিত)। আপনি এখন পাইপ-সক্ষম অপারেটরগুলি ব্যবহার করেন, যেমন:

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

0

ইন্টারসেপ্টর ব্যবহার করে আপনি ত্রুটি ধরতে পারেন। নীচে কোড রয়েছে:

@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.