工厂

如果给AngularJS一个函数，AngularJS将在请求工厂时缓存并注入返回值。

例子：

app.factory('factory', function() {
    var name = '';
    // Return value **is** the object that will be injected
    return {
        name: name;
    }
})

用法：

app.controller('ctrl', function($scope, factory) {
     $scope.name = factory.name;
});

服务

如果给AngularJS一个函数，AngularJS将调用new来实例化它。AngularJS创建的实例将在请求服务时缓存并注入。由于new用于实例化服务，因此关键字this是有效的，并引用实例。

例子：

app.service('service', function() {
     var name = '';
     this.setName = function(newName) {
         name = newName;
     }
     this.getName = function() {
         return name;
     }
});

用法：

app.controller('ctrl', function($scope, service) {
   $scope.name = service.getName();
});

供应商

给AngularJS一个函数，AngularJS将调用它的$get函数。它是$get函数的返回值，将在请求服务时缓存并注入。

提供程序允许您在AngularJS调用$get方法获取可注入对象之前配置提供程序。

例子：

app.provider('provider', function() {
     var name = '';
     this.setName = function(newName) {
          name = newName;
     }
     this.$get = function() {
         return {
            name: name
         }
     }
})

用法（作为控制器中的注射剂）

app.controller('ctrl', function($scope, provider) {
    $scope.name = provider.name;
});

用法（在调用$get以创建可注射对象之前配置提供程序）

app.config(function(providerProvider) {
    providerProvider.setName('John');
});

所有的好答案都已经有了。我想在服务和工厂方面再补充几点。以及服务/工厂之间的差异。你也可以有这样的问题：

我应该使用服务还是工厂？有什么不同？他们的行为是否相同？

让我们从服务和工厂之间的区别开始：

两者都是Singleton：每当Angular第一次发现它们作为依赖项时，它都会创建服务/工厂的单个实例。创建实例后，将永远使用同一实例。可用于对具有行为的对象进行建模：它们都可以有方法、内部状态变量等。尽管编写代码的方式会有所不同。

服务：

服务是一个构造函数，Angular将通过调用newyourServiceName（）来实例化它。这意味着一些事情。

函数和实例变量将是它的财产。您不需要返回值。当Angular调用new yourServiceName（）时，它将接收此对象以及您在其上放置的所有财产。

示例：

angular.service('MyService', function() {
  this.aServiceVariable = "Ved Prakash"
  this.aServiceMethod = function() {
    return //code
  };
});

当Angular将此MyService服务注入控制器时取决于它，该控制器将获得它可以调用的MyService上的函数，例如MyService.aServiceMethod（）。

注意：

由于构造的服务是一个对象，因此当调用它们时，它内部的方法可以引用它：

angular.service('ScoreKeeper', function($http) {
  this.score = 0;

  this.getScore = function() {
    return this.score;
  };

  this.setScore = function(newScore) {
    this.score = newScore;
  };

  this.addOne = function() {
    this.score++;
  };
});

例如，如果您通过从服务器$http.get（'/score'）.then（ScoreKeeper.setScore）获取分数来初始化分数，那么您可能会尝试在承诺链中调用ScoreKeeper。这样做的问题是，ScoreKeeer.setScore将在该绑定为空的情况下被调用，并且您会收到错误。更好的方法是$http.get（'/score'）.then（ScoreKeeper.setScore.bind（ScoreKeeper））。无论您是否选择在服务方法中使用它，请注意如何调用它们。

从服务返回值：

由于JavaScript构造函数的工作方式，若从构造函数函数返回一个复杂值（即Object），调用者将获得该Object而不是该实例。

这意味着你基本上可以从下面复制粘贴工厂示例，用服务替换工厂，它会起作用：

angular.service('MyService', function($http) {
  var api = {};

  api.aServiceMethod= function() {
    return $http.get('/users');
  };
  return api;
});

因此，当Angular使用新的MyService（）构造服务时，它将获得该api对象而不是MyService实例。

这是任何复杂值（对象、函数）的行为，但不是基本类型的行为。

工厂：

工厂是一个返回值的普通旧函数。返回值是注入到依赖于工厂的事物中的值。Angular中的一个典型工厂模式是返回一个具有函数作为财产的对象，如下所示：

angular.factory('MyFactory', function($http) {
  var api = {};

  api.aFactoryMethod= function() {
    return $http.get('/users');
  };

  return api;
});

工厂依赖项的注入值是工厂的返回值值，并且它不必是对象。这可能是一种功能

以上1和2个问题的答案：

大多数情况下，只要坚持使用工厂就可以了。他们的行为更容易理解。别无选择关于是否返回一个值，此外，没有错误如果你做错事，就会被介绍。当我谈论注射时，我仍然将其称为“服务”但它们是依赖关系。服务/工厂行为非常相似，有些人会说任何一个都很好。这有点正确，但我觉得遵循约翰·帕帕风格指南的建议，坚持工厂**

让我们以简单的方式讨论AngularJS中处理业务逻辑的三种方法：（灵感来自Yaakov的Coursera AngularJS课程）

服务：

语法：

应用程序.js

 var app = angular.module('ServiceExample',[]);
 var serviceExampleController =
              app.controller('ServiceExampleController', ServiceExampleController);
 var serviceExample = app.service('NameOfTheService', NameOfTheService);

 ServiceExampleController.$inject = ['NameOfTheService'] //protects from minification of js files

function ServiceExampleController(NameOfTheService){
     serviceExampleController = this;
     serviceExampleController.data = NameOfTheService.getSomeData();
 }

function NameOfTheService(){
     nameOfTheService = this;
     nameOfTheService.data = "Some Data";
     nameOfTheService.getSomeData = function(){
           return nameOfTheService.data;
     }     
}

索引html

<div ng-controller = "ServiceExampleController as serviceExample">
   {{serviceExample.data}}
</div>

服务特点：

懒惰实例化：如果它没有被注入，就永远不会被实例化。因此，要使用它，必须将其注入到模块中。Singleton：如果注入到多个模块，所有模块都只能访问一个特定的实例。这就是为什么在不同控制器之间共享数据非常方便的原因。

工厂

首先让我们看看语法：

应用.js：

var app = angular.module('FactoryExample',[]);
var factoryController = app.controller('FactoryController', FactoryController);
var factoryExampleOne = app.factory('NameOfTheFactoryOne', NameOfTheFactoryOne);
var factoryExampleTwo = app.factory('NameOfTheFactoryTwo', NameOfTheFactoryTwo);

//first implementation where it returns a function
function NameOfTheFactoryOne(){
   var factory = function(){
      return new SomeService();
    }
   return factory;
}

//second implementation where an object literal would be returned
function NameOfTheFactoryTwo(){
   var factory = {
      getSomeService : function(){
          return new SomeService();
       }
    };
   return factory;
}

现在在控制器中使用以上两个：

 var factoryOne = NameOfTheFactoryOne() //since it returns a function
 factoryOne.someMethod();

 var factoryTwo = NameOfTheFactoryTwo.getSomeService(); //accessing the object
 factoryTwo.someMethod();

工厂特点：

遵循工厂设计模式。工厂是生产新对象或功能的中心场所。不仅生成单例，还生成可定制的服务。.service（）方法是一个工厂，它总是生成相同类型的服务，这是一个单例，没有任何简单的方法来配置它的行为。.service（）方法通常用作不需要任何配置的快捷方式。

供应商

让我们先来看看语法：

angular.module('ProviderModule', [])
.controller('ProviderModuleController', ProviderModuleController)
.provider('ServiceProvider', ServiceProvider)
.config(Config); //optional

Config.$inject = ['ServiceProvider'];
function Config(ServiceProvider) {
  ServiceProvider.defaults.maxItems = 10; //some default value
}


ProviderModuleController.$inject = ['ServiceProvider'];
function ProviderModuleController(ServiceProvider) {
  //some methods
}

function ServiceProvider() {
  var provider = this;

  provider.defaults = {
    maxItems: 10
  };

  provider.$get = function () {
    var someList = new someListService(provider.defaults.maxItems);

    return someList;
  };
}

}

提供商的特点：

Provider是在Angular中创建服务的最灵活的方法。我们不仅可以创建一个可动态配置的工厂，而且在使用工厂时，通过提供程序方法，我们可以在整个应用程序启动时自定义配置工厂一次。然后，工厂可以在整个应用程序中使用自定义设置。换句话说，我们可以在应用程序启动之前配置此工厂。事实上，在angular文档中提到，当我们使用.service或.factory方法配置服务时，提供者方法实际上是在幕后执行的。$get是一个直接附加到提供程序实例的函数。该函数是工厂函数。换句话说，它就像我们用来提供给.factory方法的一样。在该函数中，我们创建自己的服务。这个$get属性是一个函数，它使提供者成为提供者。AngularJS希望提供程序具有$get属性，该属性的值是Angular将作为工厂函数处理的函数。但使整个提供程序设置非常特殊的是，我们可以在服务提供程序内部提供一些配置对象，这通常带有默认值，我们可以稍后在步骤中覆盖这些默认值，在该步骤中我们可以配置整个应用程序。

从AngularJS邮件列表中，我得到了一个令人惊叹的线程，它解释了服务与工厂与供应商以及它们的注入用法。编写答案：

服务

语法：module.service（'serviceName'，function）；结果：当将serviceName声明为可注入参数时，将为您提供函数的实例。换句话说，新的FunctionYouPassedToService（）。

工厂

语法：module.factory（'factoryName'，function）；结果：当将factoryName声明为可注入参数时，将提供通过调用传递给module.factory的函数引用返回的值。

提供商

语法：module.provider（'providerName'，function）；结果：当将providerName声明为可注入参数时，将提供（newProviderFunction（））$get（）。在调用$get方法之前实例化构造函数函数-ProviderFunction是传递给module.provider的函数引用。

提供程序的优点是可以在模块配置阶段进行配置。

请参阅此处获取提供的代码。

下面是Misko的进一步解释：

provide.value('a', 123);

function Controller(a) {
  expect(a).toEqual(123);
}

在这种情况下，注入器只是按原样返回值。但是如果您想计算该值呢？然后使用工厂

provide.factory('b', function(a) {
  return a*2;
});

function Controller(b) {
  expect(b).toEqual(246);
}

因此，工厂是一个负责创造价值的职能部门。注意，工厂函数可以要求其他依赖项。

但是，如果你想成为更多的OO，并拥有一个名为Greeter的类呢？

function Greeter(a) {
  this.greet = function() {
    return 'Hello ' + a;
  }
}

然后，要实例化，必须编写

provide.factory('greeter', function(a) {
  return new Greeter(a);
});

然后我们可以像这样在控制器中请求“问候者”

function Controller(greeter) {
  expect(greeter instanceof Greeter).toBe(true);
  expect(greeter.greet()).toEqual('Hello 123');
}

但这太啰嗦了。一个简短的写法是provider.service（“greeter”，greeter）；

但是如果我们想在注入之前配置Greeter类呢？然后我们可以写

provide.provider('greeter2', function() {
  var salutation = 'Hello';
  this.setSalutation = function(s) {
    salutation = s;
  }

  function Greeter(a) {
    this.greet = function() {
      return salutation + ' ' + a;
    }
  }

  this.$get = function(a) {
    return new Greeter(a);
  };
});

然后我们可以这样做：

angular.module('abc', []).config(function(greeter2Provider) {
  greeter2Provider.setSalutation('Halo');
});

function Controller(greeter2) {
  expect(greeter2.greet()).toEqual('Halo 123');
}

顺便说一句，服务、工厂和价值都来自提供者。

provider.service = function(name, Class) {
  provider.provide(name, function() {
    this.$get = function($injector) {
      return $injector.instantiate(Class);
    };
  });
}

provider.factory = function(name, factory) {
  provider.provide(name, function() {
    this.$get = function($injector) {
      return $injector.invoke(factory);
    };
  });
}

provider.value = function(name, value) {
  provider.factory(name, function() {
    return value;
  });
};

我的理解很简单。

工厂：您只需在工厂内部创建一个对象并返回它。

服务：

您只需要一个使用此关键字定义函数的标准函数。

供应商：

您定义了一个$get对象，它可以用于获取返回数据的对象。

Angular文档摘要：

有五种配方类型定义了如何创建对象：Value，工厂、服务、供应商和常量。工厂和服务是最常用的配方。它们之间的唯一区别是，Service配方对自定义类型的对象更有效，而Factory可以生成JavaScript原语和函数。提供者配方是核心配方类型，所有其他配方都只是其语法上的糖。提供程序是最复杂的配方类型。除非您正在构建一段需要全局配置的可重用代码，否则您不需要它。

SO的最佳答案：

https://stackoverflow.com/a/26924234/165673（<--良好）https://stackoverflow.com/a/27263882/165673https://stackoverflow.com/a/16566144/165673