Golang implementiert die Zugriffsschicht

Mit der kontinuierlichen Weiterentwicklung der Internettechnologie müssen immer mehr Systeme auf mehrere externe Serviceschnittstellen zugreifen, um verschiedene Funktionen zu implementieren. Um die Verwaltung zu vereinheitlichen und Aufrufe an externe Schnittstellen zu vereinfachen, muss eine Zugriffsschicht eingeführt werden, um die zugrunde liegende Architektur vor Änderungen an externen APIs zu schützen. In diesem Artikel wird erläutert, wie Sie mit Golang eine Zugriffsschicht implementieren, um einfach auf externe Serviceschnittstellen zuzugreifen.

1. Was ist die Zugriffsschicht?

Die Zugriffsschicht bezieht sich auf eine Abstraktionsebene zwischen dem Inneren und Äußeren des Systems. Sie ist hauptsächlich für interne und externe Schnittstellenaufrufe verantwortlich. Die Zugriffsschicht kann die API-Aufrufe mehrerer externer Systeme einheitlich verwalten und steuern, die zugrunde liegenden Schnittstellendetails verbergen und externen Benutzern vereinfachte Schnittstellenaufrufmethoden bereitstellen. 2. Vorteile von Golang Garbage-Collection-Mechanismus, keine manuelle Speicherverwaltung erforderlich;

Zuverlässiges Typsystem, das potenzielle Fehler im Voraus erkennen kann.

Zusammenfassend lässt sich sagen, dass Golang sehr gut für die Implementierung der Zugriffsschicht geeignet ist. Im Folgenden wird erläutert, wie Sie mit Golang eine grundlegende Zugriffsschicht implementieren.

1. 3. Implementierung der Zugriffsschicht
2. Struktur der Zugriffsschicht
4. Bevor Sie mit dem Schreiben von Code beginnen, müssen Sie zunächst eine grundlegende Architektur der Zugriffsschicht erstellen. Die Struktur der Zugriffsschicht besteht aus drei Teilen:

Handler: Verarbeitet verschiedene Schnittstellenanforderungen.

Schnittstellenmanager: Verwaltet alle Schnittstellen und ist für die Weiterleitung von Anforderungen vom Access Layer Center und die Weiterleitung der Anforderungen an den richtigen Handler verantwortlich.

Center: Nimmt Anfragen von externen Diensten entgegen und sendet die Anfragen an den Schnittstellenmanager, sodass der richtige Handler ausgewählt wird, um die Anfrage zum richtigen Zeitpunkt zu bearbeiten.
1. Implementierende Handler

Handler sind der wichtigste Teil der Zugriffsschicht. Sie sind für die Bearbeitung von Anfragen externer Systeme an die Zugriffsschicht verantwortlich. Je nach Anforderungstyp können wir unterschiedliche Handler schreiben.

1. Hier ist ein Beispiel-Handler, der HTTP-GET-Anfragen verarbeitet:

package handlers

import (
    "fmt"
    "net/http"
)

func GetHandler(w http.ResponseWriter, r *http.Request) {
    fmt.Fprintf(w, "This is a GET request, URL: %s", r.URL.Path[1:])
}

2. Implementieren des Schnittstellenmanagers
4. Der Schnittstellenmanager ist Teil des Access Layer Centers und kann verwendet werden, um alle verfügbaren Schnittstellen zu verwalten und Anforderungen an den richtigen Handler weiterzuleiten Vorgesetzter. Das Folgende ist eine einfache Schnittstellenmanager-Implementierung:

package manager

import (
    "fmt"
    "net/http"
)

var (
    handlers = make(map[string]func(http.ResponseWriter, *http.Request))
)

func AddHandler(name string, handler func(http.ResponseWriter, *http.Request)) {
    handlers[name] = handler
}

func GetHandlerByName(name string) (func(http.ResponseWriter, *http.Request), bool) {
    val, ok := handlers[name]
    return val, ok
}

func Router(w http.ResponseWriter, r *http.Request) {
    handler, ok := GetHandlerByName(r.URL.Path[1:])
    if ok {
        handler(w, r)
    } else {
        fmt.Fprintf(w, "Unknown request URL: %s", r.URL.Path[1:])
    }
}

Das Schnittstellenmanagerpaket implementiert die AddHandler()-Methode, die zum Hinzufügen verfügbarer Schnittstellen verwendet wird. Gleichzeitig implementiert es auch die Methode GetHandlerByName(), mit der der Handler mit dem angegebenen Namen gefunden wird. Wenn die Router()-Methode aufgerufen wird, verwendet sie GetHandlerByName(), um den richtigen Handler zu finden und die Anforderung an diesen Handler weiterzuleiten.

Implementierungszentrum

3. Das Zentrum ist das Herzstück der Zugriffsschicht. Es empfängt alle Anfragen externer Dienste und leitet sie an den richtigen Schnittstellenmanager weiter. Das Folgende ist eine einfache zentrale Implementierung:

package center

import (
    "log"
    "net/http"

    "manager"
)

func StartServer(port string) {
    http.HandleFunc("/", manager.Router)
    log.Fatal(http.ListenAndServe(":"+port, nil))
}

Die zentrale StartServer()-Methode verwendet die http.HandleFunc()-Methode, um Routing-Regeln zu definieren, wobei „/“ als Routing-Präfix und die Router()-Methode als Handler verwendet wird. Rufen Sie die Methode log.Fatal() auf, um die Programmausführung sofort zu stoppen und eine Fehlermeldung zu erhalten. Wenn die Netzwerküberwachung fehlschlägt, wird das Programm nicht gestartet.

4. Verwendung der Zugriffsschicht

Nach Abschluss des Schreibens der Zugriffsschicht können wir sie in der Anwendung mithilfe der folgenden Schritte verwenden:

4. Fügen Sie die Schnittstelle hinzu, die dem Schnittstellenmanager über die Methode AddHandler() zugänglich gemacht werden soll . Um beispielsweise eine Schnittstelle mit dem Namen „/hello“ hinzuzufügen:

manager.AddHandler("hello", handlers.HelloHandler)

Starten Sie das Center über den Schnittstellenmanager und leiten Sie die Anfrage an den richtigen Handler weiter.

center.StartServer("8080")

Nachdem Sie das Center gestartet haben, können Sie die Schnittstelle ganz einfach mit dem Curl-Befehl testen. Um beispielsweise die Schnittstelle mit dem Namen „/hello“ zu testen:

curl -X GET http://localhost:8080/hello

5. Zusammenfassung

1. In diesem Artikel haben wir die Grundkonzepte der Zugriffsschicht und die Methode zur Verwendung von Golang zur Implementierung der Zugriffsschicht vorgestellt. Durch die Verwendung von Golang kann auf einfache Weise eine effiziente und leicht zu wartende Zugriffsschicht implementiert werden, sodass wir externe Dienste besser verwalten und verarbeiten können. Darüber hinaus haben wir erläutert, wie die Zugriffsschicht auf der Clientseite verwendet wird, damit wir die Schnittstelle einfach testen und ihre Funktionalität verstehen können.

Das obige ist der detaillierte Inhalt vonGolang implementiert die Zugriffsschicht. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!