Comment faire un serveur en Golang ?

Comment faire un serveur en golang ?

Comment faire un serveur en golang :

On sait que le package net/http en golang supporte très bien le réseau, ce qui nous permettra de comparer Il est facile de configurer un serveur relativement simple. Jetons un coup d'œil à un morceau de code

func sayHi(w http.ResponseWriter, r *http.Request)  {
    fmt.Fprint(w,"Hi")
}
func main() {
    http.HandleFunc("/sayHi", sayHi)
    log.Fatal(http.ListenAndServe("localhost:8080", nil))
}

Un serveur relativement simple est configuré ici. Qu'est-ce que cela signifie ? Parlons-en maintenant brièvement. Ici, nous écoutons un port de notre machine locale, puis acceptons la demande du client, puis répondons au client avec les données correspondantes.

Regardons un autre morceau de code

func sayHi(w http.ResponseWriter, r *http.Request)  {
    fmt.Fprint(w,"Hi")
}
func main() {
    serveMux := http.DefaultServeMux
    serveMux.HandleFunc("/sayHi", sayHi)
    log.Fatal(http.ListenAndServe("localhost:8080", serveMux))
}

Les deux morceaux de code ont la même fonction, mais il existe quelques différences dans la méthode d'écriture. Analysons ce que sont Handler, HandlerFunc et DefaultServeMux. sont utilisés pour.

Dans le premier morceau de code, jetons un œil au code source de la fonction HandleFunc.

func HandleFunc(pattern string, handler func(ResponseWriter, *Request)) {
    DefaultServeMux.HandleFunc(pattern, handler)
}

Dans le code source, appeler cette fonction appellera une méthode qu'elle contient.

func (mux *ServeMux) HandleFunc(pattern string, handler func(ResponseWriter, *Request)) {
    mux.Handle(pattern, HandlerFunc(handler))
}

Cette méthode est définie sur la structure ServeMux, alors que fait exactement ce ServeMux ? Ne vous inquiétez pas pour l'instant. Examinons le code source. Ici, nous appelons une méthode Handle définie sur la structure ServeMux.

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)
    }
    mux.m[pattern] = muxEntry{h: handler, pattern: pattern}
    if pattern[0] != '/' {
        mux.hosts = true
    }
}

Ici, nous voyons que quelque chose a été ajouté à ServeMux, y compris des modèles et des gestionnaires. À quoi sert d'ajouter ces éléments ? Revenons en arrière et regardons le deuxième morceau de code en haut.

serveMux := http.DefaultServeMux
serveMux.HandleFunc("/sayHi", sayHi)

Le gros morceau de code précédent est une préparation pour ces deux lignes de code. S'il est écrit de cette façon, nous devons mettre notre propre fonction définie sayHi dans serveMux. Cependant, golang l'a déjà fait pour nous. . Un serveMux par défaut est DefaultServeMux, puis le chemin URL/sayHi auquel nous devons accéder, la méthode de traitement correspondante est une correspondance individuelle dans DefaultServeMux, donc ici nous avons un peu de compréhension, ce DefaultServeMux stocke-t-il notre chemin d'accès et nos exigences ? Qu’en est-il d’un ensemble de méthodes de traitement ?

Oui, ce qui est stocké, c'est le handler correspondant au pattern, on l'appelle ici routage.

Alors, comment cela fonctionne-t-il ? Ici, vous devez regarder le code source de http.ListenAndServe("localhost:8080", serveMux).

Voyons comment l'implémenter. Le code source ici est relativement long. Sélectionnons quelques-uns des paragraphes les plus importants pour y jeter un œil

func ListenAndServe(addr string, handler Handler) error {
    server := &Server{Addr: addr, Handler: handler}
    return server.ListenAndServe()
}

Ici, l'adresse surveillée et. le gestionnaire à traiter est transmis. En regardant plus bas

go c.serve(ctx)

Ici, goroutine est démarré pour répondre à chaque demande client. Le traitement final se fait dans la méthode c.serve. cette méthode, il y a des lieux à noter.

serverHandler{c.server}.ServeHTTP(w, w.req)

Ici, une autre méthode ServeHTTP est appelée, et voyons ensuite ce que cette méthode gère.

Dans cette méthode, nous voyons un tel morceau de code

if handler == nil {
        handler = DefaultServeMux
    }
...
handler.ServeHTTP(rw, req)

Ici, nous voyons que si aucun gestionnaire n'est transmis, alors le DefaultServeMux par défaut est utilisé. Nous comprenons maintenant pourquoi dans le premier paragraphe. le début Dans le code, nous devons passer un zéro, puis handler.ServeHTTP(rw, req) appelle la méthode d'implémentation de l'interface Handler De cette façon, nous pouvons décider à quel gestionnaire un certain modèle doit correspondre. comprenons-le quand on voit cela. Quel est le principe général de ce serveur ? Bien sûr, c'est une analyse très superficielle, et il y a encore beaucoup de choses plus profondes qui doivent être étudiées.

Tutoriel recommandé : "tutoriel de langue go"

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!