生命不止，继续go go go !!!
不知不觉，2018年第一个月份已经过完，看了看一月份uv统计：
北京 9887
深圳 5088
上海 4767
杭州 2834
广州 2559
成都 2059
武汉 1536
南京 1444
西安 982
言归正传！
Middlewares(中间件)
wiki上对中间件的解释：
中间件（英语：Middleware），又译中间件，是提供系统软件和应用软件之间连接的软件，以便于软件各部件之间的沟通，特别是应用软件对于系统软件的集中的逻辑，在现代信息技术应用框架如Web服务、面向服务的体系结构等中应用比较广泛。
通俗的讲：
当你正在构建一个Web应用程序有可能要运行许多（甚至全部）的HTTP请求一些共享功能：
你可能想记录每一个request
gzip压缩的每个response
验证
等等
实现这个共享功能的一种方法是将其设置为中间件。
Middleware in Webservice
If you have some code that needs to be run for some common requests,you need some way to stack on top of each other and run them in sequence. This problem is solved elegantly through middleware packages.
看看上面的英文描述，是不是更清晰一点点了。
Go语言中实现和使用middleware是非常简单
- Implement our middleware so that it satisfies the http.Handler interface.(使我们的中间件能搞满足 http.handlers 这个接口)
- Build up a chain of handlers containing both our middleware handler and our normal application handler,which we can register with a http.ServeMux.(建立一个 handlers 链，使其能够满足中间件的 handler 和 正常应用的 handler，并且能够注册到 http.ServeMux)
如果不了解golang总的http handler，可以参考：
A Recap of Request Handling in Go
ServeMux
A ServeMux is essentially a HTTP request router (or multiplexor). It compares incoming requests against a list of predefined URL paths,and calls the associated handler for the path whenever a match is found.Handlers
Handlers are responsible for writing response headers and bodies. Almost any object can be a handler,so long as it satisfies the http.Handler interface.
一个带有多个中间件的例子
package main
import (
"log"
"net/http"
)
func middlewareOne(next http.Handler) http.Handler {
return http.HandlerFunc(func(w http.ResponseWriter,r *http.Request) {
log.Println("Executing middlewareOne")
next.ServeHTTP(w,r)
log.Println("Executing middlewareOne again")
})
}
func middlewareTwo(next http.Handler) http.Handler {
return http.HandlerFunc(func(w http.ResponseWriter,r *http.Request) {
log.Println("Executing middlewareTwo")
if r.URL.Path != "/" {
return
}
next.ServeHTTP(w,r)
log.Println("Executing middlewareTwo again")
})
}
func final(w http.ResponseWriter,r *http.Request) {
log.Println("Executing finalHandler")
w.Write([]byte("OK"))
}
func main() {
finalHandler := http.HandlerFunc(final)
http.Handle("/",middlewareOne(middlewareTwo(finalHandler)))
http.ListenAndServe(":8080",nil)
}
浏览器访问：http://localhost:8080/
结果：
2018/02/01 13:04:48 Executing middlewareOne
2018/02/01 13:04:48 Executing middlewareTwo
2018/02/01 13:04:48 Executing finalHandler
2018/02/01 13:04:48 Executing middlewareTwo again
2018/02/01 13:04:48 Executing middlewareOne again
使用中间件检查请求体的存在
package main
import (
"bytes"
"net/http"
)
func enforceXMLHandler(next http.Handler) http.Handler {
return http.HandlerFunc(func(w http.ResponseWriter,r *http.Request) {
// Check for a request body
if r.ContentLength == 0 {
http.Error(w,http.StatusText(400), 400)
return
}
// Check its MIME type
buf := new(bytes.Buffer)
buf.ReadFrom(r.Body)
if http.DetectContentType(buf.Bytes()) != "text/xml; charset=utf-8" {
http.Error(w,http.StatusText(415), 415)
return
}
next.ServeHTTP(w,r)
})
}
func main() {
finalHandler := http.HandlerFunc(final)
http.Handle("/",enforceXMLHandler(finalHandler))
http.ListenAndServe(":8080",nil)
}
func final(w http.ResponseWriter,r *http.Request) {
w.Write([]byte("OK"))
}
使用中间件写日志
package main
import (
"fmt"
"log"
"net/http"
"time"
)
func loggingHandle(next http.Handler) http.Handler {
fn := func(w http.ResponseWriter,r *http.Request) {
t1 := time.Now()
next.ServeHTTP(w,r)
t2 := time.Now()
log.Printf("[%s] %q %v\n",r.Method,r.URL.String(),t2.Sub(t1))
}
return http.HandlerFunc(fn)
}
func aboutHandler(w http.ResponseWriter,r *http.Request) {
fmt.Fprintf(w,"you are on about page")
}
func main() {
aboutHandler := http.HandlerFunc(aboutHandler)
http.Handle("/",loggingHandle(aboutHandler))
http.ListenAndServe(":8080",nil)
}
浏览器访问：http://localhost:8080/
结果：
2018/02/01 13:16:56 [GET] “/” 499.5µs
goji/httpauth
HTTP Authentication middlewares
获取：
go get github.com/goji/httpauth
package main
import (
"net/http"
"github.com/goji/httpauth"
)
func main() {
finalHandler := http.HandlerFunc(final)
authHandler := httpauth.SimpleBasicAuth("username","password")
http.Handle("/",authHandler(finalHandler))
http.ListenAndServe(":8080",r *http.Request) {
w.Write([]byte("OK"))
}
curl测试：
curl --i username:password@localhost:8080
HTTP/1.1 200 OK
Date: Thu,01 Feb 2018 05:27:33 GMT
Content-Length: 2
Content-Type: text/plain; charset=utf-8
OK
gorilla/handlers
请参考：
Go实战–Gorilla web toolkit使用之gorilla/handlers
package main
import (
"github.com/gorilla/handlers"
"net/http"
"os"
)
func main() {
finalHandler := http.HandlerFunc(final)
logFile,err := os.OpenFile("server.log",os.O_WRONLY|os.O_CREATE|os.O_APPEND, 0666)
if err != nil {
panic(err)
}
http.Handle("/",handlers.LoggingHandler(logFile,finalHandler))
http.ListenAndServe(":3000",r *http.Request) {
w.Write([]byte("OK"))
}
justinas/alice
Painless middleware chaining for Go
github地址：
https://github.com/justinas/alice
获取：
go get github.com/justinas/alice
To start you call New() passing in each handler you want to execute,in the order that you want them to execute. That returns a structure off which you will call Then(),which tells Alice the final handler that must execute,which needs to be our router. This sample assumes the logger middleware function we setup previously is in a directory named middleware.
func NewHttpServer(address string,port int) *http.Server {
router := setupHttpRouter()
server := alice.New(middleware.Logger).Then(router)
listener := &http.Server{
Addr: fmt.Sprintf("%s:%d",address,port),Handler: server,}
return listener
}
urfave/negroni
Idiomatic HTTP Middleware for Golang
github地址：
https://github.com/urfave/negroni
获取：
go get github.com/urfave/negroni
negroni.Classic()
provides some default middleware that is useful for most applications:
- negroni.Recovery - Panic Recovery Middleware.
- negroni.Logger - Request/Response Logger Middleware.
- negroni.Static - Static File serving under the “public” directory.
官方例子：
package main
import (
"fmt"
"net/http"
"github.com/urfave/negroni"
)
func main() {
mux := http.NewServeMux()
mux.HandleFunc("/",func(w http.ResponseWriter,req *http.Request) {
fmt.Fprintf(w,"Welcome to the home page!")
})
n := negroni.Classic() // Includes some default middlewares
n.UseHandler(mux)
http.ListenAndServe(":3000",n)
}
关于negroni，之后会更加详细的介绍。
版权声明：本文内容由互联网用户自发贡献，该文观点与技术仅代表作者本人。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如发现本站有涉嫌侵权/违法违规的内容， 请发送邮件至 dio@foxmail.com 举报，一经查实，本站将立刻删除。