go - 如何在 Golang 中重新输入一个函数？

Question

在我当前的 Golang 项目中，我在将日志发送到我的日志库中的 Elasticsearch 之前使用日志缓冲。我想引入类似 C atexit() 函数的东西，以在意外退出时刷新所有待处理的日志。

我找到了 atexit库，但在我的例子中它是不够的，因为它不允许将参数传递给处理函数。我决定编写我的版本并以大致相似的结构结束。我有模块 atexit:

package atexit

import (
    "fmt"
    "os"
    "reflect"
)

var handlers []interface{}
var params []interface{}

func runHandler(handler interface{}, p interface{}) {
    defer func() {
        if err := recover(); err != nil {
            fmt.Fprintln(os.Stderr, "error: atexit handler error:", err)
        }
    }()

    f := reflect.ValueOf(handler)
    s := reflectSlice(p)
    fmt.Printf("%#v", s)
    f.Call(s)
}

func reflectSlice(slice interface{}) []reflect.Value {
    s := reflect.ValueOf(slice)
    if s.Kind() != reflect.Slice {
        panic("InterfaceSlice() given a non-slice type")
    }

    ret := make([]reflect.Value, s.Len())

    for i:=0; i<s.Len(); i++ {
        ret[i] = reflect.ValueOf(s.Index(i))
    }

    return ret
}

func runHandlers() {
    for i, handler := range handlers {
        runHandler(handler, params[i])
    }
}

func Exit(code int) {
    runHandlers()
    os.Exit(code)
}

func Register(handler interface{}, p interface{}) {
    f := reflect.TypeOf(handler)
    if f.Kind() != reflect.Func {
        panic("Register() given a non-function type")
    }
    handlers = append(handlers, handler)
    params = append(params, p)
}

我从主程序中调用它:

package main
import (
    "fmt"
    "./atexit"
    "encoding/json"
    "reflect"
)

type Batch struct {
    Index string        `json:"index"`
    Type string     `json:"_Type"`
    Content interface{} `json:"Content"`
}

func flush(b ...interface{}) {
    for _, entry := range(b) {
        fmt.Printf("%#v\n", entry)
        fmt.Println(reflect.TypeOf(reflect.ValueOf(entry)))
        fmt.Println(reflect.TypeOf(entry))
        a, err  := json.Marshal(entry)
        if err != nil {
            fmt.Println("error!")
        }
        fmt.Println(string(a))
    }
}

func handler(v ...interface{}) {
    fmt.Println("Exiting")
    for _, batch := range(v) {
        fmt.Printf("%#v\n", batch)
    }
}

func main() {
    type ColorGroup struct {
        ID     int
        Name   string
        Colors []string
    }
    group := ColorGroup{
        ID:     1,
        Name:   "Reds",
        Colors: []string{"Crimson", "Red", "Ruby", "Maroon"},
    }
    fmt.Printf("%#v\n", group)
    r, err := json.Marshal(group)
    if err != nil {
        fmt.Println("error:", err)
    }
    fmt.Println(string(r))


    b := []Batch{Batch{"index", "type", "content1"},Batch{"index", "type", "content2"}}
    atexit.Register(handler, b)
    atexit.Register(flush, []ColorGroup{group})
    atexit.Exit(0)
}

如您所见，通过调用 reflect.ValueOf()，我得到结构 reflect.Value，然后将其传递给回调函数。问题似乎是此结构不包含有关 json 导出的元数据或未使用 json.Marshal() 正确处理，然后输出空 json。有什么方法可以将正确的 []interface{} 结构传递给回调函数或一些类似的机制，这些机制可以大致完成我想要完成的任务？请注意，我想要一个通用的回调机制，它应该独立于传递给它的类型。到目前为止，这似乎是不可能的，或者至少受到 f.Call(s) 的限制，它在 runHandler() 中调用，并以 reflect.Value 作为参数。

Answer 1

你不应该为此使用反射。你应该让你的处理程序成为 func() 类型，然后传入一个匿名函数(可能是一个闭包)来直接处理任何必要的参数。示例:

atexit.Register(func() {
    handler(b)
})