A brief analysis of AngularJs HTTP response interceptor_AngularJS

Why use interceptors?

Any time, if we want to add global functionality to the request, such as authentication, error handling, etc., it is a better way to intercept the request before it is sent to the server or when the server returns.

angularJs provides a way to process from the global level through interceptors.

Interceptor allows you to:

Intercept requests by implementing the request method: This method will be executed before $http sends the request to the background, so you can modify the configuration or do other operations. This method receives a request configuration object as a parameter and must return a configuration object or a promise. If an invalid configuration object or promise is returned, it will be rejected, causing the $http call to fail.

Intercept the response by implementing the response method: This method will be executed after $http receives the response from the background, so you can modify the response or do other operations. This method receives a response object as a parameter and must return a response object or promise. The response object includes request configuration, headers, status and data from the background. If an invalid response object is returned or the promise will be rejected, the $http call will fail.

Intercept request exceptions by implementing the requestError method: Sometimes a request fails to be sent or is rejected by the interceptor. The request exception interceptor captures requests that were interrupted by the previous request interceptor. It can be used to restore the request or sometimes to undo the configuration made before the request, such as closing the progress bar, activating buttons and input boxes, etc.

Intercept response exceptions by implementing the responseError method: Sometimes our background call fails. It's also possible that it was rejected by a request interceptor, or interrupted by a previous response interceptor. In this case, the response exception interceptor can help us resume the background call.

The core of the interceptor is the service factory, which is added to the $httpprovider.interceptors array. Register in $httpProvider.

AngularJs provides four interceptors, including two success interceptors (request, response) and two failure interceptors (requestError, responseError).

Add one or more interceptors to the service:

angular.module("myApp", []) 
  .factory('httpInterceptor', [ '$q', '$injector',function($q, $injector) { 
    var httpInterceptor = { 
      'responseError' : function(response) { 
        ...... 
        return $q.reject(response); 
      }, 
      'response' : function(response) { 
        ...... 
        return response; 
      }, 
      'request' : function(config) { 
        ...... 
        return config; 
      }, 
      'requestError' : function(config){ 
        ...... 
        return $q.reject(config); 
      } 
    } 
  return httpInterceptor; 
} 

Then use $httpProvider to register the interceptor in the .config() function

angular.module("myApp", []) 
.config([ '$httpProvider', function($httpProvider) { 
  $httpProvider.interceptors.push('httpInterceptor'); 
} ]); 

Actual example: (Interception of 401, 404)

routerApp.config([ '$httpProvider', function($httpProvider) { 
    $httpProvider.interceptors.push('httpInterceptor'); 
  } ]); 
  routerApp.factory('httpInterceptor', [ '$q', '$injector',function($q, $injector) { 
    var httpInterceptor = { 
      'responseError' : function(response) { 
        if (response.status == 401) { 
          var rootScope = $injector.get('$rootScope'); 
          var state = $injector.get('$rootScope').$state.current.name; 
          rootScope.stateBeforLogin = state; 
          rootScope.$state.go("login"); 
          return $q.reject(response); 
        } else if (response.status === 404) { 
          alert("404!"); 
          return $q.reject(response); 
        } 
      }, 
      'response' : function(response) { 
        return response; 
      } 
    } 
    return httpInterceptor; 
  }  
]); 

Session injection (request interceptor)

There are two ways to implement server-side authentication. The first is traditional Cookie-Based authentication. The user is authenticated for each request through server-side cookies. Another way is Token-Based verification. When the user logs in, he will get a sessionToken from the background. The sessionToken identifies each user on the server side and is included in every request sent to the server.

The following sessionInjector adds the x-session-token header to each captured request (if the current user is logged in):

<!-- lang: js -->
module.factory('sessionInjector', ['SessionService', function(SessionService) {
  var sessionInjector = {
    request: function(config) {
      if (!SessionService.isAnonymus) {
        config.headers['x-session-token'] = SessionService.token;
      }
      return config;
    }
  };
  return sessionInjector;
}]);
module.config(['$httpProvider', function($httpProvider) {
  $httpProvider.interceptors.push('sessionInjector');
}]);

Then create a request:

<!-- lang: js -->
$http.get('https://api.github.com/users/naorye/repos');

The configuration object before being intercepted by sessionInjector is like this:

<!-- lang: js -->
{
  "transformRequest": [
    null
  ],
  "transformResponse": [
    null
  ],
  "method": "GET",
  "url": "https://api.github.com/users/naorye/repos",
  "headers": {
    "Accept": "application/json, text/plain, */*"
  }
}

The configuration object after being intercepted by sessionInjector is like this:

<!-- lang: js -->
{
  "transformRequest": [
    null
  ],
  "transformResponse": [
    null
  ],
  "method": "GET",
  "url": "https://api.github.com/users/naorye/repos",
  "headers": {
    "Accept": "application/json, text/plain, */*",
    "x-session-token": 415954427904
  }
}

The above content introduces you to the relevant knowledge of AngularJs HTTP response interceptor. I hope that sharing this article can help you.