1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14

package main

import (
	"log"
	"net/http"
)

func main() {
	http.HandleFunc("/", func(w http.ResponseWriter, r *http.Request) {
		w.Write([]byte("hello world"))
	})
	log.Fatal(http.ListenAndServe(":8080", nil))
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14

func (sh serverHandler) ServeHTTP(rw ResponseWriter, req *Request) {
	//此handler即为http.ListenAndServe 中的第二个参数
	handler := sh.srv.Handler 
	if handler == nil {
		//如果handler为空则使用内部的DefaultServeMux 进行处理
		handler = DefaultServeMux
	}
	if req.RequestURI == "*" && req.Method == "OPTIONS" {
		handler = globalOptionsHandler{}
	}
	//这里就开始处理http请求
	//如果需要使用自定义的mux，就需要实现ServeHTTP方法，即实现Handler接口。
	handler.ServeHTTP(rw, req)
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26

package main

import (
	"log"
	"net/http"
)

func main() {
	//规则1
	http.HandleFunc("/", func(w http.ResponseWriter, r *http.Request) {
		w.Write([]byte("hello world"))
	})
	
	//规则2
	http.HandleFunc("/path/", func(w http.ResponseWriter, r *http.Request) {
		w.Write([]byte("pattern path: /path/ "))
	})

	//规则3
	http.HandleFunc("/path/subpath", func(w http.ResponseWriter, r *http.Request) {
		w.Write([]byte("pattern path: /path/subpath"))
	})

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

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12

type ServeMux struct {
	mu    sync.RWMutex  //处理并发，增加读写锁
	m     map[string]muxEntry  //存放规则map，key即为设置的path
	hosts bool // whether any patterns contain hostnames（是否包含host）
}

type muxEntry struct {
	explicit bool //是否完全匹配
	h        Handler//相应匹配规则的handler
	pattern  string//匹配路径
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39

func (mux *ServeMux) Handle(pattern string, handler Handler) {
	mux.mu.Lock()
	defer mux.mu.Unlock()

	if pattern == "" {
		panic("http: invalid pattern " + pattern)
	}
	if handler == nil {
		panic("http: nil handler")
	}
	//如果已经匹配到了则panic
	if mux.m[pattern].explicit {
		panic("http: multiple registrations for " + pattern)
	}
    
    //增加一个新的匹配规则
	mux.m[pattern] = muxEntry{explicit: true, h: handler, pattern: pattern}
	
	//根据path的第一个字母判断是否有host
	if pattern[0] != '/' {
		mux.hosts = true
	}

	//！！这里看清楚 就是实现了情景二的情况 ，看判断条件
	n := len(pattern)
	if n > 0 && pattern[n-1] == '/' && !mux.m[pattern[0:n-1]].explicit{
		// If pattern contains a host name, strip it and use remaining
		// path for redirect.
		path := pattern
		if pattern[0] != '/' {
			// In pattern, at least the last character is a '/', so
			// strings.Index can't be -1.
			path = pattern[strings.Index(pattern, "/"):]
		}
		url := &url.URL{Path: path}
		mux.m[pattern[0:n-1]] = muxEntry{h: RedirectHandler(url.String(), StatusMovedPermanently), pattern: pattern}
	}
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15

func (mux *ServeMux) match(path string) (h Handler, pattern string) {
	var n = 0
	for k, v := range mux.m {
		if !pathMatch(k, path) {
			continue
		}
		//如果匹配到了一个规则，并没有马上返回handler，而且继续匹配并且判断path的长度是否是最长的，这是关键！！！
		if h == nil || len(k) > n {
			n = len(k)
			h = v.h
			pattern = v.pattern
		}
	}
	return
}

1
2
3
4
5
6
7

type HandlerFunc func(ResponseWriter, *Request)

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