Practice and discussion of factory pattern in Golang

Factory pattern is a design pattern used to create objects without specifying specific classes. Its advantages include decoupling the creation process, scalability and flexibility. It is suitable for complex creation processes, the need to dynamically select products, or the need to provide Situation where new product type capabilities are created.

Factory Pattern in Go: Practice and Exploration

Introduction

Factory pattern is a design pattern used to create objects. No need to specify a specific class. It allows the application to obtain the required object without knowing the creation process.

Code examples

type Product interface {
    DoSomething()
}

type ProductA struct {}

func (p *ProductA) DoSomething() {
    fmt.Println("ProductA doing something...")
}

type ProductB struct {}

func (p *ProductB) DoSomething() {
    fmt.Println("ProductB doing something...")
}

type Factory interface {
    CreateProduct() Product
}

type FactoryA struct {}

func (f *FactoryA) CreateProduct() Product {
    return &ProductA{}
}

type FactoryB struct {}

func (f *FactoryB) CreateProduct() Product {
    return &ProductB{}
}

func main() {
    factoryA := &FactoryA{}
    productA := factoryA.CreateProduct()
    productA.DoSomething() // Output: ProductA doing something...

    factoryB := &FactoryB{}
    productB := factoryB.CreateProduct()
    productB.DoSomething() // Output: ProductB doing something...
}

Practical cases

The factory pattern is often used to decouple the creation process and the use of objects. For example, when using a dependency injection framework, it allows you to create objects without directly relying on concrete classes.

Advantages

• Decoupled creation process: The application no longer needs to understand the creation process of specific classes.
• Extensibility: New product types can be easily added by adding new factory classes.
• Flexibility: Allows the application to decide at runtime what type of objects to create.

Disadvantages

• Increased complexity: Introducing the factory pattern will increase the complexity of the application, especially when there are a large number of different types of products .
• Potential overhead: Each factory class must create its own object instance, which may cause performance overhead.

When to use

Situations when considering using the factory pattern include:

• The creation process is complex or products need to be dynamically selected based on conditions.
• Need to decouple the creation process and the use of objects.
• Want to provide the ability to create new product types without modifying existing code.

The above is the detailed content of Practice and discussion of factory pattern in Golang. For more information, please follow other related articles on the PHP Chinese website!