4.5 File upload

Suppose you have a website like Instagram and you want users to upload their beautiful photos. How would you implement that functionality?

You have to add property enctype to the form that you want to use for uploading photos. There are three possible values for this property:

  1. application/x-www-form-urlencoded   Transcode all characters before uploading (default).
  2. multipart/form-data   No transcoding. You must use this value when your form has file upload controls.
  3. text/plain    Convert spaces to "+", but no transcoding for special characters.

Therefore, the HTML content of a file upload form should look like this:

  1. <html>
  2. <head>
  3.        <title>Upload file</title>
  4. </head>
  5. <body>
  6. <form enctype="multipart/form-data" action="http://127.0.0.1:9090/upload" method="post">
  7.     <input type="file" name="uploadfile" />
  8.     <input type="hidden" name="token" value="{{.}}"/>
  9.     <input type="submit" value="upload" />
  10. </form>
  11. </body>
  12. </html>

We need to add a function on the server side to handle this form.

  1. http.HandleFunc("/upload", upload)
  3. // upload logic
  4. func upload(w http.ResponseWriter, r *http.Request) {
  5.        fmt.Println("method:", r.Method)
  6.        if r.Method == "GET" {
  7.            crutime := time.Now().Unix()
  8.            h := md5.New()
  9.            io.WriteString(h, strconv.FormatInt(crutime, 10))
  10.            token := fmt.Sprintf("%x", h.Sum(nil))
  12.            t, _ := template.ParseFiles("upload.gtpl")
  13.            t.Execute(w, token)
  14.        } else {
  15.            r.ParseMultipartForm(32 << 20)
  16.            file, handler, err := r.FormFile("uploadfile")
  17.            if err != nil {
  18.                fmt.Println(err)
  19.                return
  20.            }
  21.            defer file.Close()
  22.            fmt.Fprintf(w, "%v", handler.Header)
  23.            f, err := os.OpenFile("./test/"+handler.Filename, os.O_WRONLY|os.O_CREATE, 0666)
  24.            if err != nil {
  25.                fmt.Println(err)
  26.                return
  27.            }
  28.            defer f.Close()
  29.            io.Copy(f, file)
  30.        }
  31. }

As you can see, we need to call r.ParseMultipartForm for uploading files. The function ParseMultipartForm takes the maxMemory argument. After you call ParseMultipartForm, the file will be saved in the server memory with maxMemory size. If the file size is larger than maxMemory, the rest of the data will be saved in a system temporary file. You can use r.FormFile to get the file handle and use io.Copy to save to your file system.

You don’t need to call r.ParseForm when you access other non-file fields in the form because Go will call it when it’s necessary. Also, calling ParseMultipartForm once is enough -multiple calls make no difference.

We use three steps for uploading files as follows:

  1. Add enctype="multipart/form-data" to your form.
  2. Call r.ParseMultipartForm on the server side to save the file either to memory or to a temporary file.
  3. Call r.FormFile to get the file handle and save to the file system.

The file handler is the multipart.FileHeader. It uses the following struct:

  1. type FileHeader struct {
  2.        Filename string
  3.        Header   textproto.MIMEHeader
  4.        // contains filtered or unexported fields
  5. }

4.5. File upload - 图1

Figure 4.5 Print information on server after receiving file.

Clients upload files

I showed an example of using a form to a upload a file. We can impersonate a client form to upload files in Go as well.

  1. package main
  3. import (
  4.     "bytes"
  5.     "fmt"
  6.     "io"
  7.     "io/ioutil"
  8.     "mime/multipart"
  9.     "net/http"
  10.     "os"
  11. )
  13. func postFile(filename string, targetUrl string) error {
  14.     bodyBuf := &bytes.Buffer{}
  15.     bodyWriter := multipart.NewWriter(bodyBuf)
  17.     // this step is very important
  18.     fileWriter, err := bodyWriter.CreateFormFile("uploadfile", filename)
  19.     if err != nil {
  20.         fmt.Println("error writing to buffer")
  21.         return err
  22.     }
  24.     // open file handle
  25.     fh, err := os.Open(filename)
  26.     if err != nil {
  27.         fmt.Println("error opening file")
  28.         return err
  29.     }
  30.     defer fh.Close()
  32.     //iocopy
  33.     _, err = io.Copy(fileWriter, fh)
  34.     if err != nil {
  35.         return err
  36.     }
  38.     contentType := bodyWriter.FormDataContentType()
  39.     bodyWriter.Close()
  41.     resp, err := http.Post(targetUrl, contentType, bodyBuf)
  42.     if err != nil {
  43.         return err
  44.     }
  45.     defer resp.Body.Close()
  46.     resp_body, err := ioutil.ReadAll(resp.Body)
  47.     if err != nil {
  48.         return err
  49.     }
  50.     fmt.Println(resp.Status)
  51.     fmt.Println(string(resp_body))
  52.     return nil
  53. }
  55. // sample usage
  56. func main() {
  57.     target_url := "http://localhost:9090/upload"
  58.     filename := "./astaxie.pdf"
  59.     postFile(filename, target_url)
  60. }

The above example shows you how to use a client to upload files. It uses multipart.Write to write files into cache and sends them to the server through the POST method.

If you have other fields that need to write into data, like username, call multipart.WriteField as needed.