What is the Factory Method Pattern?

The Factory Method Pattern is a creational design pattern that creates objects by defining an interface, but defers the specific implementation of the object to the subclass. This means that the Factory Method Pattern allows subclasses to decide which class to instantiate, making code extension more flexible and easier to maintain.

Compared with the simple factory pattern, the factory method pattern no longer relies on a single factory class, but implements object creation through an abstract factory interface. This pattern emphasizes"Program to the interface, not the implementation"To learn about other design patterns, click here. Design Patterns in Software Engineering: Best Practices for Problem Solving

The difference between factory method pattern and simple factory pattern

The factory method pattern and the simple factory pattern are both creational design patterns. Their main differences are reflected in the flexibility of object creation, scalability, and compliance with design principles. Let's compare these two patterns in detail. For an introduction and example of the simple factory pattern, see the previous blog post.In-depth understanding of the simple factory pattern design pattern: implementation and application in Golang

1. Class structure design

• Simple factory pattern：The object creation logic is concentrated in a factory class, which determines what type of object to return based on the input parameters. The factory class is responsible for the creation of all products.

  • Simple structure: There is only one factory class responsible for creating different product objects.
  • Create a logical set: All creation logic is concentrated in one place.

• Factory Method Pattern: Through an abstract factory interface, the creation of objects is deferred to subclasses. Each specific factory class is responsible for creating only one type of product.

  • More flexibility: Each specific factory is responsible for creating a specific product type and supports extension through inheritance or implementation of interfaces.
  • Decentralized creation logic: Different factory classes are responsible for the creation of specific products, and the creation logic is decentralized.

2. Scalability

• Simple factory pattern: If you need to add a new product type, you must modify the factory class code, which will violate the "Open/Closed Principle” (Open for extension, closed for modification). Every time a new product is added, the implementation of the factory class is affected.

• Factory Method Pattern:conform toOpen/Closed PrincipleWhen adding a new product type, you only need to create a new factory subclass and the corresponding product class without modifying the existing factory class or client code. Each factory subclass is independently responsible for the creation of a specific product.

3. Product Category

• Simple factory pattern: Applicable toFewer product varieties, and the creation logic is not complex. When the number of product types increases, the factory class may become too complex and difficult to maintain.

• Factory Method Pattern: Applicable toA wide variety of products, and the product type needs to be frequently expanded or changed. Each specific factory class only handles the creation of one product, and the structure is clearer.

4. Usage scenarios

• Simple factory pattern:

  • The usage scenarios are simple, with only a small number of product types.
  • Suitable for projects that do not frequently expand product types.
  • The code maintenance cost is low and it is suitable for small systems.

• Factory Method Pattern:

  • This method is used when a large number of different types of products need to be created and the creation logic is relatively complex.
  • Suitable for projects where product types change frequently or expansion is required.
  • The code is more scalable and suitable for large systems or complex business scenarios.

5. Implementation complexity

• Simple factory pattern：The implementation is relatively simple and only requires a factory class to decide which product to create based on the input parameters.

• Factory Method Pattern：The implementation is relatively complex, involving multiple factory classes and product classes. It is necessary to define the factory interface, and different factory subclasses are used to implement the creation of specific products.

Summarize

• Simple factory patternIt is suitable for scenarios with simple creation logic, fewer product types, and lower expansion requirements. Its advantages are simple implementation and ease of use, but it will gradually become difficult to maintain as the number of product types increases.
• Factory Method PatternIt is suitable for scenarios that require frequent expansion of product categories and high requirements for system flexibility. Although the implementation is more complicated, it provides better scalability and clearer structure, and complies with the open-closed principle of object-oriented design.

Depending on the complexity and expansion requirements of the project, developers can choose the appropriate factory mode to improve the maintainability and scalability of the code.

What problem does it solve?

The factory method pattern solves the following problems:

• Decoupling: By introducing the factory interface, the client code no longer directly depends on the specific class, which improves the flexibility of the code.
• Scalability: The addition of new products does not require modifying existing code, only the creation of new subclasses and corresponding factory classes is required, which complies with the open-closed principle.
• Unified creation logic：The creation logic of all products is centrally managed in the factory, which facilitates maintenance and expansion.

When to use the Factory Method pattern?

The Factory Method pattern is an ideal choice in the following scenarios:

• When a class cannot predict the type of object that will be created.
• When a class expects its subclasses to specify the type of objects created.
• When you need to decouple the creation of an object from its use.

Advantages and disadvantages of the factory method pattern

advantage:

1. High flexibility: New types of products only require adding new factories and product classes, without affecting existing code.
2. Comply with the opening and closing principle: Functionality can be extended without modifying existing code.
3. Clear code structure: Through the abstract factory interface, the code structure is clearer and easier to manage.

shortcoming:

1. Increasing the number of classes: New classes need to be created for each product and corresponding factory, which may lead to an increase in the number of classes and increase system complexity.
2. Simple scenes are too complex: For scenarios with few product types, using the factory method pattern may be too complicated.

Implementation of Factory Method Pattern in Golang

Below we will show you how to implement the factory method pattern in Golang through a practical example. Suppose we need to create different types of transportation (such as bicycles and cars), each with its own implementation. The factory method pattern uses subclasses to delay the generation of objects to subclasses. There is no concept of inheritance in Golang, so here we use anonymous combination to implement it.

package main import "fmt" // Vehicle is the interface for all vehicles type Vehicle interface { Drive() string } // Bike bicycles implement the Vehicle interface type Bike struct{} func (b *Bike) Drive() string { return "Bike is being driven" } // Car cars implement the Vehicle interface type Car struct{} func (c *Car) Drive() string { return "Car is being driven" } // VehicleFactory is an abstract factory interface type VehicleFactory interface { CreateVehicle() Vehicle } // BikeFactory is a specific factory used to create bicycles type BikeFactory struct{} func (b *BikeFactory) CreateVehicle() Vehicle { return &Bike{} } // CarFactory is a specific factory used to create cars type CarFactory struct{} func (c *CarFactory) CreateVehicle() Vehicle { return &Car{} } func main() { // Create a factory instance var factory VehicleFactory // Use the bicycle factory factory = &BikeFactory{} vehicle1 := factory.CreateVehicle() fmt.Println(vehicle1.Drive()) // Use car factory factory = &CarFactory{} vehicle2 := factory.CreateVehicle() fmt.Println(vehicle2.Drive()) }

Golang Implementation Notes

• Defined Vehicle interface, all types of transport (Bike and Car) have implemented this interface Drive() method.
• Created VehicleFactory Abstract factory interface, and defines CreateVehicle() method.
• BikeFactory and CarFactory Realized respectively VehicleFactory Interface used to create the corresponding type of transportation.
• exist main() In the function, different factories are used to create vehicle objects and call their Drive() method.

Precautions for use in actual development

1. Factory interface design: When designing the factory interface, make sure it covers all the product types that need to be created. Reasonable interface design can simplify subsequent expansion.
2. Keep your code clean: Try to avoid complex dependencies between factory classes and ensure that each factory has a single responsibility.
3. Performance Considerations: If the creation logic of the factory method is very complex, it may affect performance. In this case, you can consider using a caching mechanism or other optimization strategies.
4. Documentation and Examples: When working in a team, provide adequate documentation and examples for the Factory Method pattern to ensure that team members understand how to use it.

Reference Links

• Golang official documentation
• Design Patterns - Factory Method Pattern (Wikipedia)