Golang发送Get和Post请求的实现

公西囡囡

目录

• Get请求
  
• Post请求
  

最近在研究钉钉机器人，发现钉钉的第三方接口有时需要用Get或者Post请求访问，虽然说可以通过Apifox直接模拟发送请求，但是我还是想研究一个如何使用Golang来发送Get和Post请求。

Get请求

1. package getUserid
   
2. 
   
3. import (
   
4.         "crypto/tls"
   
5.         "encoding/json"
   
6.         "io/ioutil"
   
7.         "net/http"
   
8.         "strings"
   
9.         "time"
   
10. )
    
11. 
    
12. type User struct { //我们发送get请求需要传递一个参数mobile，我们封装一个对应的结构体
    
13.         Mobile string `json:"mobile"`
    
14. }
    
15. type UserResopnseFail struct { //这个是如果访问失败的话，把失败信息保存在结构体创建的对象中
    
16.         Errcode int    `json:"errcode"`
    
17.         Errmsg  string `json:"errmsg"`
    
18.         Result  struct {
    
19.                 Userid string `json:"userid"`
    
20.         } `json:"result"`
    
21.         RequestId string `json:"request_id"`
    
22. }
    
23. type UserResponseSucc struct {// //这个是如果访问成功的话，把成功信息保存在结构体创建的对象中
    
24.         Errcode int    `json:"errcode"`
    
25.         Errmsg  string `json:"errmsg"`
    
26.         Result  struct {
    
27.                 Userid string `json:"userid"`
    
28.         } `json:"result"`
    
29.         RequestId string `json:"request_id"`
    
30. }
    
31. 
    
32. func GetUserID(number,access_token string) (userid string,err error) {
    
33.         var client *http.Client //封装客户端
    
34.         var request *http.Request //封装请求
    
35.         var resp *http.Response //封装响应
    
36.         var body []byte
    
37.         urlForUserID := "https://oapi.dingtalk.com/topapi/v2/user/getbymobile?access_token=" + access_token//拼接URL
    
38.         client = &http.Client{Transport: &http.Transport{ //对客户端进行一些配置
    
39.                 TLSClientConfig: &tls.Config{
    
40.                         InsecureSkipVerify: true,
    
41.                 },
    
42.         }, Timeout: time.Duration(time.Second * 5)}
    
43.         u := User{
    
44.                 Mobile: number,
    
45.         } //声明一个结构体对象，把我们传递的参数放进去
    
46.         usermarshal, err := json.Marshal(&u) //把结构体序列化成byte[]类型
    
47.         if err != nil {
    
48.                 return
    
49.         }
    
50.        
    
51.         reqBody := strings.NewReader(string(usermarshal))//此处再处理一步，才能放入下方请求中
    
52.         request, err = http.NewRequest(http.MethodPost, urlForUserID, reqBody)
    
53.         if err != nil {
    
54.                 return
    
55.         }
    
56.         resp, err = client.Do(request)//发送请求
    
57.         if err != nil {
    
58.                 return
    
59.         }
    
60.         defer resp.Body.Close()
    
61.         body, err = ioutil.ReadAll(resp.Body) //把请求到的body转化成byte[]
    
62.         if err != nil {
    
63.                 return
    
64.         }
    
65.         dataSucc := UserResponseSucc{} //声明一个响应对象
    
66.         err = json.Unmarshal(body, &dataSucc)//把resq.Body反序列化成一个结构体对象
    
67.         if err != nil {
    
68.                 dateFail := UserResopnseFail{}
    
69.                 err = json.Unmarshal(body, &dateFail)
    
70.                 if err != nil {
    
71.                         return
    
72.                 }
    
73.         }
    
74.         return dataSucc.Result.Userid,err
    
75. 
    
76.         return
    
77. }

复制代码

以上即是Golang发送一个简单的Get请求。

Post请求

1. func Post(需要的参数) (需要返回的数据) {
   
2.         var client *http.Client
   
3.         var request *http.Request
   
4.         var resp *http.Response
   
5.         var body []byte
   
6.         URL := "xxx"
   
7.         client = &http.Client{Transport: &http.Transport{ //对客户端进行一些配置
   
8.                 TLSClientConfig: &tls.Config{
   
9.                         InsecureSkipVerify: true,
   
10.                 },
    
11.         }, Timeout: time.Duration(time.Second * 5)}
    
12. //此处是post请求的请求题，我们先初始化一个对象
    
13.         b := Body{
    
14.                 xxx :xxx,
    
15.         }
    
16. //然后把结构体对象序列化一下
    
17.         bodymarshal, err := json.Marshal(&b)
    
18.         if err != nil {
    
19.                 return
    
20.         }
    
21. //再处理一下
    
22.         reqBody := strings.NewReader(string(bodymarshal))
    
23. //然后就可以放入具体的request中的
    
24.         request, err = http.NewRequest(http.MethodPost, URL, reqBody)
    
25.         if err != nil {
    
26.                 return
    
27.         }
    
28.         resp, err = client.Do(request)
    
29.         if err != nil {
    
30.                 return
    
31.         }
    
32.         defer resp.Body.Close()
    
33.         body, err = ioutil.ReadAll(resp.Body) //把请求到的body转化成byte[]
    
34.         if err != nil {
    
35.                 return
    
36.         }
    
37. //初始化结构体对象
    
38.         r := Response{}
    
39. //把请求到的结构反序列化到专门接受返回值的对象上面
    
40.         err = json.Unmarshal(body, &r)
    
41.         if err != nil {
    
42.                 return
    
43.         }
    
44.         // 此处举行具体的逻辑判断，然后返回即可
    
45.         return
    
46. }
    
47. //此处是发送Post请求的请求体（我们根据具体的接口文档定义即可）
    
48. type Body struct {
    
49.         xxx   string `json:"xxx"`
    
50. }
    
51. //此处是请求的返回结果（我们根据具体的接口文档定义即可）
    
52. type Response struct {
    
53.         Errcode int `json:"errcode"`
    
54.         Result Result `json:"result"`
    
55. }

复制代码

到此这篇关于Golang发送Get和Post请求的实现的文章就介绍到这了,更多相关Golang发送Get和Post请求内容请搜索晓枫资讯以前的文章或继续浏览下面的相关文章希望大家以后多多支持晓枫资讯！

免责声明：如果侵犯了您的权益，请联系站长，我们会及时删除侵权内容，谢谢合作！

June625

顶顶更健康！！！