The Factory design pattern is widely used in object-oriented programming. It provides an interface for creating objects, but allows subclasses to decide which classes to instantiate. In this article, we will explore how to implement the Factory pattern in Golang, understand its benefits and analyze a practical example of use inspired by everyday situations.

What is Factory?

Factory defines an interface for creating objects, but delegates the responsibility for instantiating the concrete class to subclasses. This promotes the creation of objects in a decoupled and flexible way, allowing the code to be more modular and easier to maintain.

Benefits

• Decoupling: Separates the creation of objects from their implementation, promoting cleaner and more modular code.
• Flexibility: Makes it easy to introduce new classes without modifying existing code.
• Maintenance: Makes the code easier to maintain and evolve, as the creation logic is centralized in a single place.

Implementing a Factory

Let's use an everyday example to illustrate the Factory pattern: a system for ordering food, where some different types of meals (Pizza and Salad) can be created.

1 - Creating the interface

First, we need to define an interface that will be implemented by all "concrete classes" of meals.

package main

type Food interface {
    Prepare()
}

2 - Creating an ENUM and implementing the interface

To make our lives easier during development and avoid typing something wrong during validation, a good practice is to create an ENUM to have consistency and also make it easier if we want to add new foods in the future

package main

type FoodType int

const (
    PizzaType FoodType = iota
    SaladType
)

type Food interface {
    Prepare()
}

And now let's implement the Food interface. In the example we will just display a message, in real life this is where the object we are working on would be created

package main

type FoodType int

const (
    PizzaType FoodType = iota
    SaladType
)

type Food interface {
    Prepare()
}

type Pizza struct{}

func (p Pizza) Prepare() {
    fmt.Println("Preparing a Pizza...")
}

type Salad struct{}

func (s Salad) Prepare() {
    fmt.Println("Preparing a Salad...")
}

3 - Creating the Factory

Now, let's create the factory that will decide which concrete class to instantiate based on the enum it received as a parameter.

package main

type FoodFactory struct{}

func (f FoodFactory) CreateFood(ft FoodType) Food {
    switch ft {
    case PizzaType:
        return &Pizza{}
    case SaladType:
        return &Salad{}
    default:
        return nil
    }
}

4 - Using Factory

Finally, we will use the factory to create our food.

package main

func main() {
    kitchen := FoodFactory{}

    pizza := kitchen.CreateFood(PizzaType)
    if pizza != nil {
        pizza.Prepare()
    }

    salad := kitchen.CreateFood(SaladType)
    if salad != nil {
        salad.Prepare()
    }
}

This will be the result after running our application:

Preparing a Pizza...
Preparing a Salad...

Summary of what we did

1. Food Interface: Defines the contract that all concrete meals must follow, ensuring that they all implement the Prepare method.
2. Enum FoodType: Uses typed constants to represent different types of food, increasing code readability and security.
3. Concrete classes (Pizza and Salad): Implement the Food interface and provide their own implementations of the Prepare method.
4. FoodFactory: Contains object creation logic. The CreateFood method decides which concrete class to instantiate based on the FoodType enum.
5. Main method: Demonstrates the use of the factory to create different objects and call their methods, illustrating the flexibility and decoupling provided by the Factory pattern.

Conclusion

The Factory design pattern is a powerful tool for promoting decoupling and flexibility in object creation. In Golang, the implementation of this pattern is direct and effective, allowing the creation of modular and easy-to-maintain systems. Using interfaces and factories, we can centralize creation logic and simplify code evolution as new requirements emerge.