Golang 反射实战：原理、性能优化与中间件应用详解

func Sprint(x interface{}) string {
    type stringer interface {
        String() string
    }
    switch x := x.(type) {
    case stringer:
        return x.String()
    case string:
        return x
    case int:
        return strconv.Itoa(x)
    // ... 其他类型需逐个添加
    default:
        return "wrong parameter type"
    }
}

func NewUserInfoByReflect(req interface{}) *UserInfo {
    if req == nil {
        return nil
    }
    reqType := reflect.TypeOf(req)
    // 如果是指针类型，取消引用获取基础类型
    if reqType.Kind() == reflect.Ptr {
        reqType = reqType.Elem()
    }
    // reflect.New 创建一个指向新零值的指针
    return reflect.New(reqType).Interface().(*UserInfo)
}

func FilterOkrRespData(reqData interface{}, objId int64) {
    rv := reflect.ValueOf(reqData).Elem()
    for i := 0; i < rv.NumField(); i++ {
        fieldValue := rv.Field(i)
        if fieldValue.Kind() != reflect.Slice {
            continue
        }
        // 获取 Slice 的元素类型（例如 []*ObjInfo）
        sliceType := fieldValue.Type().Elem()
        
        // 创建新的空 Slice
        newSlice := reflect.MakeSlice(reflect.SliceOf(sliceType), 0, 0)
        
        // 遍历原 Slice，保留符合条件的元素
        for j := 0; j < fieldValue.Len(); j++ {
            item := fieldValue.Index(j).Elem() // 获取当前元素的 struct 值
            // 假设我们需要过滤 ObjId == objId 的项
            objIdVal := item.FieldByName("ObjId").Int()
            if objIdVal == objId {
                newSlice = reflect.Append(newSlice, fieldValue.Index(j))
            }
        }
        // 将过滤后的结果写回原结构体字段
        fieldValue.Set(newSlice)
    }
}

func ModifyOkrDetailRespData(req interface{}) {
    reqValue := reflect.ValueOf(req).Elem()
    // 检查是否可设置
    fmt.Println(reqValue.CanSet())
    
    // 获取 UInfo 字段的类型
    uType := reqValue.FieldByName("UInfo").Type().Elem()
    
    // 创建一个新的 UserInfo 实例
    uInfo := reflect.New(uType)
    
    // 使用索引访问字段以提高性能（假设为第1个字段）
    reqValue.Field(1).Set(uInfo)
}

// 反射方式
tf = reflect.New(t).Interface().(*TestReflectField)
// 直接方式
tf = new(TestReflectField)

func OkrBaseMW(next endpoint.EndPoint) endpoint.EndPoint {
    return func(ctx context.Context, req interface{}) (resp interface{}, err error) {
        requestValue := reflect.ValueOf(req)
        if requestValue.IsNil() {
            return next(ctx, req)
        }
        
        // 处理指针解引用
        kind := requestValue.Type().Kind()
        if kind == reflect.Ptr {
            requestValue = requestValue.Elem()
        }
        
        // 必须是结构体才能继续
        if requestValue.Kind() != reflect.Struct {
            return next(ctx, req)
        }
        
        // 提取 OkrBase 字段
        okrBaseField := requestValue.FieldByName("OkrBase")
        if !okrBaseField.IsValid() {
            return next(ctx, req)
        }
        
        // 尝试转换为具体类型并注入上下文
        if okr, ok := okrBaseField.Interface().(*okrx.OkrBase); ok && okr != nil {
            ctx = contextWithUserInfo(ctx, okr)
            ctx = contextWithLocaleInfo(ctx, okr)
            // ... 其他 Context 注入逻辑
        }
        
        return next(ctx, req)
    }
}