Denetleyici çağrılmadan önce verilerin alınabilmesi için app.config dosyasına bir hizmet enjekte etmek istiyorum. Ben böyle denedim:

Hizmet:

app.service('dbService', function() {
    return {
        getData: function($q, $http) {
            var defer = $q.defer();
            $http.get('db.php/score/getData').success(function(data) {
                defer.resolve(data);            
            });
            return defer.promise;
        }
    };
});

Yapılandırma:

app.config(function ($routeProvider, dbService) {
    $routeProvider
        .when('/',
        {
            templateUrl: "partials/editor.html",
            controller: "AppCtrl",
            resolve: {
                data: dbService.getData(),
            }
        })
});

Ama bu hatayı alıyorum:

Hata: Bilinmeyen sağlayıcı: EditorApp'dan dbService

Kurulum nasıl düzeltilir ve bu hizmet enjekte edilir?

Alex, yapmaya çalıştığın şeyi yapamamanın doğru nedenini sağladı, bu yüzden +1. Ancak bu sorunla karşılaşıyorsunuz çünkü tam olarak kullanmıyorsanız bunların nasıl tasarlandığını çözüyor.

resolvehizmetin dizesini veya enjekte edilecek değeri döndüren bir işlevi alır. İkincisini yaptığınızdan, gerçek bir işlevi geçmeniz gerekir:

resolve: {
  data: function (dbService) {
    return dbService.getData();
  }
}

Çerçeve dataçözülmeye başladığında dbService, işlevi içine enjekte eder , böylece serbestçe kullanabilirsiniz. Bunu configbaşarmak için bloğa enjekte etmeniz gerekmez .

Afiyet olsun!

Hizmetinizi özel bir AngularJS Sağlayıcısı olarak ayarlama

Kabul edilen cevabın söylediklerine rağmen, aslında ne yapmak istediğinizi YAPABİLİRSİNİZ , ancak yapılandırma aşamasında servis olarak kullanılabilmesi için yapılandırılabilir bir sağlayıcı olarak ayarlamanız gerekir. İlk olarak, Servicebir sağlayıcıya değiştirin Aşağıda gösterildiği gibi. Buradaki en önemli fark, değerini deferayarladıktan sonra, defer.promiseözelliği döndürülen söz verilen nesneye ayarlamanızdır $http.get:

Hizmet Sağlayıcı Hizmeti: (sağlayıcı: hizmet tarifi)

app.provider('dbService', function dbServiceProvider() {

  //the provider recipe for services require you specify a $get function
  this.$get= ['dbhost',function dbServiceFactory(dbhost){
     // return the factory as a provider
     // that is available during the configuration phase
     return new DbService(dbhost);  
  }]

});

function DbService(dbhost){
    var status;

    this.setUrl = function(url){
        dbhost = url;
    }

    this.getData = function($http) {
        return $http.get(dbhost+'db.php/score/getData')
            .success(function(data){
                 // handle any special stuff here, I would suggest the following:
                 status = 'ok';
                 status.data = data;
             })
             .error(function(message){
                 status = 'error';
                 status.message = message;
             })
             .then(function(){
                 // now we return an object with data or information about error 
                 // for special handling inside your application configuration
                 return status;
             })
    }    
}

Şimdi, yapılandırılabilir bir özel Sağlayıcınız var, sadece enjekte etmeniz gerekiyor. Burada önemli fark eksik "enjekte edilebilir üzerinde Sağlayıcı" olmasıdır.

yapılandırma:

app.config(function ($routeProvider) { 
    $routeProvider
        .when('/', {
            templateUrl: "partials/editor.html",
            controller: "AppCtrl",
            resolve: {
                dbData: function(DbService, $http) {
                     /*
                     *dbServiceProvider returns a dbService instance to your app whenever
                     * needed, and this instance is setup internally with a promise, 
                     * so you don't need to worry about $q and all that
                     */
                    return DbService('http://dbhost.com').getData();
                }
            }
        })
});

çözümlenmiş verileri kullanın appCtrl

app.controller('appCtrl',function(dbData, DbService){
     $scope.dbData = dbData;

     // You can also create and use another instance of the dbService here...
     // to do whatever you programmed it to do, by adding functions inside the 
     // constructor DbService(), the following assumes you added 
     // a rmUser(userObj) function in the factory
     $scope.removeDbUser = function(user){
         DbService.rmUser(user);
     }

})

Olası Alternatifler

Aşağıdaki alternatif benzer bir yaklaşımdır, ancak .confighizmetin uygulamanız bağlamında belirli bir modül içinde kapsüllenerek tanımın gerçekleşmesine izin verir . Size en uygun yöntemi seçin. Ayrıca, tüm bu şeyleri askıya almanıza yardımcı olacak 3. alternatif ve yararlı bağlantılar hakkında notlar için aşağıya bakın.

app.config(function($routeProvider, $provide) {
    $provide.service('dbService',function(){})
    //set up your service inside the module's config.

    $routeProvider
        .when('/', {
            templateUrl: "partials/editor.html",
            controller: "AppCtrl",
            resolve: {
                data: 
            }
        })
});

Birkaç yardımcı Kaynak

• John Lindquist'in 5 dakikalık mükemmel bir açıklaması ve gösterimi var. egghead.io'da bunun sahiptir ve ücretsiz derslerden biridir! Temelde $httpbu istek bağlamında gösterisini değiştirerek gösterisini değiştirdim
• Sağlayıcılar hakkındaki AngularJS Geliştirici kılavuzunu görüntüleyin
• Clevertech.biz hakkında factory/ service/ hakkında da mükemmel bir açıklama var provider . .

Sağlayıcı, .serviceyöntem üzerinde biraz daha fazla yapılandırma sağlar , bu da bir uygulama düzeyi sağlayıcısı olarak daha iyi olmasını sağlar, ancak aşağıdaki $providegibi yapılandırma enjekte ederek bunu yapılandırma nesnesinin içinde kapsülleyebilirsiniz :

Kısa cevap: yapamazsınız. AngularJS, doğru bir şekilde yüklendiklerinden emin olamadığından hizmetleri yapılandırma içine enjekte etmenize izin vermez.

Bu soruya ve cevaba bakın: module.config içindeki değerin AngularJS bağımlılığı enjeksiyonu

Bir modül, bootstrap işlemi sırasında uygulamaya uygulanan bir yapılandırma ve çalıştırma blokları koleksiyonudur. En basit şekliyle modül, iki tür bloktan oluşur:

Yapılandırma blokları - sağlayıcı kayıtları ve yapılandırma aşamasında yürütülür. Yapılandırma bloklarına yalnızca sağlayıcılar ve sabitler enjekte edilebilir. Bu, hizmetlerin tam olarak yapılandırılmadan önce yanlışlıkla başlatılmasını önlemektir.

Bunu yapabileceğinizi sanmıyorum, ancak bir configbloğa başarılı bir şekilde hizmet verdim . (Açısal JS v1.0.7)

angular.module('dogmaService', [])
    .factory('dogmaCacheBuster', [
        function() {
            return function(path) {
                return path + '?_=' + Date.now();
            };
        }
    ]);

angular.module('touch', [
        'dogmaForm',
        'dogmaValidate',
        'dogmaPresentation',
        'dogmaController',
        'dogmaService',
    ])
    .config([
        '$routeProvider',
        'dogmaCacheBusterProvider',
        function($routeProvider, cacheBuster) {
            var bust = cacheBuster.$get[0]();

            $routeProvider
                .when('/', {
                    templateUrl: bust('touch/customer'),
                    controller: 'CustomerCtrl'
                })
                .when('/screen2', {
                    templateUrl: bust('touch/screen2'),
                    controller: 'Screen2Ctrl'
                })
                .otherwise({
                    redirectTo: bust('/')
                });
        }
    ]);

angular.module('dogmaController', [])
    .controller('CustomerCtrl', [
        '$scope',
        '$http',
        '$location',
        'dogmaCacheBuster',
        function($scope, $http, $location, cacheBuster) {

            $scope.submit = function() {
                $.ajax({
                    url: cacheBuster('/customers'),  //server script to process data
                    type: 'POST',
                    //Ajax events
                    // Form data
                    data: formData,
                    //Options to tell JQuery not to process data or worry about content-type
                    cache: false,
                    contentType: false,
                    processData: false,
                    success: function() {
                        $location
                            .path('/screen2');

                        $scope.$$phase || $scope.$apply();
                    }
                });
            };
        }
    ]);

Yapılandırmanızdaki bir hizmeti enjekte etmek için $ inject hizmetini kullanabilirsiniz

App.config (function ($ sağlamak) {

    $ serve.decorator ("$ exceptionHandler", işlev ($ delegate, $ injector) {
        dönüş işlevi (istisna, neden) {
            var $ rootScope = $ injector.get ("$ rootScope");
            $ rootScope.addError ({message: "Exception", nedeni: exception});
            $ delegate (istisna, neden);
        };
    });

});

Kaynak: http://odetocode.com/blogs/scott/archive/2014/04/21/better-error-handling-in-angularjs.aspx

** Angular.injector kullanarak açıkça diğer modüllerden hizmet isteyin **

Kim3er'in cevabını detaylandırmak için , diğer modüllere dahil oldukları sürece, sağlayıcılara değiştirmeden hizmetler, fabrikalar vb.

Ancak, *Provideraçısal tembel yük modülleri olarak (bir hizmeti veya fabrikayı işledikten sonra dahili olarak açısal olarak yapılan) her zaman kullanılabilir olup olmadığından emin değilim (ilk yüklenene bağlı olabilir).

Değerleri yeniden enjekte etmek isterseniz sabit olarak kabul edilmesi gerektiğini unutmayın.

İşte bunu yapmanın daha açık ve muhtemelen daha güvenilir bir yolu + çalışan bir dalgıç

var base = angular.module('myAppBaseModule', [])
base.factory('Foo', function() { 
  console.log("Foo");
  var Foo = function(name) { this.name = name; };
  Foo.prototype.hello = function() {
    return "Hello from factory instance " + this.name;
  }
  return Foo;
})
base.service('serviceFoo', function() {
  this.hello = function() {
    return "Service says hello";
  }
  return this;
});

var app = angular.module('appModule', []);
app.config(function($provide) {
  var base = angular.injector(['myAppBaseModule']);
  $provide.constant('Foo', base.get('Foo'));
  $provide.constant('serviceFoo', base.get('serviceFoo'));
});
app.controller('appCtrl', function($scope, Foo, serviceFoo) {
  $scope.appHello = (new Foo("app")).hello();
  $scope.serviceHello = serviceFoo.hello();
});

Config içindeki hizmet yöntemlerini çağırmak için $ injector kullanma

Benzer bir sorun yaşadım ve yukarıda gösterildiği gibi $ enjektör servisini kullanarak çözdüm. Doğrudan hizmeti enjekte denedim ama $ http dairesel bir bağımlılık ile sona erdi. Hizmet hata ile bir modal görüntüler ve ben de $ https bağımlılığı olan ui-bootstrap modal kullanıyorum.

    $httpProvider.interceptors.push(function($injector) {
    return {
        "responseError": function(response) {

            console.log("Error Response status: " + response.status);

            if (response.status === 0) {
                var myService= $injector.get("myService");
                myService.showError("An unexpected error occurred. Please refresh the page.")
            }
        }
    }

Bunu yapmak çok kolay bir çözüm

Not : Servis, yapılandırma yürütmesinde hizmet başlatılmadığından, yalnızca bir asenkron çağrısı içindir.

run()Yöntemi kullanabilirsiniz . Misal :

1. Hizmetinize "MyService" adı verilir
2. Bir sağlayıcı "MyProvider" üzerinde bir asenkron yürütmesi için kullanmak istiyorsunuz

Senin kodun :

(function () { //To isolate code TO NEVER HAVE A GLOBAL VARIABLE!

    //Store your service into an internal variable
    //It's an internal variable because you have wrapped this code with a (function () { --- })();
    var theServiceToInject = null;

    //Declare your application
    var myApp = angular.module("MyApplication", []);

    //Set configuration
    myApp.config(['MyProvider', function (MyProvider) {
        MyProvider.callMyMethod(function () {
            theServiceToInject.methodOnService();
        });
    }]);

    //When application is initialized inject your service
    myApp.run(['MyService', function (MyService) {
        theServiceToInject = MyService;
    }]);
});

Bununla biraz uğraştım, ama aslında yaptım.

Açısal değişikliklerden dolayı cevapların modası geçmiş olup olmadığını bilmiyorum, ancak bu şekilde yapabilirsiniz:

Bu sizin hizmetiniz:

.factory('beerRetrievalService', function ($http, $q, $log) {
  return {
    getRandomBeer: function() {
      var deferred = $q.defer();
      var beer = {};

      $http.post('beer-detail', {})
      .then(function(response) {
        beer.beerDetail = response.data;
      },
      function(err) {
        $log.error('Error getting random beer', err);
        deferred.reject({});
      });

      return deferred.promise;
    }
  };
 });

Ve bu yapılandırma

.when('/beer-detail', {
  templateUrl : '/beer-detail',
  controller  : 'productDetailController',

  resolve: {
    beer: function(beerRetrievalService) {
      return beerRetrievalService.getRandomBeer();
    }
  }
})

En kolay yol: $injector = angular.element(document.body).injector()

Sonra çalıştırmak için kullanın invoke()veyaget()