Building RESTful APIs with Go

Willkommen zu Teil 2 unserer Backend-Engineering für Full-Stack-Entwickler-Reihe! ? Heute befassen wir uns mit einem der grundlegendsten Themen: Erstellen von RESTful-APIs mit Go. Unabhängig davon, ob Sie ein internes Tool oder eine öffentliche API erstellen, ist es wichtig zu verstehen, wie RESTful-Endpunkte strukturiert und implementiert werden.

In diesem Beitrag behandeln wir Folgendes:

• Was macht eine API RESTful aus (und warum es wichtig ist).
• So entwerfen Sie Endpunkte und handhaben HTTP-Methoden.
• Erstellen einer einfachen CRUD-API mit dem Net/http-Paket von Go und Gorilla Mux.
• Verarbeitung von JSON-Anfragen und -Antworten.

Am Ende haben Sie ein solides Verständnis dafür, wie Sie skalierbare RESTful-APIs in Go entwerfen und implementieren. Fangen wir an! ?

---

Was macht eine API RESTful aus? ?

Bevor wir uns mit dem Code befassen, schauen wir uns kurz an, was eine API RESTful ausmacht. REST (Representational State Transfer) ist ein Architekturstil zum Erstellen von APIs, der diesen Prinzipien folgt:

1. Staatenlos: Jede Anfrage des Kunden muss alle für die Bearbeitung notwendigen Informationen enthalten. Der Server speichert keine Sitzungsinformationen.
2. Ressourcenorientiert: URLs stellen Ressourcen dar, wie /users, /products oder /orders, und HTTP-Methoden definieren die Aktionen.
3. HTTP-Methoden: RESTful-APIs verwenden HTTP-Methoden, um Aktionen anzugeben:
   • GET: Daten abrufen.
   • POST: Neue Ressourcen erstellen.
   • PUT: Vorhandene Ressourcen aktualisieren.
   • LÖSCHEN: Ressourcen entfernen.
4. Verwendung von HTTP-Statuscodes: RESTful-APIs nutzen HTTP-Statuscodes gut (200 für Erfolg, 404 für nicht gefunden usw.).

---

Einrichten Ihres Go-Projekts

Lassen Sie uns eine grundlegende CRUD-API für die Benutzerverwaltung mit Go und dem Gorilla Mux-Router erstellen. Unsere API wird die folgenden Endpunkte haben:

HTTP Method	Endpoint	Action
GET	/users	Retrieve all users
GET	/users/{id}	Retrieve a specific user
POST	/users	Create a new user
PUT	/users/{id}	Update an existing user
DELETE	/users/{id}	Delete a user

HTTP-Methode Endpunkt Aktion GET /users Alle Benutzer abrufen GET /users/{id} Einen bestimmten Benutzer abrufen POST /users Neuen Benutzer erstellen PUT /users/{id} Aktualisieren Sie einen vorhandenen Benutzer LÖSCHEN /users/{id} Benutzer löschen

Step 1: Install Dependencies

First, install the Gorilla Mux router for routing:

go get -u github.com/gorilla/mux

Create a simple main.go file to get started:

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

---

Step 2: Define the Handlers

Now, let’s define our API handlers. These will correspond to our CRUD actions. We’ll use a simple in-memory map to store user data for this example.

In-Memory Data Store

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

var users = make(map[string]User)

Step 3: Implement CRUD Handlers

We’ll implement each CRUD operation: Create, Read, Update, and Delete users.

GET /users – Retrieve All Users

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} – Retrieve a Specific User

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 – Create a New User

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} – Update an Existing User

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} – Delete a User

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

---

Step 4: Register Routes

Now that we’ve defined our handlers, let’s add the routes to our router in the main function:

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

---

Step 5: Testing the API

You can test your API using Postman or curl commands. Here’s how you can create a new user and retrieve users:

1. Create a New User:

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

1. Get All Users:

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

1. Get a Specific User:

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

1. Update a User:

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

1. Delete a User:

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

---

Best Practices for Building RESTful APIs

1. Use Proper HTTP Methods: Follow RESTful principles by using GET for reads, POST for creates, PUT for updates, and DELETE for deletes.
2. Return Appropriate Status Codes: Always use correct HTTP status codes (e.g., 201 Created for successful resource creation, 404 Not Found for missing resources).
3. Handle Errors Gracefully: Don’t expose internal errors to users. Use generic messages like "User not found" or "Invalid request."
4. Use Pagination for Large Data Sets: When returning large lists (like /users), implement pagination to prevent excessive data loading.
5. Secure Your API: Use authentication methods like JWT or OAuth2 to secure sensitive endpoints.

---

What’s Next?

Now that we’ve built a basic RESTful API, it’s time to integrate database support so we can persist our data. In the next post, we’ll dive into using an ORM to connect our Go API to a database. Stay tuned for Part 3! ?

The above is the detailed content of Building RESTful APIs with Go. For more information, please follow other related articles on the PHP Chinese website!