Golang反射实现通用验证函数方法-Golang-PHP中文网

Golang反射实现通用验证函数方法

P粉602998670

发布： 2025-09-14 09:51:01

原创

647人浏览过

答案：通过反射递归处理嵌套结构体并支持自定义规则。使用reflect遍历字段，遇struct则递归验证；扩展Validate函数添加新规则如email，结合策略模式将验证逻辑模块化，提升可维护性。

golang反射实现通用验证函数方法

Golang反射实现通用验证函数方法，核心在于利用反射机制动态地检查结构体字段的类型和值，并根据预定义的规则进行验证。这种方法可以减少重复代码，提高代码的可维护性和灵活性。

解决方案

首先，我们需要定义一个验证规则的结构体，用于存储字段名、验证类型（如required、minLength、maxLength等）以及相关参数。然后，编写一个通用的验证函数，该函数接收一个结构体实例作为参数，并使用反射获取结构体的类型信息和字段值。

接下来，遍历结构体的每个字段，检查是否存在验证规则。如果存在，则根据验证类型执行相应的验证逻辑。例如，如果验证类型是“required”，则检查字段值是否为空；如果验证类型是“minLength”，则检查字段值的长度是否小于指定的最小值。

立即学习“go语言免费学习笔记（深入）”；

最后，将验证结果返回。如果所有字段都通过验证，则返回true；否则，返回false，并附带错误信息。

package main

import (
    "fmt"
    "reflect"
    "strings"
)

// 验证规则结构体
type ValidationRule struct {
    Field   string
    Type    string
    Params  map[string]interface{}
    Message string
}

// 通用验证函数
func Validate(obj interface{}, rules []ValidationRule) (bool, map[string]string) {
    val := reflect.ValueOf(obj)
    if val.Kind() == reflect.Ptr {
        val = val.Elem()
    }

    if val.Kind() != reflect.Struct {
        return false, map[string]string{"error": "Only struct can be validated"}
    }

    typeOfT := val.Type()
    errors := make(map[string]string)

    for _, rule := range rules {
        fieldVal := val.FieldByName(rule.Field)
        if !fieldVal.IsValid() {
            errors[rule.Field] = fmt.Sprintf("Field %s is invalid", rule.Field)
            continue
        }

        fieldKind := fieldVal.Kind()

        switch rule.Type {
        case "required":
            if isEmpty(fieldVal) {
                errors[rule.Field] = rule.Message
            }
        case "minLength":
            minLen, ok := rule.Params["length"].(int)
            if !ok {
                errors[rule.Field] = "minLength rule requires 'length' parameter"
                continue
            }

            switch fieldKind {
            case reflect.String:
                if fieldVal.Len() < minLen {
                    errors[rule.Field] = rule.Message
                }
            default:
                errors[rule.Field] = fmt.Sprintf("minLength rule can only be applied to string fields, got %s", fieldKind)
            }
        }
    }

    return len(errors) == 0, errors
}

// 检查字段是否为空
func isEmpty(field reflect.Value) bool {
    switch field.Kind() {
    case reflect.String:
        return strings.TrimSpace(field.String()) == ""
    case reflect.Int, reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64:
        return field.Int() == 0
    case reflect.Uint, reflect.Uint8, reflect.Uint16, reflect.Uint32, reflect.Uint64:
        return field.Uint() == 0
    case reflect.Float32, reflect.Float64:
        return field.Float() == 0.0
    case reflect.Bool:
        return !field.Bool()
    case reflect.Ptr, reflect.Interface:
        return field.IsNil()
    }
    return false
}

type User struct {
    Name     string `validate:"required"`
    Age      int    `validate:"min=18"`
    Email    string
    Password string
}

func main() {
    user := User{
        Name:     "",
        Age:      15,
        Email:    "test@example.com",
        Password: "password",
    }

    rules := []ValidationRule{
        {
            Field:   "Name",
            Type:    "required",
            Message: "Name is required",
        },
        {
            Field:   "Password", // 密码字段
            Type:    "required", // 不能为空
            Message: "Password is required",
        },
        {
            Field:   "Name",
            Type:    "minLength",
            Params: map[string]interface{}{
                "length": 3,
            },
            Message: "Name must be at least 3 characters long",
        },
    }

    isValid, errors := Validate(user, rules)

    if isValid {
        fmt.Println("Validation passed!")
    } else {
        fmt.Println("Validation failed:")
        for field, err := range errors {
            fmt.Printf("%s: %s\n", field, err)
        }
    }
}

登录后复制

如何处理嵌套结构体的验证？