文章部分参考自该博客


踩坑记录在这
请求使用代理


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
如果URLHTML页面,则为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]))
}
分类: go

0 条评论

发表评论

Avatar placeholder

您的电子邮箱地址不会被公开。 必填项已用*标注

ICP备案号: 辽ICP备20003309号