Wie Golang Ihre erste Arbeitsaufgabe löst

Golang oder einfach Go ist als Go-Gopher-Sprache bekannt geworden. Wenn Sie immer noch nicht verstehen, warum der Gopher, finden Sie in diesem Artikel eine überraschende Maskottchengeschichte. Fangen wir ganz von vorne an: Golang gilt als eine der produktivsten Programmiersprachen auf dem Markt. Im Gegensatz zu herkömmlichen Sprachen wie Java oder Python bietet Go eine einzigartige Balance zwischen einfach zu schreibendem Code und schneller Ausführung, wodurch die Entwicklung beschleunigt und die Debug- und Testzeit verkürzt wird. In diesem Artikel wird ein reales Beispiel für die Verwendung von Goroutinen und Kontext in einem Projekt betrachtet, das mit einem langsamen und instabilen REST-API-Mikrodienst interagiert.

Die Aufgabe
Stellen wir uns vor, Sie sind gerade dem Team beigetreten und Ihr Teamleiter bittet Sie, einen neuen in Golang geschriebenen Microservice (z. B. den Risikomanager) an den Benutzer-Microservice zu binden, der über die REST-API bereitgestellt wird.

Das Problem
Der Risikomanager muss mit einer REST-API interagieren, die langsam und instabil sein kann, sodass wir solche Anfragen sorgfältig bearbeiten müssen. Ich werde Goroutinen für asynchrone HTTP-Anfragen und Kontext verwenden, um Anforderungszeitüberschreitungen und Fehlerbehandlung zu verwalten.

Die Lösung

Die Verwendung von Goroutinen und Kontext in Golang ermöglicht die effiziente Verwaltung gleichzeitiger Aufgaben und den Umgang mit langsamen oder instabilen externen APIs.

Der erste Schritt zur Interpretation in einem Code besteht darin, die API zu erstellen. Ich habe den Shareware-Dienst https://mockapi.io/ verwendet. Es ist praktisch, einen REST zu generieren API mit einem grundlegenden Satz von Entitäten, wie z. B. Benutzer.

Angenommen, jemand hat sein Bestes gegeben und Ihr Unternehmen verfügt über einen internen Dienst, der Benutzer auflistet. Unsere Aufgabe besteht darin, die Benutzerliste im neuen Risikomanager wiederzuverwenden (die Benutzerdatenstruktur entspricht dem von mockapi.io beschriebenen Vertrag). Der folgende Code stellt eine Anfrage, verarbeitet den Text und erzeugt entweder eine Liste von Benutzern oder den entsprechenden Fehler.

type User struct {
    CreatedAt string
    Name      string
    Avatar    string
    Id        string
}

// Original slow request
func fetchUsers(ctx context.Context) (*[]User, error) {
    resp, err := http.Get("https://<use your id after sign up>.mockapi.io/api/v1/users")
    if err != nil {
        return nil, err
    }
    defer resp.Body.Close()

    if resp.StatusCode != http.StatusOK {
        return nil, fmt.Errorf("failed to fetch users: %s", resp.Status)
    }

    var users []User
    if err := json.NewDecoder(resp.Body).Decode(&users); err != nil {
        return nil, err
    }

    return &users, nil
}

Um den Vorgang zu steuern, verwende ich den obersten übergeordneten Kontext für alle anderen Kontexte – context.Background. Ich werde diesen Kontext mit neuen Daten ergänzen, in diesem Fall dem Timeout – context.WithTimeout, das ich als 2 Sekunden definieren werde. Weitere Informationen zum Arbeiten mit Kontexten in Go finden Sie in diesem Artikel.

ctx, cancel := context.WithTimeout(context.Background(), 2*time.Second)
defer cancel()

usersChan := make(chan *[]User)
errChan := make(chan error)

go func() {
    users, err := fetchUsers(ctx)
    if err != nil {
        errChan <- err
        return
    }
    usersChan <- user
}()

select {
case users := <-usersChan:
    fmt.Printf("Fetched users: %+v\n", users)
case err := <-errChan:
    fmt.Printf("Error fetching users: %v\n", err)
case <-ctx.Done():
    fmt.Println("Request timed out")
}

Im Beispiel verwende ich zwei Kanäle – „usersChan“, um das von unserem internen Dienst empfangene Ergebnis aufzuzeichnen, und den zweiten Kanal „errChan“, um den Fehler aufzuzeichnen.
Wenn die Antwort einer langsamen API nicht innerhalb von 2 Sekunden eintrifft, erkennen wir einen Fehler und geben die Möglichkeit, ihn auf einer externen Ebene korrekt zu verarbeiten.

In diesem praktischen Beispiel mit dem Risikomanager ermöglichten Goroutinen asynchrone HTTP-Anfragen, während der Kontext die Timeout-Behandlung sicherstellte, was für den Aufbau zuverlässiger und belastbarer Microservices von entscheidender Bedeutung ist.

P.S.

Dieser Artikel richtet sich an Anfängerentwickler, die über Grundkenntnisse verfügen, aber keine Ahnung haben, wo sie ihr Wissen anwenden können. Ich freue mich über Ihr Feedback und beantworte gerne Ihre Fragen.
Ein funktionierendes Beispiel und mehrere andere Implementierungen der grundlegendsten Dinge in der Go-Sprache finden Sie auf meinem GitHub unter dem Link

Das obige ist der detaillierte Inhalt vonWie Golang Ihre erste Arbeitsaufgabe löst. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!