Go语言通用数据访问策略：接口、类型断言与函数式过滤

type Person struct {
    FirstName string
    Age       int
}

type Company struct {
    Industry string
    Name     string
}

// 假设我们有一个getItems函数，能够根据类型、字段和值获取数据
// var persons []Person
// persons = getItems("Person", "FirstName", "John")

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

// 模拟一个数据源
var database = []interface{}{
    Person{FirstName: "John", Age: 30},
    Company{Industry: "Software", Name: "TechCorp"},
    Person{FirstName: "Jane", Age: 25},
    Company{Industry: "Finance", Name: "GlobalInvest"},
}

// getItems 模拟从数据库获取所有数据，并以 []interface{} 形式返回
func getItems() []interface{} {
    return database
}

// getPersons 从通用数据中筛选并返回 Person 类型的切片
func getPersons() []Person {
    slice := getItems() // 获取所有通用数据
    output := make([]Person, 0)

    for _, item := range slice {
        // 类型断言：检查 item 是否为 Person 类型
        // thing 是转换后的 Person 值，ok 表示断言是否成功
        thing, ok := item.(Person)
        if ok {
            output = append(output, thing)
        }
    }
    return output
}

// getCompanies 从通用数据中筛选并返回 Company 类型的切片
func getCompanies() []Company {
    slice := getItems() // 获取所有通用数据
    output := make([]Company, 0)

    for _, item := range slice {
        thing, ok := item.(Company)
        if ok {
            output = append(output, thing)
        }
    }
    return output
}

// getItemsByCriteria 根据传入的过滤函数从数据源中筛选数据
func getItemsByCriteria(criteria func(item interface{}) bool) []interface{} {
    output := make([]interface{}, 0)
    for _, item := range database { // 遍历模拟数据源
        if criteria(item) {
            output = append(output, item)
        }
    }
    return output
}

// 示例：获取所有 FirstName 为 "John" 的 Person
func getPersonsByFirstName(firstName string) []Person {
    // 定义一个过滤函数
    criteria := func(item interface{}) bool {
        p, ok := item.(Person) // 尝试断言为 Person
        if !ok {
            return false // 不是 Person 类型，不符合条件
        }
        return p.FirstName == firstName // 检查 FirstName
    }

    // 调用通用过滤函数
    filteredItems := getItemsByCriteria(criteria)

    // 对过滤后的结果进行类型断言和转换
    output := make([]Person, 0)
    for _, item := range filteredItems {
        p, ok := item.(Person)
        if ok {
            output = append(output, p)
        }
    }
    return output
}

// 示例：获取所有 Industry 为 "Software" 的 Company
func getCompaniesByIndustry(industry string) []Company {
    criteria := func(item interface{}) bool {
        c, ok := item.(Company) // 尝试断言为 Company
        if !ok {
            return false // 不是 Company 类型，不符合条件
        }
        return c.Industry == industry // 检查 Industry
    }

    filteredItems := getItemsByCriteria(criteria)

    output := make([]Company, 0)
    for _, item := range filteredItems {
        c, ok := item.(Company)
        if ok {
            output = append(output, c)
        }
    }
    return output
}

// Query 函数接受一个过滤条件和一个目标类型，返回符合条件的 []interface{}
// 在实际应用中，targetType 可能会通过 reflect.Type 或 Go 1.18+ 泛型来指定
func Query(criteria func(item interface{}) bool) []interface{} {
    return getItemsByCriteria(criteria) // 直接复用之前的函数
}

// GetPersonsFiltered 结合 Query 和类型断言
func GetPersonsFiltered(criteria func(item interface{}) bool) []Person {
    genericItems := Query(criteria)
    persons := make([]Person, 0)
    for _, item := range genericItems {
        if p, ok := item.(Person); ok {
            persons = append(persons, p)
        }
    }
    return persons
}

// GetCompaniesFiltered 结合 Query 和类型断言
func GetCompaniesFiltered(criteria func(item interface{}) bool) []Company {
    genericItems := Query(criteria)
    companies := make([]Company, 0)
    for _, item := range genericItems {
        if c, ok := item.(Company); ok {
            companies = append(companies, c)
        }
    }
    return companies
}

// 获取年龄大于28的Person
personsOlderThan28 := GetPersonsFiltered(func(item interface{}) bool {
    p, ok := item.(Person)
    return ok && p.Age > 28
})
// 获取行业包含"Soft"的Company
softwareCompanies := GetCompaniesFiltered(func(item interface{}) bool {
    c, ok := item.(Company)
    return ok && strings.Contains(c.Industry, "Soft")
})

// Go 1.18+ 泛型示例 (概念性)
// func Filter[T any](items []T, predicate func(T) bool) []T {
//     var result []T
//     for _, item := range items {
//         if predicate(item) {
//             result = append(result, item)
//         }
//     }
//     return result
// }
// 这种方式将大大简化上述的类型转换和断言逻辑。