AngularJS - Step 10: Factories (For Java Developers)

Play Store Application link – Java to AngularJS in 16 Steps – App on Google Play

In AngularJS, a Factory is a tool for creating and sharing reusable code across different parts of your application. Think of it as a way to produce objects, functions, or values that can be used by various components like controllers or directives.

Java Comparison:

In Java, you often use design patterns like Singleton or Factory to manage and create instances of objects. For example, the Factory pattern in Java can create different types of objects based on input. AngularJS Factories serve a similar purpose by providing a way to create and manage reusable code.

Java Example (Factory Pattern):

Here’s a simple example of the Factory pattern in Java:

public class MessageFactory {
    public static Message createMessage(String type) {
        if ("greeting".equals(type)) {
            return new GreetingMessage();
        } else if ("farewell".equals(type)) {
            return new FarewellMessage();
        }
        throw new IllegalArgumentException("Unknown type");
    }
}

In this Java example, MessageFactory creates instances of different types of Message objects.

AngularJS Factory Example

In AngularJS, factories are similar to Java factories in that they return an object or function that can be used throughout your application. Here’s how to define and use a factory in AngularJS.

Step-by-Step Example:

Define the Factory:
Use the factory method to create a factory that returns an object, function, or value.
Use the Factory in a Controller:
Inject the factory into a controller and use it to access its methods or properties.

Code Example

Here’s a complete example of how to use a factory in AngularJS. Save this code as an HTML file and open it in a browser to see it in action.

<!DOCTYPE html>
<html ng-app="myApp">
<head>
  <title>AngularJS Factory Example</title>
  <script src="https://ajax.googleapis.com/ajax/libs/angularjs/1.8.2/angular.min.js"></script>
</head>
<body>

  <div ng-controller="myController">
    <p>{{ message }}</p>
  </div>

  <script>
    // Define the AngularJS module and factory
    angular.module('myApp', [])
      .factory('myFactory', function() {
        var factory = {};
        factory.sayHello = function() {
          return "Hello World!";
        };
        return factory;
      })

      // Define the controller and inject the factory
      .controller('myController', function($scope, myFactory) {
        $scope.message = myFactory.sayHello();
      });
  </script>

</body>
</html>

Breakdown of the Example:

Define the Factory:

AngularJS: Use .factory('myFactory', function() { ... }) to define a factory. This factory returns an object with a method sayHello.
Java Equivalent: Similar to how a Java Factory class might provide methods to create objects.

Use the Factory in a Controller:

AngularJS: Inject myFactory into myController and use its method to set a scope variable.
Java Equivalent: Similar to using a factory method to get an instance of an object and then calling its methods.

Key Takeaways:

Factories in AngularJS are used to create and manage reusable code that can be shared across controllers, directives, and other parts of your application.
Factory vs. Service: Factories return an object or function, which can be a new instance each time it’s injected. Services return a singleton instance, meaning the same instance is used throughout the application.
Usage: Factories are great for creating reusable logic and are particularly useful when you need a new instance each time it’s injected.

By understanding AngularJS Factories in the context of Java design patterns, you can leverage your existing knowledge to build more maintainable and modular AngularJS applications.

Java Programmatic Universe

Java- write once, run away!

AngularJS – Step 10: Factories (For Java Developers)