Golang

关注公众号 jb51net

关闭
首页 > 脚本专栏 > Golang > Go语言net/http库

Go语言net/http库使用详解

作者:n8n

net/http是Go语言标准库中用于处理HTTP协议的核心组件,它提供了完整HTTP客户端和服务器实现,这个包让开发者能够快速构建高性能的Web服务,无需依赖第三方框架,感兴趣的可以了解一下

1 概述

net/http是Go语言标准库中用于处理HTTP协议的核心组件,它提供了完整HTTP客户端和服务器实现。这个包让开发者能够快速构建高性能的Web服务,无需依赖第三方框架。

1.1 主要特性

2 HTTP服务器开发

2.1 基本服务器搭建

以下是创建一个最简单HTTP服务器的示例:

package main

import (
    "fmt"
    "net/http"
)

func main() {
    // 注册处理函数
    http.HandleFunc("/", func(w http.ResponseWriter, r *http.Request) {
        fmt.Fprint(w, "Hello, World!")
    })
    
    // 启动服务器
    fmt.Println("Starting server on :8080")
    err := http.ListenAndServe(":8080", nil)
    if err != nil {
        fmt.Printf("Error starting server: %v\n", err)
    }
}

2.2 处理不同的HTTP方法

可以根据请求方法执行不同的逻辑:

func handler(w http.ResponseWriter, r *http.Request) {
    switch r.Method {
    case http.MethodGet:
        fmt.Fprint(w, "This is a GET request.")
    case http.MethodPost:
        fmt.Fprint(w, "This is a POST request.")
    default:
        http.Error(w, "Method not allowed", http.StatusMethodNotAllowed)
    }
}

2.3 请求参数处理

查询参数(URL参数)

func queryHandler(w http.ResponseWriter, r *http.Request) {
    name := r.URL.Query().Get("name")
    age := r.URL.Query().Get("age")
    fmt.Fprintf(w, "Hello, %s! Age: %s", name, age)
}

表单数据

func formHandler(w http.ResponseWriter, r *http.Request) {
    if r.Method == "POST" {
        err := r.ParseForm()
        if err != nil {
            http.Error(w, "Bad Request", http.StatusBadRequest)
            return
        }
        username := r.FormValue("username")
        password := r.FormValue("password")
        fmt.Fprintf(w, "Username: %s, Password: %s", username, password)
    }
}

JSON请求体

func jsonHandler(w http.ResponseWriter, r *http.Request) {
    type RequestData struct {
        Name  string `json:"name"`
        Email string `json:"email"`
    }
    
    var data RequestData
    err := json.NewDecoder(r.Body).Decode(&data)
    if err != nil {
        http.Error(w, err.Error(), http.StatusBadRequest)
        return
    }
    
    fmt.Fprintf(w, "Name: %s, Email: %s", data.Name, data.Email)
}

2.4 路由管理

使用ServeMux进行路由管理

func main() {
    mux := http.NewServeMux()
    
    mux.HandleFunc("/", homeHandler)
    mux.HandleFunc("/users", usersHandler)
    mux.HandleFunc("/posts", postsHandler)
    
    http.ListenAndServe(":8080", mux)
}

动态路由参数(需配合第三方路由库)

虽然标准库的ServeMux不支持动态路由参数,但可以结合正则表达式或使用第三方库实现。

3 HTTP客户端开发

3.1 发送GET请求

package main

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

func main() {
    resp, err := http.Get("https://jsonplaceholder.typicode.com/posts/1")
    if err != nil {
        fmt.Printf("Error: %v\n", err)
        return
    }
    defer resp.Body.Close()
    
    body, err := io.ReadAll(resp.Body)
    if err != nil {
        fmt.Printf("Error reading body: %v\n", err)
        return
    }
    
    fmt.Println(string(body))
}

3.2 发送POST请求

func main() {
    data := []byte(`{"title": "foo", "body": "bar", "userId": 1}`)
    
    resp, err := http.Post(
        "https://jsonplaceholder.typicode.com/posts",
        "application/json",
        bytes.NewBuffer(data),
    )
    if err != nil {
        fmt.Printf("Error: %v\n", err)
        return
    }
    defer resp.Body.Close()
    
    // 处理响应...
}

3.3 自定义请求

使用http.NewRequest可以创建更复杂的请求:

func main() {
    // 创建请求
    data := []byte(`{"name": "Go"}`)
    req, err := http.NewRequest("POST", "https://httpbin.org/post", bytes.NewBuffer(data))
    if err != nil {
        fmt.Printf("Error creating request: %v\n", err)
        return
    }
    
    // 设置请求头
    req.Header.Set("Content-Type", "application/json")
    req.Header.Set("Authorization", "Bearer token123")
    
    // 发送请求
    client := &http.Client{
        Timeout: time.Second * 10,
    }
    
    resp, err := client.Do(req)
    if err != nil {
        fmt.Printf("Error sending request: %v\n", err)
        return
    }
    defer resp.Body.Close()
    
    // 处理响应...
}

3.4 客户端超时设置

func main() {
    client := &http.Client{
        Timeout: 10 * time.Second,
    }
    
    resp, err := client.Get("https://www.example.com")
    if err != nil {
        fmt.Printf("Error: %v\n", err)
        return
    }
    defer resp.Body.Close()
}

4 高级特性

4.1 中间件开发

中间件可以在处理HTTP请求前后执行特定逻辑:

func loggingMiddleware(next http.Handler) http.Handler {
    return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
        start := time.Now()
        next.ServeHTTP(w, r)
        log.Printf("Request: %s %s processed in %v", 
            r.Method, r.URL.Path, time.Since(start))
    })
}

func authMiddleware(next http.Handler) http.Handler {
    return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
        token := r.Header.Get("Authorization")
        if token != "valid-token" {
            http.Error(w, "Unauthorized", http.StatusUnauthorized)
            return
        }
        next.ServeHTTP(w, r)
    })
}

func main() {
    mux := http.NewServeMux()
    mux.HandleFunc("/", func(w http.ResponseWriter, r *http.Request) {
        fmt.Fprint(w, "Hello, World!")
    })
    
    // 应用中间件
    handler := loggingMiddleware(authMiddleware(mux))
    
    http.ListenAndServe(":8080", handler)
}

4.2 静态文件服务

func main() {
    // 提供静态文件服务
    fs := http.FileServer(http.Dir("static"))
    http.Handle("/static/", http.StripPrefix("/static/", fs))
    
    http.HandleFunc("/", func(w http.ResponseWriter, r *http.Request) {
        fmt.Fprint(w, "Main page")
    })
    
    http.ListenAndServe(":8080", nil)
}

4.3 Cookie处理

func cookieHandler(w http.ResponseWriter, r *http.Request) {
    // 读取Cookie
    cookie, err := r.Cookie("session")
    if err != nil {
        // 创建新Cookie
        cookie = &http.Cookie{
            Name:     "session",
            Value:    "session-id-123",
            Path:     "/",
            HttpOnly: true,
        }
        http.SetCookie(w, cookie)
    }
    
    fmt.Fprintf(w, "Cookie value: %s", cookie.Value)
}

4.4 JSON响应

func jsonResponseHandler(w http.ResponseWriter, r *http.Request) {
    type Response struct {
        Status  string `json:"status"`
        Message string `json:"message"`
        Data    interface{} `json:"data,omitempty"`
    }
    
    response := Response{
        Status:  "success",
        Message: "Data retrieved successfully",
        Data: map[string]interface{}{
            "id":   1,
            "name": "John Doe",
        },
    }
    
    w.Header().Set("Content-Type", "application/json")
    json.NewEncoder(w).Encode(response)
}

5 常见问题与解决方案

5.1 易错点及避免方法

易错点问题描述解决方案
资源泄露未关闭响应体总是使用defer resp.Body.Close()
路由冲突路由匹配顺序错误明确路由优先级,从具体到一般
阻塞操作长时间运行的操作阻塞服务使用goroutine处理耗时任务
内存泄漏不当使用全局变量或缓存合理管理资源生命周期

5.2 性能优化建议

  1. 连接复用:使用http.Client的默认连接池
  2. 超时设置:为客户端和服务器设置合理的超时时间
  3. 并发处理:利用Go的并发特性处理请求
  4. 静态资源缓存:合理设置缓存头减少重复传输

5.3 安全最佳实践

func secureHeadersMiddleware(next http.Handler) http.Handler {
    return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
        // 设置安全相关的HTTP头
        w.Header().Set("X-Content-Type-Options", "nosniff")
        w.Header().Set("X-Frame-Options", "DENY")
        w.Header().Set("X-XSS-Protection", "1; mode=block")
        w.Header().Set("Strict-Transport-Security", "max-age=63072000; includeSubDomains")
        
        next.ServeHTTP(w, r)
    })
}

6 实战案例:完整的API服务

以下是一个完整的用户管理API示例:

package main

import (
    "encoding/json"
    "log"
    "net/http"
    "strconv"
    "time"
    
    "github.com/gorilla/mux"
)

type User struct {
    ID    int    `json:"id"`
    Name  string `json:"name"`
    Email string `json:"email"`
}

var users = []User{
    {ID: 1, Name: "Alice", Email: "alice@example.com"},
    {ID: 2, Name: "Bob", Email: "bob@example.com"},
}

func getUsers(w http.ResponseWriter, r *http.Request) {
    w.Header().Set("Content-Type", "application/json")
    json.NewEncoder(w).Encode(users)
}

func getUser(w http.ResponseWriter, r *http.Request) {
    w.Header().Set("Content-Type", "application/json")
    params := mux.Vars(r)
    id, _ := strconv.Atoi(params["id"])
    
    for _, user := range users {
        if user.ID == id {
            json.NewEncoder(w).Encode(user)
            return
        }
    }
    
    http.Error(w, "User not found", http.StatusNotFound)
}

func createUser(w http.ResponseWriter, r *http.Request) {
    var user User
    err := json.NewDecoder(r.Body).Decode(&user)
    if err != nil {
        http.Error(w, err.Error(), http.StatusBadRequest)
        return
    }
    
    user.ID = len(users) + 1
    users = append(users, user)
    
    w.Header().Set("Content-Type", "application/json")
    w.WriteHeader(http.StatusCreated)
    json.NewEncoder(w).Encode(user)
}

func loggingMiddleware(next http.Handler) http.Handler {
    return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
        start := time.Now()
        next.ServeHTTP(w, r)
        log.Printf("%s %s %v", r.Method, r.URL.Path, time.Since(start))
    })
}

func main() {
    router := mux.NewRouter()
    
    // 路由定义
    router.HandleFunc("/users", getUsers).Methods("GET")
    router.HandleFunc("/users/{id}", getUser).Methods("GET")
    router.HandleFunc("/users", createUser).Methods("POST")
    
    // 应用中间件
    router.Use(loggingMiddleware)
    
    log.Println("Server starting on :8080")
    log.Fatal(http.ListenAndServe(":8080", router))
}

7 总结

Go语言的net/http包提供了一个强大而灵活的工具集,用于构建HTTP客户端和服务器应用程序。通过本文的介绍,您应该能够:

  1. 创建基本的HTTP服务器和客户端
  2. 处理各种类型的HTTP请求和响应
  3. 实现中间件以增强功能
  4. 避免常见的陷阱和错误
  5. 构建生产级别的Web服务

net/http包的简洁设计和强大功能使得Go语言成为构建高性能Web服务的理想选择。随着对包的深入理解,您可以构建出既强大又易于维护的Web应用程序。

到此这篇关于Go语言net/http库使用详解的文章就介绍到这了,更多相关Go语言net/http库内容请搜索脚本之家以前的文章或继续浏览下面的相关文章希望大家以后多多支持脚本之家!

您可能感兴趣的文章:
阅读全文