首先通过一个函数启动一个服务器，只提供一个方法并返回Hello World!，当你在浏览器输入http://127.0.0.1:8080，就会看到Hello World。
对于http.ListenAndServe来说，需要我们提供一个Addr和一个Handler，所以当我们使用Hello实现了Handler的ServeHTTP方法后，Hello就会被认为是一个Handler，并将其提供给http.ListenAndServe后会自动调用ServeHTTP方法。
type Hello struct {
}
func (hello Hello) ServeHTTP(w http.ResponseWriter, r *http.Request) {
w.Write([]byte("Hello World!"))
}
func main() {
http.ListenAndServe(":8080", Hello{})
}
根据上图我们看到http的ListenAndServe调用了Server中的ListenAndServe方法，所以以上代码可以写成，再次使用浏览器访问http://127.0.0.1:8080，我们看到了Hello World。
type Hello struct {
}
func (hello Hello) ServeHTTP(w http.ResponseWriter, r *http.Request) {
w.Write([]byte("Hello World!"))
}
func main() {
server := http.Server{Addr: ":8080", Handler: Hello{}}
server.ListenAndServe()
}
以上的方法我们只能通过根路径访问我们想要的结果，如何使用不同的路径访问不同的处理程序呢，你可以写成下面这样，使用http的Handle方法，把路径和程序关联起来并注册到程序中。使用浏览器访问http://127.0.0.1:8080/hello，我们看到了Hello World，那如果访问http://127.0.0.1:8080会是什么呢，我们看一下，是404 page not found。
type Hello struct {
}
func (hello Hello) ServeHTTP(w http.ResponseWriter, r *http.Request) {
w.Write([]byte("Hello World!"))
}
func main() {
http.Handle("/hello", Hello{})
http.ListenAndServe(":8080", nil)
}
好的，我们继续看http的Handle做了什么，点开源码，发现它使用DefaultServeMux调用了一个Handle函数
func Handle(pattern string, handler Handler) { DefaultServeMux.Handle(pattern, handler) }
那DefaultServeMux是什么，我们继续展开，发现DefaultServeMux是ServeMux实例的一个指针，而且ServeMux是一个struct，通过Handle方法把程序路径和程序进行注册。
// DefaultServeMux is the default ServeMux used by Serve.
var DefaultServeMux = &defaultServeMux
var defaultServeMux ServeMux
// Handle registers the handler for the given pattern.
// If a handler already exists for pattern, Handle panics.
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
}
}
继续观察这个struct，发现它实现了ServeHTTP，那也就是说明ServeMux是一个Handler
// ServeHTTP dispatches the request to the handler whose
// pattern most closely matches the request URL.
func (mux *ServeMux) ServeHTTP(w ResponseWriter, r *Request) {
if r.RequestURI == "*" {
if r.ProtoAtLeast(1, 1) {
w.Header().Set("Connection", "close")
}
w.WriteHeader(StatusBadRequest)
return
}
h, _ := mux.Handler(r)
h.ServeHTTP(w, r)
}
根据以上分析发现DefaultServeMux是一个默认的路由程序，它将接收到的不同的程序映射到不同的路径上等待访问，同时它也是一个Handler。
现在我把程序变动一下，这样也能达到同样的效果， 使用浏览器访问http://127.0.0.1:8080/hello依然能看到Hello World。
func main() {
http.HandleFunc("/hello", func(w http.ResponseWriter, r *http.Request) {
w.Write([]byte("Hello World!"))
})
http.ListenAndServe(":8080", nil)
}
那http中的HandleFunc又是什么呢，我们点进去看一下，发现这个方法需要传入func(ResponseWriter, *Request)类型的函数。并且最终被传入了我们前面提到的ServeMux的Handle中。但是，我们知道只有实现了ServeHTTP方法才是Handler，而ServeMux的Handle需要一个Handler类型的变量，显然这个handler函数并不是一个真正的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))
}
但是我们看到它被强转成了HandlerFunc类型。那么我们继续查看HandlerFunc，HandlerFunc实现了ServeHTTP，那么这就说明HandlerFunc是一个Handler，所以最终传入到ServeMux.Handle中的HandlerFunc(handler)是一个Handler
// The HandlerFunc type is an adapter to allow the use of
// ordinary functions as HTTP handlers. If f is a function
// with the appropriate signature, HandlerFunc(f) is a
// Handler that calls f.
type HandlerFunc func(ResponseWriter, *Request)
// ServeHTTP calls f(w, r).
func (f HandlerFunc) ServeHTTP(w ResponseWriter, r *Request) {
f(w, r)
}
那么我们的代码也可以写成这样：
func Hello(w http.ResponseWriter, r *http.Request) {
w.Write([]byte("Hello World!"))
}
func main() {
http.HandleFunc("/hello", Hello)
http.ListenAndServe(":8080", nil)
}
或者这样：
func Hello(w http.ResponseWriter, r *http.Request) {
w.Write([]byte("Hello World!"))
}
func main() {
http.Handle("/hello",http.HandlerFunc(Hello))
http.ListenAndServe(":8080", nil)
}
最后http包中还有几个内置的Handler，您可以自己去探索：
NotFoundHandler
StripPrefix
RedirectHandler
TimeoutHandler
FileServer
