In Go, how to define a common interface using factory pattern to handle different parameter types for the same method of different interfaces?

Go language factory mode solves the difference in interface method parameter type

This article discusses how to define a common interface using factory pattern in Go to handle different parameter types of the same method in different interfaces. The challenge of this problem is that multiple interfaces implement the same method, but the parameter types of these methods vary. Using interface{} or any type directly will lose type information and reduce code security.

Suppose we have two interfaces IAXX and IBXX , both of which contain Create method, but the parameter types of Create method are model.AXX and model.BXX respectively. In order to define a public interface ICommonInterface while avoiding type loss, we can adopt factory mode.

The core idea is to create an ICreatorFactory interface, which is responsible for creating and providing different types of method parameters. The Create method of ICreator interface accepts ICreatorFactory as a parameter, thereby indirectly accepting different types of parameters.

Code example:

 package main

import "fmt"

// Define the model type (assumption)
type modelAXX struct {
    Value string
}

type modelBXX struct {
    Value int
}

// Define factory interface ICreatorFactory
type ICreatorFactory interface {
    GetCreatePayload() interface{}
}

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

// IAXX interface implements type IAXX struct{}

func (ia *IAXX) Create(factory ICreatorFactory) {
    payload := factory.GetCreatePayload().(modelAXX) // type assertion fmt.Printf("IAXX Create: % v\n", payload)
}

// IBXX interface implements type IBXX struct{}

func (ib *IBXX) Create(factory ICreatorFactory) {
    payload := factory.GetCreatePayload().(modelBXX) // type assertion fmt.Printf("IBXX Create: % v\n", payload)
}


// Factory implementation: Create modelAXX
type AXXFactory struct{}

func (af *AXXFactory) GetCreatePayload() interface{} {
    return modelAXX{Value: "Hello from AXX"}
}

// Factory implementation: Create modelBXX
type BXXFactory struct{}

func (bf *BXXFactory) GetCreatePayload() interface{} {
    return modelBXX{Value: 123}
}

func main() {
    ia := &IAXX{}
    ib := &IBXX{}

    ia.Create(&AXXFactory{})
    ib.Create(&BXXFactory{})
}

In this example, AXXFactory and BXXFactory implement ICreatorFactory respectively and return their respective model types. IAXX and IBXX securely obtain parameters through type assertions, avoiding the problem of type mismatch. This method maintains the flexibility and scalability of the code and avoids the type safety risks brought about by using interface{} . It should be noted that the use of type assertions ( .(modelAXX) ) requires ensuring that the incoming factory does return the correct type, otherwise the runtime panic will occur. More robust implementations may require the addition of error handling mechanisms.

The above is the detailed content of In Go, how to define a common interface using factory pattern to handle different parameter types for the same method of different interfaces?. For more information, please follow other related articles on the PHP Chinese website!