如何在Golang中使用Go接口实现类似Java的功能

在Go中，可以使用接口和泛型（Go 1.18+）来实现类似Java的通用数据访问功能。以下是几种解决方案：

方案1：使用接口和类型断言

type DatabaseDocument interface {
    GetDocs() interface{}
}

type EventConfigDbDocs struct {
    Docs []EventConfiguration `json:"docs"`
}

func (e EventConfigDbDocs) GetDocs() interface{} {
    return e.Docs
}

type EventDataDbDocs struct {
    Docs []Event `json:"docs"`
}

func (e EventDataDbDocs) GetDocs() interface{} {
    return e.Docs
}

func getFromDatabase[T any](selector string, dbDoc DatabaseDocument) []T {
    // 模拟数据库查询
    // ...
    
    // 类型断言获取具体数据
    if docs, ok := dbDoc.GetDocs().([]T); ok {
        return docs
    }
    return nil
}

方案2：使用泛型（Go 1.18+）

type DbDocs[T any] struct {
    Docs []T `json:"docs"`
}

func getFromDatabase[T any](selector string) []T {
    var result DbDocs[T]
    
    // 模拟数据库查询和JSON解码
    // json.Unmarshal(data, &result)
    
    return result.Docs
}

// 使用示例
func main() {
    // 获取EventConfiguration
    eventConfigs := getFromDatabase[EventConfiguration]("event_config")
    
    // 获取Event
    events := getFromDatabase[Event]("event_data")
}

方案3：结合接口和泛型的完整示例

package main

import (
    "encoding/json"
    "fmt"
)

type DatabaseQuery interface {
    Query(selector string) ([]byte, error)
}

type EventConfiguration struct {
    ID   string `json:"id"`
    Name string `json:"name"`
}

type Event struct {
    ID        string `json:"id"`
    Timestamp int64  `json:"timestamp"`
}

type DbResponse[T any] struct {
    Docs []T `json:"docs"`
}

func getGenericData[T any](db DatabaseQuery, selector string) ([]T, error) {
    data, err := db.Query(selector)
    if err != nil {
        return nil, err
    }
    
    var response DbResponse[T]
    if err := json.Unmarshal(data, &response); err != nil {
        return nil, err
    }
    
    return response.Docs, nil
}

// 模拟数据库实现
type MockDatabase struct{}

func (m MockDatabase) Query(selector string) ([]byte, error) {
    // 根据selector返回不同的模拟数据
    if selector == "event_config" {
        return json.Marshal(DbResponse[EventConfiguration]{
            Docs: []EventConfiguration{
                {ID: "1", Name: "Config1"},
                {ID: "2", Name: "Config2"},
            },
        })
    }
    
    return json.Marshal(DbResponse[Event]{
        Docs: []Event{
            {ID: "1", Timestamp: 1234567890},
            {ID: "2", Timestamp: 1234567891},
        },
    })
}

func main() {
    db := MockDatabase{}
    
    // 获取EventConfiguration
    configs, _ := getGenericData[EventConfiguration](db, "event_config")
    fmt.Printf("Configs: %+v\n", configs)
    
    // 获取Event
    events, _ := getGenericData[Event](db, "event_data")
    fmt.Printf("Events: %+v\n", events)
}

方案4：使用反射（灵活性最高）

import (
    "encoding/json"
    "reflect"
)

func getData(selector string, result interface{}) error {
    // 根据selector查询数据库
    var data []byte
    // ... 数据库查询逻辑
    
    // 使用反射处理不同类型
    v := reflect.ValueOf(result)
    if v.Kind() != reflect.Ptr || v.Elem().Kind() != reflect.Struct {
        return fmt.Errorf("result must be a pointer to struct")
    }
    
    // 创建临时结构体来解析
    temp := struct {
        Docs json.RawMessage `json:"docs"`
    }{}
    
    if err := json.Unmarshal(data, &temp); err != nil {
        return err
    }
    
    // 解码到具体的Docs字段
    docsField := v.Elem().FieldByName("Docs")
    if !docsField.IsValid() {
        return fmt.Errorf("struct has no Docs field")
    }
    
    return json.Unmarshal(temp.Docs, docsField.Addr().Interface())
}

// 使用示例
func exampleUsage() {
    var configDocs EventConfigDbDocs
    getData("event_config", &configDocs)
    
    var eventDocs EventDataDbDocs
    getData("event_data", &eventDocs)
}

推荐使用方案2的泛型方法，它提供了类型安全且代码简洁。如果项目使用Go 1.18以下版本，可以使用方案1的接口方法。