Web框架中的FormFile绑定

在 Echo 框架中，通过表单提交文件时，默认情况下无法直接通过绑定模型获取文件信息。为了解决这个问题，需要重新实现 Echo 的绑定器，将文件信息绑定到模型中。可以通过包装绑定函数，在绑定过程中检查表单类型是否包含文件，如果是，则通过 `EchoBindFile` 函数将文件信息设置到模型中。通过这种方式，可以在绑定模型中直接获取表单提交的文件。

我正在使用 echo 框架作为接受表单数据的发布端点。我使用 struct 作为绑定模型来提取表单数据。我的绑定模型和上传处理程序代码如下所示。

type FormModel struct {
    ID string                `form:"ID"`
    FirstName string                `form:"FirstName"`
    File      *multipart.FileHeader `form:"myFileName"`
}

func (cs *handler) uploadForm(c echo.Context) error {
s := new(FormModel)
if err := c.Bind(s); err != nil {
    return nil
}

fileHandler, err := c.FormFile("myFileName")

我能够通过绑定获取 id 和 firstname 等表单值。但我在绑定过程中无法获取该文件。我必须使用 filehandler, err := c.formfile("myfilename") 来获取文件。有什么方法可以获取绑定模型中的文件信息吗？

解决方案

echo默认不支持绑定multipart.form.file数据，需要重新binder实现接口。

额外封装了一层bind formfile，用于echo bind。如果结构体指针类型的属性类型是*multipart.fileheader或[]*multipart.fileheader，则该属性将通过反射设置为formfile的值。

我大概实现了这个功能。我没有使用过echo，也没有测试过，但是这个想法是正确的。

最后更新：添加示例并修复要构建的代码。感谢 @victrolla 指出 typemultipartfileheader 类型定义错误。

package main

import (
    "bytes"
    "fmt"
    "github.com/labstack/echo"
    "io/ioutil"
    "mime/multipart"
    "net/http"
    "reflect"
    "strings"
    "time"
)

var (
    typeMultipartFileHeader      = reflect.TypeOf((*multipart.FileHeader)(nil))
    typeMultipartSliceFileHeader = reflect.TypeOf(([]*multipart.FileHeader)(nil))
)

type File struct {
    File  *multipart.FileHeader   `form:"file"`
    Files []*multipart.FileHeader `form:"files"`
}

func main() {
    app := echo.New()
    // warp bind suppet bind FormFile
    app.Binder = NewBindFile(app.Binder)
    app.Any("/file", func(ctx echo.Context) error {
        var file File
        err := ctx.Bind(&file)
        if err != nil {
            return err
        }

        readfile := func(file *multipart.FileHeader) {
            f, err := file.Open()
            if err != nil {
                fmt.Printf("open %s error: %s\n", file.Filename, err.Error())
                return
            }
            body, err := ioutil.ReadAll(f)
            fmt.Printf("read file %s error: %v body: %s\n", file.Filename, err, body)
        }

        readfile(file.File)
        for _, file := range file.Files {
            readfile(file)
        }
        return err
    })

    go func() {
        time.Sleep(200 * time.Millisecond)
        buf := bytes.NewBuffer(nil)
        w := multipart.NewWriter(buf)
        part, _ := w.CreateFormFile("file", "file")
        part.Write([]byte("this one file"))
        part, _ = w.CreateFormFile("files", "files")
        part.Write([]byte("fils part 1"))
        part, _ = w.CreateFormFile("files", "files")
        part.Write([]byte("fils part 2"))
        part, _ = w.CreateFormFile("files", "files")
        part.Write([]byte("fils part 3"))
        part, _ = w.CreateFormFile("files", "files")
        part.Write([]byte("fils part 4"))
        w.Close()
        http.Post("http://localhost:1323/file", w.FormDataContentType(), buf)
    }()

    app.Start(":1323")
}

type BindFunc func(interface{}, echo.Context) error

func (fn BindFunc) Bind(i interface{}, ctx echo.Context) error {
    return fn(i, ctx)
}

func NewBindFile(b echo.Binder) echo.Binder {
    return BindFunc(func(i interface{}, ctx echo.Context) error {
        err := b.Bind(i, ctx)
        if err == nil {
            ctype := ctx.Request().Header.Get(echo.HeaderContentType)
            // if bind form
            if strings.HasPrefix(ctype, echo.MIMEApplicationForm) || strings.HasPrefix(ctype, echo.MIMEMultipartForm) {
                // get form files
                var form *multipart.Form
                form, err = ctx.MultipartForm()
                if err == nil {
                    err = EchoBindFile(i, ctx, form.File)
                }
            }
        }
        return err
    })
}

func EchoBindFile(i interface{}, ctx echo.Context, files map[string][]*multipart.FileHeader) error {
    iValue := reflect.Indirect(reflect.ValueOf(i))
    // check bind type is struct pointer
    if iValue.Kind() != reflect.Struct {
        return fmt.Errorf("BindFile input not is struct pointer, indirect type is %s", iValue.Type().String())
    }

    iType := iValue.Type()
    for i := 0; i < iType.NumField(); i++ {
        fType := iType.Field(i)
        // check canset field
        fValue := iValue.Field(i)
        if !fValue.CanSet() {
            continue
        }
        // revc type must *multipart.FileHeader or []*multipart.FileHeader
        switch fType.Type {
        case typeMultipartFileHeader:
            file := getFiles(files, fType.Name, fType.Tag.Get("form"))
            if len(file) > 0 {
                fValue.Set(reflect.ValueOf(file[0]))
            }
        case typeMultipartSliceFileHeader:
            file := getFiles(files, fType.Name, fType.Tag.Get("form"))
            if len(file) > 0 {
                fValue.Set(reflect.ValueOf(file))
            }
        }
    }
    return nil
}

func getFiles(files map[string][]*multipart.FileHeader, names ...string) []*multipart.FileHeader {
    for _, name := range names {
        file, ok := files[name]
        if ok {
            return file
        }
    }
    return nil
}

今天带大家了解了的相关知识，希望对你有所帮助；关于Golang的技术知识我们会一点点深入介绍，欢迎大家关注golang学习网公众号，一起学习编程~