Informationen zu http.Handle () und http.NewServeMux (). Handle ()

Angenommen, Sie haben den folgenden Code: Ist es nicht dasselbe, was beide tun? Als Ergebnis meiner Untersuchung.

http.Handle("/any/", anyHandler)
http.ListenAndServe(":8080", nil)

mux := http.NewServeMux()
mux.Handle("/any/", anyHandler)
http.ListenAndServe(":8080", mux)

Fazit

Beide machten im Grunde genommen intern dasselbe.

http.Handle() Das URL-Muster und der entsprechende Handler sind in DefaultServeMux registriert.

Die Implementierung ist wie folgt.

// Handle registers the handler for the given pattern
// in the DefaultServeMux.
// The documentation for ServeMux explains how patterns are matched.
func Handle(pattern string, handler Handler) { DefaultServeMux.Handle(pattern, handler) }

Was ist DefaultServeMux?

DefaultServeMux ist eine Variable, die den Zeigertyp von ServeMux speichert.

Was ist ServeMux?

HTTP-Multiplexer. Die Implementierung ist wie folgt.

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
}

Das Zentrum von http.Handle () ist DefaultServeMux.Handle (Muster, Handler)

Das URL-Muster und der entsprechende Handler sind in DefaultServeMux registriert.

Das heißt, der Teil von "DefaultServeMux.Handle (Muster, Handler)". Ein dem URL-Muster entsprechender Handler wird zu "ServeMux.m" hinzugefügt.

Die Implementierung ist wie folgt.

// 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
	}
}

http.NewServeMux().Handle() Das URL-Muster und der entsprechende Handler sind in ServeMux registriert. Die Implementierung ist wie folgt.

// 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
	}
}

Ist es nicht genau der gleiche Prozess wie "DefaultServeMux.Handle (Muster, Handler)"? .. Mit anderen Worten, es führt intern dieselbe Verarbeitung durch wie "http.Handle ()".

Nochmals Fazit

Der Code am Anfang kann genau das Gleiche tun. Da jedoch "http.NewServeMux (). Handle ()" ServeMux selbst erstellt Es kann verwendet werden, wenn Sie den Wert darin unabhängig ändern möchten.

Verweise

Package http