In Go language, how to solve the problem of different public method parameter types of different interfaces through factory mode?

In Go, how to elegantly define a common interface and deal with the problem of the same method but different parameter types in the interface implementation? This article will use an example to demonstrate how to solve such problems using factory patterns. Suppose there are two interfaces IAxx and IBxx , both of which contain Create method, but the parameter types are different.

Although it is feasible to use interface{} directly as a parameter to Create method, it lacks type safety and is difficult to maintain. To solve this problem, we can introduce the factory model.

First, define a public interface ICreator , which contains Create method and the parameter type is a factory interface ICreatorFactory . The ICreatorFactory interface is responsible for providing the parameters required by the Create method.

 package main

import "fmt"

// Define public interface ICreator
type ICreator interface {
    Create(factory ICreatorFactory)
}

// Define factory interface ICreatorFactory
type ICreatorFactory interface {
    GetCreatePayload() map[any]any
}

Next, implement IAxx and IBxx interfaces and their corresponding factories:

 // IAxx interface implements ImplA
type ImplA struct{}

func (a *ImplA) Create(factory ICreatorFactory) {
    payload := factory.GetCreatePayload()
    fmt.Printf("ImplA Create: %v\n", payload) // Process payload
}

// IAxx factory implements ModelA
type ModelA struct{}

func (a *ModelA) GetCreatePayload() map[any]any {
    return map[any]any{"keyA": "valueA"}
}

// IBxx interface implements ImplB
type ImplB struct{}

func (b *ImplB) Create(factory ICreatorFactory) {
    payload := factory.GetCreatePayload()
    fmt.Printf("ImplB Create: %v\n", payload) // Process payload
}

// IBxx factory implements ModelB
type ModelB struct{}

func (b *ModelB) GetCreatePayload() map[any]any {
    return map[any]any{"keyB": 123}
}

In the main function, we can create different objects through factories:

 func main() {
    implA := &ImplA{}
    implA.Create(&ModelA{})

    implB := &ImplB{}
    implB.Create(&ModelB{})
}

In this way, we use the factory pattern to encapsulate the creation logic of different parameter types in their respective factory implementations. The parameter types of the Create method of ICreator interface are consistent, thus solving the problem of inconsistent parameter types while maintaining code flexibility and scalability. map[any]any although sacrifices a certain type safety, provides sufficient flexibility to handle various parameter types. More stringent type checking can be implemented inside the Create methods of ImplA and ImplB .

The above is the detailed content of In Go language, how to solve the problem of different public method parameter types of different interfaces through factory mode?. For more information, please follow other related articles on the PHP Chinese website!