Home
Contact Me

Abstract Factory

 This pattern allows the creation of families of related or dependent objects without specifying their concrete classes. It is useful when you want to create a set of objects that must be used together and when you want to ensure that these objects are created consistently.


Implementing the abstract factory pattern involves creating an abstract factory interface, which defines methods for creating the desired objects, and one or more concrete implementations of that interface. Each concrete implementation creates a family of related objects according to its own creation logic.


For example, imagine that you are creating a database management system for a company that has two different databases: MySQL and Oracle. Instead of creating two database connection classes, one for each database, you can create an abstract factory interface called 'DatabaseConnectionFactory' with a method 'createConnection()' and two concrete implementations called 'MySqlConnectionFactory' and 'OracleConnectionFactory'. Each of these concrete implementations will create a connection to the specific database it is intended to manage.

// Abstract factory interface

class DatabaseConnectionFactory {

 createConnection() {

  throw new Error('createConnection method must be implemented');

 }

}

// Concrete implementation for MySQL

class MySqlConnectionFactory extends DatabaseConnectionFactory {

 createConnection() {

  return new MySqlConnection();

 }

}

// Concrete implementation for Oracle

class OracleConnectionFactory extends DatabaseConnectionFactory {

 createConnection(){

  return new OracleConnection();

 }

}

// MySQL database connection class

class MySqlConnection {

 connect() {

  console.log('Connecting to the database MySQL...');

 }

}

// Oracle connection class

class OracleConnection {

 connect() {

  console.log('Connecting to the database Oracle...');

 }

}

// Using the abstract factory pattern

const mysqlFactory = new MySqlConnectionFactory( );

const mysqlConnection = mysqlFactory.createConnection();

mysqlConnection.connect();

const oracleFactory = new OracleConnectionFactory();

const oracleConnection = oracleFactory.createConnection();

oracleConnection.connect();


The abstract factory pattern is useful because it allows you to create objects without specifying their concrete classes, which makes the code more flexible and easier to modify in the future. Additionally, it provides a consistent way to create related objects, which can be useful in complex systems with many dependencies between objects.