Membina API RESTful dengan Go

Selamat datang ke Bahagian 2 siri Backend Engineering untuk Full Stack Devs kami! ? Hari ini, kami menyelami salah satu topik paling asas: Membina API RESTful dengan Go. Sama ada anda sedang membina alat dalaman atau API awam, memahami cara menstruktur dan melaksanakan titik akhir RESTful adalah penting.

Dalam siaran ini, kami akan membincangkan:

• Apa yang menjadikan API TENANG (dan mengapa ia penting).
• Cara mereka bentuk titik tamat dan mengendalikan kaedah HTTP.
• Membina API CRUD mudah dengan pakej net/http Go dan Gorilla Mux.
• Mengendalikan permintaan dan respons JSON.

Pada akhirnya, anda akan mempunyai pemahaman yang kukuh tentang cara mereka bentuk dan melaksanakan API RESTful berskala dalam Go. Mari mulakan! ?

Apa yang Membuatkan API RESTful? ?

Sebelum kita menyelami kod tersebut, mari kita semak dengan cepat perkara yang menjadikan API REHAT. REST (Pemindahan Negeri Perwakilan) ialah gaya seni bina untuk membina API yang mengikut prinsip ini:

1. Stateless: Setiap permintaan daripada pelanggan mesti mengandungi semua maklumat yang diperlukan untuk memprosesnya. Pelayan tidak menyimpan maklumat sesi.
2. Berorientasikan Sumber: URL mewakili sumber, seperti /users, /products atau /orders dan kaedah HTTP mentakrifkan tindakan.
3. Kaedah HTTP: API RESTful menggunakan kaedah HTTP untuk menentukan tindakan:
   • DAPATKAN: Dapatkan semula data.
   • SIARAN: Cipta sumber baharu.
   • PUT: Kemas kini sumber sedia ada.
   • PADAM: Alih keluar sumber.
4. Penggunaan Kod Status HTTP: API RESTful menggunakan kod status HTTP dengan baik (200 untuk kejayaan, 404 untuk tidak ditemui, dll.).

Menyediakan Projek Pergi Anda

Mari bina CRUD API asas untuk mengurus pengguna menggunakan Go dan penghala Gorilla Mux. API kami akan mempunyai titik akhir berikut:

Schritt 1: Abhängigkeiten installieren

Installieren Sie zunächst den Gorilla Mux-Router für das Routing:

go get -u github.com/gorilla/mux

Erstellen Sie zunächst eine einfache main.go-Datei:

package main

import (
    "log"
    "net/http"
    "github.com/gorilla/mux"
)

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

    // Define routes here
    http.Handle("/", r)

    log.Println("Server started on :8080")
    log.Fatal(http.ListenAndServe(":8080", nil))
}

Schritt 2: Definieren Sie die Handler

Jetzt definieren wir unsere API-Handler. Diese werden unseren CRUD-Aktionen entsprechen. Für dieses Beispiel verwenden wir eine einfache In-Memory-Map zum Speichern von Benutzerdaten.

In-Memory-Datenspeicher

type User struct {
    ID   string `json:"id"`
    Name string `json:"name"`
    Age  int    `json:"age"`
}

var users = make(map[string]User)

Schritt 3: Implementieren Sie CRUD-Handler

Wir implementieren jede CRUD-Operation: Erstellen, Lesen, Aktualisieren und Löschen Benutzer.

GET /users – Alle Benutzer abrufen

func getUsers(w http.ResponseWriter, r *http.Request) {
    w.Header().Set("Content-Type", "application/json")
    var userList []User
    for _, user := range users {
        userList = append(userList, user)
    }
    json.NewEncoder(w).Encode(userList)
}

GET /users/{id} – Einen bestimmten Benutzer abrufen

func getUser(w http.ResponseWriter, r *http.Request) {
    params := mux.Vars(r)
    user, found := users[params["id"]]
    if !found {
        http.Error(w, "User not found", http.StatusNotFound)
        return
    }
    w.Header().Set("Content-Type", "application/json")
    json.NewEncoder(w).Encode(user)
}

POST /users – Erstellen Sie einen neuen Benutzer

func createUser(w http.ResponseWriter, r *http.Request) {
    w.Header().Set("Content-Type", "application/json")
    var user User
    _ = json.NewDecoder(r.Body).Decode(&user)
    users[user.ID] = user
    w.WriteHeader(http.StatusCreated)
    json.NewEncoder(w).Encode(user)
}

PUT /users/{id} – Einen vorhandenen Benutzer aktualisieren

func updateUser(w http.ResponseWriter, r *http.Request) {
    params := mux.Vars(r)
    user, found := users[params["id"]]
    if !found {
        http.Error(w, "User not found", http.StatusNotFound)
        return
    }
    _ = json.NewDecoder(r.Body).Decode(&user)
    user.ID = params["id"]  // Ensure the ID stays the same
    users[params["id"]] = user
    w.Header().Set("Content-Type", "application/json")
    json.NewEncoder(w).Encode(user)
}

DELETE /users/{id} – Einen Benutzer löschen

func deleteUser(w http.ResponseWriter, r *http.Request) {
    params := mux.Vars(r)
    _, found := users[params["id"]]
    if !found {
        http.Error(w, "User not found", http.StatusNotFound)
        return
    }
    delete(users, params["id"])
    w.WriteHeader(http.StatusNoContent)
}

Schritt 4: Routen registrieren

Da wir nun unsere Handler definiert haben, fügen wir die Routen zu unserem Router in der Hauptfunktion hinzu:

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

    r.HandleFunc("/users", getUsers).Methods("GET")
    r.HandleFunc("/users/{id}", getUser).Methods("GET")
    r.HandleFunc("/users", createUser).Methods("POST")
    r.HandleFunc("/users/{id}", updateUser).Methods("PUT")
    r.HandleFunc("/users/{id}", deleteUser).Methods("DELETE")

    http.Handle("/", r)

    log.Println("Server started on :8080")
    log.Fatal(http.ListenAndServe(":8080", nil))
}

Schritt 5: Testen der API

Sie können Ihre API mit Postman oder Curl-Befehlen testen. So können Sie einen neuen Benutzer erstellen und Benutzer abrufen:

1. Neuen Benutzer erstellen:

   curl -X POST http://localhost:8080/users \
   -H "Content-Type: application/json" \
   -d '{"id":"1", "name":"John Doe", "age":30}'

1. Alle Benutzer abrufen:

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

1. Suchen Sie einen bestimmten Benutzer:

   curl -X GET http://localhost:8080/users/1

1. Benutzer aktualisieren:

   curl -X PUT http://localhost:8080/users/1 \
   -H "Content-Type: application/json" \
   -d '{"name":"John Smith", "age":31}'

1. Benutzer löschen:

   curl -X DELETE http://localhost:8080/users/1

Best Practices zum Erstellen von RESTful-APIs

1. Verwenden Sie die richtigen HTTP-Methoden: Befolgen Sie die RESTful-Prinzipien, indem Sie GET zum Lesen, POST zum Erstellen, PUT zum Aktualisieren und DELETE zum Löschen verwenden.
2. Geeignete Statuscodes zurückgeben: Verwenden Sie immer die richtigen HTTP-Statuscodes (z. B. 201 Erstellt für erfolgreiche Ressourcenerstellung, 404 Nicht gefunden für fehlende Ressourcen).
3. Gehen Sie ordnungsgemäß mit Fehlern um: Machen Sie den Benutzern keine internen Fehler zugänglich. Verwenden Sie allgemeine Nachrichten wie „Benutzer nicht gefunden“ oder „Ungültige Anfrage“.
4. Verwenden Sie Paginierung für große Datensätze: Wenn Sie große Listen (wie /users) zurückgeben, implementieren Sie Paginierung, um ein übermäßiges Laden von Daten zu verhindern.
5. Sichern Sie Ihre API: Verwenden Sie Authentifizierungsmethoden wie JWT oder OAuth2, um sensible Endpunkte zu sichern.

Was kommt als nächstes?

Da wir nun eine grundlegende RESTful-API erstellt haben, ist es an der Zeit, Datenbankunterstützung zu integrieren, damit wir unsere Daten beibehalten können. Im nächsten Beitrag werden wir uns mit der Verwendung eines ORM befassen, um unsere Go-API mit einer Datenbank zu verbinden. Seien Sie gespannt auf Teil 3! ?

Atas ialah kandungan terperinci Membina API RESTful dengan Go. Untuk maklumat lanjut, sila ikut artikel berkaitan lain di laman web China PHP!