How to apply factory pattern in Golang

Factory Pattern In Go, the factory pattern allows the creation of objects without specifying a concrete class: defining an interface (such as Shape) that represents the object. Create concrete types (such as Circle and Rectangle) that implement the interface. Create a factory class to create objects of a given type (for example, ShapeFactory). Use factory classes to create objects in client code. This design pattern increases the flexibility of the code without directly coupling to concrete types.

Demystifying the factory pattern in Golang

Introduction

The factory pattern is a design pattern that allows We create objects without specifying concrete classes. This can be achieved by creating a factory class that is responsible for creating and returning object instances with a specific interface.

Implementation

In Golang, we can create factory patterns using interface{} and type. First, we need to define an interface to represent the object we will create. Let's take creating a shape factory as an example:

type Shape interface {
    Area() float64
    Perimeter() float64
}

Next, we need to create specific shape types, which implement the Shape interface:

type Circle struct {
    radius float64
}

func (c *Circle) Area() float64 {
    return math.Pi * c.radius * c.radius
}

func (c *Circle) Perimeter() float64 {
    return 2 * math.Pi * c.radius
}

type Rectangle struct {
    length float64
    width float64
}

func (r *Rectangle) Area() float64 {
    return r.length * r.width
}

func (r *Rectangle) Perimeter() float64 {
    return 2 * (r.length + r.width)
}

Factory

Now we can create a factory class responsible for creating shape objects according to the given type:

type ShapeFactory struct{}

func (f *ShapeFactory) CreateShape(shapeType string) Shape {
    switch shapeType {
    case "circle":
        return &Circle{}
    case "rectangle":
        return &Rectangle{}
    default:
        return nil
    }
}

Practical case

In our In the case, we can use the factory class to create the shape object in the client code:

factory := &ShapeFactory{}

circle := factory.CreateShape("circle")
circle.radius = 5
fmt.Println("Circle area:", circle.Area())

rectangle := factory.CreateShape("rectangle")
rectangle.length = 10
rectangle.width = 5
fmt.Println("Rectangle area:", rectangle.Area())

Output result:

Circle area: 78.53981633974483
Rectangle area: 50

Conclusion

Passed Using the Factory pattern, we are able to create shape objects without specifying a specific shape. This makes our code more flexible and maintainable.

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