Post
查看二进制数据Post,比较常用
服务器如何解释此数据取决于Content-Type标头的值。
表单键/值对最常作为URL编码的数据发送，其内容类型为application / x-www-form-urlencoded。
HTTP POST和url编码数据
HTTP POST最常用于将HTML页面中的表单数据提交给服务器。
表单数据是键/值对的字典，其中key是字符串，值是字符串数组(通常是带有单个元素的数组)。
// 基本HTTP HEAD
// 类似于HTTP GET，但使用http.Client.Head(uri字符串)方法
client := &http.Client{}
client.Timeout = time.Second * 15
uri := "https://httpbin.org/post"
// 发送原始文本。 在大多数情况下，服务器期望正文为url编码格式。
body := bytes.NewBufferString("text we send")
resp, err := client.Post(uri, "text/plain", body)
if err != nil {
log.Fatalf("client.Post() failed with '%s'\n", err)
}
defer resp.Body.Close()
d, err := ioutil.ReadAll(resp.Body)
if err != nil {
log.Fatalf("http.Get() failed with '%s'\n", err)
}
Post json
这种格式抓包的话，
webforms表格是空的
请求体json格式请求的
用python请求的话差不多是这样
payload = json.dumps({
"code": "m5rdKp",
"uid": "35972375602270208",
"time_stamps": "1533815006608"
})
headers = {
'User-Agent': 'apifox/1.0.0 (https://www.apifox.cn)',
'Content-Type': 'application/json'
}
response = requests.request("POST", url, headers=headers, data=payload)
print(response.text)
go json请求的demo网上找了一圈，每一个能打的，抄来抄去
改bug改了一下午
http client发送
// post json demo
func PostCaptchaMethod8(p *models.Login) bool {
user := &Param2{
TimeStamps: "0000000",
Code: p.Code,
Uid: p.CodeUID,
}
d, err := json.Marshal(user)
res, err := http.NewRequest("POST", CaptchaUrl, strings.NewReader(string(d)))
if !dealErr(err){
return
}
// 设置请求头
res.Header.Set("User-Agent", "Mozilla/5.06")
res.Header.Set("Content-Type", "application/json")
defer res.Body.Close()
client := &http.Client{}
// 这里才是发请求
resp, err := client.Do(res)
if !dealErr(err){
return
}
body, err := ioutil.ReadAll(resp.Body)
if !dealErr(err){
return
}
fmt.Println(string(body))
return true
}
func dealErr(err error)bool{
if err != nil {
fmt.Println("err", err)
return false
}
return true
}
http.Post
func PostCaptchaMethod8(p *models.Login) bool {
timestamp := strconv.FormatInt(time.Now().Unix(), 10)
user := Param2{
TimeStamps: timestamp,
Code: p.Code,
Uid: p.CodeUID,
}
d, err := json.Marshal(user)
res, err := http.Post(CaptchaUrl, Application, strings.NewReader(string(d)))
if !dealErr(err){
return
}
res.Header.Set("User-Agent", "Mozilla/5.0")
res.Header.Set("Content-Type", "application/json")
defer res.Body.Close()
body, err := ioutil.ReadAll(res.Body)
if !dealErr(err){
return
}
fmt.Println(string(body))
var t RetJson
if err = json.Unmarshal(body, &t); err != nil {
fmt.Println(err)
return false
}
return t.Data
}
"github.com/ddliu/go-httpclient"
"github.com/ddliu/go-httpclient"
func PostCaptchaMethod(p *models.Login) bool {
user := &models.Param2{
TimeStamps: "1111111111111",
Code: p.Code,
Uid: p.CodeUID,
}
d, err := json.Marshal(user)
res, err := httpclient.PostJson(CaptchaUrl, string(d))
if err != nil {
zap.L().Error("controllers.PostCaptcha() file:postCaptcha", zap.Error(err))
return false
}
bodyString, err := res.ToString()
if err != nil {
zap.L().Error("controllers.PostCaptcha() file:postCaptcha", zap.Error(err))
return false
}
// 为空，但toString()不为空,这里的bug有大佬的话可以看一下
//zap.L().Info("message:", zap.String("body:", bodyString))
//bodyBytes, err := ioutil.ReadAll(res.Body)
//res.Body.Close()
//fmt.Println(bodyBytes)
//fmt.Println("-----", string(bodyBytes))
var t RetJson
err = json.Unmarshal([]byte(bodyString), &t)
if err != nil {
zap.L().Error("message:", zap.Error(err))
return false
}
return t.Data
}
Json PUT请求
user := User{
Name: "xiaosheng",
Email: "xiaosheng@example.com",
}
d, err := json.Marshal(user)
if err != nil {
log.Fatalf("json.Marshal() failed with '%s'\n", err)
}
client := &http.Client{}
client.Timeout = time.Second * 15
uri := ""
body := bytes.NewBuffer(d)
req, err := http.NewRequest(http.MethodPut, uri, body)
if err != nil {
log.Fatalf("http.NewRequest() failed with '%s'\n", err)
}
req.Header.Set("Content-Type", "application/json; charset=utf-8")
resp, err := client.Do(req)
if err != nil {
log.Fatalf("client.Do() failed with '%s'\n", err)
}
defer resp.Body.Close()
d, err = ioutil.ReadAll(resp.Body)
if err != nil {
log.Fatalf("ioutil.ReadAll() failed with '%s'\n", err)
}
fmt.Printf("Response status code: %d, text:\n%s\n", resp.StatusCode, string(d))
Post二进制数据
服务器如何解释此数据取决于Content-Type标头的值。
表单键/值对最常作为URL编码的数据发送，其内容类型为application / x-www-form-urlencoded。
HTTP POST和url编码数据
HTTP POST最常用于将HTML页面中的表单数据提交给服务器。
表单数据是键/值对的字典，其中key是字符串，值是字符串数组(通常是带有单个元素的数组)。
client := &http.Client{}
client.Timeout = time.Second * 15
uri := ""
data := url.Values{
"name": []string{"xiaosheng"},
"email": []string{"yusheng@gmail.com"},
}
resp, err := client.PostForm(uri, data)
if err != nil {
log.Fatalf("client.PosFormt() failed with '%s'\n", err)
}
defer resp.Body.Close()
_, err = ioutil.ReadAll(resp.Body)
if err != nil {
log.Fatalf("ioutil.ReadAll() failed with '%s'\n", err)
}
fmt.Printf("PostForm() sent '%s'. Response status code: %d\n", data.Encode(), resp.StatusCode)
带上下文的超时请求
// 使用context.Context超时单个HTTP请求
uri := ""
req, err := http.NewRequest("GET", uri, nil)
if err != nil {
log.Fatalf("http.NewRequest() failed with '%s'\n", err)
}
// create a context indicating 100 ms timeout
ctx, _ := context.WithTimeout(context.Background(), time.Millisecond*100)
// get a new request based on original request but with the context
req = req.WithContext(ctx)
resp, err := http.DefaultClient.Do(req)
if err != nil {
// the request should timeout because we want to wait max 100 ms
// but the server doesn't return response for 3 seconds
log.Fatalf("http.DefaultClient.Do() failed with:\n'%s'\n", err)
}
defer resp.Body.Close()
Get
最好不要使用http.Get，因为默认客户端没有超时，这意味着它将永远等待连接到速度慢，错误的服务器或恶意服务器
uri := ""
resp, err := http.Get(uri)
if err != nil {
log.Fatalf("http.Get() failed with '%s'\n", err)
}
// 必须关闭
defer resp.Body.Close()
d, err := ioutil.ReadAll(resp.Body)
if err != nil {
log.Fatalf("ioutil.ReadAll() failed with '%s'\n", err)
}
contentType := resp.Header.Get("Content-Type")
fmt.Printf("http.Get() returned content of type '%s' and size %d bytes.\nStatus code: %d\n", contentType, len(d), resp.StatusCode)
headers其类型为map [string] [] string，因为根据HTTP规范，可以使用多个具有相同名称的标头
如果没有错误，则http.Get()返回* http.Response，
正文是包含响应内容的io.Reader。
如果URL是HTML页面，则为HTML数据。
如果网址是PNG图片，则为PNG数据
http.client
// 使用client
client := &http.Client{}
// 设置了非常短的超时，以证明超过该超时将取消连接
client.Timeout = time.Millisecond * 100
uri := "https://httpbin.org/delay/3"
resp, err := client.Get(uri)
if err != nil {
log.Fatalf("http.Get() failed with '%s'\n", err)
}
带有URL参数和JSON响应的GET
GET请求正确编码URL参数，以及解析返回的JSON输出
type postItem struct {
Score int `json:"score"`
Link string `json:"link"`
}
type postsType struct {
Items []postItem `json:"items"`
}
values := url.Values{
"order": []string{"desc"},
"sort": []string{"activity"},
"site": []string{"stackoverflow"},
}
// 后来设置值
values.Set("page", "1")
values.Set("pagesize", "10")
uri := "https://api.com/posts?"
client := &http.Client{
Timeout: 15 * time.Second,
}
resp, err := client.Get(uri + values.Encode())
if err != nil {
log.Fatalf("http.Get() failed with '%s'\n", err)
}
defer resp.Body.Close()
if resp.StatusCode != http.StatusOK {
d, _ := ioutil.ReadAll(resp.Body)
log.Fatalf("Request was '%s' (%d) and not OK (200). Body:\n%s\n", resp.Status, resp.StatusCode, string(d))
}
dec := json.NewDecoder(resp.Body)
var p postsType
err = dec.Decode(&p)
if err != nil {
log.Fatalf("dec.Decode() failed with '%s'\n", err)
}
fmt.Println("Top 10 most recently active StackOverflow posts:")
fmt.Println("Score", "Link")
for _, post := range p.Items {
fmt.Println(post.Score, post.Link)
}
设置请求头
userAgent := "Special Agent v 1.0.16"
client := &http.Client{}
client.Timeout = time.Second * 15
uri := "https://httpbin.org/user-agent"
req, err := http.NewRequest(http.MethodGet, uri, nil)
if err != nil {
log.Fatalf("http.NewRequest() failed with '%s'\n", err)
}
req.Header.Set("User-Agent", userAgent)
resp, err := client.Do(req)
if err != nil {
log.Fatalf("client.Do() failed with '%s'\n", err)
}
defer resp.Body.Close()
d, err := ioutil.ReadAll(resp.Body)
if err != nil {
log.Fatalf("ioutil.ReadAll() failed with '%s'\n", err)
}
fmt.Printf("Response status code: %d, text:\n%s\n", resp.StatusCode, string(d))
总结
这里是对执行HTTP GET请求的3种方式的概述。
使用http.Get()函数
最简单的方法是使用顶级http.Get()函数，但由于缺少超时，因此不建议使用。
使用http.Client.Get()方法
使用＆http.Client {}创建* http.Client
设置适当的超时
使用其Get()或Post()或PostForm()方法
使用http.Client.Do()方法
这样可以最大程度地控制请求。
创建http.Client并设置适当的超时
使用http.NewRequest创建* http.Request
将其方法设置为“ GET”，“ POST”，“ HEAD”，“ PUT”或“ DELETE”
设置自定义标头，例如User-Agentwith Header.Set(key，value string)
通过设置io.ReadCloser类型的主体来设置要发送的主体
设置TransferEncoding
与client.Do(req * http.Request)发送请求
通过使用上下文包含截止期限req = request.WithContext(ctx)的新请求来设置每个请求超时
这是执行PUT或DELETE请求的唯一方法。
使用代理
func proxy() {
proxy_raw := "127.0.0.1:8889"
proxy_str := fmt.Sprintf("http://%s", proxy_raw)
fmt.Println(proxy_str)
proxy, err := url.Parse(proxy_str)
client := &http.Client{Transport: &http.Transport{Proxy: http.ProxyURL(proxy)}}
req, _ := http.NewRequest("GET", "https://www.baidu.com", nil)
req.Header.Add("User-Agent", "Mozilla/5.0 (Windows NT 6.1; WOW64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/39.0.2171.71 Safari/537.36")
req.Header.Add("Accept", "gzip, deflate, sdch")
res, err := client.Do(req)
if err != nil {
panic(err)
}
defer res.Body.Close()
body, err := ioutil.ReadAll(res.Body)
if err != nil {
panic(err)
}
fmt.Println(string(body[:50]))
}
