golang implements http

1. Introduction
With the increasing popularity of RESTful API, more and more developers are trying to develop http services themselves. As an efficient and highly parallel language, golang's net/http library can help us easily build reliable and high-performance http services. Today we will learn how to use golang to implement http.

2. Preparation work
We need to install the golang environment first, and use golang's package management tool go mod to manage our package dependencies.

3. Golang implements http
We can use golang’s net/http library to implement http service. The specific steps are as follows:

1. Import the net/http package and fmt package
We need to import the net/http package to use the http service-related interface it provides, and we use the fmt package to output logs.

import (
    "fmt"
    "net/http"
)

2. Implement http service
We can implement http service by calling the interface provided by net/http library. Among them, http.HandleFunc is used to register routes. The parameters resp and req in the callback function represent response and request respectively.

func main() {
    http.HandleFunc("/", myHandler)
    http.ListenAndServe(":8080", nil)
}

func myHandler(resp http.ResponseWriter, req *http.Request) {
    fmt.Println("收到请求!")
    resp.Write([]byte("Hello world!"))
}

3. Run http service
We enter the project root directory on the command line, and then execute the following command:

go run main.go

At this time we enter http:/ in the browser /localhost:8080, you can see "Hello world!". This is a complete http service implementation.

4. Route matching
In actual development, we need to specify different processing logic for different routes. The http package in golang provides a simple route matching method, which is to use the http.HandleFunc function to register routes.

In the above example, we used the default routing character "/", which means that all requests we accept will be passed to myHandler for processing. In practical applications, we usually need to specify different processing logic for different routes. Route matching can be achieved in the following way:

http.HandleFunc("/user", userHandler)
http.HandleFunc("/book", bookHandler)

In this way, when http://localhost:8080/user is requested, the userHandler function will be executed; when http://localhost:8080/book is requested, The bookHandler function will be executed.

5. Middleware
Middleware is a very common mode, which plays an important role in the processing process of http requests. The http library in golang provides a simple way to implement middleware. We can use http.HandlerFunc to encapsulate a function to implement middleware.

The following is a simple middleware example for recording the time of the current request:

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

http.HandleFunc("/", logMiddleware(myHandler))

In this code, we define a logMiddleware middleware and wrap myHandler in it. The return value of the logMiddleware function is a function that will receive a ResponseWriter and Request parameters, print the method, path and processing time of the current request inside the function, and finally call next to continue execution. In practical applications, we can add more logic to the logMiddleware implementation, such as identity authentication, request parameter verification, etc.

6. Error handling
In practical applications, we need to handle errors that may occur in http requests. golang's http library provides a simple error handling method, using the http.Error function.

The following is a simple error handling example:

func myHandler(w http.ResponseWriter, r *http.Request) {
    file, err := os.Open("abc.txt")
    if err != nil {
        http.Error(w, err.Error(), http.StatusBadRequest)
        return
    }
    defer file.Close()
}

In this code, we try to open a file that does not exist, and use http.Error to return an error response when an error occurs. The first parameter of http.Error represents the response; the second parameter is the error message; and the third parameter is the http status code.

7. Summary
In this article, we introduced how to use golang to implement http services. Specifically, we learned how to use golang's net/http library to implement http services, route matching, middleware, and error handling. For beginners, mastering these knowledge points is enough to write a simple http service.

The above is the detailed content of golang implements http. For more information, please follow other related articles on the PHP Chinese website!