Java Design Pattern - Creational - Abstract Factory Pattern

Mastering Java Design Patterns: The Abstract Factory Creational Pattern

Continuing our journey of mastering Java design patterns, today we explore the Abstract Factory Pattern. This pattern is essential for creating families of related objects without being tied to their concrete classes, ensuring consistency and scalability in your projects.

What is the Abstract Factory Pattern?

The Abstract Factory Pattern is a creational design pattern that allows you to create families of related objects without being tied to their concrete classes. This pattern promotes consistency among products by ensuring that related products are created together. It enhances scalability by allowing the creation of new product families without changing the existing code.

Example: Databases and Connections

In this example, we'll use the Abstract Factory Pattern to create a system that handles different types of databases (e.g., MySQL, PostgreSQL) and their respective connections.

Step-by-Step Code Explanation

Step 1: Define Interfaces

We'll start by defining the interfaces for our products: Database and Connection.

public interface Database {
    void connect();
}

public interface Connection {
    void executeQuery(String query);
}

Step 2: Implement Concrete Products

Next, we'll implement the concrete classes for each type of database and connection.

public class MySqlDatabase implements Database {
    @Override
    public void connect() {
        // Logic relevant to MySQL database connection
        System.out.println("Connecting to MySQL Database...");
    }
}

public class PostgresDatabase implements Database {
    @Override
    public void connect() {
        // Logic relevant to PostgreSQL database connection
        System.out.println("Connecting to PostgreSQL Database...");
    }
}

public class MySqlConnection implements Connection {
    @Override
    public void executeQuery(String query) {
        // Logic relevant to executing a query on MySQL
        System.out.println("Executing query on MySQL: " + query);
    }
}

public class PostgresConnection implements Connection {
    @Override
    public void executeQuery(String query) {
        // Logic relevant to executing a query on PostgreSQL
        System.out.println("Executing query on PostgreSQL: " + query);
    }
}

Step 3: Create the Abstract Factory

The abstract factory declares methods for creating abstract product objects.

public abstract class DatabaseFactory {
    public abstract Database createDatabase();
    public abstract Connection createConnection();
}

Step 4: Implement Concrete Factories

Concrete factories implement the creation methods for the specific product variants.

public class MySqlFactory extends DatabaseFactory {
    @Override
    public Database createDatabase() {
        return new MySqlDatabase();
    }

    @Override
    public Connection createConnection() {
        return new MySqlConnection();
    }
}

public class PostgresFactory extends DatabaseFactory {
    @Override
    public Database createDatabase() {
        return new PostgresDatabase();
    }

    @Override
    public Connection createConnection() {
        return new PostgresConnection();
    }
}

Step 5: Main Class Example

Here's an example of a main method that demonstrates how to use the Abstract Factory Pattern to create a database and a connection, and then execute a query using these objects.

public class Main {
    public static void main(String[] args) {
        // Choose the factory type (MySQL or PostgreSQL)
        DatabaseFactory factory = getFactory("MySQL");

        // Create the database and connection objects using the factory
        Database database = factory.createDatabase();
        Connection connection = factory.createConnection();

        // Connect to the database
        database.connect();

        // Execute a query
        connection.executeQuery("SELECT * FROM users");
    }

    private static DatabaseFactory getFactory(String type) {
        if (type.equalsIgnoreCase("MySQL")) {
            return new MySqlFactory();
        } else if (type.equalsIgnoreCase("PostgreSQL")) {
            return new PostgresFactory();
        } else {
            throw new IllegalArgumentException("Unknown database type: " + type);
        }
    }
}

Structure of Abstract Factory Pattern

Benefits of the Abstract Factory Pattern

1. Consistency: Ensures that related products are compatible by creating them through a single factory.
2. Scalability: Easily add new product families without changing the existing code.
3. Flexibility: Abstracts the creation process, making the system more flexible and easier to maintain.

Conclusion

The Abstract Factory Pattern is a powerful tool in a developer's toolkit for creating scalable, maintainable, and consistent systems. By abstracting the creation of related objects, this pattern allows us to build systems that are easier to extend and modify.