Confundido acerca de Servicio vs Fábrica

Según lo entiendo, cuando estoy dentro de una fábrica devuelvo un objeto que se inyecta en un controlador. Cuando estoy dentro de un servicio, trato con el objeto usando this y no devuelvo nada.

Estaba bajo la suposición de que un servicio siempre era un singleton , y que un nuevo objeto de fábrica se inyecta en cada controlador. Sin embargo, como resultado, un objeto de fábrica es un singleton también?

Código de ejemplo para demostrar:

 var factories = angular.module('app.factories', []); var app = angular.module('app', ['ngResource', 'app.factories']); factories.factory('User', function () { return { first: 'John', last: 'Doe' }; }); app.controller('ACtrl', function($scope, User) { $scope.user = User; }); app.controller('BCtrl', function($scope, User) { $scope.user = User; }); 

Al cambiar user.first en ACtrl , resulta que el user.first en BCtrl también se cambia, por ejemplo, el User es un singleton?

¿Mi suposición era que una nueva instancia se inyectó en un controlador con una fábrica?

Todos los servicios angulares son singletons :

Documentos (ver Servicios como singletons ): https://docs.angularjs.org/guide/services

Por último, es importante darse cuenta de que todos los servicios de Angular son singletons de aplicación. Esto significa que solo hay una instancia de un servicio determinado por inyector.

Básicamente, la diferencia entre el servicio y la fábrica es la siguiente:

 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 + "!"; } } }); 

Consulte esta presentación sobre $ provide: http://slides.wesalvaro.com/20121113/#/

Esas diapositivas se utilizaron en una de las reuniones de AngularJs: http://blog.angularjs.org/2012/11/more-angularjs-meetup-videos.html

Para mí, la revelación vino cuando me di cuenta de que todos funcionan de la misma manera: ejecutando algo una vez , almacenando el valor que obtienen, y luego emitiendo el mismo valor almacenado cuando se hace referencia a través de Inyección de Dependencia.

Digamos que tenemos:

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

La diferencia entre los tres es que:

  1. a valor almacenado de una proviene de ejecutar fn , en otras palabras: fn()
  2. El valor almacenado de b proviene de new ing fn , en otras palabras: new fn()
  3. El valor almacenado de c proviene de obtener primero una instancia mediante una new fn , y luego ejecutar un método $get de la instancia

lo que significa que hay algo así como un objeto de caché dentro de angular, cuyo valor de cada inyección solo se asigna una vez, cuando se han inyectado la primera vez y donde:

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

Es por eso que usamos this en servicios y definimos this.$get in providers.

Espero que esto ayude.

ejemplo en vivo

Ejemplo de “Hola mundo”

con la factory / service / provider :

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

También hay una manera de devolver una función de constructor para que pueda devolver clases nuevas en fábricas, como esta:

 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 }); }; }); 

Entonces puede hacer esto en un controlador que usa MyObjectWithParam:

 var obj = new MyObjectWithParam("hello"), 

Vea aquí el ejemplo completo:
http://plnkr.co/edit/GKnhIN?p=preview

Y aquí las páginas del grupo de google, donde se discutió:
https://groups.google.com/forum/#!msg/angular/56sdORWEoqg/b8hdPskxZXsJ

Estas son las principales diferencias:

Servicios

Sintaxis: module.service( 'serviceName', function );

Resultado: al declarar ServiceName como un argumento inyectable, se le proporcionará la instancia de una función que se pasa a module.service .

Uso: podría ser útil para compartir funciones de utilidad que son útiles para invocar simplemente agregando () a la referencia de función inyectada. También se podría ejecutar con injectedArg.call( this ) o similar.

Suerte

Sintaxis: module.factory( 'factoryName', function );

Resultado: al declarar factoryName como un argumento inyectable, se le proporcionará el valor que se devuelve al invocar la referencia de función pasada a module.factory .

Uso: podría ser útil para devolver una función de ‘clase’ que luego se puede renovar para crear instancias.

También revise la documentación de AngularJS y preguntas similares sobre stackoverflow confundidas acerca del servicio frente a la fábrica .

Aquí hay un ejemplo usando servicios y fábrica . Leer más sobre servicio AngularJS vs fábrica .

Agregando a la primera respuesta, creo que .service () es para las personas que han escrito su código en un estilo más orientado a objetos (C # / Java) (usando esta palabra clave y instanciando objetos a través de la función prototipo / Constructor).

Factory es para desarrolladores que escriben código que es más natural para javascript / estilo funcional de encoding.

Eche un vistazo al código fuente de .service y .factory method dentro de angular.js – internamente todos ellos llaman método de proveedor:

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

Muy simple:

.service: la función registrada se invocará como un constructor (también conocido como ‘newed’)

.factory – la función registrada se invocará como una función simple

Ambos se invocan una vez, lo que resulta en un objeto singleton que se inyecta en otros componentes de la aplicación.

Todos los proveedores trabajan de la misma manera. Los diferentes métodos de service , factory , provider solo le permiten lograr lo mismo en menos código.

PD: también hay value y constant .

Cada caso especial en la cadena que comienza con el provider y termina con el value tiene una limitación adicional. Entonces, para decidir entre ellos, debes preguntarte qué puedes lograr con menos código.

Aquí hay una imagen que muestra lo que quiero decir:

enter image description here

Puede obtener una guía de referencia y referencia en la publicación del blog de la que obtuve esta imagen:

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

Aquí hay algunos ejemplos más de servicios vs fábricas que pueden ser útiles para ver la diferencia entre ellos. Básicamente, un servicio tiene “nuevo …” llamado, ya está instanciado. Una fábrica no se crea una instancia automáticamente.

Ejemplos básicos

Devuelve un objeto de clase que tiene un único método

Aquí hay un servicio que tiene un único método:

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

Aquí hay una fábrica que devuelve un objeto con un método:

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

Devuelve un valor

Una fábrica que devuelve una lista de números:

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

Un servicio que devuelve una lista de números:

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

El resultado en ambos casos es el mismo, la lista de números.

Ejemplos avanzados

Variables de “clase” usando fábricas

En este ejemplo definimos un CounterFactory, incrementa o disminuye un contador y usted puede obtener el recuento actual u obtener cuántos objetos de CounterFactory se han creado:

 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; }; } }) 

Usamos CounterFactory para crear múltiples contadores. Podemos acceder a la variable de clase para ver cuántos contadores se crearon:

 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()); 

El resultado de este código es:

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

“Fábrica” ​​y “Servicio” son formas diferentes de hacer DI (Inyección de Dependencia) en angular.

Entonces cuando definimos DI usando “servicio” como se muestra en el código a continuación. Esto crea una nueva instancia GLOBAL del objeto “Logger” y lo inyecta en la función.

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

Cuando define DI utilizando una “fábrica”, no crea una instancia. Simplemente pasa el método y luego el consumidor internamente tiene que hacer llamadas a la fábrica para instancias de objetos.

 app.factory("Customerfactory", CreateCustomer); 

A continuación se muestra una imagen simple que muestra visualmente cómo el proceso DI para “Servicio” es diferente a “Fábrica”.

enter image description here

Debe utilizarse la fábrica cuando queremos crear diferentes tipos de objetos según los escenarios. Por ejemplo, dependiendo del escenario, queremos crear un objeto simple “Cliente”, o “Cliente” con el objeto “Dirección” o “Cliente” con el objeto “Teléfono”. Aquí hay una explicación detallada de este párrafo

Se debe usar el servicio cuando tengamos funciones de utilidad o compartidas para inyectar como Utility, Logger, Error Handler, etc.

Estilo de servicio : ( probablemente el más simple ) devuelve la función real: útil para compartir funciones de utilidad que son útiles para invocar simplemente añadiendo () a la referencia de función inyectada.

Un servicio en AngularJS es un objeto de JavaScript único que contiene un conjunto de funciones

 var myModule = angular.module("myModule", []); myModule.value ("myValue" , "12345"); function MyService(myValue) { this.doIt = function() { console.log("done: " + myValue; } } myModule.service("myService", MyService); myModule.controller("MyController", function($scope, myService) { myService.doIt(); }); 

Estilo de fábrica : ( más involucrado pero más sofisticado ) devuelve el valor de retorno de la función: crea una instancia de un objeto como nuevo Object () en java.

Factory es una función que crea valores. Cuando un servicio, controlador, etc. necesita un valor inyectado de una fábrica, la fábrica crea el valor a pedido. Una vez creado, el valor se reutiliza para todos los servicios, controladores, etc. que lo necesitan.

 var myModule = angular.module("myModule", []); myModule.value("numberValue", 999); myModule.factory("myFactory", function(numberValue) { return "a value: " + numberValue; }) myModule.controller("MyController", function($scope, myFactory) { console.log(myFactory); }); 

Estilo del proveedor : ( versión completa, configurable ) devuelve el resultado de la función $ get de la función: Configurable.

Los proveedores en AngularJS son la forma más flexible de fábrica que puede crear. Registra un proveedor con un módulo como lo hace con un servicio o una fábrica, excepto que utiliza la función provider ().

 var myModule = angular.module("myModule", []); myModule.provider("mySecondService", function() { var provider = {}; var config = { configParam : "default" }; provider.doConfig = function(configParam) { config.configParam = configParam; } provider.$get = function() { var service = {}; service.doService = function() { console.log("mySecondService: " + config.configParam); } return service; } return provider; }); myModule.config( function( mySecondServiceProvider ) { mySecondServiceProvider.doConfig("new config param"); }); myModule.controller("MyController", function($scope, mySecondService) { $scope.whenButtonClicked = function() { mySecondService.doIt(); } }); 

src jenkov

      JS Bin   {{serviceOutput}} 

{{factoryOutput}}

{{providerOutput}}

La diferencia básica es que el proveedor permite establecer valores de funciones primitivas (no objetos), de matriz o de callback en la variable declarada de fábrica y, por lo tanto, si se devuelve un objeto, debe declararse y devolverse explícitamente.

Por otro lado, un servicio solo puede usarse para establecer la variable declarada de servicio a un objeto, de esta manera podemos evitar la creación y devolución explícita de los objetos, mientras que, por otro lado, permite el uso de esta palabra clave.

O en palabras cortas “el proveedor es una forma más genérica mientras que el servicio se limita solo a los objetos”.

Así es como entendí la diferencia entre ellos en términos de patrones de diseño:

Servicio : devuelve un tipo, que se actualizará para crear un objeto de ese tipo. Si se utiliza la analogía de Java, el servicio devuelve una definición de la clase de Java .

Fábrica : devuelve un objeto concreto que se puede usar inmediatamente. En Java Analogy a Factory devuelve un objeto Java .

La parte que a menudo confunde a las personas (incluyéndome a mí) es que cuando se inyecta un Servicio o una Fábrica en su código pueden usarse de la misma manera, lo que obtienes en tu código en ambos casos es un objeto concreto que puedes invocar inmediatamente. Lo que significa que en el caso del Servicio, angular llama “nuevo” en la statement de servicio en su nombre. Creo que este es un concepto complicado.

AngularJS Service vs Factory

 module.service( 'serviceName', function ); module.factory( 'factoryName', function ); 

Al declarar serviceName como un argumento injectable se le proporcionará una instancia de la función. En otras palabras, la nueva FunctionYouPassedToService() . Esta instancia de objeto se convierte en el objeto de servicio que AngularJS registra e inyecta posteriormente a otros services / controllers si es necesario.

Al declarar factoryName como un argumento injectable se le proporcionará el valor que se devuelve invocando la referencia de función pasada a module.factory .

En el ejemplo siguiente, definimos MyService de dos maneras diferentes. Observe cómo en .service creamos métodos de servicio usando this.methodname . En .factory creamos un objeto de fábrica y le asignamos los métodos.

AngularJS .servicio

 module.service('MyService', function() { this.method1 = function() { //.. } this.method2 = function() { //.. } }); 

AngularJS .factory

 module.factory('MyService', function() { var factory = {}; factory.method1 = function() { //.. } factory.method2 = function() { //.. } return factory; }); 

Podemos definir un servicio como este:

 app.service('MyService', function () { this.sayHello = function () { console.log('hello'); }; }); 

.service() es un método en nuestro módulo que toma un nombre y una función que define el servicio. Muy claro. Una vez definido, podemos inyectar y usar ese servicio en particular en otros componentes, como controladores, directivas y filtros, como este:

Ahora lo mismo que una fábrica:

 app.factory('MyService', function () { return { sayHello: function () { console.log('hello'); } } }); 

Nuevamente, .factory() es un método en nuestro módulo y también toma un nombre y una función, que define la fábrica. Podemos inyectar y usar esa cosa exactamente de la misma manera que lo hicimos con el servicio. Ahora, ¿cuál es la diferencia aquí?

Bueno, puede ver que en lugar de trabajar con esto en la fábrica, estamos devolviendo un objeto literal. ¿Porqué es eso? Resulta que un servicio es una función constructora mientras que una fábrica no lo es. En algún lugar profundo de este mundo angular, existe este código que llama a Object.create () con la función del constructor del servicio, cuando se crea una instancia. Sin embargo, una función de fábrica es simplemente una función que se llama, por lo que debemos devolver un objeto de forma explícita.

Esta sería la mejor y más corta respuesta para entender el Servicio Vs Factory Vs Provider

Fuente : https://groups.google.com/forum/#!msg/angular/56sdORWEoqg/HuZsOsMvKv4J

Aquí lo que dice Ben con una demostración http://jsbin.com/ohamub/1/edit?html,output

“Hay comentarios en el código que ilustran las diferencias principales, pero los ampliaré un poco aquí. Como nota, estoy entendiendo esto, así que si digo algo que está mal, por favor háganmelo saber.

Servicios

Sintaxis : module.service (‘serviceName’, function);

Resultado : cuando declare serviceName como un argumento inyectable, se le proporcionará la referencia de función real pasada a module.service.

Uso : podría ser útil para compartir funciones de utilidad que son útiles para invocar simplemente agregando () a la referencia de función inyectada. También se podría ejecutar con injectedArg.call (this) o similar.

Suerte

Sintaxis : module.factory (‘factoryName’, function);

Resultado : al declarar factoryName como un argumento inyectable, se le proporcionará el valor que se devuelve al invocar la referencia de función pasada a module.factory.

Uso : podría ser útil para devolver una función de ‘clase’ que luego se puede renovar para crear instancias.

Proveedores

Sintaxis : module.provider (‘providerName’, function);

Resultado : al declarar providerName como un argumento inyectable, se le proporcionará el valor que se devuelve al invocar el método $ get de la referencia de función pasada a module.provider.

Uso : podría ser útil para devolver una función de ‘clase’ que luego puede ser renovada para crear instancias, pero eso requiere algún tipo de configuración antes de ser inyectado. ¿Quizás útil para clases que son reutilizables en todos los proyectos? Todavía un poco confuso en este. “Ben

Tuve esta confusión por un tiempo y estoy haciendo todo lo posible para proporcionar una explicación simple aquí. Espero que esto ayude!

angular .factory y angular .service ambos se utilizan para inicializar un servicio y trabajar de la misma manera.

La única diferencia es cómo quiere inicializar su servicio.

Ambos son Singletons


 var app = angular.module('app', []); 

Fábrica

app.factory ( , )

Si desea inicializar su servicio desde una función que tiene con un valor de retorno , debe utilizar este método de factory .

p.ej

 function myService() { //return what you want var service = { myfunc: function (param) { /* do stuff */ } } return service; } app.factory('myService', myService); 

Al inyectar este servicio (por ejemplo, a su controlador):

  • Angular llamará a su función dada (como myService() ) para devolver el objeto
  • Singleton : solo se llama una vez, se almacena y pasa el mismo objeto.

Servicio

app.service ( , )

Si desea inicializar su servicio desde una función de constructor (usando this palabra clave), debe usar este método de service .

p.ej

 function myService() { this.myfunc: function (param) { /* do stuff */ } } app.service('myService', myService); 

Al inyectar este servicio (por ejemplo, a su controlador):

  • Angular new myService() su función dada (como new myService() ) para devolver el objeto
  • Singleton : solo se llama una vez, se almacena y pasa el mismo objeto.

NOTA: Si usa factory con o service con , no funcionará.


Ejemplos: DEMO

  • Servicio Angular vs Fábrica
  • Servicio Angular vs Fábrica (con ruta)

Esto es lo que me ayudó a entender la diferencia, gracias a una publicación de blog de Pascal Precht.

Un servicio es un método en un módulo que toma un nombre y una función que define el servicio. Puede inyectar y usar ese servicio en particular en otros componentes, como controladores, directivas y filtros. Una fábrica es un método en un módulo y también tiene un nombre y una función, que define la fábrica. También podemos inyectar y usar el mismo modo que lo hicimos con el servicio.

Los objetos creados con nuevo usan el valor de la propiedad prototipo de su función de constructor como su prototipo, así que encontré el código angular que llama a Object.create (), que creo que es la función de constructor de servicio cuando se crea una instancia. Sin embargo, una función de fábrica es simplemente una función que se llama, por lo que tenemos que devolver un objeto literal para la fábrica.

Aquí está el código angular 1.5 que encontré para la fábrica:

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

Fragmento de código fuente angular para la función factory ():

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

It takes the name and the factory function that is passed and returns a provider with the same name, that has a $get method which is our factory function. Whenever you ask the injector for a specific dependency, it basically asks the corresponding provider for an instance of that service, by calling the $get() method. That’s why $get() is required, when creating providers.

Here is the angular 1.5 code for service.

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

It turns out that when we call service(), it actually calls factory()! However, it doesn’t just pass our service constructor function to the factory as is. It also passes a function that asks the injector to instantiate an object by the given constructor.

In other words, if we inject MyService somewhere, what happens in the code is:

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

To restate it again, a service calls a factory, which is a $get() method on the corresponding provider. Moreover, $injector.instantiate() is the method that ultimately calls Object.create() with the constructor function. That’s why we use “this” in services.

For ES5 it doesn’t matter which we use: service() or factory(), it’s always a factory that is called which creates a provider for our service.

You can do the exact same thing with services as well though. A service is a constructor function, however, that doesn’t prevent us from returning object literals. So we can take our service code and write it in a way that it basically does the exact same thing as our factory or in other words, you can write a service as a factory to return an object.

Why do most people recommend to use factories over services? This is the best answer I’ve seen which comes from Pawel Kozlowski’s book: Mastering Web Application Development with AngularJS.

The factory method is the most common way of getting objects into AngularJS dependency injection system. It is very flexible and can contain sophisticated creation logic. Since factories are regular functions, we can also take advantage of a new lexical scope to simulate “private” variables. This is very useful as we can hide implementation details of a given service.”

  • With the factory you actually create an object inside of the factory and return it.
  • With the service you just have a standard function that uses the this keyword to define function.
  • With the provider there’s a $get you define and it can be used to get the object that returns the data.

There are three ways of handling business logic in AngularJS: ( Inspired by Yaakov’s Coursera AngularJS course ) which are:

  1. Servicio
  2. Fábrica
  3. Proveedor

Here we are only going to talk about Service vs Factory

SERVICE :

Sintaxis:

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

 
{{serviceExample.data}}

The main features of Service:

  1. Lazily Instantiated : If the service is not injected it won’t be instantiated ever. So to use it you will have to inject it to a module.

  2. Singleton : If it is injected to multiple modules, all will have access to only one particular instance. That is why, it is very convenient to share data across different controllers.

FACTORY

Now let’s talk about the Factory in AngularJS

First let’s have a look at the syntax :

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; } 

Now using the above two in the controller:

  var factoryOne = NameOfTheFactoryOne() //since it returns a function factoryOne.someMethod(); var factoryTwo = NameOfTheFactoryTwo.getSomeService(); //accessing the object factoryTwo.someMethod(); 

Features of Factory:

  1. This types of services follow the factory design pattern . The factory can be thought of as a central place that creates new objects or methods.

  2. This does not only produce singleton, but also customizable services.

  3. The .service() method is a factory that always produces the same type of service, which is a singleton. There is no easy way to configure it’s behavior. That .service() method is usually used as a shortcut for something that doesn’t require any configuration whatsoever.

For short and simple explanation refer https://stackoverflow.com/a/26924234/5811973 .

For detailed explanation refer https://stackoverflow.com/a/15666049/5811973 .

Also from angularJs documentation: enter image description here

You can understand the difference with this analogy – Consider the difference between a normal function that will return some value and constructor function that will get instantiated using new keyword.So creating factory is just similar to create normal function that will return some value(primitive or an object) whereas creating service is like creating constructor function(OO class) of which we can create instance using new keyword. The only thing to notice is here is that when we use Service method to create services it will automatically create instance of it using dependency injection mechanism supported by AngularJS