go http server 编程

第一种：最简单的

package main

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

func myHandler(w http.ResponseWriter, r *http.Request) {
	fmt.Fprintf(w, "hello http server!")
}

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

上面的变种1:

//上面的一个变种
package main

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

func myHandler(w http.ResponseWriter, r *http.Request) {
	fmt.Fprintf(w, "hello http server 1!")
}

func main() {
	//// 通过 HandlerFunc 把函数转换成 Handler 接口的实现对象
	handler := http.HandlerFunc(myHandler)
	http.Handle("/", handler)
	log.Fatal(http.ListenAndServe(":8080", nil))
}

ListenAndServe函数负责监听并处理连接。

第二种：Handler接口

上面的那种方式发挥余地太小，比如我想设置server的Timeout时间都不能设置。这时候我们就用到了 自定义的server

type Server struct {
    Addr		string		//TCP address to listen on
    Handler		Handler		//handler to invoke
    ReadTimeout	time.Duration	//maximum duration before timing out read of the request
    WriteTimeout time.Duration	//maximum duration before timing out write of the response
    TLSConfig	*tls.Config
    ...
}
//Handler是一个interface，定义如下
type Handler interface {
    ServeHTTP(ResponseWrite, *Request)
}

所以只要我们实现了Handler接口的方法ServeHTTP就可以自定义我们的server了。示例代码如下

package main

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

type myHandler struct{}

func (myHandler myHandler) ServeHTTP(w ResponseWrite, r *Request) {
	fmt.Fprintf(w, "hello serverhttp 1")
}

func main() {
	server := http.Server{
		Addr:        ":8080",
		Handler:     &myHandler{},
		ReadTimeout: 3 * time.Second,
	}
	log.Fatal(server.ListenAndServe(":8080", nil))
}

还有下面这种：

package main

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

type myHandler struct{}

func (myHandler *myHandler) ServeHTTP(w http.ResponseWriter, r *http.Request) {
	fmt.Fprintf(w, "hello, server 2!")
}

func main() {
	http.Handle("/", &myHandler{})
	log.Fatal(http.ListenAndServe(":8080", nil))
}

还有这种：

package main

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

type MyHandler struct{}

func (myHandler *MyHandler) ServeHTTP(w http.ResponseWriter, r *http.Request) {
	switch r.URL.Path {
	case "/":
		fmt.Fprintf(w, "URL.Path = %q\n", r.URL.Path)
	case "/hello":
		for k, v := range r.Header {
			fmt.Fprintf(w, "Header[%q] = %q\n", k, v)
		}
	default:
		fmt.Fprintf(w, "404 not found: %s\n", r.URL)
	}
}

func main() {
	myHandler := new(MyHandler)
	log.Fatal(http.ListenAndServe(":8080", myHandler))
}

第三种：多个url的ServeMux

ServeMux可以注册多个URL和handler的对应关系，并自动把请求转移到对应的handler进行处理。

package main

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

func myHandler(w http.ResponseWriter, r *http.Request) {
	fmt.Fprintf(w, "hello server!")
}

func yourHandler(w http.ResponseWriter, r *http.Request) {
	fmt.Fprintf(w, "your handler")
}

func main() {
	mux := http.NewServeMux()
	mux.HandleFunc("/my", myHandler)
	mux.HandleFunc("/your", yourHandler)

	log.Fatal(http.ListenAndServe(":8080", mux))
}

• 通过 NewServeMux 生成了 ServerMux 结构，URL 和 handler 是通过它注册的
• http.ListenAndServe 方法第二个参数变成了上面的 mux 变量

思考：上面写的那些程序是怎么实现的？

一个HTTP请求过程要认识几个概念，服务器端的几个重要概念：

• Request： 用户请求的信息，这个可以用来处理用户的请求信息，POST，url，cookie，header等信息
• Response：服务器返回给用户的信息
• Conn：每次连接的信息
• Handler：处理请求和生成返回处理信息的逻辑

url路由到处理函数是怎么实现的？就是上面所说的Handler的处理逻辑。

我们先来看看golang自带的包 net/http 下的程序，主要程序在 net/http/server.go 文件中。

经过追踪程序，去掉其他的细节末节，处理url到handler的一个最重要函数是 func (mux *ServeMux) Handle(pattern string, handler Handler)，即使是func (mux *ServeMux) HandleFunc(pattern string, handler func(ResponseWriter, *Request))这个处理函数，最后也是Handle函数来处理的，看看它们具体的代码：

//具体处理url路由到Handler
func (mux *ServeMux) Handle(pattern string, handler Handler) {
    mux.mu.Lock()
    defer mux.mu.Unlock()
    if pattern == "" {
        panic("http: invalid pattern")
    }
    if handler == nil {
        panic("http: nil handler")
    }
    if _, exist := mux.m[pattern]; exist {
        panic("http: multiple registrations for " + pattern)
    }
    if mux.m == nil {
        mux.m = make(map[string]muxEntry)
    }
    e := muxEntry{h: handler, pattern: pattern}
    mux.m[pattern] = e
    if pattern[len(pattern)-1] == '/' {
        mux.es = appendSorted(mux.es, e)
    }
    if pattern[0] != '/' {
        mux.hosts = true
    }
}

// HandleFunc registers the handler function for the given pattern.
//路由url到HandleFunc，与上面的函数（func (mux *ServeMux) Handle(pattern string, handler Handler)）有什么区别？
//这个HandleFunc是具体的处理函数，而上面的Handle函数是一个接口，一个类型只要实现接口里面的方法，那么就可以传入进来作为Handler进行处理
//我的理解就是提供了2中不同的处理url路由的方法
//其实这个函数最后处理还是用了上面的Handle()方法
func (mux *ServeMux) HandleFunc(pattern string, handler func(ResponseWriter, *Request)) {
    if handler == nil {
        panic("http: nil handler")
    }
    mux.Handle(pattern, HandlerFunc(handler))
}

有了处理函数，肯定会有另外一个疑问，url是怎么映射到处理函数的呢？其实我们从上面方法就可以看出来，方法有一个接收体 mux *ServeMux ，看看这个具体代码是什么？

// 一个结构体，存储了url，也存储了对于的Handler，在muxEntry里
type ServeMux struct {
    mu    sync.RWMutex
    m     map[string]muxEntry
    es    []muxEntry // slice of entries sorted from longest to shortest.
    hosts bool       // whether any patterns contain hostnames
}

// 定义了存储的路由和根据路由来处理逻辑的Handler
type muxEntry struct {
    h       Handler   //根据路由具体的处理接口
    pattern string   //定义的路由
}

// DefaultServeMux is the default ServeMux used by Serve.
var DefaultServeMux = &defaultServeMux
var defaultServeMux ServeMux

上面的muxEntry struct 结构体有一个h字段，他是 Handler接口，它具体是什么呢？

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

它是处理HTTP请求的一个接口。这也是设计好程序的一个方法，依赖接口，而不是具体的实现。

也就是说只要实现了这个接口里的方法ServeHTTP(ResponseWriter, *Request)，就是处理HTTP请求了。

包里面就有一个这样的程序：

//装饰器模式
type HandlerFunc func(ResponseWriter, *Request)
// ServeHTTP calls f(w, r). 实现了 Handler interface里的方法
func (f HandlerFunc) ServeHTTP(w ResponseWriter, r *Request) {
    f(w, r)
}

包里还定义了默认处理方法，如下

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

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

其实我们看看上面的方法，是不是调用的最开始我们分析的DefaultServeMux.Handle(pattern, handler) 和 DefaultServeMux.HandleFunc(pattern, handler)

2个处理函数 Handle 和 HandleFunc。

包里有默认处理函数，那我们能不能自定义函数处理呢？

答案：当然可以的。你看 第二种：Handler接口 就是自定义的处理函数，因为我们定义一个类型struct，然后它实现了Handler 接口方法 ServeHTTP , 而处理url路由到Handler的方法第二个参数就是Handler接口，

看看方法：func (mux *ServeMux) Handle(pattern string, handler Handler)。 所以当然是可以的。

这也是一个依赖接口设计的好处，不仅官方包可以写处理函数，我们也可以自定义处理函数。但是Handle函数参数不用修改。只要传一个实现了接口方法的类型数据就可以了。

update: 2020.01.20 晚