go的http详解

       Go提供了一个完善的net/http包用于搭建web服务器，同时http能很简单的对web的路由进行设置和操作。

      http包建立的简单的web服务器，路由器的配置，请求的监听和处理。

package main
import (
	"fmt"
	"net/http"
	"log"
)
type sayHello struct{
}
func (s *sayHello) ServeHTTP(w http.ResponseWriter, r *http.Request){
	fmt.Println("sayhello")
	fmt.Fprintf(w,"sayhello")
}
func hello(w http.ResponseWriter, r *http.Request){
	fmt.Println("hello")
	fmt.Fprintf(w,"hello")
}
func main(){
	t:=&sayHello{}
	http.HandleFunc("/",hello)
	http.Handle("/index",t)
	http.ListenAndServe(":8080",nil)
}

路由器的配置

      http服务端程序主要有内部默认路由器和外部自定义路由器。
      内部默认的路由器结构：  

var DefaultServeMux = &defaultServeMux//内部默认路由器
var defaultServeMux ServeMux
type ServeMux struct {
	mu    sync.RWMutex//同步锁，用于涉及并发的请求处理
	m     map[string]muxEntry//路由规则，一个string对应一个muxEntry
	hosts bool // whether any patterns contain hostnames
}
type muxEntry struct {
	explicit bool//是否精确匹配
	h        Handler//路由对应的handle
	pattern  string//匹配字符串
}
type Handler interface {
	ServeHTTP(ResponseWriter, *Request)
}

       http包中有两个注册内部路由规则的方法：Handle函数和HandleFunc函数，这两个函数底层都

是调用了DefaultServerMux对象的Handle函数。

type HandlerFunc func(ResponseWriter, *Request)// HandlerFunc实现ServeHTTP方法，得以适配handler接口
func (f HandlerFunc) ServeHTTP(w ResponseWriter, r *Request) {
	f(w, r)
}
//通过传入实现ServeHTTP方法的类型
func Handle(pattern string, handler Handler) { DefaultServeMux.Handle(pattern, handler) }
//通过传入func(ResponseWriter, *Request)类型的方法，注册路由
func HandleFunc(pattern string, handler func(ResponseWriter, *Request)) {
	DefaultServeMux.HandleFunc(pattern, handler)
}
func (mux *ServeMux) HandleFunc(pattern string, handler func(ResponseWriter, *Request)) {
	mux.Handle(pattern, HandlerFunc(handler))
}//底层的路由存储，以string-muxEntry的形式存到DefaultServeMux的m中
func (mux *ServeMux) Handle(pattern string, handler Handler) {
	mux.mu.Lock()
	defer mux.mu.Unlock()

	if mux.m == nil {
		mux.m = make(map[string]muxEntry)
	}
	mux.m[pattern] = muxEntry{explicit: true, h: handler, pattern: pattern}

	if pattern[0] != '/' {
		mux.hosts = true
	}
	n := len(pattern)
	if n > 0 && pattern[n-1] == '/' && !mux.m[pattern[0:n-1]].explicit {
		path := pattern
		if pattern[0] != '/' {
			path = pattern[strings.Index(pattern, "/"):]
		}
		url := &url.URL{Path: path}
		mux.m[pattern[0:n-1]] = muxEntry{h: RedirectHandler(url.String(), StatusMovedPermanently), pattern: pattern}
	}
}

       外部自定义路由器

      外部自定义路由就是定义一个struct实现ServeHTTP函数，在ServeHTTP中进行路由转发。

package main
import (
	"fmt"
	"net/http"
)
type MyMux struct {
}
func (p *MyMux) ServeHTTP(w http.ResponseWriter, r *http.Request) {
	if r.URL.Path == "/" {
		hello(w, r)
		return
	}
	http.NotFound(w, r)
	return
}
func hello(w http.ResponseWriter, r *http.Request){
	fmt.Println("hello")
	fmt.Fprintf(w,"hello")
}
func main() {
	mux := &MyMux{}
	http.ListenAndServe(":9090", mux)
}

请求监听和处理

       从web服务端处理程序可以看到ListenAndServe函数进行了端口的监听，接收请求，分配handle进行

请求处理。函数的底层实现主要是初始化一个server对象，然后调用net.Listen("tcp", addr)利用tcp进行端

口监听,然后通过server对象的Serve函数进行http请求的接收和处理。

func ListenAndServe(addr string, handler Handler) error {
	server := &Server{Addr: addr, Handler: handler}
	return server.ListenAndServe()
}
func (srv *Server) ListenAndServe() error {
	addr := srv.Addr
	……
	ln, err := net.Listen("tcp", addr)
	……
	return srv.Serve(tcpKeepAliveListener{ln.(*net.TCPListener)})
}  

     server对象的Serve函数的实现

func (srv *Server) Serve(l net.Listener) error {
	defer l.Close()
	var tempDelay time.Duration // how long to sleep on accept failure
	for {
		rw, e := l.Accept()
		if e != nil {
			if ne, ok := e.(net.Error); ok && ne.Temporary() {
				if tempDelay == 0 {
					tempDelay = 5 * time.Millisecond
				} else {
					tempDelay *= 2
				}
				if max := 1 * time.Second; tempDelay > max {
					tempDelay = max
				}
				time.Sleep(tempDelay)
				continue
			}
			return e
		}
		tempDelay = 0
		c := srv.newConn(rw)//对于每个请求实例化一个conn对象
		c.setState(c.rwc, StateNew) // before Serve can return
		go c.serve(ctx)//开启一个goroutine接收数据并处理
	}
}
func (c *conn) serve(ctx context.Context) {
	……
	for {//读取请求数据
		w, err := c.readRequest(ctx)
		……
		serverHandler{c.server}.ServeHTTP(w, w.req)
		……	
	}
}
func (sh serverHandler) ServeHTTP(rw ResponseWriter, req *Request) {
	handler := sh.srv.Handler//ListenAndServe传入的自定义路由器
	if handler == nil {//没有传入自定义路由器
		handler = DefaultServeMux//http包的默认路由器
	}
	handler.ServeHTTP(rw, req)
}
func (mux *ServeMux) ServeHTTP(w ResponseWriter, r *Request) {
	……
	h, _ := mux.Handler(r)//根据url获取对应的handler
	h.ServeHTTP(w, r)//执行handler的ServerHTTP函数处理请求
}