Boolescher Wert

Ich denke, es gibt jetzt einen noch einfacheren Weg. Dies ermöglicht das grundlegende Caching für alle $ http-Anforderungen (die $ resource erbt):

 var app = angular.module('myApp',[])
      .config(['$httpProvider', function ($httpProvider) {
            // enable http caching
           $httpProvider.defaults.cache = true;
      }])

Eine einfachere Möglichkeit, dies in der aktuellen stabilen Version (1.0.6) zu tun, erfordert viel weniger Code.

Fügen Sie nach dem Einrichten Ihres Moduls eine Fabrik hinzu:

var app = angular.module('myApp', []);
// Configure routes and controllers and views associated with them.
app.config(function ($routeProvider) {
    // route setups
});
app.factory('MyCache', function ($cacheFactory) {
    return $cacheFactory('myCache');
});

Jetzt können Sie dies an Ihren Controller übergeben:

app.controller('MyController', function ($scope, $http, MyCache) {
    $http.get('fileInThisCase.json', { cache: MyCache }).success(function (data) {
        // stuff with results
    });
});

Ein Nachteil ist, dass die Schlüsselnamen auch automatisch eingerichtet werden, was das Löschen schwierig machen kann. Hoffentlich fügen sie etwas hinzu, um Schlüsselnamen zu erhalten.

Schauen Sie sich den Winkel-Cache der Bibliothek an, wenn Sie das integrierte Caching von $ http mögen, aber mehr Kontrolle wünschen. Sie können es verwenden, um den $ http-Cache nahtlos mit einer regelmäßigen Lebensdauer der Lebensdauer und der Option zu erweitern, den Cache für localStorage beizubehalten, damit er sitzungsübergreifend verfügbar ist.

FWIW bietet außerdem Tools und Muster, mit denen Sie Ihren Cache zu einem dynamischeren Datenspeicher machen können, mit dem Sie als POJOs interagieren können, und nicht nur mit den Standard-JSON-Zeichenfolgen. Ich kann das Dienstprogramm dieser Option noch nicht kommentieren.

(Dann Hinzu kommt, dass, im Zusammenhang Bibliothek Winkeldaten sind eine Art Ersatz für $ Ressourcen- und / oder Restangular, und hängen von Winkel-cache) .

Da AngularJS-Fabriken Singletons sind , können Sie das Ergebnis der http-Anforderung einfach speichern und abrufen, wenn Ihr Dienst das nächste Mal in etwas injiziert wird.

angular.module('myApp', ['ngResource']).factory('myService',
  function($resource) {
    var cache = false;
    return {
      query: function() {
        if(!cache) {
          cache = $resource('http://example.com/api').query();
        }
        return cache;
      }
    };
  }
);

angularBlogServices.factory('BlogPost', ['$resource',
    function($resource) {
        return $resource("./Post/:id", {}, {
            get:    {method: 'GET',    cache: true,  isArray: false},
            save:   {method: 'POST',   cache: false, isArray: false},
            update: {method: 'PUT',    cache: false, isArray: false},
            delete: {method: 'DELETE', cache: false, isArray: false}
        });
    }]);

Setzen Sie den Cache auf true.

In Angular 8 können wir Folgendes tun:

import { Injectable } from '@angular/core';
import { YourModel} from '../models/<yourModel>.model';
import { UserService } from './user.service';
import { Observable, of } from 'rxjs';
import { map, catchError } from 'rxjs/operators';
import { HttpClient } from '@angular/common/http';

@Injectable({
  providedIn: 'root'
})

export class GlobalDataService {

  private me: <YourModel>;

  private meObservable: Observable<User>;

  constructor(private yourModalService: <yourModalService>, private http: HttpClient) {

  }

  ngOnInit() {

  }


  getYourModel(): Observable<YourModel> {

    if (this.me) {
      return of(this.me);
    } else if (this.meObservable) {
      return this.meObservable;
    }
    else {
      this.meObservable = this.yourModalService.getCall<yourModel>() // Your http call
      .pipe(
        map(data => {
          this.me = data;
          return data;
        })
      );
      return this.meObservable;
    }
  }
}

Sie können es so nennen:

this.globalDataService.getYourModel().subscribe(yourModel => {


});

Der obige Code speichert das Ergebnis der Remote-API beim ersten Aufruf im Cache, damit es bei weiteren Anforderungen an diese Methode verwendet werden kann.