Factory Method and Singleton Patterns

Definition

Factory Method

The Factory Method Pattern defines an interface for creating an object, but lets subclass decide which class to instantiate. Factory Method lets a class defer instantiation to subclasses.

Figure 01. Class diagram of the Factory Method. Ref:http://en.wikipedia.org/wiki/Factory_method_pattern

Singleton

The Singleton Pattern ensures a class has only one instance, and provides a global point of access to it.

Figure 02. Singleton class Ref: http://en.wikipedia.org/wiki/Singleton_pattern

Scenario

One of the applications of the Singleton Pattern is in a Factory class, due to the fact that factories don’t need to be instantiated multiple times and just one factory can create as many objects as required, we can save memory in the system making the Factory a Singleton.

For this reason we will create a small factory that will create two (or can be more) types of users:

• A simple user
• A super user

What is going to differentiate these users is going to be the rights attached to them:

• A simple user will have these rights: Review and Edit customers.
• A super user will have these rights: Remove and Create customers.

For the design of the proposed study case we will refer to the following class diagram:

Figure 03. Class diagram of the solution proposed

As it can be seen in this figure, we will have two factories that will create a specific type of user, and an abstract factory that will set all the common data for both factories that extends the abstract class UserWithRightsFactory.

UserWithRightsFactory.java

package chris.desingpatterns.factorysingleton.factory;

import java.util.ArrayList;
import java.util.List;

import chris.desingpatterns.factorysingleton.server.pojos.Right;

public abstract class UserWithRightsFactory {
    
    protected abstract User getNewUser();
    
    public User createUser(){
        User user = getNewUser();
        
        List<Right> rights = new ArrayList<Right>();
        
        setBasicRights(rights);
        
        if(user instanceof SuperUser){
            setSuperRights(rights);
        }
        
        user.setRights(rights);
        return user;
    }
    
    private void setBasicRights(List<Right> rights){
        //Basic rights
        rights.add(Right.REVIEW_CUSTOMER);
        rights.add(Right.EDIT_CUSTOMER);
    }
    
    private void setSuperRights(List<Right> rights){
        //Super rights
        rights.add(Right.REMOVE_CUSTOMER);
        rights.add(Right.CREATE_CUSTOMER);
    }

}

The specific factories that will create new Customer objects, are the ones that will implement the Singleton Pattern; the main characteristic of a singleton class is that there is an static method that is going to verify if an instance of this class was already created or not, if is the case that the instance of the singleton was already created, then this static method will just return the existing singleton object, otherwise it will create a new instance of the singleton; usually the name of this method in a Singleton class is: getInstance().

 

In the following snippet it can be seen how a singleton is implemented.

 

SimpleUserRightsFactory.java

 

package chris.desingpatterns.factorysingleton.factory;


public class SimpleUserRightsFactory extends UserWithRightsFactory {
    
    private static SimpleUserRightsFactory uniqueInstance;
    
    private SimpleUserRightsFactory() {} 
    
    public static SimpleUserRightsFactory getInstance(){
        if(uniqueInstance == null){
            uniqueInstance = new SimpleUserRightsFactory();
        }
        
        return uniqueInstance;
    }

    protected User getNewUser() {
        return new User();
    }

}

And the class that will run our scenario:

 

Main.java

 

package chris.desingpatterns.factorysingleton;

import java.util.ArrayList;
import java.util.List;

import chris.desingpatterns.factorysingleton.factory.SimpleUserRightsFactory;
import chris.desingpatterns.factorysingleton.factory.SuperUser;
import chris.desingpatterns.factorysingleton.factory.SuperUserRightsFactory;
import chris.desingpatterns.factorysingleton.factory.User;
import chris.desingpatterns.factorysingleton.factory.UserWithRightsFactory;
import chris.desingpatterns.factorysingleton.server.pojos.Address;
import chris.desingpatterns.factorysingleton.server.pojos.ContactInformation;
import chris.desingpatterns.factorysingleton.server.pojos.Identification;
import chris.desingpatterns.factorysingleton.server.pojos.IdentificationDocument;
import chris.desingpatterns.factorysingleton.server.pojos.Name;

public class Main {
    
    public static void main(String... args){
        Name name = new Name();
        name.setFirstName("Christian");
        name.setLastName("Roman");
        
        Address address = new Address();
        address.setCity("La Paz");
        address.setCountry("Bolivia");
        address.setHouseNumber("333");
        address.setStreet("Ocobaya");
        
        Identification identifcation = new Identification();
        identifcation.setDocument(IdentificationDocument.ID);
        identifcation.setNumber("123456789");
        
        ContactInformation contactInformation = new ContactInformation();
        contactInformation.setEmail("cralcubo@yahoo.com");
        contactInformation.setTelephone("0652630333");
        
        User simpleUser = createSimpleUser(name, address, 
                identifcation, contactInformation);
        
        Name nameB = new Name();
        nameB.setFirstName("Karl");
        nameB.setLastName("Taylor");
        
        Address addressB = new Address();
        addressB.setCity("Utrecht");
        addressB.setCountry("Netherlands");
        addressB.setHouseNumber("2");
        addressB.setStreet("Zijdebalenstraat");
        
        Identification identificationB = new Identification();
        identificationB.setDocument(IdentificationDocument.DRIVING_LICENSE);
        identificationB.setNumber("ABCD1234564");
        
        ContactInformation contactInformationB = new ContactInformation();
        contactInformationB.setEmail("karl@taylor.com");
        contactInformationB.setTelephone("0612345678");
        
        User simpleUserB = createSimpleUser(nameB, addressB, 
                identificationB, contactInformationB);
        
        Name nameC = new Name();
        nameC.setFirstName("Anna");
        nameC.setLastName("Korte");
        
        Address addressC = new Address();
        addressC.setCity("Groningen");
        addressC.setCountry("Netherlands");
        addressC.setHouseNumber("568");
        addressC.setStreet("Boliviastraat");
        
        Identification identificationC = new Identification();
        identificationC.setDocument(IdentificationDocument.PASSPORT);
        identificationC.setNumber("9875631XX");
        
        ContactInformation contactInformationC = new ContactInformation();
        contactInformationC.setEmail("anna@gmail.com");
        contactInformationC.setTelephone("0652369875");
        
        User superUser = createSuperUser(nameC, addressC, 
                identificationC, contactInformationC);
        List<User> usersManged = new ArrayList<User>();
        usersManged.add(simpleUser);
        usersManged.add(simpleUserB);
        ((SuperUser)superUser).setUsersManged(usersManged );
        
        //Optionally you could print the info of all the users 
        //created by the factories.
        //printAllUsersinformation(simpleUser, simpleUserB, superUser);

        
    }
    
    /**
     * Method that will print all the information of the 
     * users created in the Main method.
     * 
     * @param users
     */
    private static void printAllUsersinformation(User ...users) {
        for(User user : users){
            String userType = (user instanceof SuperUser) ? "SUPER USER" : "USER";
            System.out.println(".:. " + userType + " .:.");
            System.out.println(user.toString());
            if(user instanceof SuperUser){
                System.out.println("Users Managed: ");
                for(User simpleUser : ((SuperUser)user).getUsersManged()){
                    System.out.println("- " + simpleUser.getName().getFirstName());
                }
            }
        }
        
    }
    
    /**
     * Method that will create a Simple User.
     * 
     * @param name
     * @param address
     * @param identification
     * @param contactInformation
     * @return
     */
    private static User createSimpleUser(Name name, 
            Address address, 
            Identification identification, 
            ContactInformation contactInformation){
        
        UserWithRightsFactory simpleUserRightsFactory = 
                                      SimpleUserRightsFactory.getInstance();
        return createUser(simpleUserRightsFactory, name, address, 
                          identification, contactInformation);
    }
    
    /**
     * Method that will create a Super User.
     * 
     * @param name
     * @param address
     * @param identification
     * @param contactInformation
     * @return
     */
    private static User createSuperUser(Name name, 
            Address address, 
            Identification identification, 
            ContactInformation contactInformation){
        
        UserWithRightsFactory superUserRightsFactory = 
                                        SuperUserRightsFactory.getInstance();
        return createUser(superUserRightsFactory, name, address, 
                          identification, contactInformation);
    }
    
    /**
     * General Method that will create any type of User.
     * 
     * @param factory
     * @param name
     * @param address
     * @param identification
     * @param contactInformation
     * @return
     */
    private static User createUser(UserWithRightsFactory factory, 
            Name name, 
            Address address, 
            Identification identification, 
            ContactInformation contactInformation){
        
        System.out.println("Factory class: " + factory + 
                           " created user: " + name.getFirstName());

        User user = factory.createUser(); 
        user.setName(name);
        user.setAddress(address);
        user.setIdentification(identification);
        user.setContactInformation(contactInformation);
        
        return user;
    }

}

That is it!

 

To download the code click in the following link:

 

Factory Method and Singleton Pattern

Do you have any recommendations or amendments to be done, please let me know to improve this post!

Abstract Factory Pattern

Definition

The Abstract Factory Pattern provides an interface for creating families of related or dependent objects without specifying their concrete classes.

Figure 01. Abstract Factory class diagram. Ref: http://www.oodesign.com/abstract-factory-pattern.html

Scenario

A telecom company wants to have a system that could register the different Internet offers that they have for their customers. Between all their requirements, they mentioned that with the time new internet offers may come and that for each internet plan the user have to have also a router with capabilities according to the plan that they choose. The routers are provided by the internet company.

Reviewing the requirements mentioned, we noticed that the costumer that choose an internet plan is linked to a router to have the internet connection. Because there can be different internet plans, that can have different routers, we can use a factory that is going to link both products (products in the sense of a Factory are the Objects that are created from it) : The Internet Plan and the Internet Hardware.

Figure 02. Class diagram of the solution proposed for the case study *

^{*Click on the figure to magnify it}

As it can be seen in the previous figure our Abstract Factory (InternetPlanAbstractFactory) is going to be the responsible to delegate the creation of specific products by specific factories (BasicInternetFactory and FastInternetFactory).

InternetPlanAbstractFactory

package chris.desingpatterns.factory.factories;

import chris.desingpatterns.factory.products.hardware.AbstractInternetHardware;
import chris.desingpatterns.factory.products.plans.AbstractInternetPlan;

public interface InternetPlanAbstractFactory {
    /**
     * Method that will create an Internet Plan.
     * 
     * @return
     */
    public AbstractInternetPlan createInternetPlan();
    
    /**
     * Method that will create an Internet Hardware
     * 
     * @return
     */
    public AbstractInternetHardware createInternetHardware();

}

In the previous snippet AbstractInternetPlan and AbstractInternetHardware are the abstract products that can be created by our factories. For example the FastInternetFactory that will create products related to a Fast Internet Plan would look like this:

FastInternetFactory

package chris.desingpatterns.factory.factories;

import chris.desingpatterns.factory.products.hardware.AbstractInternetHardware;
import chris.desingpatterns.factory.products.hardware.FastInternetHardware;
import chris.desingpatterns.factory.products.plans.FastInternetPlan;
import chris.desingpatterns.factory.products.plans.AbstractInternetPlan;

public class FastInternetFactory implements InternetPlanAbstractFactory {
    
    /**
     * {@inheritDoc}
     */
    public AbstractInternetPlan createInternetPlan() {
        return new FastInternetPlan();
    }
    
    /**
     * {@inheritDoc}
     */
    public AbstractInternetHardware createInternetHardware() {
        return new FastInternetHardware();
    }

}

Now this specific factory will create these products: FastInternetPlan and FastInternetHardware. If the requirements change it is easier to modify the factories to get the products that we need.

The client in this case that will use a Factory to get the right products is the Customer class:

Customer

package chris.desingpatterns.factory;

import chris.desingpatterns.factory.factories.InternetPlanAbstractFactory;
import chris.desingpatterns.factory.products.hardware.AbstractInternetHardware;
import chris.desingpatterns.factory.products.plans.AbstractInternetPlan;

public class Customer {
    private String name;
    private InternetPlanAbstractFactory internetFactory;
    private AbstractInternetHardware internetHardware;
    private AbstractInternetPlan internetPlan;
    
    public Customer(String name) {
        this.name = name;
    }
    
    /**
     * Method that will set the specific
     * Internet plan and Internet hardware
     * for a customer.
     * 
     */
    public void setUpInternetService() {
        internetHardware = internetFactory.createInternetHardware();
        internetPlan = internetFactory.createInternetPlan();
    }

    public String getName() {
        return name;
    }
    
    public void setName(String name) {
        this.name = name;
    }
    
    public void setInternetFactory(InternetPlanAbstractFactory internetFactory) {
        this.internetFactory = internetFactory;
    }

    public AbstractInternetHardware getInternetHardware() {
        return internetHardware;
    }

    public AbstractInternetPlan getInternetPlan() {
        return internetPlan;
    }

}

As can be seen here the client (Customer) just relies in abstract classes or interfaces:

• InternetPlanAbstractFactory
• AbstractInternetHardware
• AbstractInternetPlan

Here fits perfectly well the Design Principle:

Depend upon abstractions. Do not depend upon concrete classes.

Finally the main class that will run this case study:

Main

package chris.desingpatterns.factory;

import chris.desingpatterns.factory.factories.BasicInternetFactory;
import chris.desingpatterns.factory.factories.FastInternetFactory;
import chris.desingpatterns.factory.factories.InternetPlanAbstractFactory;
import chris.desingpatterns.factory.products.hardware.AbstractInternetHardware;
import chris.desingpatterns.factory.products.plans.AbstractInternetPlan;

public class Main {

    /**
     * Method that will run the implementation of the 
     * Abstract Factory Pattern.
     * 
     * For this example we will have two customers:
     * - CustomerA with Basic Internet Plan.
     * - CustomerB with Fast Internet. 
     * 
     * Thanks to the factory, the required characteristics
     * of the Internet plan such as Internet Speed and costs
     * are correctly determined in the factories, without 
     * setting this extra information in other methods.
     * 
     * Factories are easy to maintain in case a New Internet
     * plan would be required, without changing any other 
     * classes or methods.
     * 
     * @param args
     */
    public static void main(String[] args) {
        //Customer A: 
        Customer customerA = new Customer("Christian");
        // Customer choose the Internet plan: Basic Internet
        setInternetPlan(customerA, new BasicInternetFactory());
        // The Serial Number of the Router 
        String serialNumberA = "11233654564AXB";
        setHardwareSerial(customerA, serialNumberA);
        printInfo(customerA);
        
        //Customer B:
        Customer customerB = new Customer("Kasia");
        // Customer choose Fast Internet
        setInternetPlan(customerB, new FastInternetFactory());
        // The serial number of the router
        String serialNumberB = "PSN123456";
        setHardwareSerial(customerB, serialNumberB);
        printInfo(customerB);
    }
    
    
    private static void setInternetPlan(Customer customer, 
            InternetPlanAbstractFactory internetFactory){
        
        customer.setInternetFactory(internetFactory);
        customer.setUpInternetService();
        
    }
    
    private static void setHardwareSerial(Customer customer, String serialNumber){
        AbstractInternetHardware hardwareOwned = customer.getInternetHardware();
        hardwareOwned.setSerialNumber(serialNumber);
    }
    
    private static void printInfo(Customer customer) {
        System.out.println("--------------------------------------");
        System.out.println("Hello: " + customer.getName());
        AbstractInternetPlan internetPlan = customer.getInternetPlan();
        
        System.out.println("You have chosen the following plan: " + 
                internetPlan.getName());
        
        System.out.println(internetPlan.getDescription());
        AbstractInternetHardware hardware = customer.getInternetHardware();
        
        System.out.println("You will receive the following device from us: " + 
                hardware.getModel() + " S/N: " + hardware.getSerialNumber());
        
        System.out.println(hardware.getCapabilities());
        System.out.println("TOTAL COST: " + internetPlan.getCost() + " Euros");
        System.out.println("--------------------------------------");
    }

}

That is it folks !
As always, you can download the source code and dig into it to see how it works and maybe modify it to see how flexible de application of this pattern is:

Abstract Factory Pattern

Do you have any recommendations or amendments to be done, please let me know to improve this post!