À propos de http.Handle () et http.NewServeMux (). Handle ()

Supposons que vous ayez le code suivant: N'est-ce pas la même chose que les deux font? À la suite de mon enquête.

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

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

Conclusion

Les deux faisaient essentiellement la même chose en interne.

http.Handle() Le modèle d'URL et le gestionnaire correspondant sont enregistrés dans DefaultServeMux.

La mise en œuvre est la suivante.

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

Qu'est-ce que DefaultServeMux?

DefaultServeMux est une variable qui stocke le type de pointeur de ServeMux.

Alors, qu'est-ce que ServeMux?

Multiplexeur HTTP. La mise en œuvre est la suivante.

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
}

Le centre de http.Handle () est DefaultServeMux.Handle (modèle, gestionnaire)

Le modèle d'URL et le gestionnaire correspondant sont enregistrés dans DefaultServeMux.

Autrement dit, la partie de DefaultServeMux.Handle (pattern, handler). Un gestionnaire correspondant au modèle d'URL est ajouté à ServeMux.m.

La mise en œuvre est la suivante.

// 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() Le modèle d'URL et le gestionnaire correspondant sont enregistrés dans ServeMux. La mise en œuvre est la suivante.

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

N'est-ce pas exactement le même processus que DefaultServeMux.Handle (pattern, handler)? .. En d'autres termes, il effectue en interne le même traitement que http.Handle ().

Conclusion encore

Le code au début peut faire exactement la même chose. Cependant, puisque http.NewServeMux (). Handle () crée ServeMux par lui-même Il peut être utilisé lorsque vous souhaitez modifier la valeur indépendamment.

Références

• Package http