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

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

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

生活的例子

" 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()];
}​

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

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服务都是单例:

文档(请参阅服务为单例):https://docs.angularjs.org/guide/services

最后，重要的是要认识到所有Angular服务都是应用程序单例。这意味着每个注入器只有一个给定服务的实例。

基本上，服务和工厂的区别如下:

app.service('myService', function() {

  // service is just a constructor function
  // that will be called with 'new'

  this.sayHello = function(name) {
     return "Hi " + name + "!";
  };
});

app.factory('myFactory', function() {

  // factory returns an object
  // you can run some code before

  return {
    sayHello : function(name) {
      return "Hi " + name + "!";
    }
  }
});

查看关于$ provider的演示:http://slides.wesalvaro.com/20121113/#/

这些幻灯片被用于AngularJs的一个聚会:http://blog.angularjs.org/2012/11/more-angularjs-meetup-videos.html

“工厂”和“服务”是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”。下面是这一段的详细说明

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

多亏了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依赖注入系统。它是非常灵活的，可以 包含复杂的创建逻辑。因为工厂是正规的 函数，也可以利用新的词法作用域来实现 模拟“私有”变量。这很有用，因为我们可以隐藏 给定服务的实现细节。”