Go语言中如何正确访问接口类型（interface{}）的底层结构体字段

package search

import (
    "encoding/json"
    "fmt"
    "net/http"
)

// SearchItemsByUser 函数解码JSON数据并返回一个interface{}类型的值
func SearchItemsByUser(body []byte) interface{} { // 假设body是已读取的请求体

    type results struct { // results结构体定义在函数内部
        Hits             interface{} // 简化处理
        NbHits           int
        NbPages          int
        HitsPerPage      int
        ProcessingTimeMS int
        Query            string
        Params           string
    }

    var Result results

    er := json.Unmarshal(body, &Result)
    if er != nil {
        fmt.Println("error:", er)
    }
    return Result
}

func test(w http.ResponseWriter, r *http.Request) {
    // 假设r.Body已被读取并转换为[]byte，这里仅作示意
    dummyBody := []byte(`{"Hits":{},"NbHits":10,"NbPages":1,"HitsPerPage":10,"ProcessingTimeMS":50,"Query":"test","Params":"some_params"}`)
    result := SearchItemsByUser(dummyBody) // result的类型是interface{}

    // 尝试直接访问字段，这将导致编译错误
    // fmt.Fprintf(w, "%s", result.Params) // 编译错误：result.Params undefined (type interface {} has no field Params)
}

package main

import (
    "encoding/json"
    "fmt"
    "net/http"
)

// 定义在包级别，以便其他函数或包可以引用
type MySearchResults struct {
    Hits             interface{}
    NbHits           int
    NbPages          int
    HitsPerPage      int
    ProcessingTimeMS int
    Query            string
    Params           string
}

func SearchItemsByUser(body []byte) interface{} { // 仍然返回interface{}
    var result MySearchResults
    er := json.Unmarshal(body, &result)
    if er != nil {
        fmt.Println("error:", er)
    }
    return result
}

func testHandler(w http.ResponseWriter, r *http.Request) {
    dummyBody := []byte(`{"Hits":{},"NbHits":10,"NbPages":1,"HitsPerPage":10,"ProcessingTimeMS":50,"Query":"test","Params":"some_params_via_assertion"}`)
    resultInterface := SearchItemsByUser(dummyBody) // 类型为 interface{}

    // 使用类型断言将 interface{} 转换为 MySearchResults
    // 这是一个安全的类型断言，会返回两个值：转换后的值和是否成功的布尔值
    if concreteResult, ok := resultInterface.(MySearchResults); ok {
        fmt.Fprintf(w, "Params (via assertion): %s\n", concreteResult.Params)
        fmt.Fprintf(w, "Query (via assertion): %s\n", concreteResult.Query)
    } else {
        // 如果断言失败，说明底层类型不是 MySearchResults
        fmt.Fprintf(w, "Error: Could not assert type to MySearchResults\n")
    }
}

// 示例：模拟HTTP服务器
func main() {
    http.HandleFunc("/test", testHandler)
    fmt.Println("Server listening on :8080/test")
    // http.ListenAndServe(":8080", nil) // 实际运行时取消注释
}

package search // 假设这是 search 包

import (
    "encoding/json"
    "fmt"
    // "net/http" // 如果 SearchItemsByUser 不直接处理 http.Request，可以移除
)

// MySearchResults 定义在包级别，且首字母大写，可被其他包访问
type MySearchResults struct {
    Hits             interface{}
    NbHits           int
    NbPages          int
    HitsPerPage      int
    ProcessingTimeMS int
    Query            string
    Params           string
}

// SearchItemsByUser 函数现在直接返回 MySearchResults 类型
func SearchItemsByUser(body []byte) MySearchResults {
    var result MySearchResults
    er := json.Unmarshal(body, &result)
    if er != nil {
        fmt.Println("error:", er)
    }
    return result
}

// 修改前: func SearchItemsByUser(body []byte) interface{}
// 修改后: func SearchItemsByUser(body []byte) MySearchResults

package main

import (
    "fmt"
    "net/http"
    "your_module_path/search" // 假设 search 包在你的模块路径下
)

func testHandler(w http.ResponseWriter, r *http.Request) {
    dummyBody := []byte(`{"Hits":{},"NbHits":10,"NbPages":1,"HitsPerPage":10,"ProcessingTimeMS":50,"Query":"test","Params":"some_params_direct"}`)

    // 直接接收 MySearchResults 类型
    concreteResult := search.SearchItemsByUser(dummyBody) 

    // 直接访问字段，编译器会进行类型检查
    fmt.Fprintf(w, "Params (direct access): %s\n", concreteResult.Params)
    fmt.Fprintf(w, "Query (direct access): %s\n", concreteResult.Query)
}

// 示例：模拟HTTP服务器
func main() {
    http.HandleFunc("/test", testHandler)
    fmt.Println("Server listening on :8080/test")
    // http.ListenAndServe(":8080", nil) // 实际运行时取消注释
}