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

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

// 期望的通用函数签名
// getItems(typ string, field string, val string) ([]interface{})

// 假设这是从数据库中获取所有数据的通用函数，返回 []interface{}
// 实际实现会根据 typ, field, val 进行过滤
func getItems(typ string, field string, val string) []interface{} {
    // 模拟数据库查询逻辑
    var allData []interface{}
    if typ == "Person" {
        if field == "FirstName" && val == "John" {
            allData = append(allData, Person{FirstName: "John"})
        }
        allData = append(allData, Person{FirstName: "Alice"})
    } else if typ == "Company" {
        if field == "Industry" && val == "Software" {
            allData = append(allData, Company{Industry: "Software"})
        }
        allData = append(allData, Company{Industry: "Finance"})
    }
    return allData
}

// getPersons 封装了类型断言，将通用结果转换为 []Person
func getPersons(field string, val string) []Person {
    // 调用通用获取函数，获取 []interface{}
    slice := getItems("Person", field, val)
    output := make([]Person, 0, len(slice)) // 预分配容量

    for _, item := range slice {
        // 类型断言：尝试将 item 转换为 Person 类型
        p, ok := item.(Person)
        if ok {
            output = append(output, p)
        }
    }
    return output
}

// 示例用法
func main() {
    var persons []Person
    persons = getPersons("FirstName", "John")
    fmt.Printf("Persons named John: %+v\n", persons) // 输出：Persons named John: [{FirstName:John}]

    // 同样可以为 Company 类型编写 getCompanies 函数
    // var companies []Company
    // companies = getCompanies("Industry", "Software")
}

// getItemByCriteria 接受一个条件函数，根据该函数过滤数据
func getItemByCriteria(criteria func(interface{}) bool) []interface{} {
    output := make([]interface{}, 0)
    // 模拟从一个“数据库”中遍历所有数据
    // 实际应用中，这里会是数据库查询结果的迭代
    databaseItems := []interface{}{
        Person{FirstName: "John"},
        Company{Industry: "Software"},
        Person{FirstName: "Alice"},
        Company{Industry: "Finance"},
    }

    for _, item := range databaseItems {
        if criteria(item) { // 如果满足条件，则添加到结果中
            output = append(output, item)
        }
    }
    return output
}

// 示例用法
func main() {
    // 定义一个条件函数：查找 FirstName 为 "John" 的 Person
    isPersonNamedJohn := func(item interface{}) bool {
        p, ok := item.(Person) // 尝试断言为 Person
        return ok && p.FirstName == "John"
    }

    // 使用高阶函数进行查询
    johns := getItemByCriteria(isPersonNamedJohn)
    fmt.Printf("Found items matching criteria (John): %+v\n", johns) // 输出：Found items matching criteria (John): [{FirstName:John}]

    // 定义另一个条件函数：查找 Industry 为 "Software" 的 Company
    isCompanyInSoftware := func(item interface{}) bool {
        c, ok := item.(Company) // 尝试断言为 Company
        return ok && c.Industry == "Software"
    }

    softwareCompanies := getItemByCriteria(isCompanyInSoftware)
    fmt.Printf("Found items matching criteria (Software Company): %+v\n", softwareCompanies) // 输出：Found items matching criteria (Software Company): [{Industry:Software}]
}

// AdvancedGetItems 结合了字段匹配和自定义条件函数
// fieldName 和 fieldValue 用于常见的相等匹配，criteriaFunc 提供更复杂的过滤逻辑
func AdvancedGetItems(typ string, fieldName string, fieldValue string, criteriaFunc func(interface{}) bool) []interface{} {
    output := make([]interface{}, 0)
    // 模拟数据库中的所有数据
    databaseItems := []interface{}{
        Person{FirstName: "John"},
        Company{Industry: "Software"},
        Person{FirstName: "Alice"},
        Company{Industry: "Finance"},
        Person{FirstName: "John"}, // 增加一个重复项
    }

    for _, item := range databaseItems {
        // 首先根据 typ 进行初步过滤 (如果需要，实际数据库查询会更复杂)
        // 这里简化为模拟
        typeMatches := false
        if typ == "Person" {
            _, ok := item.(Person)
            typeMatches = ok
        } else if typ == "Company" {
            _, ok := item.(Company)
            typeMatches = ok
        }

        if !typeMatches {
            continue
        }

        // 其次，检查字段和值匹配（如果提供了 fieldName 和 fieldValue）
        fieldMatches := true
        if fieldName != "" && fieldValue != "" {
            // 这里需要使用反射来动态访问字段，或者在外部处理
            // 为简化示例，这里只做概念性说明，实际实现会更复杂
            // 假设我们有一个机制可以根据 fieldName 检查 fieldValue
            if typ == "Person" {
                if p, ok := item.(Person); ok && fieldName == "FirstName" && p.FirstName != fieldValue {
                    fieldMatches = false
                }
            } else if typ == "Company" {
                if c, ok := item.(Company); ok && fieldName == "Industry" && c.Industry != fieldValue {
                    fieldMatches = false
                }
            }
        }

        if !fieldMatches {
            continue
        }

        // 最后，应用自定义条件函数（如果提供了）
        if criteriaFunc == nil || criteriaFunc(item) {
            output = append(output, item)
        }
    }
    return output
}

// getPersonsWithAdvancedQuery 封装了 AdvancedGetItems 并进行类型断言
func getPersonsWithAdvancedQuery(firstName string, age int) []Person {
    // 示例：查找 FirstName 为 "John" 且年龄大于 30 的 Person
    // 这里我们只演示 FirstName，年龄需要 Person 结构体有 Age 字段
    // 为了匹配示例，我们假设 Person 结构体只有 FirstName
    criteria := func(item interface{}) bool {
        p, ok := item.(Person)
        // 假设 Person 结构体有 Age 字段，并且我们想过滤 age > 30
        // if ok && p.FirstName == firstName && p.Age > age {
        //     return true
        // }
        // 简化为只匹配 FirstName
        return ok && p.FirstName == firstName
    }

    // 调用 AdvancedGetItems，并传入类型、字段值和自定义条件
    // 注意：这里的 fieldName 和 fieldValue 在 criteria 中已处理，可以留空
    // 或者用于初步过滤，criteria 做更复杂的过滤
    genericResults := AdvancedGetItems("Person", "", "", criteria)

    persons := make([]Person, 0, len(genericResults))
    for _, item := range genericResults {
        if p, ok := item.(Person); ok {
            persons = append(persons, p)
        }
    }
    return persons
}

func main() {
    // 使用结合策略的示例
    johns := getPersonsWithAdvancedQuery("John", 30) // 这里的 30 只是示例，实际取决于 Person 结构
    fmt.Printf("Persons matching advanced query (John): %+v\n", johns)
    // 预期输出: Persons matching advanced query (John): [{FirstName:John} {FirstName:John}]
}