Go语言中实现通用数据访问函数

type Person struct{ FirstName string }
type Company struct{ Industry string }

// 期望的通用获取函数签名（在没有泛型之前）
// getItems(typ string, field string, val string) ([]interface{}) {
//     // ... 实际的数据库查询逻辑
// }

// 使用示例
// var persons []Person
// persons = getItems("Person", "FirstName", "John")

// var companies []Company
// companies = getItems("Company", "Industry", "Software")

// 模拟数据库数据
var database = []interface{}{
    Person{FirstName: "John"},
    Company{Industry: "Software"},
    Person{FirstName: "Jane"},
    Company{Industry: "Hardware"},
}

// 假设的通用getItems函数，这里简化为从内存中过滤
func getItemsGeneric(field string, val string) []interface{} {
    output := make([]interface{}, 0)
    // 实际场景中这里会是数据库查询逻辑
    for _, item := range database {
        // 简化示例：假设我们能通过某种方式匹配字段和值
        // 真实场景需要更复杂的反射或ORM逻辑
        if p, ok := item.(Person); ok && field == "FirstName" && p.FirstName == val {
            output = append(output, item)
        } else if c, ok := item.(Company); ok && field == "Industry" && c.Industry == val {
            output = append(output, item)
        }
    }
    return output
}

// 针对特定类型进行断言和转换的辅助函数
func getPersons(field string, val string) []Person {
    slice := getItemsGeneric(field, val)
    output := make([]Person, 0)
    for _, item := range slice {
        // 类型断言！
        thing, ok := item.(Person)
        if ok {
            output = append(output, thing)
        }
    }
    return output
}

// 示例用法
func main() {
    persons := getPersons("FirstName", "John")
    fmt.Println("Found Persons:", persons) // Output: Found Persons: [{John}]

    // 同样可以为Company编写getCompanies函数
    // companies := getCompanies("Industry", "Software")
}

// 模拟数据库数据
var database = []interface{}{
    Person{FirstName: "John"},
    Company{Industry: "Software"},
    Person{FirstName: "Jane"},
    Company{Industry: "Hardware"},
}

// 更加通用的getItem函数，接受一个判别函数
func getItemWithCriteria(criteria func(interface{}) bool) []interface{} {
    output := make([]interface{}, 0)
    for _, item := range database {
        if criteria(item) { // 使用传入的函数进行过滤
            output = append(output, item)
        }
    }
    return output
}

// 示例用法
func main() {
    // 查找名字为"John"的Person
    johns := getItemWithCriteria(func(item interface{}) bool {
        if p, ok := item.(Person); ok {
            return p.FirstName == "John"
        }
        return false
    })
    fmt.Println("Found John (via criteria):", johns) // Output: Found John (via criteria): [{John}]

    // 查找行业为"Software"的Company
    softwareCompanies := getItemWithCriteria(func(item interface{}) bool {
        if c, ok := item.(Company); ok {
            return c.Industry == "Software"
        }
        return false
    })
    fmt.Println("Found Software Companies (via criteria):", softwareCompanies) // Output: Found Software Companies (via criteria): [{Software}]
}

import (
    "fmt"
    "reflect" // 用于在运行时获取字段值
)

// 模拟数据库数据
var genericDatabase = []interface{}{
    Person{FirstName: "John"},
    Company{Industry: "Software"},
    Person{FirstName: "Jane"},
    Company{Industry: "Hardware"},
}

// GetItems 是一个泛型函数，用于从数据库中获取指定类型的数据
// T 是类型参数，any 表示可以是任何类型
// field 和 val 用于指定查询条件
func GetItems[T any](field string, val string) ([]T, error) {
    var output []T // 声明一个特定类型T的切片

    // 遍历模拟数据库
    for _, item := range genericDatabase {
        // 使用类型断言检查 item 是否可以转换为 T
        // 这是泛型内部处理异构数据源的常见模式
        if concreteItem, ok := item.(T); ok {
            // 使用反射来获取字段值，因为我们不知道T的具体类型
            // 这是一个在泛型内部处理动态字段访问的常见方法
            v := reflect.ValueOf(concreteItem)

            // 确保v是一个结构体并且字段存在
            if v.Kind() == reflect.Struct {
                fieldValue := v.FieldByName(field)
                if fieldValue.IsValid() && fieldValue.CanInterface() {
                    // 比较字段值
                    if fmt.Sprintf("%v", fieldValue.Interface()) == val {
                        output = append(output, concreteItem)
                    }
                }
            }
        }
    }
    return output, nil
}

// 示例用法
func main() {
    // 获取 FirstName 为 "John" 的 Person 类型数据
    persons, err := GetItems[Person]("FirstName", "John")
    if err != nil {
        fmt.Println("Error:", err)
    } else {
        fmt.Println("Found Persons (via generics):", persons) // Output: Found Persons (via generics): [{John}]
    }

    // 获取 Industry 为 "Software" 的 Company 类型数据
    companies, err := GetItems[Company]("Industry", "Software")
    if err != nil {
        fmt.Println("Error:", err)
    } else {
        fmt.Println("Found Companies (via generics):", companies) // Output: Found Companies (via generics): [{Software}]
    }

    // 尝试获取不存在的类型或条件
    nonExistent, err := GetItems[Person]("FirstName", "Bob")
    if err != nil {
        fmt.Println("Error:", err)
    } else {
        fmt.Println("Found Non-existent Persons:", nonExistent) // Output: Found Non-existent Persons: []
    }
}