Go语言的http库怎么使用

Go语言的标准库中提供了一个强大且易用的net/http包，用于构建HTTP客户端和服务器。本文将介绍如何使用Go语言的net/http包来创建HTTP服务器、处理HTTP请求、发送HTTP请求等常见操作。

1. 创建一个简单的HTTP服务器

首先，我们来看如何创建一个简单的HTTP服务器。以下是一个最基本的HTTP服务器示例：

package main

import (
    "fmt"
    "net/http"
)

func helloHandler(w http.ResponseWriter, r *http.Request) {
    fmt.Fprintf(w, "Hello, World!")
}

func main() {
    http.HandleFunc("/", helloHandler)
    fmt.Println("Starting server at port 8080...")
    if err := http.ListenAndServe(":8080", nil); err != nil {
        fmt.Println("Error starting server:", err)
    }
}

在这个示例中，我们定义了一个helloHandler函数，它会在收到HTTP请求时向客户端返回”Hello, World!“。然后，我们使用http.HandleFunc将根路径/与helloHandler函数绑定。最后，我们调用http.ListenAndServe启动服务器，监听8080端口。

2. 处理不同的HTTP方法

在实际开发中，我们通常需要根据HTTP方法（如GET、POST等）来处理不同的请求。以下是一个处理GET和POST请求的示例：

package main

import (
    "fmt"
    "net/http"
)

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

func main() {
    http.HandleFunc("/", handler)
    fmt.Println("Starting server at port 8080...")
    if err := http.ListenAndServe(":8080", nil); err != nil {
        fmt.Println("Error starting server:", err)
    }
}

在这个示例中，我们根据r.Method来判断请求的HTTP方法，并分别处理GET和POST请求。如果请求方法不是GET或POST，我们返回一个405 Method Not Allowed错误。

3. 解析请求参数

在处理HTTP请求时，我们通常需要解析请求中的参数。以下是一个解析GET请求参数的示例：

package main

import (
    "fmt"
    "net/http"
)

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

func main() {
    http.HandleFunc("/", handler)
    fmt.Println("Starting server at port 8080...")
    if err := http.ListenAndServe(":8080", nil); err != nil {
        fmt.Println("Error starting server:", err)
    }
}

在这个示例中，我们使用r.URL.Query().Get("name")来获取URL中的name参数。如果name参数不存在，我们默认使用”Guest”作为名字。

对于POST请求，我们可以使用r.ParseForm()来解析表单数据：

package main

import (
    "fmt"
    "net/http"
)

func handler(w http.ResponseWriter, r *http.Request) {
    if r.Method == "POST" {
        r.ParseForm()
        name := r.FormValue("name")
        fmt.Fprintf(w, "Hello, %s!", name)
    } else {
        http.Error(w, "Method not allowed", http.StatusMethodNotAllowed)
    }
}

func main() {
    http.HandleFunc("/", handler)
    fmt.Println("Starting server at port 8080...")
    if err := http.ListenAndServe(":8080", nil); err != nil {
        fmt.Println("Error starting server:", err)
    }
}

在这个示例中，我们使用r.ParseForm()来解析POST请求的表单数据，并使用r.FormValue("name")来获取表单中的name字段。

4. 发送HTTP请求

除了创建HTTP服务器，net/http包还提供了发送HTTP请求的功能。以下是一个发送GET请求的示例：

package main

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

func main() {
    resp, err := http.Get("https://jsonplaceholder.typicode.com/posts/1")
    if err != nil {
        fmt.Println("Error making GET request:", err)
        return
    }
    defer resp.Body.Close()

    body, err := ioutil.ReadAll(resp.Body)
    if err != nil {
        fmt.Println("Error reading response body:", err)
        return
    }

    fmt.Println(string(body))
}

在这个示例中，我们使用http.Get函数发送一个GET请求，并读取响应的内容。

对于POST请求，我们可以使用http.Post或http.PostForm函数：

package main

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

func main() {
    data := url.Values{}
    data.Set("title", "foo")
    data.Set("body", "bar")
    data.Set("userId", "1")

    resp, err := http.PostForm("https://jsonplaceholder.typicode.com/posts", data)
    if err != nil {
        fmt.Println("Error making POST request:", err)
        return
    }
    defer resp.Body.Close()

    body, err := ioutil.ReadAll(resp.Body)
    if err != nil {
        fmt.Println("Error reading response body:", err)
        return
    }

    fmt.Println(string(body))
}

在这个示例中，我们使用http.PostForm函数发送一个POST请求，并传递表单数据。

5. 使用中间件

中间件是一种在请求处理之前或之后执行某些操作的机制。我们可以使用中间件来实现日志记录、身份验证等功能。以下是一个简单的日志中间件示例：

package main

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

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

func helloHandler(w http.ResponseWriter, r *http.Request) {
    fmt.Fprintf(w, "Hello, World!")
}

func main() {
    http.Handle("/", loggingMiddleware(http.HandlerFunc(helloHandler)))
    fmt.Println("Starting server at port 8080...")
    if err := http.ListenAndServe(":8080", nil); err != nil {
        fmt.Println("Error starting server:", err)
    }
}

在这个示例中，我们定义了一个loggingMiddleware函数，它会在每个请求处理前后记录请求的方法、路径和处理时间。然后，我们将loggingMiddleware应用到helloHandler上。

6. 使用自定义路由

虽然net/http包提供了基本的路由功能，但在实际开发中，我们通常需要使用更强大的路由库，如gorilla/mux或httprouter。以下是一个使用gorilla/mux的示例：

package main

import (
    "fmt"
    "net/http"
    "github.com/gorilla/mux"
)

func helloHandler(w http.ResponseWriter, r *http.Request) {
    fmt.Fprintf(w, "Hello, World!")
}

func main() {
    r := mux.NewRouter()
    r.HandleFunc("/", helloHandler)
    fmt.Println("Starting server at port 8080...")
    if err := http.ListenAndServe(":8080", r); err != nil {
        fmt.Println("Error starting server:", err)
    }
}

在这个示例中，我们使用gorilla/mux库创建了一个路由器，并将根路径/与helloHandler函数绑定。

7. 处理静态文件

在Web开发中，我们通常需要提供静态文件（如CSS、JavaScript、图片等）。以下是一个处理静态文件的示例：

package main

import (
    "fmt"
    "net/http"
)

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.Fprintf(w, "Welcome to the homepage!")
    })

    fmt.Println("Starting server at port 8080...")
    if err := http.ListenAndServe(":8080", nil); err != nil {
        fmt.Println("Error starting server:", err)
    }
}

在这个示例中，我们使用http.FileServer来提供static目录下的静态文件，并通过http.StripPrefix去除URL中的/static/前缀。

8. 处理JSON数据

在现代Web开发中，JSON是一种常见的数据格式。以下是一个处理JSON数据的示例：

package main

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

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

func handler(w http.ResponseWriter, r *http.Request) {
    if r.Method == "POST" {
        var user User
        err := json.NewDecoder(r.Body).Decode(&user)
        if err != nil {
            http.Error(w, err.Error(), http.StatusBadRequest)
            return
        }
        fmt.Fprintf(w, "Received user: %+v", user)
    } else {
        http.Error(w, "Method not allowed", http.StatusMethodNotAllowed)
    }
}

func main() {
    http.HandleFunc("/", handler)
    fmt.Println("Starting server at port 8080...")
    if err := http.ListenAndServe(":8080", nil); err != nil {
        fmt.Println("Error starting server:", err)
    }
}

在这个示例中，我们定义了一个User结构体，并使用json.NewDecoder来解析POST请求中的JSON数据。

9. 处理文件上传

处理文件上传是Web开发中的常见需求。以下是一个处理文件上传的示例：

package main

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

func uploadHandler(w http.ResponseWriter, r *http.Request) {
    if r.Method == "POST" {
        file, handler, err := r.FormFile("file")
        if err != nil {
            http.Error(w, "Unable to read file", http.StatusBadRequest)
            return
        }
        defer file.Close()

        dst, err := os.Create(handler.Filename)
        if err != nil {
            http.Error(w, "Unable to create file", http.StatusInternalServerError)
            return
        }
        defer dst.Close()

        if _, err := io.Copy(dst, file); err != nil {
            http.Error(w, "Unable to save file", http.StatusInternalServerError)
            return
        }

        fmt.Fprintf(w, "File uploaded successfully: %s", handler.Filename)
    } else {
        http.Error(w, "Method not allowed", http.StatusMethodNotAllowed)
    }
}

func main() {
    http.HandleFunc("/upload", uploadHandler)
    fmt.Println("Starting server at port 8080...")
    if err := http.ListenAndServe(":8080", nil); err != nil {
        fmt.Println("Error starting server:", err)
    }
}

在这个示例中，我们使用r.FormFile("file")来获取上传的文件，并将其保存到服务器上。

10. 使用HTTPS

在生产环境中，我们通常需要使用HTTPS来加密通信。以下是一个使用HTTPS的示例：

package main

import (
    "fmt"
    "net/http"
)

func helloHandler(w http.ResponseWriter, r *http.Request) {
    fmt.Fprintf(w, "Hello, World!")
}

func main() {
    http.HandleFunc("/", helloHandler)
    fmt.Println("Starting HTTPS server at port 443...")
    if err := http.ListenAndServeTLS(":443", "server.crt", "server.key", nil); err != nil {
        fmt.Println("Error starting HTTPS server:", err)
    }
}

在这个示例中，我们使用http.ListenAndServeTLS来启动一个HTTPS服务器，并指定证书文件和私钥文件。

总结

Go语言的net/http包提供了丰富的功能，使得构建HTTP服务器和客户端变得非常简单。通过本文的介绍，你应该已经掌握了如何使用net/http包来创建HTTP服务器、处理HTTP请求、发送HTTP请求等常见操作。在实际开发中，你可以根据需要结合其他库（如gorilla/mux）来构建更复杂的Web应用。