Golang Writer.FormDataContentType方法代码示例

func (r Client) PostWithMultiPartData(req_url string, headers map[string][]string, params map[string][]string, body io.Reader, filename string) (resp *http.Response, err error) {
	var buffer *bytes.Buffer = new(bytes.Buffer)
	var writer *multipart.Writer = multipart.NewWriter(buffer)
	for k, v := range params {
		for _, field := range v {
			err1 := writer.WriteField(k, field)
			if err1 != nil {
				err = err1
				return
			}
		}
	}
	w, err := writer.CreateFormFile("file", filename)
	if err != nil {
		return
	}
	_, err = io.Copy(w, body)
	if err != nil {
		return
	}
	err = writer.Close()
	if err != nil {
		return
	}
	if headers == nil {
		headers = make(map[string][]string)
	}
	headers["Content-Type"] = []string{writer.FormDataContentType()}
	return r.Post(req_url, headers, buffer, int64(buffer.Len()))
}

func HttpUploadRequest(b *bytes.Buffer, writer *multipart.Writer) (*http.Request, *pb.ProgressBar) {

	url := API_URL + configuration.ACCESS_TOKEN

	var bar = pb.New(b.Len()).SetUnits(pb.U_BYTES)
	reader := bar.NewProxyReader(b)

	request, err := http.NewRequest("POST", url, reader)
	if err != nil {
		OutputError("Error building request")
		os.Exit(2)
	}

	request.Header.Add("Content-Type", writer.FormDataContentType())

	return request, bar
}

//.........这里部分代码省略.........
	time.Sleep(1 * time.Second)
	buf.Reset()
	w = multipart.NewWriter(buf)
	if bw, err = w.CreateFormFile("file", "./test/1.jpg"); err != nil {
		t.Errorf("w.CreateFormFile() error(%v)", err)
		t.FailNow()
	}
	if f, err = os.Open("./test/1.jpg"); err != nil {
		t.Errorf("os.Open() error(%v)", err)
		t.FailNow()
	}
	defer f.Close()
	if _, err = io.Copy(bw, f); err != nil {
		t.Errorf("io.Copy() error(%v)", err)
		t.FailNow()
	}
	if err = w.WriteField("vid", "1"); err != nil {
		t.Errorf("w.WriteField() error(%v)", err)
		t.FailNow()
	}
	if err = w.WriteField("key", "15"); err != nil {
		t.Errorf("w.WriteField() error(%v)", err)
		t.FailNow()
	}
	if err = w.WriteField("cookie", "15"); err != nil {
		t.Errorf("w.WriteField() error(%v)", err)
		t.FailNow()
	}
	w.Close()
	if req, err = http.NewRequest("POST", "http://localhost:6062/upload", buf); err != nil {
		t.Errorf("http..NewRequest() error(%v)", err)
		t.FailNow()
	}
	req.Header.Set("Content-Type", w.FormDataContentType())
	if resp, err = client.Do(req); err != nil {
		t.Errorf("client.Do() error(%v)", err)
		t.FailNow()
	}
	defer resp.Body.Close()
	if body, err = ioutil.ReadAll(resp.Body); err != nil {
		t.Errorf("ioutil.ReadAll() error(%v)", err)
		t.FailNow()
	}
	if err = json.Unmarshal(body, tr); err != nil {
		t.Errorf("json.Unmarshal() error(%v)", err)
		t.FailNow()
	}
	if tr.Ret != 1 {
		t.Errorf("ret: %d", tr.Ret)
		t.FailNow()
	}
	buf.Reset()
	w = multipart.NewWriter(buf)
	if err = w.WriteField("vid", "1"); err != nil {
		t.Errorf("w.WriteField() error(%v)", err)
		t.FailNow()
	}
	for i := 1; i < 10; i++ {
		if bw, err = w.CreateFormFile("file", "./test/"+strconv.Itoa(i)+".jpg"); err != nil {
			t.Errorf("w.CreateFormFile() error(%v)", err)
			t.FailNow()
		}
		if f, err = os.Open("./test/" + strconv.Itoa(i) + ".jpg"); err != nil {
			t.Errorf("os.Open() error(%v)", err)
			t.FailNow()
		}

// Http params
func Http(method, uri string, params url.Values, buf []byte, res interface{}) (err error) {
	var (
		body    []byte
		w       *multipart.Writer
		bw      io.Writer
		bufdata = &bytes.Buffer{}
		req     *http.Request
		resp    *http.Response
		ru      string
		enc     string
		ctype   string
	)
	enc = params.Encode()
	if enc != "" {
		ru = uri + "?" + enc
	}
	if method == "GET" {
		if req, err = http.NewRequest("GET", ru, nil); err != nil {
			return
		}
	} else {
		if buf == nil {
			if req, err = http.NewRequest("POST", uri, strings.NewReader(enc)); err != nil {
				return
			}
			req.Header.Set("Content-Type", "application/x-www-form-urlencoded")
		} else {
			w = multipart.NewWriter(bufdata)
			if bw, err = w.CreateFormFile("file", "1.jpg"); err != nil {
				return
			}
			if _, err = bw.Write(buf); err != nil {
				return
			}
			for key, _ := range params {
				w.WriteField(key, params.Get(key))
			}
			ctype = w.FormDataContentType()
			if err = w.Close(); err != nil {
				return
			}
			if req, err = http.NewRequest("POST", uri, bufdata); err != nil {
				return
			}
			req.Header.Set("Content-Type", ctype)
		}
	}
	td := _timer.Start(5*time.Second, func() {
		_canceler(req)
	})
	if resp, err = _client.Do(req); err != nil {
		log.Errorf("_client.Do(%s) error(%v)", ru, err)
		return
	}
	td.Stop()
	defer resp.Body.Close()
	if res == nil {
		return
	}
	if resp.StatusCode != http.StatusOK {
		log.Errorf("_client.Do(%s) status: %d", ru, resp.StatusCode)
		return
	}
	if body, err = ioutil.ReadAll(resp.Body); err != nil {
		log.Errorf("ioutil.ReadAll(%s) uri(%s) error(%v)", body, ru, err)
		return
	}
	if err = json.Unmarshal(body, res); err != nil {
		log.Errorf("json.Unmarshal(%s) uri(%s) error(%v)", body, ru, err)
	}
	return
}

func (client rest) MultipartPut(token string, m *multipart.Writer, url string, data *bytes.Buffer, body interface{}) Reply {
	return client.req(token, "PUT", url, m.FormDataContentType(), "", "", data, body)
}

func PostFile(req_url, path, filename string, start, end, filesize int, params map[string]string) (body string, err error) {
	var buffer *bytes.Buffer = bytes.NewBuffer(make([]byte, 0))
	var writer *multipart.Writer = multipart.NewWriter(buffer)

	for k, v := range params {
		err = writer.WriteField(k, v)
		if err != nil {
			return
		}
	}

	var file *os.File
	if file, err = os.OpenFile(path, os.O_RDONLY, 0644); err != nil {
		return
	}
	defer file.Close()

	w, err := writer.CreateFormFile("file", filename)
	if err != nil {
		return
	}

	var size = end - start + 1
	if size == filesize {
		_, err = io.Copy(w, file)
		if err != nil {
			return
		}
	} else {
		var section []byte = make([]byte, size)
		var n int
		n, err = file.ReadAt(section, int64(start))
		if err != nil || n != size {
			return
		}
		var buf *bytes.Buffer = bytes.NewBuffer(make([]byte, 0))
		buf.Write(section)
		_, err = io.Copy(w, buf)
		if err != nil {
			return
		}
	}
	writer.Close()

	var client *http.Client = new(http.Client)
	var req *http.Request
	req, err = http.NewRequest("POST", req_url, buffer)
	if err != nil {
		return
	}
	req.Header.Set("Content-Type", writer.FormDataContentType())
	req.Header.Set("User-Agent", "Mozilla/5.0 (Windows NT 6.1; rv:17.0) Gecko/20100101 Firefox/17.0")
	var resp *http.Response
	resp, err = client.Do(req)
	if err != nil {
		return
	}
	defer resp.Body.Close()
	resp_body, err := ioutil.ReadAll(resp.Body)
	body = string(resp_body)
	if resp.StatusCode != 200 {
		err = errors.New(fmt.Sprintf("%d", resp.StatusCode))
		return
	}
	return
}

func (douban *Douban) post(requestUrl string, accessToken string, params Params, picReader io.Reader, picFormat string, response interface{}) error {
	var urlBuffer bytes.Buffer
	urlBuffer.WriteString(requestUrl)

	var bodyBuffer bytes.Buffer
	var writer *multipart.Writer
	if picReader == nil {
		body := url.Values{}
		for k, v := range params {
			value := fmt.Sprint(v)
			body.Add(k, value)
		}
		bodyBuffer = *bytes.NewBufferString(body.Encode())
	} else {
		writer = multipart.NewWriter(&bodyBuffer)
		picWriter, err := writer.CreateFormFile("image", "image."+picFormat)
		if err != nil {
			return err
		}
		_, e := io.Copy(picWriter, picReader)
		if e != nil {
			return e
		}

		for k, v := range params {
			value := fmt.Sprint(v)
			if k != "" && value != "" {
				writer.WriteField(k, value)
			}
		}
		writer.Close()
	}
	//	log.Printf("URL: %s\n", urlBuffer.String())
	//	log.Printf("Body: %#v\n", bodyBuffer)

	req, err := http.NewRequest("POST", urlBuffer.String(), &bodyBuffer)
	if err != nil {
		return err
	}
	req.Header.Add("Authorization", accessToken)

	if picReader == nil {
		req.Header.Add("Content-Type", "application/x-www-form-urlencoded")
	} else {
		req.Header.Add("Content-Type", writer.FormDataContentType())
	}
	//	log.Printf("Header: %#V\n", req.Header)
	resp, err := douban.httpClient.Do(req)
	if err != nil {
		return err
	}
	defer resp.Body.Close()

	respContent, err := ioutil.ReadAll(resp.Body)
	if err != nil {
		return err
	}

	if resp.StatusCode != 200 {
		doubanError := DoubanError{}
		err := json.Unmarshal(respContent, &doubanError)
		if err != nil {
			return err
		} else {
			return &doubanError
		}
	}
	//log.Printf("==================================\n================================\n%s\n", respContent)
	return json.Unmarshal(respContent, &response)

}

//.........这里部分代码省略.........
	t.Log("Upload")
	buf.Reset()
	w = multipart.NewWriter(buf)
	if bw, err = w.CreateFormFile("file", "./test/1.jpg"); err != nil {
		t.Errorf("w.CreateFormFile() error(%v)", err)
		t.FailNow()
	}
	if f, err = os.Open("./test/1.jpg"); err != nil {
		t.Errorf("os.Open() error(%v)", err)
		t.FailNow()
	}
	defer f.Close()
	if _, err = io.Copy(bw, f); err != nil {
		t.Errorf("io.Copy() error(%v)", err)
		t.FailNow()
	}
	if err = w.WriteField("vid", "1"); err != nil {
		t.Errorf("w.WriteField() error(%v)", err)
		t.FailNow()
	}
	if err = w.WriteField("key", "15"); err != nil {
		t.Errorf("w.WriteField() error(%v)", err)
		t.FailNow()
	}
	if err = w.WriteField("cookie", "15"); err != nil {
		t.Errorf("w.WriteField() error(%v)", err)
		t.FailNow()
	}
	w.Close()
	if req, err = http.NewRequest("POST", "http://localhost:6062/upload", buf); err != nil {
		t.Errorf("http..NewRequest() error(%v)", err)
		t.FailNow()
	}
	req.Header.Set("Content-Type", w.FormDataContentType())
	if resp, err = client.Do(req); err != nil {
		t.Errorf("client.Do() error(%v)", err)
		t.FailNow()
	}
	defer resp.Body.Close()
	if body, err = ioutil.ReadAll(resp.Body); err != nil {
		t.Errorf("ioutil.ReadAll() error(%v)", err)
		t.FailNow()
	}
	if err = json.Unmarshal(body, tr); err != nil {
		t.Errorf("json.Unmarshal() error(%v)", err)
		t.FailNow()
	}
	if tr.Ret != 1 {
		t.Errorf("ret: %d", tr.Ret)
		t.FailNow()
	}
	t.Log("Uploads")
	buf.Reset()
	w = multipart.NewWriter(buf)
	if err = w.WriteField("vid", "1"); err != nil {
		t.Errorf("w.WriteField() error(%v)", err)
		t.FailNow()
	}
	for i := 1; i < 10; i++ {
		if bw, err = w.CreateFormFile("file", "./test/"+strconv.Itoa(i)+".jpg"); err != nil {
			t.Errorf("w.CreateFormFile() error(%v)", err)
			t.FailNow()
		}
		if f, err = os.Open("./test/" + strconv.Itoa(i) + ".jpg"); err != nil {
			t.Errorf("os.Open() error(%v)", err)
			t.FailNow()

// 向微博API服务器发送POST请求
//
// 输入参数的含义请见Upload函数注释。当reader == nil时使用query string模式，否则使用multipart。
func (weibo *Weibo) sendPostHttpRequest(uri string, token string, params Params, reader io.Reader, imageFormat string, response interface{}) error {
	// 生成POST请求URI
	requestUri := fmt.Sprintf("%s?access_token=%s", uri, token)

	// 生成POST内容
	var bodyBuffer bytes.Buffer
	var writer *multipart.Writer
	if reader == nil {
		// reader为nil时无文件上传，因此POST body为简单的query string模式
		pb := url.Values{}
		pb.Add("access_token", token)

		for k, v := range params {
			value := fmt.Sprint(v)
			if k != "" && value != "" {
				pb.Add(k, value)
			}
		}
		bodyBuffer = *bytes.NewBufferString(pb.Encode())
	} else {
		// 否则POST body使用multipart模式
		writer = multipart.NewWriter(&bodyBuffer)
		imagePartWriter, _ := writer.CreateFormFile("pic", "image."+imageFormat)
		io.Copy(imagePartWriter, reader)
		for k, v := range params {
			value := fmt.Sprint(v)
			if k != "" && value != "" {
				writer.WriteField(k, value)
			}
		}
		writer.Close()
	}

	// 生成POST请求
	req, err := http.NewRequest("POST", requestUri, &bodyBuffer)
	if err != nil {
		return err
	}
	if reader == nil {
		// reader为nil时使用一般的内容类型
		req.Header.Set("Content-Type", "application/x-www-form-urlencoded")
	} else {
		// 否则使用带boundary的multipart类型
		req.Header.Set("Content-Type", writer.FormDataContentType())
	}

	// 发送请求
	resp, err := weibo.httpClient.Do(req)
	if err != nil {
		return err
	}
	defer resp.Body.Close()

	// 解析API服务器返回内容
	bytes, _ := ioutil.ReadAll(resp.Body)
	if resp.StatusCode == 200 {
		err := json.Unmarshal(bytes, &response)
		if err != nil {
			return err
		}
		return nil
	} else {
		var weiboErr WeiboError
		err := json.Unmarshal(bytes, &weiboErr)
		if err != nil {
			return err
		}
		return weiboErr
	}
	return nil
}