AngularJS service de réessayer quand la promesse est rejetée

Vous pouvez réessayer la demande dans le service lui-même, pas le contrôleur.

Donc, AsyncService.query peut être quelque chose comme:

AsyncService.query = function() {
  var counter = 0
  var queryResults = $q.defer()

  function doQuery() {
    $http({method: 'GET', url: 'https://example.com'})
      .success(function(body) {
        queryResults.resolve(body)
      })
      .error(function() {
        if (counter < 3) {
          doQuery()
          counter++ 
        }
      })
  }

  return queryResults.promise
}

Et vous pouvez vous débarrasser de votre fonction d'erreur dans le contrôleur:

myApp.controller('myController', ['$scope', 'AsyncService',
  function($scope, AsyncService) {
    $scope.getData = function(query) {
      return AsyncService.query(query).then(function(response) {
        //Got success response
        return response;
      });
    }
  }
]);

OriginalL'auteur M.K. Safi

J'ai écrit une mise en œuvre avec l'intervalle exponentielle qui ne veut pas utiliser la récursivité (ce qui serait créé imbriquée pile d'images, correct?) La façon dont il est mis en œuvre le coût de l'utilisation de plusieurs minuteries et il crée toujours toutes les frames de pile pour la make_single_xhr_call (même après la réussite, au lieu de seulement après l'échec). Je ne sais pas si ça vaut le coup (surtout si la moyenne des cas est un succès), mais c'est de la nourriture pour la pensée.

J'étais inquiet au sujet d'une condition de concurrence entre des appels, mais si javascript est monothread et n'a pas de changements de contexte (ce qui permettrait à un $http.le succès d'être interrompu par un autre et lui permettre d'exécuter deux fois), puis nous nous sommes bien ici, c'est exact?

Aussi, je suis très nouveau pour angularjs et moderne javascript pour que les conventions n'ont peut-être un peu sale aussi. Laissez-moi savoir ce que vous en pensez.

var app = angular.module("angular", []);

app.controller("Controller", ["$scope", "$http", "$timeout",
    function($scope, $http, $timeout) {

  /**
   * Tries to make XmlHttpRequest call a few times with exponential backoff.
   * 
   * The way this works is by setting a timeout for all the possible calls
   * to make_single_xhr_call instantly (because $http is asynchronous) and
   * make_single_xhr_call checks the global state ($scope.xhr_completed) to
   * make sure another request was not already successful.
   *
   * With sleeptime = 0, inc = 1000, the calls will be performed around:
   * t = 0
   * t = 1000 (+1 second)
   * t = 3000 (+2 seconds)
   * t = 7000 (+4 seconds)
   * t = 15000 (+8 seconds)
   */
  $scope.repeatedly_xhr_call_until_success = function() {
    var url = "/url/to/data";
    $scope.xhr_completed = false
    var sleeptime = 0;
    var inc = 1000;
    for (var i = 0, n = 5 ; i < n ; ++i) {
      $timeout(function() {$scope.make_single_xhr_call(url);}, sleeptime);
      sleeptime += inc;
      inc = (inc << 1); //multiply inc by 2
    }
  };

  /**
   * Try to make a single XmlHttpRequest and do something with the data.
   */
  $scope.make_single_xhr_call = function(url) {
    console.log("Making XHR Request to " + url);

    //avoid making the call if it has already been successful
    if ($scope.xhr_completed) return;
    $http.get(url)
      .success(function(data, status, headers) {
        //this would be later (after the server responded)-- maybe another
        //one of the calls has already completed.
        if ($scope.xhr_completed) return;
        $scope.xhr_completed = true;
        console.log("XHR was successful");
        //do something with XHR data
      })
      .error(function(data, status, headers) {
        console.log("XHR failed.");
      });
  };

}]);

OriginalL'auteur mathewguest