Golang中PATCH请求单字段验证的最优实现方案问询

问题背景 #

给定Golang的Talent结构体定义：

type Talent struct {
    Code               string   `json:"code" gorm:"type:varchar(10);not null"`
    FirstName          string   `json:"firstName" example:"Ravi" gorm:"type:varchar(50)"`
    LastName           string   `json:"lastName" example:"Sharma" gorm:"type:varchar(50)"`
    Email              string   `json:"email" example:"john@doe.com" gorm:"type:varchar(100)"`
    Contact            string   `json:"contact" example:"1234567890" gorm:"type:varchar(15)"`
    AcademicYear       *uint8   `json:"academicYear" example:"1" gorm:"type:tinyint(2)"`
    Type               *uint8   `json:"talentType" example:"4" gorm:"type:tinyint(2)"`
    Resume             *string  `json:"resume" gorm:"type:varchar(200)"`
    ExperienceInMonths *uint    `json:"experienceInMonths"`
    Image              *string  `json:"image" gorm:"type:varchar(200)"`
    Gender             *string  `json:"gender" gorm:"type:varchar(50)"`
    DateOfBirth        *string  `json:"dateOfBirth" gorm:"type:date"`
}

需求为：通过PATCH请求每次仅更新单个字段，后端将JSON解析为Talent结构体后，仅目标字段有有效值（其余为nil或空），需对该字段执行非空、最大长度等校验，且不想用switch-case实现，寻求更优方案。

优化方案 #

1. 反射+自定义结构体标签 #

给结构体字段添加校验规则的自定义标签，通过反射遍历结构体，定位被设置的字段，取出标签规则执行校验。

首先给Talent结构体补充校验标签：

type Talent struct {
    Code               string   `json:"code" gorm:"type:varchar(10);not null" validate:"required,max=10"`
    FirstName          string   `json:"firstName" example:"Ravi" gorm:"type:varchar(50)" validate:"required,max=50"`
    LastName           string   `json:"lastName" example:"Sharma" gorm:"type:varchar(50)" validate:"required,max=50"`
    Email              string   `json:"email" example:"john@doe.com" gorm:"type:varchar(100)" validate:"required,max=100,email"`
    Contact            string   `json:"contact" example:"1234567890" gorm:"type:varchar(15)" validate:"required,max=15"`
    AcademicYear       *uint8   `json:"academicYear" example:"1" gorm:"type:tinyint(2)" validate:"required,min=1,max=5"`
    Type               *uint8   `json:"talentType" example:"4" gorm:"type:tinyint(2)" validate:"required,min=1,max=4"`
    Resume             *string  `json:"resume" gorm:"type:varchar(200)" validate:"max=200"`
    ExperienceInMonths *uint    `json:"experienceInMonths" validate:"min=0"`
    Image              *string  `json:"image" gorm:"type:varchar(200)" validate:"max=200"`
    Gender             *string  `json:"gender" gorm:"type:varchar(50)" validate:"max=50"`
    DateOfBirth        *string  `json:"dateOfBirth" gorm:"type:date" validate:"required,date"`
}

然后实现校验逻辑：

import (
    "fmt"
    "reflect"
    "strconv"
    "strings"
    "time"
)

func ValidatePatchTalent(t *Talent) error {
    val := reflect.ValueOf(t).Elem()
    typ := val.Type()

    for i := 0; i < val.NumField(); i++ {
        field := val.Field(i)
        fieldType := typ.Field(i)

        // 判断字段是否被客户端设置
        isSet := false
        switch field.Kind() {
        case reflect.String:
            isSet = field.String() != ""
        case reflect.Ptr:
            isSet = !field.IsNil()
        }

        if isSet {
            validateTag := fieldType.Tag.Get("validate")
            if err := executeValidation(field.Interface(), validateTag); err != nil {
                return fmt.Errorf("invalid %s: %w", fieldType.Tag.Get("json"), err)
            }
            // PATCH仅更新单个字段，找到后直接返回
            return nil
        }
    }
    return fmt.Errorf("no field provided for update")
}

// 根据校验标签执行对应规则校验
func executeValidation(value interface{}, tag string) error {
    rules := strings.Split(tag, ",")
    for _, rule := range rules {
        switch {
        case rule == "required":
            switch v := value.(type) {
            case string:
                if v == "" {
                    return fmt.Errorf("cannot be empty")
                }
            case *uint8, *uint, *string:
                if v == nil {
                    return fmt.Errorf("cannot be nil")
                }
            }
        case strings.HasPrefix(rule, "max="):
            maxVal, err := strconv.Atoi(strings.TrimPrefix(rule, "max="))
            if err != nil {
                return fmt.Errorf("invalid max rule")
            }
            switch v := value.(type) {
            case string:
                if len(v) > maxVal {
                    return fmt.Errorf("length cannot exceed %d", maxVal)
                }
            case uint8:
                if uint(v) > uint(maxVal) {
                    return fmt.Errorf("value cannot exceed %d", maxVal)
                }
            case uint:
                if v > uint(maxVal) {
                    return fmt.Errorf("value cannot exceed %d", maxVal)
                }
            }
        case strings.HasPrefix(rule, "min="):
            minVal, err := strconv.Atoi(strings.TrimPrefix(rule, "min="))
            if err != nil {
                return fmt.Errorf("invalid min rule")
            }
            switch v := value.(type) {
            case uint8:
                if uint(v) < uint(minVal) {
                    return fmt.Errorf("value cannot be less than %d", minVal)
                }
            case uint:
                if v < uint(minVal) {
                    return fmt.Errorf("value cannot be less than %d", minVal)
                }
            }
        case rule == "email":
            s, ok := value.(string)
            if !ok {
                return fmt.Errorf("invalid email type")
            }
            if !strings.Contains(s, "@") || !strings.Contains(s, ".") {
                return fmt.Errorf("invalid email format")
            }
        case rule == "date":
            s, ok := value.(string)
            if !ok {
                return fmt.Errorf("invalid date type")
            }
            if _, err := time.Parse("2006-01-02", s); err != nil {
                return fmt.Errorf("invalid date format (expected YYYY-MM-DD)")
            }
        }
    }
    return nil
}

2. 第三方校验库+字段追踪 #

使用go-playground/validator这类成熟校验库，同时通过自定义JSON解析器追踪被提交的字段，仅对这些字段执行校验。

示例实现：

import (
    "encoding/json"
    "fmt"
    "reflect"
    "github.com/go-playground/validator/v10"
)

type Talent struct {
    Code               string   `json:"code" validate:"required,max=10"`
    FirstName          string   `json:"firstName" validate:"required,max=50"`
    LastName           string   `json:"lastName" validate:"required,max=50"`
    // 其他字段同之前的校验标签定义...
    UpdatedFields []string `json:"-"` // 记录被提交的字段名
}

// 自定义JSON解析，追踪被设置的字段
func (t *Talent) UnmarshalJSON(data []byte) error {
    type tempTalent Talent
    var temp tempTalent
    if err := json.Unmarshal(data, &temp); err != nil {
        return err
    }

    val := reflect.ValueOf(&temp).Elem()
    typ := val.Type()

    for i := 0; i < val.NumField(); i++ {
        field := val.Field(i)
        fieldType := typ.Field(i)
        jsonTag := fieldType.Tag.Get("json")
        if jsonTag == "" {
            jsonTag = fieldType.Name
        }

        isSet := false
        switch field.Kind() {
        case reflect.String:
            isSet = field.String() != ""
        case reflect.Ptr:
            isSet = !field.IsNil()
        }

        if isSet {
            t.UpdatedFields = append(t.UpdatedFields, jsonTag)
        }
    }

    *t = Talent(temp)
    return nil
}

// 仅对被提交的字段执行校验
func ValidatePatchTalent(t *Talent, validate *validator.Validate) error {
    if len(t.UpdatedFields) == 0 {
        return fmt.Errorf("no field provided for update")
    }
    if len(t.UpdatedFields) > 1 {
        return fmt.Errorf("patch request can only update one field at a time")
    }

    fieldName := t.UpdatedFields[0]
    if err := validate.StructField(t, fieldName); err != nil {
        return fmt.Errorf("invalid %s: %w", fieldName, err)
    }
    return nil
}

3. 校验函数映射表 #

定义一个以字段JSON名为键、校验函数为值的映射表，解析请求体后直接根据字段名调用对应校验函数。

示例实现：

import (
    "encoding/json"
    "fmt"
    "strings"
)

type Talent struct {
    // 结构同之前定义...
}

type fieldValidator func(interface{}) error

// 初始化各字段的校验函数
var talentFieldValidators = map[string]fieldValidator{
    "code": func(value interface{}) error {
        s, ok := value.(string)
        if !ok {
            return fmt.Errorf("must be string type")
        }
        if s == "" {
            return fmt.Errorf("cannot be empty")
        }
        if len(s) > 10 {
            return fmt.Errorf("length cannot exceed 10 characters")
        }
        return nil
    },
    "firstName": func(value interface{}) error {
        s, ok := value.(string)
        if !ok {
            return fmt.Errorf("must be string type")
        }
        if s == "" {
            return fmt.Errorf("cannot be empty")
        }
        if len(s) > 50 {
            return fmt.Errorf("length cannot exceed 50 characters")
        }
        return nil
    },
    "lastName": func(value interface{}) error {
        s, ok := value.(string)
        if !ok {
            return fmt.Errorf("must be string type")
        }
        if s == "" {
            return fmt.Errorf("cannot be empty")
        }
        if len(s) > 50 {
            return fmt.Errorf("length cannot exceed 50 characters")
        }
        return nil
    },
    // 其他字段的校验函数依次补充...
}

func ValidatePatchTalent(requestBody []byte) error {
    var reqMap map[string]interface{}
    if err := json.Unmarshal(requestBody, &reqMap); err != nil {
        return fmt.Errorf("invalid request body: %w", err)
    }

    if len(reqMap) != 1 {
        return fmt.Errorf("patch request must contain exactly one field")
    }

    for field, value := range reqMap {
        validator, exists := talentFieldValidators[field]
        if !exists {
            return fmt.Errorf("unsupported field: %s", field)
        }
        if err := validator(value); err != nil {
            return fmt.Errorf("invalid %s: %w", field, err)
        }
    }
    return nil
}

内容的提问来源于stack exchange，提问作者Sejal Naik