基本的区别在于，提供程序允许将原语(非对象)、数组或回调函数的值设置到工厂声明的变量中，因此如果返回一个对象，它必须显式地声明和返回。

另一方面，服务只能用于将服务声明的变量设置为对象，因此可以避免显式地创建和返回对象，而另一方面，它允许使用this关键字。

或者简而言之，“提供者是一种更通用的形式，而服务仅限于对象”。

多亏了Pascal Precht的一篇博客文章，这帮助我理解了其中的区别。

服务是模块上的一个方法，它接受定义服务的名称和函数。你可以在其他组件中注入和使用特定的服务，比如控制器、指令和过滤器。工厂是模块上的一个方法，它还接受一个定义工厂的名称和函数。我们还可以像对服务那样注入和使用it。

用new创建的对象使用其构造函数的prototype属性的值作为原型，所以我找到了调用Object.create()的Angular代码，我相信它是服务构造函数的实例化。然而，工厂函数实际上只是一个被调用的函数，这就是为什么我们必须为工厂返回一个对象字面量。

下面是我为factory找到的angular 1.5代码:

var needsRecurse = false;
    var destination = copyType(source);

    if (destination === undefined) {
      destination = isArray(source) ? [] : Object.create(getPrototypeOf(source));
      needsRecurse = true;
    }

factory()函数的Angular源代码片段:

 function factory(name, factoryFn, enforce) {
    return provider(name, {
      $get: enforce !== false ? enforceReturnValue(name, factoryFn) : factoryFn
    });
  }

它接受传递的名称和工厂函数，并返回一个具有相同名称的提供者，它有一个$get方法，也就是我们的工厂函数。无论何时你向注入器请求特定的依赖项，它基本上都是通过调用$get()方法向相应的提供者请求该服务的实例。这就是为什么在创建提供程序时需要$get()。

下面是angular 1.5中服务的代码。

function service(name, constructor) {
    return factory(name, ['$injector', function($injector) {
      return $injector.instantiate(constructor);
    }]);
  }

事实证明，当我们调用service()时，它实际上调用了factory()!然而，它并不只是将我们的服务构造函数原样传递给工厂。它还传递一个函数，要求注入器通过给定的构造函数实例化一个对象。

换句话说，如果我们在某处注入MyService，代码中发生的事情是:

MyServiceProvider.$get(); // return the instance of the service

为了再次声明它，服务调用工厂，这是对应提供者上的$get()方法。此外，$injector.instantiate()是最终使用构造函数调用Object.create()的方法。这就是为什么我们在服务中使用“this”。

对于ES5，我们使用哪个并不重要:service()或factory()，它总是一个被调用的工厂，它为我们的服务创建了一个提供者。

您也可以对服务做同样的事情。然而，服务是一个构造函数，它不阻止我们返回对象字面量。所以我们可以使用我们的服务代码并以一种基本上与工厂完全相同的方式来编写它，换句话说，你可以将服务编写为工厂来返回一个对象。

为什么大多数人建议使用工厂而不是服务?这是我所见过的最好的答案，来自Pawel Kozlowski的书:Mastering Web Application Development with AngularJS。

工厂方法是获取对象的最常用方法 AngularJS依赖注入系统。它是非常灵活的，可以 包含复杂的创建逻辑。因为工厂是正规的 函数，也可以利用新的词法作用域来实现 模拟“私有”变量。这很有用，因为我们可以隐藏 给定服务的实现细节。”

生活的例子

" Hello world "的例子

与工厂/服务/供应商:

var myApp = angular.module('myApp', []);
 
//service style, probably the simplest one
myApp.service('helloWorldFromService', function() {
    this.sayHello = function() {
        return "Hello, World!"
    };
});
 
//factory style, more involved but more sophisticated
myApp.factory('helloWorldFromFactory', function() {
    return {
        sayHello: function() {
            return "Hello, World!"
        }
    };
});
    
//provider style, full blown, configurable version     
myApp.provider('helloWorld', function() {
    // In the provider function, you cannot inject any
    // service or factory. This can only be done at the
    // "$get" method.
 
    this.name = 'Default';
 
    this.$get = function() {
        var name = this.name;
        return {
            sayHello: function() {
                return "Hello, " + name + "!"
            }
        }
    };
 
    this.setName = function(name) {
        this.name = name;
    };
});
 
//hey, we can configure a provider!            
myApp.config(function(helloWorldProvider){
    helloWorldProvider.setName('World');
});
        
 
function MyCtrl($scope, helloWorld, helloWorldFromFactory, helloWorldFromService) {
    
    $scope.hellos = [
        helloWorld.sayHello(),
        helloWorldFromFactory.sayHello(),
        helloWorldFromService.sayHello()];
}​

补充第一个答案，我认为.service()适合那些以更面向对象的风格(c# /Java)编写代码的人(使用这个关键字并通过prototype/Constructor函数实例化对象)。

Factory是为那些编写更自然的javascript/函数式代码的开发人员准备的。

看看angular.js中.service和.factory方法的源代码——在内部它们都调用provider方法:

  function provider(name, provider_) {
    if (isFunction(provider_)) {
      provider_ = providerInjector.instantiate(provider_);
    }
    if (!provider_.$get) {
      throw Error('Provider ' + name + ' must define $get factory method.');
    }
    return providerCache[name + providerSuffix] = provider_;
  }

  function factory(name, factoryFn) { \
    return provider(name, { $get: factoryFn }); 
  }

  function service(name, constructor) {
    return factory(name, ['$injector', function($injector) {
      return $injector.instantiate(constructor);
    }]);
  }

在AngularJS中有三种处理业务逻辑的方法:(灵感来自Yaakov的Coursera AngularJS课程):

服务 工厂 提供者

这里我们只讨论服务vs工厂

服务:

语法:

app.js

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

 ServiceExampleController.$inject = ['NameOfTheService'] //very important as this 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;
     }     
}

index . html

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

服务的主要特点:

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

工厂

现在让我们来谈谈AngularJS中的工厂

首先让我们看一下语法:

app.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()方法通常用作不需要任何配置的快捷方式。

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

假设我们有:

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在供应商。