Understanding the Factory Design Pattern in Flutter/Dart

When software engineers try to solve a problem, always try to find a pattern that they already used before or try to create a new one. Because it is very important for future uses and others can understand it well. That’s why design pattern comes and there are some patterns that are approved worldwide. These are very much logical things. Not dependent on any programming language.

In software development, ensuring that code is maintainable, scalable, and easy to extend is key. One design pattern that helps developers achieve these goals is the Factory Pattern. This pattern is especially useful when you want to create objects without exposing the creation logic to the client, and it allows the client to request objects of a specific type.

In this article, we will explore the Factory Pattern in three steps: What it is, Its use case, and The benefits. Finally, we'll see a Dart implementation using Flutter to make things clearer.

1. What is the Factory Pattern?

The Factory Pattern is a creational design pattern that provides an interface for creating objects in a superclass, but allows subclasses to decide which object to instantiate. It helps you encapsulate the logic for object creation and ensures that the client code remains independent from the specific classes being instantiated.

In simple terms, the Factory Pattern delegates the responsibility of object creation to a dedicated class, known as the "factory.".

2. When to Use the Factory Pattern

The Factory Pattern is perfect when:

• You need to create objects of different types based on some input (like sending a notification as email, SMS, etc.).
• You want to make it easier to add new types of objects (like adding a push notification feature later).
• You’re working with complex object creation logic that you want to keep separate from the rest of your code.

Other Real-World Examples:

• Transportation app: You might want to create different vehicle objects (car, bike, or truck) based on the user’s choice.
• Payment systems: Depending on the method selected, you could create a credit card payment object or a PayPal payment object.
• UI components: You might want to create different UI widgets (buttons, forms) based on the platform (Android, iOS).

3. Benefits of Using the Factory Pattern

• Simplicity: The object creation logic is separated from the rest of your code, making it cleaner and more organized.
• Flexibility: You can easily add more types of objects later without changing the existing code.
• Reduced Coupling: Your client code (the part that uses the objects) doesn’t need to know about how these objects are created.

Example: Sending Different Types of Notifications

Let’s say you’re building an app that sends out notifications in different formats: email and SMS. You don’t want your main code to worry about which type of notification to send or how it works. You just want to send a message and let the factory handle the rest.

Here’s how you can do it using the Factory Pattern in Dart.

Step 1: Define a Common Interface

First, create an abstract class Notification that defines a common method for sending notifications.

abstract class Notification {
  void send(String message);
}
        

Step 2: Create Specific Notification Classes

Next, we’ll create two concrete classes: EmailNotification and SMSNotification. Both implement the Notification interface.

class EmailNotification implements Notification {
  @override
  void send(String message) {
    print("Sending Email: $message");
  }
}

class SMSNotification implements Notification {
  @override
  void send(String message) {
    print("Sending SMS: $message");
  }
}
        

Step 3: Create the Factory

Now comes the factory class that will decide which notification to create based on input.

class NotificationFactory {
  static Notification createNotification(String type) {
    if (type == 'email') {
      return EmailNotification();
    } else if (type == 'sms') {
      return SMSNotification();
    } else {
      throw Exception('Notification type not supported');
    }
  }
}
        

Step 4: Use the Factory to Send Notifications

Finally, in your main code, you can use the factory to create and send notifications without worrying about the details.

void main() {
  Notification emailNotification = NotificationFactory.createNotification('email');
  emailNotification.send('Hello via Email!');

  Notification smsNotification = NotificationFactory.createNotification('sms');
  smsNotification.send('Hello via SMS!');
}
        

Conclusion

The Factory Pattern is a powerful tool that simplifies object creation. Whether you're working on a notification system, a payment gateway, or even UI components, this pattern helps you keep your code clean and flexible. By letting a factory handle the object creation, you can easily add new features without cluttering your existing code.

So, next time you’re facing complex object creation logic, remember that the Factory Pattern might just be the solution you need!