对我来说，当我意识到它们都以相同的方式工作时，我得到了启示:通过运行一次，存储它们得到的值，然后在通过依赖注入引用时吐出相同的存储值。

假设我们有:

app.factory('a', fn);
app.service('b', fn);
app.provider('c', fn);

这三者的区别在于:

A的存储值来自运行fn，换句话说:fn() B的存储值来自于new fn，换句话说:new fn() C的存储值来自于首先通过new fn获得一个实例，然后运行实例的$get方法

这意味着，在angular内部有一个类似缓存对象的东西，它的每次注入的值只被赋值一次，当它们第一次被注入时，并且在:

cache.a = fn()
cache.b = new fn()
cache.c = (new fn()).$get()

这就是为什么我们在服务中使用This，并定义一个This。$get在供应商。

这里有更多的服务与工厂的例子，这些例子可能有助于了解它们之间的区别。基本上，一个服务调用了“new…”，它已经被实例化了。工厂不会自动实例化。

基本的例子

返回一个只有一个方法的类对象

下面是一个只有一个方法的服务:

angular.service('Hello', function () {
  this.sayHello = function () { /* ... */ };
});

下面是一个工厂，它返回一个带有方法的对象:

angular.factory('ClassFactory', function () {
  return {
    sayHello: function () { /* ... */ }
  };
});

返回一个值

返回数字列表的工厂:

angular.factory('NumberListFactory', function () {
  return [1, 2, 3, 4, 5];
});

console.log(NumberListFactory);

一个返回数字列表的服务:

angular.service('NumberLister', function () {
  this.numbers = [1, 2, 3, 4, 5];
});

console.log(NumberLister.numbers);

这两种情况下的输出是相同的，都是数字列表。

先进的例子

使用工厂“分类”变量

在这个例子中，我们定义了一个CounterFactory，它增加或减少一个计数器，你可以得到当前的计数或已经创建了多少个CounterFactory对象:

angular.factory('CounterFactory', function () {
  var number_of_counter_factories = 0; // class variable

  return function () {
    var count = 0; // instance variable
    number_of_counter_factories += 1; // increment the class variable

    // this method accesses the class variable
    this.getNumberOfCounterFactories = function () {
      return number_of_counter_factories;
    };

    this.inc = function () {
      count += 1;
    };
    this.dec = function () {
      count -= 1;
    };
    this.getCount = function () {
      return count;
    };
  }

})

我们使用CounterFactory创建多个计数器。我们可以访问class变量来查看创建了多少个计数器:

var people_counter;
var places_counter;

people_counter = new CounterFactory();
console.log('people', people_counter.getCount());
people_counter.inc();
console.log('people', people_counter.getCount());

console.log('counters', people_counter.getNumberOfCounterFactories());

places_counter = new CounterFactory();
console.log('places', places_counter.getCount());

console.log('counters', people_counter.getNumberOfCounterFactories());
console.log('counters', places_counter.getNumberOfCounterFactories());

这段代码的输出是:

people 0
people 1
counters 1
places 0
counters 2
counters 2

还有一种方法可以返回构造函数，这样你就可以在工厂中返回可更新的类，像这样:

function MyObjectWithParam($rootScope, name) {
  this.$rootScope = $rootScope;
  this.name = name;
}
MyObjectWithParam.prototype.getText = function () {
  return this.name;
};

App.factory('MyObjectWithParam', function ($injector) {
  return function(name) { 
    return $injector.instantiate(MyObjectWithParam,{ name: name });
  };
}); 

你可以在控制器中做这个，它使用MyObjectWithParam:

var obj = new MyObjectWithParam("hello"),

完整的例子如下: http://plnkr.co/edit/GKnhIN?p=preview

这里是谷歌小组页面，讨论的地方: https://groups.google.com/forum/ !味精/角度/ 56 sdorweoqg / b8hdPskxZXsJ

“工厂”和“服务”是angular中进行DI(依赖注入)的不同方式。

因此，当我们使用“service”定义DI时，如下面的代码所示。这将创建一个新的“Logger”对象的GLOBAL实例，并将其注入到函数中。

app.service("Logger", Logger); // Injects a global object

当您使用“工厂”定义DI时，它不会创建实例。它只是传递方法，之后消费者必须在内部调用工厂以获取对象实例。

app.factory("Customerfactory", CreateCustomer);

下面是一个简单的图像，直观地显示了“服务”的DI流程与“工厂”的不同之处。

当我们想要根据场景创建不同类型的对象时，应该使用Factory。例如，根据不同的场景，我们想要创建一个简单的“Customer”对象，或者“Address”对象中的“Customer”，或者“Phone”对象中的“Customer”。下面是这一段的详细说明

当我们有实用程序或共享函数被注入，如实用程序，记录器，错误处理程序等时，应该使用服务。

所有提供者都以相同的方式工作。不同的方法服务、工厂、提供者只是让你用更少的代码完成同样的事情。

附注:还有价值和常数。

从提供者开始到价值结束的链条上的每个特殊情况都有一个附加的限制。所以要在两者之间做出选择，你必须问问自己，哪一个能让你用更少的代码完成你想要的。

下面这张图可以说明我的意思:

你可以在我的博客文章中找到这张照片的分类和参考指南:

http://www.simplygoodcode.com/2015/11/the-difference-between-service-provider-and-factory-in-angularjs/

以下是主要的区别:

服务

语法:模块。service('serviceName'，函数);

结果:当将serviceName声明为可注入参数时，你将得到传递给module.service的函数实例。

使用方法:可以通过简单地将()附加到注入的函数引用来共享有用的实用程序函数。也可以用injectedArg运行。调用(这个)或类似的方法。

工厂

语法:模块。factory('factoryName'，函数);

结果:当将factoryName声明为一个可注入参数时，你将得到通过调用传递给module.factory的函数引用返回的值。

用法:可能用于返回一个'class'函数，然后可以重新创建实例。

也可以查看AngularJS的文档和类似的关于stackoverflow混淆服务和工厂的问题。

下面是使用服务和工厂的示例。阅读更多关于AngularJS服务vs工厂的内容。