Golang反射与工厂模式结合应用实例

reflect.Type

reflect.New()

interface{}

reflect

package main

import (
    "fmt"
    "reflect"
    "sync"
)

// Product 是所有可创建对象的通用接口
type Product interface {
    GetName() string
    Execute() string
}

// ConcreteProductA 是一个具体的产品实现
type ConcreteProductA struct {
    ID   string
    Name string
}

func (p *ConcreteProductA) GetName() string {
    return p.Name
}

func (p *ConcreteProductA) Execute() string {
    return fmt.Sprintf("Executing ConcreteProductA with ID: %s, Name: %s", p.ID, p.Name)
}

// ConcreteProductB 是另一个具体的产品实现
type ConcreteProductB struct {
    Code string
}

func (p *ConcreteProductB) GetName() string {
    return "ConcreteProductB"
}

func (p *ConcreteProductB) Execute() string {
    return fmt.Sprintf("Executing ConcreteProductB with Code: %s", p.Code)
}

// ==============================================================================
// Factory 实现
// ==============================================================================

// productRegistry 存储了所有注册的类型
var (
    productRegistry = make(map[string]reflect.Type)
    registryMutex   sync.RWMutex // 读写锁，保证并发安全
)

// RegisterProduct 用于注册新的产品类型。
// 参数 productInstance 应该是一个零值实例，例如 ConcreteProductA{}。
func RegisterProduct(name string, productInstance interface{}) error {
    registryMutex.Lock()
    defer registryMutex.Unlock()

    // 获取传入实例的类型
    typ := reflect.TypeOf(productInstance)

    // 如果传入的是指针，我们通常希望注册其指向的元素类型
    if typ.Kind() == reflect.Ptr {
        typ = typ.Elem()
    }

    // 确保注册的是结构体，因为我们通常创建结构体实例
    if typ.Kind() != reflect.Struct {
        return fmt.Errorf("can only register struct types, got %s", typ.Kind())
    }

    // 检查该类型是否实现了 Product 接口
    // reflect.PtrTo(typ) 获取指向该结构体的指针类型，因为接口方法可能定义在指针接收者上
    if !reflect.PtrTo(typ).Implements(reflect.TypeOf((*Product)(nil)).Elem()) {
        return fmt.Errorf("type %s does not implement the Product interface", typ.Name())
    }

    if _, exists := productRegistry[name]; exists {
        return fmt.Errorf("product type '%s' already registered", name)
    }

    productRegistry[name] = typ
    fmt.Printf("Registered product '%s' (%s)\n", name, typ.Name())
    return nil
}

// CreateProduct 是工厂的核心方法，根据名称创建产品实例
func CreateProduct(name string) (Product, error) {
    registryMutex.RLock()
    defer registryMutex.RUnlock()

    typ, ok := productRegistry[name]
    if !ok {
        return nil, fmt.Errorf("product type '%s' not registered", name)
    }

    // 使用反射创建新实例。reflect.New返回一个指向零值的指针的reflect.Value。
    // Elem() 获取指针指向的实际值。
    // Addr() 获取该值的地址（即指向该值的指针的reflect.Value）。
    // Interface() 将reflect.Value转换为interface{}。
    // 最终我们希望得到一个 Product 接口类型的值，通常Product接口方法会定义在指针接收者上。
    // 所以这里我们创建的是一个指针，然后断言为 Product 接口。
    productValue := reflect.New(typ) // productValue 是 *typ 的 reflect.Value

    // 尝试将创建的实例转换为 Product 接口
    if product, ok := productValue.Interface().(Product); ok {
        return product, nil
    }
    // 考虑如果 Product 接口的方法是定义在值接收者上，可能需要 Elem().Interface()
    if product, ok := productValue.Elem().Interface().(Product); ok {
        return product, nil
    }

    return nil, fmt.Errorf("created instance of type '%s' does not implement Product interface", typ.Name())
}

func main() {
    // 注册产品
    err := RegisterProduct("typeA", ConcreteProductA{})
    if err != nil {
        fmt.Println("Registration error:", err)
    }
    err = RegisterProduct("typeB", &ConcreteProductB{}) // 也可以传入指针
    if err != nil {
        fmt.Println("Registration error:", err)
    }

    fmt.Println("--- Creating Products ---")

    // 创建产品A
    pA, err := CreateProduct("typeA")
    if err != nil {
        fmt.Println("Error creating typeA:", err)
    } else {
        // 对创建的产品进行类型断言，以便设置具体字段
        if concreteA, ok := pA.(*ConcreteProductA); ok {
            concreteA.ID = "A001"
            concreteA.Name = "First Product A"
        }
        fmt.Println(pA.Execute())
    }

    // 创建产品B
    pB, err := CreateProduct("typeB")
    if err != nil {
        fmt.Println("Error creating typeB:", err)
    } else {
        if concreteB, ok := pB.(*ConcreteProductB); ok {
            concreteB.Code = "B-XYZ"
        }
        fmt.Println(pB.Execute())
    }

    // 尝试创建未注册的产品
    _, err = CreateProduct("typeC")
    if err != nil {
        fmt.Println("Error creating typeC:", err) // 预期会报错
    }
}

RegisterProduct

Product

reflect.PtrTo(typ).Implements(...)

CreateProduct

reflect.New(typ)

reflect.Value

*ConcreteProductA

*ConcreteProductB

Interface()

Product

Product

productValue.Interface().(Product)

productValue.Elem().Interface().(Product)