DEV Community: Subhrodip Mohanta

Abstract Factory Design Pattern

Subhrodip Mohanta — Thu, 27 May 2021 09:14:37 +0000

This is a Creational Design Pattern under Gang of Four

Also known as

Kit

Intent

Provide an interface for creating families of related or dependent
objects without specifying their concrete classes.

Explanation

Real world example

To create a kingdom we need objects with a common theme. Elven kingdom needs an Elven king, Elven castle and Elven army whereas Orcish kingdom needs an Orcish king, Orcish castle and Orcish army. There is a dependency between the objects in the kingdom.

In plain words

A factory of factories; a factory that groups the individual but related/dependent factories together without specifying their concrete classes.

Wikipedia says

The abstract factory pattern provides a way to encapsulate a group of individual factories that have a common theme without specifying their concrete classes

Programmatic Example

Translating the kingdom example above. First of all we have some interfaces and implementation for the objects in the
kingdom.

public interface Castle {
  String getDescription();
}

public interface King {
  String getDescription();
}

public interface Army {
  String getDescription();
}

// Elven implementations ->
public class ElfCastle implements Castle {
  static final String DESCRIPTION = "This is the Elven castle!";
  @Override
  public String getDescription() {
    return DESCRIPTION;
  }
}
public class ElfKing implements King {
  static final String DESCRIPTION = "This is the Elven king!";
  @Override
  public String getDescription() {
    return DESCRIPTION;
  }
}
public class ElfArmy implements Army {
  static final String DESCRIPTION = "This is the Elven Army!";
  @Override
  public String getDescription() {
    return DESCRIPTION;
  }
}

// Orcish implementations similarly -> ...

Then we have the abstraction and implementations for the kingdom factory

public interface KingdomFactory {
  Castle createCastle();
  King createKing();
  Army createArmy();
}

public class ElfKingdomFactory implements KingdomFactory {
  public Castle createCastle() {
    return new ElfCastle();
  }
  public King createKing() {
    return new ElfKing();
  }
  public Army createArmy() {
    return new ElfArmy();
  }
}

public class OrcKingdomFactory implements KingdomFactory {
  public Castle createCastle() {
    return new OrcCastle();
  }
  public King createKing() {
    return new OrcKing();
  }
  public Army createArmy() {
    return new OrcArmy();
  }
}

Now we have our abstract factory that lets us make family of related objects i.e. Elven kingdom factory creates Elven castle, king and army etc.

var factory = new ElfKingdomFactory();
var castle = factory.createCastle();
var king = factory.createKing();
var army = factory.createArmy();

castle.getDescription();
king.getDescription();
army.getDescription();

Program output:

This is the Elven castle!
This is the Elven king!
This is the Elven Army!

Now, we can design a factory for our different kingdom factories. In this example, we created FactoryMaker, responsible for returning an instance of either ElfKingdomFactory or OrcKingdomFactory.

The client can use FactoryMaker to create the desired concrete factory which, in turn, will produce different concrete objects (Army, King, Castle).

In this example, we also used an enum to parameterize which type of kingdom factory the client will ask for.

public static class FactoryMaker {

  public enum KingdomType {
    ELF, ORC
  }

  public static KingdomFactory makeFactory(KingdomType type) {
    switch (type) {
      case ELF:
        return new ElfKingdomFactory();
      case ORC:
        return new OrcKingdomFactory();
      default:
        throw new IllegalArgumentException("KingdomType not supported.");
    }
  }
}

public static void main(String[] args) {
  var app = new App();

  LOGGER.info("Elf Kingdom");
  app.createKingdom(FactoryMaker.makeFactory(KingdomType.ELF));
  LOGGER.info(app.getArmy().getDescription());
  LOGGER.info(app.getCastle().getDescription());
  LOGGER.info(app.getKing().getDescription());

  LOGGER.info("Orc Kingdom");
  app.createKingdom(FactoryMaker.makeFactory(KingdomType.ORC));
  -- similar use of the orc factory
}

Class diagram

Applicability

Use the Abstract Factory pattern when

The system should be independent of how its products are created, composed and represented
The system should be configured with one of multiple families of products
The family of related product objects is designed to be used together, and you need to enforce this constraint
You want to provide a class library of products, and you want to reveal just their interfaces, not their implementations
The lifetime of the dependency is conceptually shorter than the lifetime of the consumer.
You need a run-time value to construct a particular dependency
You want to decide which product to call from a family at runtime.
You need to supply one or more parameters only known at run-time before you can resolve a dependency.
When you need consistency among products
You don’t want to change existing code when adding new products or families of products to the program.

Example use cases

Selecting to call to the appropriate implementation of FileSystemAcmeService or DatabaseAcmeService or NetworkAcmeService at runtime.
Unit test case writing becomes much easier
UI tools for different OS

Consequences:

Dependency injection in java hides the service class dependencies that can lead to runtime errors that would have been caught at compile time.
While the pattern is great when creating predefined objects, adding the new ones might be challenging.
The code becomes more complicated than it should be, since a lot of new interfaces and classes are introduced along with the pattern.

Tutorial

Abstract Factory Pattern Tutorial

Known uses

Related patterns

Credits

Code can be found here

Find out about more design patterns from here

Credit to Original Authors of this post:

Ilkka Seppälä

Sanket Panhale

Rodolfo Forte

Wes Gilleland

Sviataslau Shchaurouski

Prafful Agarwal

JackieNim

Narendra Pathai

Denise

Anurag Agarwal

Factory Method Design Pattern

Subhrodip Mohanta — Sun, 23 May 2021 10:15:53 +0000

This is a Creational Design Pattern under Gang of Four

Also known as

Virtual Constructor

Intent

Define an interface for creating an object, but let subclasses decide which class to instantiate.
Factory Method lets a class defer instantiation to subclasses.

Explanation

Real world example

Blacksmith manufactures weapons. Elves require Elvish weapons and orcs require Orcish weapons.
Depending on the customer at hand the right type of blacksmith is summoned.

In plain words

It provides a way to delegate the instantiation logic to child classes.

Wikipedia says

In class-based programming, the factory method pattern is a creational pattern that uses factory
methods to deal with the problem of creating objects without having to specify the exact class of
the object that will be created. This is done by creating objects by calling a factory method
— either specified in an interface and implemented by child classes, or implemented in a base
class and optionally overridden by derived classes—rather than by calling a constructor.

Programmatic Example

Taking our blacksmith example above. First of all we have a Blacksmith interface and some
implementations for it:

public interface Blacksmith {
  Weapon manufactureWeapon(WeaponType weaponType);
}

public class ElfBlacksmith implements Blacksmith {
  public Weapon manufactureWeapon(WeaponType weaponType) {
    return ELFARSENAL.get(weaponType);
  }
}

public class OrcBlacksmith implements Blacksmith {
  public Weapon manufactureWeapon(WeaponType weaponType) {
    return ORCARSENAL.get(weaponType);
  }
}

When the customers come, the correct type of blacksmith is summoned and requested weapons are
manufactured:

var blacksmith = new ElfBlacksmith();
blacksmith.manufactureWeapon(WeaponType.SPEAR);
blacksmith.manufactureWeapon(WeaponType.AXE);

Program output:

// Elven spear
// Elven axe

Class diagram

Applicability

Use the Factory Method pattern when:

Class cannot anticipate the class of objects it must create.
Class wants its subclasses to specify the objects it creates.
Classes delegate responsibility to one of several helper subclasses, and you want to localize the knowledge of which helper subclass is the delegate.

Real world examples

Credits

Code can be found here

Find out about more design patterns from here

Credit to Original Authors of this post:

Ilkka Seppälä

Rodolfo Forte

Wes Gilleland

Sviataslau Shchaurouski

JackieNim

Narendra Pathai

Hemant Bothra

Anurag Agarwal

Factory Design Pattern

Subhrodip Mohanta — Fri, 21 May 2021 15:01:38 +0000

This is a Creational Design Pattern under Gang of Four

Also known as

Simple Factory
Static Factory Method

Intent

Providing a static method encapsulated in a class called factory, in order to hide the
implementation logic and makes client code focus on usage rather then initialization new objects.

Explanation

Real world example

Lets say we have a web application connected to SQLServer, but now we want to switch to Oracle. To
do so without modifying existing source code, we need to implements Simple Factory pattern, in
which a static method can be invoked to create connection to a given database.

Wikipedia says

Factory is an object for creating other objects – formally a factory is a function or method that
returns objects of a varying prototype or class.

Programmatic Example

We have an interface Car and two implementations Ford and Ferrari.

public interface Car {
  String getDescription();
}

public class Ford implements Car {

  static final String DESCRIPTION = "This is Ford.";

  @Override
  public String getDescription() {
    return DESCRIPTION;
  }
}

public class Ferrari implements Car {

  static final String DESCRIPTION = "This is Ferrari.";

  @Override
  public String getDescription() {
    return DESCRIPTION;
  }
}

Enumeration above represents types of cars that we support (Ford and Ferrari).

public enum CarType {

  FORD(Ford::new), 
  FERRARI(Ferrari::new);

  private final Supplier<Car> constructor; 

  CarType(Supplier<Car> constructor) {
    this.constructor = constructor;
  }

  public Supplier<Car> getConstructor() {
    return this.constructor;
  }
}

Then we have the static method getCar to create car objects encapsulated in the factory class
CarsFactory.

public class CarsFactory {

  public static Car getCar(CarType type) {
    return type.getConstructor().get();
  }
}

Now on the client code we can create different types of cars using the factory class.

var car1 = CarsFactory.getCar(CarType.FORD);
var car2 = CarsFactory.getCar(CarType.FERRARI);
LOGGER.info(car1.getDescription());
LOGGER.info(car2.getDescription());

Program output:

This is Ford.
This is Ferrari.

Class Diagram

Applicability

Use the Simple Factory pattern when you only care about the creation of a object, not how to create
and manage it.

Pros

Allows keeping all objects creation in one place and avoid of spreading 'new' keyword across codebase.
Allows to write loosely coupled code. Some of its main advantages include better testability, easy-to-understand code, swappable components, scalability and isolated features.

Cons

The code becomes more complicated than it should be.

Real world examples

java.util.Calendar#getInstance()
java.util.ResourceBundle#getBundle()
java.text.NumberFormat#getInstance()
java.nio.charset.Charset#forName()
java.net.URLStreamHandlerFactory#createURLStreamHandler(String) (Returns different singleton objects, depending on a protocol)
java.util.EnumSet#of()
javax.xml.bind.JAXBContext#createMarshaller() and other similar methods.

Related patterns

Code can be found here

Find out about more design patterns from here

Credit to Original Authors of this post:

Samil Ayoub

Ilkka Seppälä

Anurag870

yonghong Xu

JackieNim

Girish Kulkarni

RuchaDalsania

How to skip CI in GitHub Actions

Subhrodip Mohanta — Tue, 23 Mar 2021 09:02:07 +0000

GitHub Actions now supports skipping workflows

All push and pull_request workflows by looking for some common keywords in your commit message.

If any commit message in your push or the HEAD commit of your PR contains one of the following strings:

[skip ci]
[ci skip]
[no ci]
[skip actions]
[actions skip]

Workflows triggered on the push or pull_request events will be skipped.

This feature have been previously supported by all major CI like:

Corona Virus Tracker Application

Subhrodip Mohanta — Wed, 20 May 2020 07:46:56 +0000

I have made a Spring Boot Application that updates every 30 minutes to show the number of confirmed COVID-19 cases from across the globe in different regions

Application Link : covid.subho.xyz

Link to Code : github.com/ohbus/covid-tracker

I have used Spring Boot Framework to build this application and link the backend to frontend using Thymeleaf to display the data. The application is packaged in a `jar` and has also been `dockerized.`

Both of these packages can be found under packages and releases inside my GitHub repo

I have been using GitKraken Pro which is absolutely amazing in managing projects. I would like to thank GitHub for providing uncountable tools and softwares for free to Student Developers

DEV Community: Subhrodip Mohanta

Abstract Factory Design Pattern

Also known as

Intent

Explanation

Class diagram

Applicability

Consequences:

Tutorial

Known uses

Related patterns

Credits

Factory Method Design Pattern

Also known as

Intent

Explanation

Class diagram

Applicability

Real world examples

Credits

Factory Design Pattern

Also known as

Intent

Explanation

Class Diagram

Applicability

Real world examples

Related patterns

How to skip CI in GitHub Actions

GitHub Actions now supports skipping workflows

Corona Virus Tracker Application

I have made a Spring Boot Application that updates every 30 minutes to show the number of confirmed COVID-19 cases from across the globe in different regions

Application Link : covid.subho.xyz

Link to Code : github.com/ohbus/covid-tracker

I have used Spring Boot Framework to build this application and link the backend to frontend using Thymeleaf to display the data. The application is packaged in a `jar` and has also been `dockerized.`

Both of these packages can be found under packages and releases inside my GitHub repo

I have been using GitKraken Pro which is absolutely amazing in managing projects. I would like to thank GitHub for providing uncountable tools and softwares for free to Student Developers

I would love if somebody to contribute to the project on developing the frontend part of this project as it has been the bare minimum.

Thank You.

DEV Community: Subhrodip Mohanta

Abstract Factory Design Pattern

Also known as

Intent

Explanation

Class diagram

Applicability

Consequences:

Tutorial

Known uses

Related patterns

Credits

Factory Method Design Pattern

Also known as

Intent

Explanation

Class diagram

Applicability

Real world examples

Credits

Factory Design Pattern

Also known as

Intent

Explanation

Class Diagram

Applicability

Real world examples

Related patterns

How to skip CI in GitHub Actions

GitHub Actions now supports skipping workflows

Corona Virus Tracker Application

I have made a Spring Boot Application that updates every 30 minutes to show the number of confirmed COVID-19 cases from across the globe in different regions

Application Link : covid.subho.xyz

Link to Code : github.com/ohbus/covid-tracker

I have used Spring Boot Framework to build this application and link the backend to frontend using Thymeleaf to display the data. The application is packaged in a jar and has also been dockerized.

Both of these packages can be found under packages and releases inside my GitHub repo

I have been using GitKraken Pro which is absolutely amazing in managing projects. I would like to thank GitHub for providing uncountable tools and softwares for free to Student Developers

I would love if somebody to contribute to the project on developing the frontend part of this project as it has been the bare minimum.

Thank You.

I have used Spring Boot Framework to build this application and link the backend to frontend using Thymeleaf to display the data. The application is packaged in a `jar` and has also been `dockerized.`