golang api restful golang搭建api服务器

Golang的net/http包提供简洁强大的HTTP交互功能。通过http.Get和http.Post可快速发起基础请求，而使用http.NewRequest结合http.Client则能实现对PUT、DELETE等方法及自定义Header的精细控制。为构建健壮应用，可通过设置http.Client的Timeout字段或自定义Transport来处理超时；对于错误重试，需结合指数退避策略并判断错误类型，仅对网络错误或5xx类服务器错误进行重试，同时注意请求幂等性。解析响应数据时，encoding/json和encoding/xml包支持将JSON或XML数据解码到结构体中，利用struct tag实现字段映射，确保类型安全与高效解析。始终记得defer resp.Body.Close()以释放资源。

Golang的

net/http

Golang HTTP客户端请求与服务器交互示例

说起Golang的HTTP客户端，我个人觉得它设计得非常优雅。初次接触时，我常常被其他语言中那些复杂的请求构建器弄得头大，但在Go里，一切似乎都回到了最本质的状态。

我们先来看一个最基础的GET请求，然后逐步深入。想象一下，你想要从某个API获取一些数据：

立即学习“go语言免费学习笔记（深入）”；

package mainimport (    "fmt"    "io/ioutil"    "log"    "net/http"    "strings" // 用于POST请求的body)func main() {    // --- GET 请求示例 ---    fmt.Println("--- 发送GET请求 ---")    resp, err := http.Get("https://jsonplaceholder.typicode.com/posts/1")    if err != nil {        log.Fatalf("GET请求失败: %v", err)    }    defer resp.Body.Close() // 确保响应体被关闭，避免资源泄露    fmt.Printf("GET请求状态码: %d\n", resp.StatusCode)    if resp.StatusCode == http.StatusOK {        bodyBytes, err := ioutil.ReadAll(resp.Body)        if err != nil {            log.Fatalf("读取响应体失败: %v", err)        }        fmt.Printf("GET响应体: %s\n", string(bodyBytes))    }    // --- POST 请求示例 ---    fmt.Println("\n--- 发送POST请求 ---")    // 模拟一个JSON请求体    jsonBody := `{"title": "foo", "body": "bar", "userId": 1}`    // http.Post 接收一个io.Reader作为body，这里用strings.NewReader将字符串转为Reader    resp, err = http.Post(        "https://jsonplaceholder.typicode.com/posts",        "application/json", // Content-Type        strings.NewReader(jsonBody),    )    if err != nil {        log.Fatalf("POST请求失败: %v", err)    }    defer resp.Body.Close()    fmt.Printf("POST请求状态码: %d\n", resp.StatusCode)    if resp.StatusCode == http.StatusCreated { // POST成功通常返回201 Created        bodyBytes, err := ioutil.ReadAll(resp.Body)        if err != nil {            log.Fatalf("读取响应体失败: %v", err)        }        fmt.Printf("POST响应体: %s\n", string(bodyBytes))    }    // --- 更灵活的请求示例 (使用http.NewRequest和http.Client) ---    // 比如你想自定义Header或者使用PUT/DELETE方法    fmt.Println("\n--- 发送带有自定义Header的GET请求 ---")    req, err := http.NewRequest("GET", "https://jsonplaceholder.typicode.com/posts/2", nil)    if err != nil {        log.Fatalf("创建请求失败: %v", err)    }    req.Header.Set("User-Agent", "MyGoHttpClient/1.0")    req.Header.Set("Accept", "application/json")    // 使用默认的http.Client发送请求    client := &http.Client{}    resp, err = client.Do(req)    if err != nil {        log.Fatalf("自定义GET请求失败: %v", err)    }    defer resp.Body.Close()    fmt.Printf("自定义GET请求状态码: %d\n", resp.StatusCode)    if resp.StatusCode == http.StatusOK {        bodyBytes, err := ioutil.ReadAll(resp.Body)        if err != nil {            log.Fatalf("读取响应体失败: %v", err)        }        fmt.Printf("自定义GET响应体: %s\n", string(bodyBytes))    }}

这段代码展示了Go语言中HTTP客户端最常见的几种用法。

http.Get

http.Post

http.NewRequest

http.Client.Do

defer resp.Body.Close()

Golang中如何优雅地处理HTTP请求超时与错误重试？

在我看来，处理HTTP请求的超时和错误重试是构建健壮网络应用不可或缺的一环。网络环境复杂多变，请求失败是常态，而不是意外。Go的

net/http

1. 处理超时：

http.Client

Timeout

import (    "net/http"    "time")func main() {    client := &http.Client{        Timeout: 10 * time.Second, // 设置10秒的请求超时    }    // 接下来用这个client来发送请求    // resp, err := client.Get("http://example.com/slow-api")    // if err != nil {    //     // err可能是net/http: request canceled (Client.Timeout exceeded)    //     log.Printf("请求超时或失败: %v", err)    // }}

有时候，我们可能需要更细粒度的超时控制，比如只控制连接建立的超时，或者只控制从服务器读取响应头的超时。这时，可以自定义

http.Transport

Transport

http.Client

import (    "net"    "net/http"    "time")func main() {    tr := &http.Transport{        DialContext: (&net.Dialer{            Timeout:   5 * time.Second, // 连接建立超时            KeepAlive: 30 * time.Second,        }).DialContext,        TLSHandshakeTimeout: 5 * time.Second, // TLS握手超时        // ResponseHeaderTimeout: 10 * time.Second, // 读取响应头超时    }    client := &http.Client{        Timeout:   30 * time.Second, // 整个请求的超时，如果上面更细粒度的超时先触发，则以更细的为准        Transport: tr,    }    // 使用这个client发送请求}

通过

DialContext

2. 错误重试：Go标准库并没有内置的重试机制，但实现起来并不复杂。通常我会写一个辅助函数来封装重试逻辑，结合指数退避（Exponential Backoff）策略，这样可以避免对失败的服务器造成过大的压力。

import (    "fmt"    "log"    "net/http"    "time")// performRequestWithRetry 尝试发送HTTP请求，并进行重试func performRequestWithRetry(client *http.Client, req *http.Request, maxRetries int) (*http.Response, error) {    for i := 0; i <= maxRetries; i++ {        resp, err := client.Do(req)        if err == nil {            // 如果请求成功，或者错误不是网络错误（比如4xx/5xx的业务错误），则不重试            // 这里可以根据实际业务需求判断哪些状态码不应该重试            if resp.StatusCode >= 200 && resp.StatusCode < 300 {                return resp, nil            }            // 对于某些服务器错误，比如500，我们可能仍然希望重试            if resp.StatusCode >= 500 && resp.StatusCode < 600 {                log.Printf("收到服务器错误 %d，尝试重试 %d/%d...", resp.StatusCode, i+1, maxRetries)                resp.Body.Close() // 关闭当前响应体                goto RETRY // 跳到重试逻辑            }            // 对于其他非网络错误，直接返回            return resp, fmt.Errorf("请求返回非成功状态码: %d", resp.StatusCode)        }        log.Printf("请求失败: %v，尝试重试 %d/%d...", err, i+1, maxRetries)    RETRY:        if i < maxRetries {            // 指数退避：每次等待时间翻倍，加上一点随机抖动避免“惊群效应”            sleepTime := time.Duration(1<<uint(i)) * time.Second            jitter := time.Duration(time.Now().UnixNano()%1000) * time.Millisecond // 0-1秒随机抖动            time.Sleep(sleepTime + jitter)        }    }    return nil, fmt.Errorf("请求在 %d 次重试后仍然失败", maxRetries)}func main() {    client := &http.Client{        Timeout: 5 * time.Second,    }    req, _ := http.NewRequest("GET", "http://localhost:8080/maybe-fail", nil) // 假设这是一个可能失败的API    resp, err := performRequestWithRetry(client, req, 3) // 最多重试3次    if err != nil {        log.Fatalf("最终请求失败: %v", err)    }    defer resp.Body.Close()    fmt.Printf("最终请求成功，状态码: %d\n", resp.StatusCode)    // ... 读取响应体}

这个重试逻辑需要注意几点：

SEO大纲和内容优化写作工具

context.Context

client.Do

除了GET和POST，Golang如何发送更复杂的HTTP请求，例如PUT、DELETE或自定义Header？

当我们跳出

http.Get

http.Post

http.NewRequest

http.Client.Do

1. 使用

http.NewRequest

http.NewRequest

func NewRequest(method, url string, body io.Reader) (*Request, error)

method

"GET"

"POST"

"PUT"

"DELETE"

"PATCH"

"HEAD"

"OPTIONS"

url

body

io.Reader

nil

package mainimport (    "bytes"    "fmt"    "io/ioutil"    "log"    "net/http")func main() {    client := &http.Client{}    // --- PUT 请求示例 ---    fmt.Println("--- 发送PUT请求 ---")    putBody := []byte(`{"id": 1, "title": "updated foo", "body": "updated bar", "userId": 1}`)    req, err := http.NewRequest("PUT", "https://jsonplaceholder.typicode.com/posts/1", bytes.NewBuffer(putBody))    if err != nil {        log.Fatalf("创建PUT请求失败: %v", err)    }    req.Header.Set("Content-Type", "application/json") // PUT/POST通常需要设置Content-Type    req.Header.Set("Authorization", "Bearer your_token_here") // 假设需要认证    resp, err := client.Do(req)    if err != nil {        log.Fatalf("PUT请求失败: %v", err)    }    defer resp.Body.Close()    fmt.Printf("PUT请求状态码: %d\n", resp.StatusCode)    if resp.StatusCode == http.StatusOK {        bodyBytes, _ := ioutil.ReadAll(resp.Body)        fmt.Printf("PUT响应体: %s\n", string(bodyBytes))    }    // --- DELETE 请求示例 ---    fmt.Println("\n--- 发送DELETE请求 ---")    req, err = http.NewRequest("DELETE", "https://jsonplaceholder.typicode.com/posts/1", nil) // DELETE通常没有请求体    if err != nil {        log.Fatalf("创建DELETE请求失败: %v", err)    }    req.Header.Set("X-Custom-Header", "GolangClient") // 自定义头部    resp, err = client.Do(req)    if err != nil {        log.Fatalf("DELETE请求失败: %v", err)    }    defer resp.Body.Close()    fmt.Printf("DELETE请求状态码: %d\n", resp.StatusCode)    if resp.StatusCode == http.StatusOK { // 200 OK 或 204 No Content 都可能表示删除成功        fmt.Println("资源删除成功")    } else {        fmt.Printf("删除失败，状态码: %d\n", resp.StatusCode)    }}

2. 自定义Header：在

http.Request

Header

http.Header

map[string][]string

Set

Add

req.Header.Set("Content-Type", "application/json")

req.Header.Set("Authorization", "Bearer your_token")

req.Header.Add("X-Forwarded-For", "192.168.1.1")

3. 处理请求体：

http.NewRequest

io.Reader

io.Reader

strings.NewReader(jsonString)

bytes.NewBuffer(byteSlice)

os.Open("file.json")

application/x-www-form-urlencoded

multipart/form-data

net/url

io.Reader

// 示例：发送表单数据import (    "net/url"    "strings")func sendFormRequest() {    data := url.Values{}    data.Set("username", "gopher")    data.Set("password", "secret")    encodedData := data.Encode() // 编码为"username=gopher&password=secret"    req, err := http.NewRequest("POST", "http://example.com/login", strings.NewReader(encodedData))    if err != nil {        log.Fatal(err)    }    req.Header.Set("Content-Type", "application/x-www-form-urlencoded")    client := &http.Client{}    resp, err := client.Do(req)    if err != nil {        log.Fatal(err)    }    defer resp.Body.Close()    fmt.Printf("Form POST Status: %d\n", resp.StatusCode)}

通过这种方式，我们可以灵活地构建各种复杂的HTTP请求，满足不同的API交互需求。

在Golang中处理HTTP响应时，如何高效地解析JSON或XML数据？

当HTTP请求成功并拿到响应体后，接下来的关键一步就是解析这些数据。在现代Web服务中，JSON和XML是最常见的两种数据格式。Go标准库为这两种格式提供了非常高效且易用的解析工具。

1. 解析JSON数据：Go的

encoding/json

package mainimport (    "encoding/json"    "fmt"    "io/ioutil"    "log"    "net/http")// 定义一个结构体来匹配JSON响应的结构type Post struct {    UserID int    `json:"userId"` // `json:"userId"`是struct tag，用于指定JSON字段名    ID     int    `json:"id"`    Title  string `json:"title"`    Body   string `json:"body"`}func main() {    resp, err := http.Get("https://jsonplaceholder.typicode.com/posts/1")    if err != nil {        log.Fatalf("GET请求失败: %v", err)    }    defer resp.Body.Close()    if resp.StatusCode != http.StatusOK {        log.Fatalf("请求失败，状态码: %d", resp.StatusCode)    }    // 读取响应体    bodyBytes, err := ioutil.ReadAll(resp.Body)    if err != nil {        log.Fatalf("读取响应体失败: %v", err)    }    // 创建一个Post结构体的实例来存储解析后的数据    var post Post    err = json.Unmarshal(bodyBytes, &post) // 将字节切片解码到结构体中    if err != nil {        log.Fatalf("JSON解析失败: %v", err)    }    fmt.Printf("解析后的JSON数据:\n")    fmt.Printf("UserID: %d\n", post.UserID)    fmt.Printf("ID: %d\n", post.ID)    fmt.Printf("Title: %s\n", post.Title)    fmt.Printf("Body: %s\n", post.Body)    // 如果JSON是一个数组，则需要定义一个结构体切片    // var posts []Post    // err = json.Unmarshal(bodyBytes, &posts)}

json.Unmarshal

json:"fieldName"

对于不确定JSON结构或者只需要获取部分字段的情况，也可以使用

map[string]interface{}

// ... (之前的代码)var rawData map[string]interface{}err = json.Unmarshal(bodyBytes, &rawData)if err != nil {    log.Fatalf("JSON解析到map失败: %v", err)}fmt.Printf("解析到map的Title: %v\n", rawData["title"])

这种方式虽然灵活，但在类型安全性和性能上不如直接映射到结构体。

2. 解析XML数据：Go的

encoding/xml

encoding/json

package mainimport (    "encoding/xml"    "fmt"    "io/ioutil"    "log"    "net/http"    "strings")// 定义结构体

以上就是GolangHTTP客户端请求与服务器交互示例的详细内容，更多请关注乐哥常识网其它相关文章！