Go-发起HTTP请求 - Powered by Discuz! Archiver

随心而飞 發表於 2023-6-26 17:38:00

Go--发起HTTP请求

<h3>一、HTTP请求</h3>
根据 HTTP 标准，HTTP 请求可以使用多种请求方法。在日常开发中大多数会用到 5 种请求方法： GET、POST、PUT、PATCH 和 DELETE
<table border="0" align="center">
<tbody>
<tr>
<td>方法</td>
<td>描述</td>
</tr>
<tr>
<td>GET</td>
<td>请求指定的页面信息，并返回实体主体</td>
</tr>
<tr>
<td>POST</td>
<td>向指定资源提交数据进行处理请求（例如提交表单或者上传文件）。数据被包含在请求体中。POST 请求可能会导致新的资源的建立和/或已有资源的修改</td>
</tr>
<tr>
<td>PUT</td>
<td>从客户端向服务器传送的数据取代指定的文档的内容</td>
</tr>
<tr>
<td>DELETE</td>
<td>请求服务器删除指定的页面</td>
</tr>
<tr>
<td>PATCH</td>
<td>是对 PUT 方法的补充，用来对已知资源进行局部更新</td>
</tr>
</tbody>
</table>
 
在一次http请求(request)中可携带参数的地方：
<table border="0" align="center">
<tbody>
<tr>
<td>部分</td>
<td>描述</td>
</tr>
<tr>
<td>URL部分</td>
<td>即以?和&分割的url参数</td>
</tr>
<tr>
<td>header部分</td>
<td>在http头中的字段，比如常用的cookie</td>
</tr>
<tr>
<td>content-body部分</td>
<td>请求正文，如果是get请求则为空；如果是post请求，则请求头中的Content-Type字段规定了content-body部分应该怎么被解析</td>
</tr>
</tbody>
</table>
 
<h3>二、GET请求</h3>
<h4>2.1 不带参数的GET请求</h4>
<div class="cnblogs_code">
<pre>package main

import (
"fmt"
"io"
"net/http"
)

func HttpGet(url string) []byte {
//发起请求
res, err := http.Get(url)
if err != nil {
 fmt.Println("get请求失败：", err)
}
//延迟关闭（返回response的body尽量关闭,避免内存泄露）
 defer res.Body.Close()
// 请求头
 fmt.Println(res.Header)
// 请求相应码
 fmt.Println(res.Status)

//读取body数据
body, err := io.ReadAll(res.Body)
if err != nil {
 fmt.Println("读取body失败：", err)
 return nil
}

return body
}

func main() {
UrlPath := "https://xxx/instance"
body := HttpGet(UrlPath)
//打印body,以字符串形式
fmt.Printf(string(body))

}</pre>
</div>
 
<h4>2.2 带参数的GET请求</h4>
<h5>2.2.1 静态参数</h5>
若参数是固定的，则将1.1中的UrlPath设置为完整的请求即可，例： UrlPath := "https://xxx/instance?name=xxx&age=18" 
 
<h5>2.2.2 动态参数</h5>
<div class="cnblogs_code">
<pre>package main

import (
"fmt"
"io"
"net/http"
)

func HttpGetUrl(url string) []byte {
//正常来说，GET请求所有的参数都应该是放在url上，body请求体中是没有数据的
//请求头可能会携带token之类的参数

//新建一个GET请求
request, err := http.NewRequest("GET", url, nil)
if err != nil {
 panic(err)
}

//请求头部信息
//Set时候，如果原来这一项已存在，后面的就修改已有的
//Add时候，如果原本不存在，则添加，如果已存在，就不做任何修改
//最终服务端获取的应该是token2
request.Header.Set("User-Agent", "自定义浏览器1...")
request.Header.Set("User-Agent", "自定义浏览器2...")
request.Header.Add("Host", "www.xxx.com")

//header:map]
request.Header.Add("name", "alnk")
request.Header.Add("name", "alnk2")

//header:map User-Agent:[自定义浏览器2...]]
request.Header.Add("Authorization", "token1...") //token

fmt.Println("header: ", request.Header)

//url参数
query := request.URL.Query()
query.Add("id", "1")
query.Add("id", "2")
query.Add("name", "wan")
request.URL.RawQuery = query.Encode()
fmt.Println("request.URL: ", request.URL) //request.URL:https://xxx/instance?id=1&id=2&name=wan

//发送请求给服务端,实例化一个客户端
client := &http.Client{}
res, err := client.Do(request)
if err != nil {
 panic(err)
}
defer res.Body.Close()

//服务端返回数据
b, err := io.ReadAll(res.Body)
if err != nil {
 panic(err)
}
return b
}

func main() {
UrlPath := "https://xxx/instance"
body := HttpGetUrl(UrlPath)
//打印body,以字符串形式
fmt.Printf(string(body))

}</pre>
</div>
 
<h3>三、POST请求</h3>
<h4>3.1 Content-Type类型</h4>
<table border="0" align="center">
<tbody>
<tr>
<td>Content-Type</td>
<td>用途</td>
</tr>
<tr>
<td>application/x-www-form-urlencoded</td>
<td>默认的方式, 比如 title=test&id=1010</td>
</tr>
<tr>
<td>multipart/form-data</td>
<td>如果你的请求里包含多个文件等二进制信息,则form 的 enctyped 需要等于这个值,浏览器生成一个 boundary 用于分割不同的字段</td>
</tr>
<tr>
<td>application/json</td>
<td>以json格式传送</td>
</tr>
<tr>
<td>raw</td>
<td>纯二进制格式,这需要服务器拿到消息后自己定义解析方式，比如protobuf</td>
</tr>
</tbody>
</table>
 
<h5> </h5>
<h4>3.2 使用 http.Post() + application/x-www-form-urlencoded</h4>
<div class="cnblogs_code">
<pre>package main

import (
"fmt"
"io"
"net/http"
"net/url"
"strings"
)

func HttpPost(urlP string) []byte {
//url.Values用来存放body参数，无参数不加
urlValues := url.Values{} //urlValues ---> map[]string
urlValues.Add("user", "test")
urlValues.Add("password", "test123")
//编码
reqBody := urlValues.Encode()

//最终http报文里面的body是 user=test&password=test123
resp, err := http.Post(urlP, "application/x-www-form-urlencoded", strings.NewReader(reqBody))
if err != nil {
 fmt.Println(err)
 return nil
}

defer resp.Body.Close()
body, _ := io.ReadAll(resp.Body)

return body
}

func main() {
var urlP = "https://www.xxx.com/json"
body := HttpPost(urlP)
fmt.Println(string(body))
}</pre>
</div>
 
<h4>3.3 使用 http.Post() + application/json</h4>
<div class="cnblogs_code">
<pre>package main

import (
"bytes"
"encoding/json"
"fmt"
"io"
"net/http"
)

func HttpPost(urlP string) []byte {
// 参数
data := make(map[string]interface{})
data["user"] = "test"
data["password"] = "test123"

// 序列化
bytesData, _ := json.Marshal(data)

resp, err := http.Post(urlP, "application/json", bytes.NewReader(bytesData))
if err != nil {
 fmt.Println(err)
 return nil
}

defer resp.Body.Close()
body, _ := io.ReadAll(resp.Body)

return body
}

func main() {
var urlP = "https://www.xxx.com/json"
body := HttpPost(urlP)
fmt.Println(string(body))
}</pre>
</div>
 
<h4>3.4 http.PostForm()</h4>
提交post表单
<div class="cnblogs_code">
<pre>package main

import (
"fmt"
"io"
"net/http"
"net/url"
)

func HttpPost(urlP string) []byte {
urlValues := url.Values{}
urlValues.Add("user", "test")
urlValues.Add("password", "test123")

resp, err := http.PostForm(urlP, urlValues)
//resp, err := http.PostForm(urlP, url.Values{
// "user": {"test"},
// "password": {"test123"},
//})
if err != nil {
 fmt.Println(err)
 return nil
}

defer resp.Body.Close()
body, _ := io.ReadAll(resp.Body)

return body
}

func main() {
var urlP = "https://www.xxx.com/json"
body := HttpPost(urlP)
fmt.Println(string(body))
}</pre>
</div>
 
<h3>四、http.NewRequest()</h3>
如2.2.2，复杂的http请求，可以通过http.NewRequest 来创建请求，再用client.Do发送，http.NewRequest支持各种请求方法
get请求如2.2.2
 
<h4>4.1 POST</h4>
<div class="cnblogs_code">
<pre>package main

import (
"fmt"
"io"
"net/http"
"net/url"
"strings"
)

func HttpPost(urlP string) []byte {
//请求body
urlMap := url.Values{}
urlMap.Add("user", "test")
urlMap.Add("password", "test123")

//新建请求
request, err := http.NewRequest("POST", urlP, strings.NewReader(urlMap.Encode()))
if err != nil {
 fmt.Println(err)
 return nil
}
fmt.Println("request.url: ", request.URL)
fmt.Println("request.method: ", request.Method)

//请求头部信息
request.Header.Add("Authorization", "token1...")
//post formdata表单请求
request.Header.Add("Content-Type", "application/x-www-form-urlencoded")

////发送json格式的参数
//data := mapinterface{}{
// "user": "test",
// "password": 123,
//}
//// 序列化
//bytesData, _ := json.Marshal(data)
//request, _ := http.NewRequest("POST", urlP, strings.NewReader(string(bytesData)))
//请求头设置
//request.Header.Add("Authorization", "token1...") //token
//request.Header.Add("Content-Type", "application/json") //json请求

//实例化一个客户端
client := &http.Client{}
//发送请求到服务端
resp, err := client.Do(request)
if err != nil {
 fmt.Println(err)
 return nil
}

defer resp.Body.Close()
body, _ := io.ReadAll(resp.Body)

return body
}

func main() {
var urlP = "https://www.xxx.com/json"
body := HttpPost(urlP)
fmt.Println(string(body))
}</pre>
</div>
 
<h4>4.2 DELETE</h4>
<div class="cnblogs_code">
<pre>package main

import (
"fmt"
"io"
"net/http"
)

func HttpDelete(urlD string) []byte {
//携带tonken
//通过ID删除
request, err := http.NewRequest("DELETE", urlD, nil)
if err != nil {
 panic(err)
}

//请求头部信息
request.Header.Add("Authorization", "token1...") //token

//url参数
query := request.URL.Query()
query.Add("id", "1")
query.Add("id", "2")
query.Add("id", "3")
request.URL.RawQuery = query.Encode()

//发送请求给服务端
client := &http.Client{}
res, err := client.Do(request)
if err != nil {
 panic(err)
}
defer res.Body.Close()

//服务端返回数据
b, err := io.ReadAll(res.Body)
if err != nil {
 panic(err)
}

return b
}

func main() {
var urlD = "https://www.xxx.com/json"
body := HttpDelete(urlD)
fmt.Println(string(body))
}</pre>
</div>
 
<h4>4.3 PUT</h4>
<div class="cnblogs_code">
<pre>package main

import (
"encoding/json"
"fmt"
"io"
"net/http"
"strings"
)

func HttpPut(urlP string) []byte {
//通过ID修改用户数据
//数据格式化
data := map[string]interface{}{
 "name": "wang",
 "age":18,
}
dataStr, err := json.Marshal(data)
if err != nil {
 panic(err)
}

//创建一个新的请求
request, err := http.NewRequest("PUT", urlP, strings.NewReader(string(dataStr)))
if err != nil {
 panic(err)
}

//请求头设置
request.Header.Add("Authorization", "token1...") //token
request.Header.Add("Content-Type", "application/json") //json请求

//url参数
query := request.URL.Query()
query.Add("id", "1")
request.URL.RawQuery = query.Encode()

//发送请求给服务端
client := &http.Client{}
res, err := client.Do(request)
if err != nil {
 panic(err)
}
defer res.Body.Close()

//服务端返回数据
b, err := io.ReadAll(res.Body)
if err != nil {
 panic(err)
}
return b
}

func main() {
var urlP = "https://www.xxx.com/json"
body := HttpPut(urlP)
fmt.Println(string(body))
}</pre>
</div>
 
<h4>4.4 PATCH</h4>
<div class="cnblogs_code">
<pre>package main

import (
"encoding/json"
"fmt"
"io"
"net/http"
"strings"
)

func HttpPatch(urlP string) []byte {

data := map[string]interface{}{
 "user": "test",
 "password": 123,
}
dataStr, err := json.Marshal(data)
if err != nil {
 panic(err)
}

//创建一个新的请求
request, err := http.NewRequest("PATCH", urlP, strings.NewReader(string(dataStr)))
if err != nil {
 panic(err)
}

//请求头设置
request.Header.Add("Authorization", "token1...") //token
request.Header.Add("Content-Type", "application/json") //json请求

//发送请求给服务端
client := &http.Client{}
res, err := client.Do(request)
if err != nil {
 panic(err)
}
defer res.Body.Close()

//服务端返回数据
b, err := io.ReadAll(res.Body)
if err != nil {
 panic(err)
}
return b
}

func main() {
var urlP = "https://www.xxx.com/json"
body := HttpPatch(urlP)
fmt.Println(string(body))
}</pre>
</div>
 
<h3>五、处理响应</h3>
不管用何种方式请求，最后都会得到 response,err ，不需要返回数据直接用_忽略，需要可将其直接打印出来，或者做进一步操作
<h4>5.1 直接打印</h4>
<div class="cnblogs_code">
<pre>package main

import (
"encoding/json"
"fmt"
"io"
"net/http"
)

func main() {
// 发起一个get请求
res, _ := http.Get("https://www.baidu.com")
fmt.Println(res.StatusCode) // 获取状态码
fmt.Println(res.Status) // 获取状态码及英文名称
fmt.Println(res.Header) // 获取响应头
body, _ := io.ReadAll(res.Body) // 读取响应body，返回为[]byte，数据基本都存储在body里
fmt.Printf(string(body)) // 转换成字符串进行打印

// 将响应数据解析为JSON格式
var jsonData map[string]interface{}
err := json.Unmarshal(body, &jsonData)
if err != nil {
 fmt.Println("解析JSON数据失败:", err)
 return
}

// 输出JSON数据
 fmt.Println(jsonData)
}</pre>
</div>
 
<h4>5.2 对返回数据做进一步操作（解析json类型的返回结果）</h4>
很多时候，请求一个接口，是需要返回数据（返回数据类型多为json）中的某些字段的数据，引用或变更，直接转换为字符串打印的话，就变成了一个整体，不便于数据拆解，故此对于返回数据还需另外处理
 
<h5>5.2.1 定义结构体</h5>
对于返回数据，可定义一个结构体（需与接口返回body的数据结构一致，不然会报错），然后使用 json.Unmarshal 函数将返回的json字符串解析为结构体类型的值，就可引用该结构体的字段来访问解析后的数据，如下：
<div class="cnblogs_code">
<pre>package main

import (
"encoding/json"
"fmt"
"io"
"net/http"
)

// RequestData 定义请求接收的数据的结构体
type RequestData struct {
ID int `json:"id"`
Name string `json:"name"`
Ageint `json:"age"`
City string `json:"city"`
}

func main() {
// 发起GET请求
resp, err := http.Get("https://www.xxx.com/data")
if err != nil {
 fmt.Println("发起请求时发生错误:", err)
 return
}
defer resp.Body.Close()

// 读取响应体的内容
body, err := io.ReadAll(resp.Body)
if err != nil {
 fmt.Println("读取响应体时发生错误:", err)
 return
}

// 解析响应体中的JSON数据到结构体
var data RequestData
err = json.Unmarshal(body, &data)
if err != nil {
 fmt.Println("解析JSON数据时发生错误:", err)
 return
}

// 输出解析后的数据，或后续引用
fmt.Println("ID:", data.ID)
fmt.Println("Name:", data.Name)
fmt.Println("Age:", data.Age)
fmt.Println("City:", data.City)

//循环
//data1 := make(mapRequestData)
//err = json.Unmarshal(body, &data)
//if err != nil {
// fmt.Println("解析JSON数据时发生错误:", err)
// return
//}
//for _, v := range data1 {
// fmt.Println(v.ID)
// fmt.Println(v.Age)
//}
}</pre>
</div>
 
<h5>5.2.2 gjson</h5>
对于一般场景，如5.1.1，定义结构体即可，但有时返回body结构太复杂，定义容易出错；或者返回数据太多，而真正需要的数据，可能只有几个字段，这时候定义个结构体去拆解所有的返回数据，就有点费时费力，且得不偿失了
故针对以上情景，可以使用gjson来处理返回body数据，方便快捷，不易出错
下载gjson： go get -u github.com/tidwall/gjson 
使用：
传入 JSON 串和要读取的键路径，路径使用点号语法，如 "name.last "或 "age"。一旦找到值，就会立即返回。
路径是一系列用点分隔的键。键可以包含特殊的通配符 "*"和"? 要访问数组值，使用索引作为键。要获取数组中的元素个数或访问子路径，请使用 "#"字符。点和通配符可以用'\'转义。
例（详细用法请访问：https://www.cnblogs.com/Xinenhui/p/17879819.html）：
<div class="cnblogs_code">
<pre>func main() {
//发送请求
request, _ := http.NewRequest("POST", urlP, bytes.NewBuffer(bytesData))
//实例化一个客户端
client := &http.Client{}
//发送请求到服务端
resp, _ := client.Do(request)
defer resp.Body.Close()
//读取响应数据
body, _ := io.ReadAll(resp.Body)
//处理数据
results := gjson.Get(string(body), "friends") //string(body)将返回数据转换成json字符串，初始数据为friends数组
results.ForEach(func(_, result gjson.Result) bool { //遍历friends数组，一般不需要键k，故用_忽略
 first1 := gjson.Get(result.Raw, "first") //默认返回的是gjson.Result类型，如果是直接打印，可直接使用，若是需进一步操作，建立转换成对应类型
 first2 := gjson.Get(result.Raw, "first").String() //从 jsonStr 中获取 "name" 字段的值，然后通过调用 .String() 方法，将获取到的值转换为字符串类型，如果 "name" 字段的值不是字符串类型，它会被转换为字符串
 first3 := gjson.Get(result.Raw, "first").Str //也是从 jsonStr 中获取 "name" 字段的值，但是是直接获取该字段的值，没有进行类型转换，如果"name"字段的值不是字符串类型，则将保持原来的类型
 //所以如果确定 "name" 字段的值一定是字符串类型，那么使用 .Str 是更简洁的方式。如果不确定 "name" 字段的值是什么类型，或者想要确保它是一个字符串类型，那么使用 .String() 进行显式转换是更安全的选择。

 fmt.Println(first1, first2, first3)
 return true　　// 表示继续处理下一个元素，而 <code>return false</code> 则会提前终止循环
})
//假设返回数据为：
//{
// "name": {"first": "Tom", "last": "Anderson"},
// "age":37,
// "children": ["Sara","Alex","Jack"],
//"friends": [
//　　{"first": "James", "last": "Murphy"},
//　　{"first": "Roger", "last": "Craig"}
//]
//}

//对应键路径的值
//"name.last" >> "Anderson"
//"age" >> 37
//"children" >> ["Sara","Alex","Jack"]
//"children.#" >> 3
//"children.1" >> "Alex"
//"child*.2" >> "Jack"
//"c?ildren.0" >> "Sara"
//"friends.#.first" >> ["James","Roger"]
}</pre>
</div>
 
<h3>六、补充</h3>
<h4>6.1 ioutil.ReadAll 已弃用</h4>
从go 1.16及之后的版本，io/ioutil就已经被正式弃用。为了兼容性考虑，依旧可以正常调用这个包，只不过当调用ioutil里面的方法，最后都是跳转到了io以及os包。
因为ioutil.ReadAll 通过 slice 将数据流读到内存中，slice 会动态扩容，对于大文件的读取会导致内存不足，被 OOM kill，并且频繁的动态扩容也会导致时间消耗增加。
故：返回的数据量小时，可继续使用或用io.ReadAll，返回的数据量大或者不清楚数据大小时，使用io.Copy()：直接从 src 读取数据，并写入到 dst，不会一次性读取全部数据，也不会频繁进行切片扩容。
详细情况请自行百度
<div class="cnblogs_code">
<pre>package main

import (
"fmt"
"io"
"net/http"
"os"
)

func main() {
res, _ := http.Get("https://www.baidu.com")
//body, _ := ioutil.ReadAll(res.Body)
//body, _ := io.ReadAll(res.Body)
body, _ := io.Copy(os.Stdout, res.Body)
fmt.Printf(string(body))
}</pre>
</div>
 
<h4>6.2 较复杂的json参数</h4>
要传递的参数形式：
<div class="cnblogs_code">
<pre>{
"content": "test",
"notifyParams": [
 {
 "type": "jobNos",
 "values": [
 "80xxxxxx",
 "W9xxxxxx",
 "O00xxxxxx"
 ]
 }
]
}</pre>
</div>
请求样例：
<div class="cnblogs_code">
<pre>package main

import (
"bytes"
"encoding/json"
"fmt"
"net/http"
)

type ttNotice struct {
Content string `json:"content"`
NotifyParams []notifyParams `json:"notifyParams"`
}
type notifyParams struct {
Type string `json:"type"`
Values []string `json:"values"`
}

func main() {
url := "http://xxx.com"

notifyList := make([]notifyParams, 0) //实例化一个list：[{type: "",Values: ["",""]},{...}]
var arrs notifyParams
arrs.Type = "jobNos"
for _, v := range arr { //arr为带有多个id的结构体
 arrs.Values = append(arrs.Values, v.SolverId)
}
//去除重复的id
var arrLen int = len(arrs.Values) - 1
for ; arrLen > 0; arrLen-- {
 //拿最后项与前面项的各项逐个(自后向前)进行比较
 for j := arrLen - 1; j >= 0; j-- {
 if arrs.Values == arrs.Values { //例：len(arrs.Values)=5,则下标为0~4，arrs.Values == arrs.Values
 arrs.Values = append(arrs.Values[:arrLen], arrs.Values...) //切片,arrs.Values[:4],arrs.Values
 break
 }
 }
}

notifyList = append(notifyList, arrs)
notice := ttNotice{
 Content: "test",
 NotifyParams: notifyList,
}
//序列化
s1, err := json.Marshal(notice)
if err != nil {
 fmt.Println(err)
}
//发送请求
_, err = http.Post(url, "application/json", bytes.NewReader(s1))
if err != nil {
 fmt.Println(err)
}
}</pre>
</div>
<h5> 6.2.1 切片</h5>
<div class="cnblogs_code">
<pre>package main

import "encoding/json"

//传参格式
type str struct {
Name string `json:"name"`
Id []string `json:"id"`
}

func main() {
s1 := []string{"2x101"}
s2 := []string{"w41e2e", "52s5sf"}

//传参
data1 := str{
 Name: "wang",
 Id: s1,
}
data2 := str{
 Name: "wang",
 Id: s2[:1],
}
bytesData, _ := json.Marshal(datax)

var s4 []string
s4 = append(s4, "1024565V")
s4 = append(s4, "1554200V")
var str1 str
str1.Name = "wang"
str1.Id = s4
bytesData, _ = json.Marshal(str1)

//s3 := mapinterface{}{
// "name": "wang",
// "id": []string{"sf451x"},
//}
//bytesData, _ = json.Marshal(s3)
}</pre>
</div>
  
来源：https://www.cnblogs.com/Xinenhui/p/17496684.html

頁: [1]

琼殿技术论坛's Archiver

Go--发起HTTP请求