Golang-API-Build

Golang ist eine Programmiersprache, die speziell für die Erstellung von Diensten und Netzwerkanwendungen mit hoher Parallelität entwickelt wurde. Golang verfügt über effiziente Parallelitäts- und Netzwerkprogrammierfunktionen, was es zur ersten Wahl vieler Entwickler macht. Um eine Golang-API zu erstellen, müssen wir viele grundlegende Konzepte und Fähigkeiten beherrschen, von der Routing-Verarbeitung bis zum Datenbankzugriff und mehr. In diesem Artikel wird erläutert, wie Sie Golang zum Erstellen von APIs verwenden.

1. Umgebungsvorbereitung

Bevor Sie mit der Erstellung der Golang-API beginnen, müssen Sie Golang auf Ihrem Computer installieren. Sie können die neueste Version von Golang über die offizielle Golang-Website (https://golang.org/) herunterladen oder über einen Paketmanager wie apt-get oder yum usw. installieren. Geben Sie nach Abschluss der Installation „go version“ in das Terminal ein, um zu überprüfen, ob die Installation erfolgreich war.

2. Installation der Abhängigkeitspakete

Verwenden Sie den Befehl „go get“ im Terminal, um die erforderlichen Abhängigkeitspakete zu installieren. Abhängige Pakete sind einige Bibliotheken, die wir häufig in der API verwenden, wie zum Beispiel „gorilla/mux“ und „gorm“. Die Installationsmethode ist wie folgt:

go get github.com/gorilla/mux 
go get github.com/jinzhu/gorm 
go get github.com/go-sql-driver/mysql

3. Routing-Verarbeitung

Alle API-Anfragen müssen durch Routing abgeschlossen werden. Eines der beliebtesten Routing-Pakete in Golang ist Gorilla/Mux, daher werden wir es auch verwenden.

Um Gorilla/Mux verwenden zu können, müssen wir das Paket importieren und ein neues Mux-Objekt erstellen. In diesem Beispiel erstellen wir zwei Routen, eine zum Anzeigen der API-Homepage und eine andere zum Verarbeiten unserer GET-Anfragen.

package main

import (
    "fmt"
    "net/http"

    "github.com/gorilla/mux"
)

func main() {
    router := mux.NewRouter()

    router.HandleFunc("/", Index)
    router.HandleFunc("/tasks", getTasks).Methods("GET")

    http.ListenAndServe(":8000", router)
}

func Index(w http.ResponseWriter, r *http.Request) {
    fmt.Fprintln(w, "Welcome to my API!")
}

func getTasks(w http.ResponseWriter, r *http.Request) {
    fmt.Fprintln(w, "You have requested all tasks")
}

Im obigen Code haben wir zwei Handlerfunktionen erstellt, Index und getTasks. Die Indexfunktion wird zum Anzeigen der API-Homepage verwendet und getTasks verarbeitet alle GET-Anfragen.

4. Datenbankzugriff

Jetzt werden wir der API Datenbankfunktionen hinzufügen. In diesem Beispiel verwenden wir eine MySQL-Datenbank und verwenden die Gorm-Bibliothek zur Verwaltung der Daten.

Zuerst müssen wir eine Datenbankverbindung erstellen. Dazu müssen wir eine Datenbankstruktur erstellen, die die Verbindungsdetails enthält. Als nächstes erstellen wir eine neue „openDB“-Funktion, um die Verbindung zu öffnen.

...

import (
    "database/sql"
    "log"

    _ "github.com/go-sql-driver/mysql"
    "github.com/jinzhu/gorm"
)

type Database struct {
    *gorm.DB
}

func (db *Database) openDB() {
    dsn := "username:password@tcp(127.0.0.1:3306)/godb?charset=utf8&parseTime=True"
    conn, err := sql.Open("mysql", dsn)
    if err != nil {
        log.Fatal(err)
    }

    db.DB = gorm.Open("mysql", conn)
}

Wir müssen jetzt ein neues Datenbankobjekt in der Hauptfunktion erstellen und die Verbindung mit der openDB-Funktion öffnen.

db := new(Database)
db.openDB()

Als nächstes erstellen wir ein Aufgabenmodell, das wir unserer Aufgabenliste zuordnen. Ein Modell ist einfach eine reguläre Go-Struktur, die einer Tabelle in unserer MySQL-Datenbank zugeordnet wird.

type Task struct {
    Id      int    `gorm:"primary_key;auto_increment"`
    Name    string `gorm:"not null"`
    Content string `gorm:"not null"`
}

Um eine neue Aufgabe zu erstellen, erstellen wir eine Handler-Funktion namens „createTask“. Diese Funktion empfängt JSON-Daten von der HTTP-Anfrage, analysiert sie und fügt sie in unsere Datenbank ein.

func createTask(w http.ResponseWriter, r *http.Request) {
    db := new(Database)
    db.openDB()

    task := &Task{}
    task.Name = r.FormValue("name")
    task.Content = r.FormValue("content")

    db.Create(&task)
    fmt.Fprintln(w, "Task successfully created")
}

Wir sehen, dass die Funktion „createTask“ zu Beginn ein neues Datenbankobjekt und ein neues Aufgabenobjekt erstellt. Anschließend analysiert es die JSON-Daten aus der HTTP-Anfrage und fügt sie durch Aufrufen der Methode db.Create() in die Datenbank ein.

Abschließend werden wir unsere Route „router.HandleFunc“ aktualisieren, um die neue Route einzuschließen.

router.HandleFunc("/tasks", createTask).Methods("POST")

5. Middleware

Middleware ist eine gängige Technologie, die zur Durchführung von Vorgängen vor oder nach der Bearbeitung einer Anfrage verwendet wird. Sie werden nicht nur in Golang, sondern auch in anderen Sprachen häufig verwendet. Sehen wir uns an, wie man Middleware verwendet, um der Golang-API einige zusätzliche Funktionen hinzuzufügen.

In Golang ist Middleware eine Funktion, die eine HTTP-Verarbeitungsfunktion als Parameter verwendet. Sie ermöglichen die Ausführung einer bestimmten Logik vor oder nach der Verarbeitung der Anfrage. Im folgenden Beispiel erstellen wir eine Middleware namens „withLogging“, die die Details aller API-Anfragen protokolliert.

func withLogging(next http.Handler) http.Handler {
    return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
        log.Println(r.Method, r.URL.Path)
        next.ServeHTTP(w, r)
    })
}

Wir sehen, dass in der Funktion eine neue http.Handler-Funktion zurückgegeben wird, die die angeforderte Methode und den URL-Pfad aufzeichnet. Die next.ServeHTTP(w, r)-Anweisung ruft den nächsten Handler auf und stellt sicher, dass der Handler weiterhin API-Anfragen verarbeitet.

Als nächstes aktualisieren wir unsere Routen und Handler, um die neue Protokollierungs-Middleware einzubinden.

router := mux.NewRouter()

router.Use(withLogging)

router.HandleFunc("/", Index)
router.HandleFunc("/tasks", createTask).Methods("POST")
router.HandleFunc("/tasks", getTasks).Methods("GET")

Fügen Sie nun die Anweisung „router.Use(withLogging)“ vor der Route hinzu und wir führen die withLogging-Middleware für alle Routenanfragen aus.

6. Zusammenfassung

In diesem Artikel haben wir vorgestellt, wie man Gorilla/Mux zur Verwaltung des Routings in Golang verwendet, Gorm zur Verwaltung der MySQL-Datenbank verwendet und wie man Middleware zur Verbesserung unserer API verwendet. Wenn wir diese grundlegenden Konzepte und Fähigkeiten verstehen, können wir mit der Entwicklung komplexerer Golang-APIs beginnen.

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