Use of go language web Middleware

A summary of the premises

Undertake the last time Use Go Language construction Web The server , We implemented a simple application HelloWorld, By listening to local 8080 port , Provide web service . Client access through http://127.0.0.1:8080/ Can get the return value “Hello World!”

The story background

Now the server wants to count the time consumed in each response to the request （ It's just about app Time spent processing requests , Other times such as link communication are not included ）, We can HelloWorld Make the following simple modifications

func HelloWorld(w http.ResponseWriter, r *http.Request) {
    
	timeStart := time.Now()
	_, err := fmt.Fprintf(w, "Hello World!")
	if err != nil {
    
		log.Panic(err)
	}
	timeElapse := time.Since(timeStart)
	log.Println(timeElapse)
}

Now if there is a second , The third application , We can also add simple code . But if there are many applications ,30 individual 、100 individual , This method obviously won't work . The key to the problem is business code and non business code （ Time statistics ） Mixed together

The introduction of middleware

The idea is simple , Is what the server will get request The request is first passed to the middleware of time statistics timeMiddleware, Then it is passed to the application by the middleware HelloWorld, Here is timeMiddleware Simple implementation

func timeMiddleware(next http.Handler) http.Handler {
    
	return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
    
		timeStart := time.Now()
		// Pass parameters to the next http.Handler
		next.ServeHTTP(w, r)
		timeElapse := time.Since(timeStart)
		log.Println(timeElapse)
	})
}

stay main Function

func main() {
    
	http.Handle("/", timeMiddleware(http.HandlerFunc(HelloWorld)))
	if err := http.ListenAndServe(":8080", nil); err != nil {
    
		log.Panic(err)
	}
}

It needs to be added here http.Handler、http.HandlerFunc、ServeHttp The relationship between

type Handler interface {
    
	ServeHTTP(ResponseWriter, *Request)
}

type HandlerFunc func(ResponseWriter, *Request)

func (f HandlerFunc) ServeHTTP(w ResponseWriter, r *Request) {
    
	f(w, r)
}

Handler It's an interface , There is only one way ServeHttp,HandlerFunc Is a function type , Realized Handler Interface , So in timeMiddleware By calling next.ServeHTTP(w, r) Is to pass parameters to execute app

Now expand , If you want to continue adding a log function , We can do this

// Add a middleware for log Generation 
func logMiddleware(h http.Handler) http.Handler {
    
	return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
    
		file, _ := os.OpenFile("test.log", os.O_APPEND|os.O_CREATE|os.O_RDWR, 0666)
		logger := log.New(file, "", log.Llongfile|log.LstdFlags)
		// take w,r Pass to next handler
		h.ServeHTTP(w, r)
		logger.Println(" Request processing complete ")
	})
}
func main() {
    
	http.Handle("/", logMiddleware(timeMiddleware(http.HandlerFunc(HelloWorld))))
	if err := http.ListenAndServe(":8080", nil); err != nil {
    
		log.Panic(err)
	}
}

After accessing through the browser , The following information can be obtained in the background log Information ：
2022/04/16 19:32:07 E:/goland-workspace/goRestful/httptest/main.go:38: Request processing complete
2022/04/16 19:32:07 E:/goland-workspace/goRestful/httptest/main.go:38: Request processing complete