golang封装回调函数调用为after

Question

services.go

type TokenHandler func(req interface{}, token_detail *TokenDetail) (interface{}, error)

//工会管理Token内容中间件处理
func WithTokenAccountValidation(handler TokenHandler) TokenHandler {
    return func(req interface{}, token *TokenDetail) (interface{}, error) {
        token_detail, err := tools.ParseToken((*token).Token)
        if err != nil {
            return nil, err
        }
 
        (*token).TokenDetail = token_detail
        return handler(req, token)
    }
}
 
调用:
    wrapped_handler := func(req interface{}, token *services.TokenDetail) (resp interface{}, err error) {
        req_params, ok := req.(*iapi.UserStreamerListReq)
        if !ok {
            return nil, fmt.Errorf("转换类型错误")
        }
 
        resp, err = user_streamer_obj.UserStreamerList(req_params, *token)
        return
    }
 
    resp,err = services.WithTokenAccountValidation(wrapped_handler)(req,&(services.TokenDetail{Token:&authorization}))
 
 
我想把这段代码封装为一个after，这样我只需要调用一个after传入参数就可以了，不用这么长的调用
 resp,err = services.WithTokenAccountValidation(wrapped_handler)(req,&(services.TokenDetail{Token:&authorization}))

Answer 1

下午好🌅🌅🌅
本答案参考通义千问

要将这段代码封装为一个 after_ 的调用方式，你可以在 services.go 中定义一个新的函数（如 AfterTokenAccountValidation），该函数接受参数并自动执行 WithTokenAccountValidation 的逻辑，从而简化调用方式。

---

✅ 目标

你希望将：

resp, err = services.WithTokenAccountValidation(wrapped_handler)(req, &(services.TokenDetail{Token: &authorization}))

简化为：

resp, err = services.AfterTokenAccountValidation(req, authorization)

---

🛠️ 解决方案

1. 定义 AfterTokenAccountValidation 函数

   这个函数将接收 req 和 token 参数，并自动创建 TokenDetail 对象，然后调用 WithTokenAccountValidation。

2. 在 services.go 中添加以下函数：

// AfterTokenAccountValidation 是一个封装后的调用函数，简化了 WithTokenAccountValidation 的使用
func AfterTokenAccountValidation(req interface{}, token string) (interface{}, error) {
    // 创建 TokenDetail 实例
    tokenDetail := &TokenDetail{
        Token: &token,
    }

    // 定义 wrapped_handler 作为 TokenHandler 类型的函数
    wrappedHandler := func(req interface{}, token *TokenDetail) (interface{}, error) {
        reqParams, ok := req.(*iapi.UserStreamerListReq)
        if !ok {
            return nil, fmt.Errorf("转换类型错误")
        }

        resp, err := user_streamer_obj.UserStreamerList(reqParams, *token)
        return resp, err
    }

    // 使用 WithTokenAccountValidation 包装 handler 并执行
    handler := WithTokenAccountValidation(wrappedHandler)
    return handler(req, tokenDetail)
}

1. 调用方式变为：

resp, err := services.AfterTokenAccountValidation(req, authorization)

---

🔍 说明

• AfterTokenAccountValidation 是一个封装函数，它内部处理了 TokenDetail 的构建和 wrapped_handler 的定义。
• WithTokenAccountValidation 被封装在 AfterTokenAccountValidation 内部，无需手动调用。
• 你只需要传入 req 和 token 即可完成整个流程。

---

⚠️ 注意事项

• 确保 user_streamer_obj 已经被正确初始化。
• 确保 TokenDetail 结构体和 ParseToken 函数已正确定义。
• 如果 TokenDetail 的结构有变化，请相应调整构造逻辑。

---

✅ 示例代码总结

// services.go

type TokenHandler func(req interface{}, token_detail *TokenDetail) (interface{}, error)

// 工会管理Token内容中间件处理
func WithTokenAccountValidation(handler TokenHandler) TokenHandler {
    return func(req interface{}, token *TokenDetail) (interface{}, error) {
        token_detail, err := tools.ParseToken((*token).Token)
        if err != nil {
            return nil, err
        }

        (*token).TokenDetail = token_detail
        return handler(req, token)
    }
}

// AfterTokenAccountValidation 封装调用逻辑
func AfterTokenAccountValidation(req interface{}, token string) (interface{}, error) {
    tokenDetail := &TokenDetail{
        Token: &token,
    }

    wrappedHandler := func(req interface{}, token *TokenDetail) (interface{}, error) {
        reqParams, ok := req.(*iapi.UserStreamerListReq)
        if !ok {
            return nil, fmt.Errorf("转换类型错误")
        }

        resp, err := user_streamer_obj.UserStreamerList(reqParams, *token)
        return resp, err
    }

    handler := WithTokenAccountValidation(wrappedHandler)
    return handler(req, tokenDetail)
}

---

✅ 最终调用方式

resp, err := services.AfterTokenAccountValidation(req, authorization)

这样就实现了你想要的“after_”式调用，使代码更简洁、易维护。