golang的http server使用及原理

目录

golang的http server使用

使用方式1：

使用方式2：

使用方式3：

http server原理

方式一和方式二对比，

方式二方式三对比

---

golang的http server使用

参考标准库手册有明确说明http://doc.golang.ltd/

使用方式1：

http.HandleFunc("/bar", func(w http.ResponseWriter, r *http.Request) {
	fmt.Fprintf(w, "Hello, %q", html.EscapeString(r.URL.Path))
})
http.ListenAndServe(":8080", nil)

使用方式2：

type FooHandler struct {
}

func (f FooHandler)ServeHTTP(w ResponseWriter, r *Request) {
    fmt.Fprintf(w, "Hello, %q", html.EscapeString(r.URL.Path))
}

fooHandler :=  FooHandler{}

http.Handle("/foo", fooHandler)

http.ListenAndServe(":8080", nil)

使用方式3：

type FooHandler struct {
}

func (f FooHandler)ServeHTTP(w ResponseWriter, r *Request) {
    fmt.Fprintf(w, "Hello, %q", html.EscapeString(r.URL.Path))
}

fooHandler :=  FooHandler{}

s := &http.Server{
	Addr:           ":8080",
	Handler:        fooHandler,
	ReadTimeout:    10 * time.Second,
	WriteTimeout:   10 * time.Second,
	MaxHeaderBytes: 1 << 20,
}
s.ListenAndServe()

http server原理

方式一和方式二对比，

不同的是

http.HandleFunc 和 http.Handle 都是用于注册路由，可以发现两者的区别在于第二个参数，前者是一个具有 func(w http.ResponseWriter, r *http.Requests) 签名的函数，而后者是一个结构体，该结构体实现了 func(w http.ResponseWriter, r *http.Requests) 签名的方法。

查看其源码可发现两个方式都是通过DefaultServeMux 调用 Handle 方法来完成路由的注册。

http.HandleFunc源码：

func HandleFunc(pattern string, handler func(ResponseWriter, *Request)) {
    DefaultServeMux.HandleFunc(pattern, handler)
}

// HandleFunc registers the handler function for the given pattern.
//   ----------重点关注----------
func (mux *ServeMux) HandleFunc(pattern string, handler func(ResponseWriter, *Request)) {
    if handler == nil {
        panic("http: nil handler")
    }
    // ----------重点关注----------
    mux.Handle(pattern, HandlerFunc(handler))
}

http.Handle源码：

func Handle(pattern string, handler Handler) {
    DefaultServeMux.Handle(pattern, handler)
}

这两种方式，一个传入Handler接口，一个传入handle函数，最后 DefaultServeMux.Handle(pattern, handler)的时候，使用的是Handler接口，那么就需要一个将函数，转化为Handler接口的方法

由上面源码可看到，这个方法貌似是    // ----------重点关注---------  mux.Handle(pattern, HandlerFunc(handler))，但发现HandlerFunc并不是一个函数，而是一个类型，handler只是构建此类型对象的一个参数。

在其ServeHTTP方法中调用了自己。HandlerFunc并不是一个函数，而是一个类型，但是其实现了ServeHTTP方法，所以也是Handler接口。所以就能直接使用。

看其源码：

type HandlerFunc func(ResponseWriter, *Request)

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

这就是一个源码里将函数转化为接口的一个巧妙的方法，值得学习

方式二方式三对比

两种方式基本一致，不同的是，一个使用net/http的ListenAndServe函数监听，一个使用http.Server.ListenAndServe方法监听，那么有啥不同呢？

看源码：

func ListenAndServe(addr string, handler Handler) error {
	server := &Server{Addr: addr, Handler: handler}
	return server.ListenAndServe()
}

发现函数里面也是实例化一个Server结构，然后调用其ListenAndServe方法，方式2和方式3其实都是一样的，只是方式3，server结构自己定义，结构中的参数可以自己定义，而通过函数的方式，则是函数中定义的。

注意：

除了上面的不同外，还有一处不同，即方式2的hand是Nil,而方式3的hand是传入的Handler对象。

那么，这又有啥不同呢？

通过方式1和方式2的对比，可知通过函数http.hand或者http.HandFunc，最终都是   DefaultServeMux.HandleFunc(pattern, handler)，因为他们的hand都是Nil。

而方式3的hand不是Nil，会调用到哪里呢？

看源码：

func (srv *Server) ListenAndServe() error {
    ...
    return srv.Serve(tcpKeepAliveListener{ln.(*net.TCPListener)})
}

继续

func (srv *Server) Serve(l net.Listener) error {
    ...
    go c.serve(ctx)
    ...
}

继续跟踪

func (c *conn) serve(ctx context.Context) {
    ...
    serverHandler{c.server}.ServeHTTP(w, w.req)
    ...
}

继续跟踪

func (sh serverHandler) ServeHTTP(rw ResponseWriter, req *Request) {
	handler := sh.srv.Handler
	if handler == nil {
		handler = DefaultServeMux
	}
	if req.RequestURI == "*" && req.Method == "OPTIONS" {
		handler = globalOptionsHandler{}
	}
	handler.ServeHTTP(rw, req)
}

好了，到这里终于明白了。

如果没有Handler,也就是为Nil的情况，那么久使用DefaultServeMux作为handler，难怪方式1，方式2，传的handler都是Nil，而hand和HandFunc都是调用的DefaultServeMux的方法。

而如果传了handler，那么久调用自定义的handler的ServeHTTP方法。