Wie erstelle ich einen Server in Golang?

Wie erstelle ich einen Server in Golang?

So erstellen Sie einen Server in Golang:

Wir wissen, dass das Net/http-Paket in Golang das Netzwerk sehr gut unterstützt, was uns dies ermöglichen wird Vergleich: Es ist einfach, einen relativ einfachen Server einzurichten. Schauen wir uns einen Code an.

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

Hier wird ein relativ einfacher Server eingerichtet. Lassen Sie uns nun kurz darüber sprechen. Hier hören wir einen Port unseres lokalen Computers ab, nehmen dann die Anfrage des Clients an und antworten dem Client dann mit den entsprechenden Daten.

Schauen wir uns einen anderen Code an

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

Die Funktionen dieser beiden Codeteile sind gleich, es gibt jedoch einige Unterschiede in der Schreibmethode. Lassen Sie uns analysieren, was diese sind Handler, HandlerFunc, und DefaultServeMux werden verwendet.

Im ersten Teil des Codes werfen wir einen Blick auf den Quellcode für die Funktion HandleFunc.

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

Im Quellcode wird durch den Aufruf dieser Funktion eine darin enthaltene Methode aufgerufen.

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

Diese Methode ist in der ServeMux-Struktur definiert. Was genau macht dieser ServeMux? Machen Sie sich vorerst keine Sorgen, schauen wir uns den Quellcode an. Hier rufen wir eine Handle-Methode auf, die in der ServeMux-Struktur definiert ist.

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

Hier sehen wir, dass etwas zu ServeMux hinzugefügt wurde, einschließlich Mustern und Handlern. Welchen Sinn hat das Hinzufügen dieser Dinge? Schauen wir uns den zweiten Codeabschnitt oben an.

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

Der große Teil des Codes ist die Vorbereitung für diese beiden Codezeilen. Wenn er so geschrieben ist, müssen wir unsere eigene definierte Funktion sayHi in ServeMux einfügen. Golang hat dies jedoch bereits für uns erledigt Ein Standard-ServeMux ist DefaultServeMux. Der URL-Pfad/Sagen wir, auf den wir zugreifen müssen, die entsprechende Verarbeitungsmethode ist eine Eins-zu-Eins-Entsprechung in DefaultServeMux. Hier haben wir ein wenig Verständnis dafür, ob dieser DefaultServeMux unseren Zugriffspfad und unsere Anforderungen speichert. Wie wäre es mit einer Sammlung von Verarbeitungsmethoden?

Ja, was gespeichert wird, ist der Handler, der dem Muster entspricht, hier nennen wir es Routing.

Wie funktioniert das? Hier müssen Sie sich den Quellcode von http.ListenAndServe("localhost:8080", ServeMux) ansehen.

Sehen wir uns an, wie man es implementiert. Wählen wir einige der wichtigeren Absätze aus, um einen Blick darauf zu werfen.

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

Hier die überwachte Adresse Der zu verarbeitende Handler wird übergeben. Weiter unten

go c.serve(ctx)

Hier wird Goroutine gestartet, um jede Client-Anfrage zu bedienen. Die endgültige Verarbeitung erfolgt in der c.serve-Methode Bei dieser Methode gibt es einen erwähnenswerten Ort.

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

Hier wird eine weitere ServeHTTP-Methode aufgerufen, und dann wollen wir sehen, was diese Methode verarbeitet.

In dieser Methode sehen wir so einen Code

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

Hier sehen wir, dass, wenn kein Handler übergeben wird, der Standard-DefaultServeMux verwendet wird. Jetzt verstehen wir im ersten Absatz, warum Am Anfang müssen wir im Code eine Null übergeben, und dann ruft handler.ServeHTTP(rw, req) die Implementierungsmethode des Interface-Handlers auf. Auf diese Weise können wir wahrscheinlich entscheiden, welchem ​​Handler ein bestimmtes Muster entsprechen soll Wenn wir das verstehen, ist das das allgemeine Prinzip dieses Servers. Natürlich ist dies eine sehr oberflächliche Analyse, und es gibt noch viele tiefergehende Dinge, die untersucht werden müssen.

Empfohlenes Tutorial: „Gehe zum Sprachtutorial“

Das obige ist der detaillierte Inhalt vonWie erstelle ich einen Server in Golang?. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!