Go dan MongoDB: Membina API CRUD daripada Scratch

Ingin membuat aplikasi web dinamik dengan hujung belakang yang mantap? Tidak perlu melihat lebih jauh daripada Go dan MongoDB! Gabungan berkuasa ini membolehkan anda membina API berskala dan cekap yang mengendalikan penciptaan data, membaca, mengemas kini dan pemadaman (CRUD) dengan mudah.

Dalam panduan mesra pemula ini, kami akan melalui proses membina API CRUD mudah menggunakan Go dan MongoDB. Kami akan merangkumi langkah-langkah penting, memberikan contoh kod dan taburkan petua berguna sepanjang perjalanan.

Bermula

Perkara pertama dahulu, mari kita sediakan persekitaran kita:

1. Pemasangan Go: Muat turun dan pasang versi terkini Go daripada https://go.dev/dl/.
2. Persediaan MongoDB: Jika anda tidak menjalankan MongoDB, anda boleh memuat turun dan memasangnya daripada https://www.mongodb.com/try/download/community.
3. IDE atau Editor Teks: Pilih persekitaran pengekodan pilihan anda. Beberapa pilihan popular termasuk Kod VS, GoLand atau Atom.

Struktur Projek:

Buat direktori projek baharu dan susun fail anda seperti ini:

my-crud-api/
├── main.go
├── models/
│   └── user.go
├── handlers/
│   └── user.go
└── config/
    └── config.go

Menentukan Model Kami

Mari mulakan dengan menentukan model data kami. Untuk contoh ini, kami akan mencipta struct Pengguna yang mudah:

// models/user.go
package models

import (
    "go.mongodb.org/mongo-driver/bson/primitive"
)

type User struct {
    ID     primitive.ObjectID `bson:"_id,omitempty"`
    Name   string             `bson:"name,omitempty"`
    Email  string             `bson:"email,omitempty"`
    Age    int                `bson:"age,omitempty"`
    Active bool               `bson:"active,omitempty"`
}

Penjelasan:

• Kami menggunakan primitive.ObjectID daripada pakej pemacu mongo untuk mewakili ID dokumen MongoDB yang unik.
• Teg bson adalah penting untuk memetakan medan struct Go kami ke medan yang sepadan dalam dokumen MongoDB kami.

Menyambung ke MongoDB

Kami perlu mewujudkan sambungan ke pangkalan data MongoDB kami. Cipta fail config.go dalam direktori konfigurasi:

// config/config.go
package config

import (
    "context"
    "fmt"
    "os"

    "go.mongodb.org/mongo-driver/mongo"
    "go.mongodb.org/mongo-driver/mongo/options"
)

func ConnectToMongoDB() (*mongo.Client, error) {
    uri := os.Getenv("MONGODB_URI")
    if uri == "" {
        return nil, fmt.Errorf("MONGODB_URI is not set")
    }

    clientOptions := options.Client().ApplyURI(uri)
    client, err := mongo.Connect(context.Background(), clientOptions)
    if err != nil {
        return nil, err
    }

    err = client.Ping(context.Background(), nil)
    if err != nil {
        return nil, err
    }

    return client, nil
}

Penjelasan:

• Kami menggunakan os.Getenv untuk mendapatkan semula URI sambungan MongoDB daripada pembolehubah persekitaran MONGODB_URI. Pastikan anda menetapkan pembolehubah ini dalam persekitaran anda.
• Kami menggunakan pakej pemacu mongo untuk menyambung ke pangkalan data MongoDB dan melaksanakan operasi asas seperti ping pangkalan data.

Pengendali Bangunan

Sekarang, mari kita bina pengendali API untuk operasi CRUD kami. Dalam direktori pengendali, cipta fail user.go:

// handlers/user.go
package handlers

import (
    "context"
    "encoding/json"
    "fmt"
    "net/http"

    "github.com/your-username/my-crud-api/config"
    "github.com/your-username/my-crud-api/models"
    "go.mongodb.org/mongo-driver/bson"
    "go.mongodb.org/mongo-driver/bson/primitive"
    "go.mongodb.org/mongo-driver/mongo"
)

// Create a new user
func CreateUser(w http.ResponseWriter, r *http.Request) {
    client, err := config.ConnectToMongoDB()
    if err != nil {
        http.Error(w, err.Error(), http.StatusInternalServerError)
        return
    }
    defer client.Disconnect(context.Background())

    var user models.User
    if err := json.NewDecoder(r.Body).Decode(&user); err != nil {
        http.Error(w, err.Error(), http.StatusBadRequest)
        return
    }

    collection := client.Database("your_database_name").Collection("users")
    result, err := collection.InsertOne(context.Background(), user)
    if err != nil {
        http.Error(w, err.Error(), http.StatusInternalServerError)
        return
    }

    json.NewEncoder(w).Encode(result)
}

// Get all users
func GetAllUsers(w http.ResponseWriter, r *http.Request) {
    client, err := config.ConnectToMongoDB()
    if err != nil {
        http.Error(w, err.Error(), http.StatusInternalServerError)
        return
    }
    defer client.Disconnect(context.Background())

    collection := client.Database("your_database_name").Collection("users")
    cursor, err := collection.Find(context.Background(), bson.D{})
    if err != nil {
        http.Error(w, err.Error(), http.StatusInternalServerError)
        return
    }
    defer cursor.Close(context.Background())

    var users []models.User
    for cursor.Next(context.Background()) {
        var user models.User
        if err := cursor.Decode(&user); err != nil {
            http.Error(w, err.Error(), http.StatusInternalServerError)
            return
        }
        users = append(users, user)
    }

    json.NewEncoder(w).Encode(users)
}

// Get a user by ID
func GetUserByID(w http.ResponseWriter, r *http.Request) {
    client, err := config.ConnectToMongoDB()
    if err != nil {
        http.Error(w, err.Error(), http.StatusInternalServerError)
        return
    }
    defer client.Disconnect(context.Background())

    id, err := primitive.ObjectIDFromHex(r.URL.Query().Get("id"))
    if err != nil {
        http.Error(w, err.Error(), http.StatusBadRequest)
        return
    }

    collection := client.Database("your_database_name").Collection("users")
    var user models.User
    if err := collection.FindOne(context.Background(), bson.M{"_id": id}).Decode(&user); err != nil {
        http.Error(w, err.Error(), http.StatusNotFound)
        return
    }

    json.NewEncoder(w).Encode(user)
}

// Update a user
func UpdateUser(w http.ResponseWriter, r *http.Request) {
    client, err := config.ConnectToMongoDB()
    if err != nil {
        http.Error(w, err.Error(), http.StatusInternalServerError)
        return
    }
    defer client.Disconnect(context.Background())

    id, err := primitive.ObjectIDFromHex(r.URL.Query().Get("id"))
    if err != nil {
        http.Error(w, err.Error(), http.StatusBadRequest)
        return
    }

    var updatedUser models.User
    if err := json.NewDecoder(r.Body).Decode(&updatedUser); err != nil {
        http.Error(w, err.Error(), http.StatusBadRequest)
        return
    }

    collection := client.Database("your_database_name").Collection("users")
    filter := bson.M{"_id": id}
    update := bson.M{"$set": updatedUser}
    result, err := collection.UpdateOne(context.Background(), filter, update)
    if err != nil {
        http.Error(w, err.Error(), http.StatusInternalServerError)
        return
    }

    json.NewEncoder(w).Encode(result)
}

// Delete a user
func DeleteUser(w http.ResponseWriter, r *http.Request) {
    client, err := config.ConnectToMongoDB()
    if err != nil {
        http.Error(w, err.Error(), http.StatusInternalServerError)
        return
    }
    defer client.Disconnect(context.Background())

    id, err := primitive.ObjectIDFromHex(r.URL.Query().Get("id"))
    if err != nil {
        http.Error(w, err.Error(), http.StatusBadRequest)
        return
    }

    collection := client.Database("your_database_name").Collection("users")
    result, err := collection.DeleteOne(context.Background(), bson.M{"_id": id})
    if err != nil {
        http.Error(w, err.Error(), http.StatusInternalServerError)
        return
    }

    json.NewEncoder(w).Encode(result)
}

Penjelasan:

• Kami melaksanakan operasi CRUD: CreateUser, GetAllUsers, GetUserByID, UpdateUser dan DeleteUser.
• Setiap fungsi bersambung ke MongoDB, mendapatkan semula koleksi, melaksanakan operasi masing-masing dan mengembalikan respons JSON.
• Kami mengendalikan kemungkinan ralat dan mengembalikan kod status HTTP yang sesuai.

Menyediakan Aplikasi Utama

Akhir sekali, mari kita gabungkan semuanya dalam fail main.go kami:

// main.go
package main

import (
    "fmt"
    "log"
    "net/http"

    "github.com/your-username/my-crud-api/handlers"
)

func main() {
    http.HandleFunc("/users", handlers.CreateUser)
    http.HandleFunc("/users", handlers.GetAllUsers)
    http.HandleFunc("/users/", handlers.GetUserByID)
    http.HandleFunc("/users/", handlers.UpdateUser)
    http.HandleFunc("/users/", handlers.DeleteUser)

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

Penjelasan:

• Kami mendaftarkan pengendali API dengan titik akhir HTTP yang sepadan.
• Kami memulakan pelayan dan mendengar pada port 8080.

Menjalankan API

1. Pembolehubah Persekitaran: Tetapkan pembolehubah persekitaran MONGODB_URI dengan rentetan sambungan MongoDB anda.
2. Bina dan Jalankan: Bina aplikasi Go menggunakan go build dan kemudian jalankannya menggunakan ./my-crud-api.

Menguji API

Anda boleh menguji API anda menggunakan alatan seperti Posman atau curl.

• Buat: Hantar permintaan POST kepada /users dengan muatan JSON yang mengandungi butiran pengguna.
• Baca: Hantar permintaan GET kepada /users untuk mendapatkan semula semua pengguna atau kepada /users/?id={user_id} untuk mendapatkan pengguna tertentu.
• Kemas kini: Hantar permintaan PUT kepada /users/?id={user_id} dengan muatan JSON yang mengandungi butiran pengguna yang dikemas kini.
• Padam: Hantar permintaan PADAM kepada /users/?id={user_id} untuk memadam pengguna.

Petua untuk Berjaya

• Pengendalian Ralat: Sentiasa kendalikan kemungkinan ralat dan kembalikan kod status HTTP yang bermakna.
• Keselamatan: Laksanakan mekanisme pengesahan dan kebenaran yang betul untuk API anda.
• Reka Bentuk Pangkalan Data: Reka skema pangkalan data anda dengan teliti untuk mengoptimumkan prestasi dan kebolehskalaan.
• Dokumentasi: Dokumentasikan titik akhir API anda, format permintaan/tindak balas dan kod ralat.

Tahniah! Anda telah berjaya membina API CRUD asas menggunakan Go dan MongoDB. Dengan asas ini, anda boleh mengembangkan API anda untuk mengendalikan fungsi yang lebih kompleks dan membina aplikasi web yang mengagumkan. Teruskan belajar dan menerokai kemungkinan besar Go dan MongoDB!

Atas ialah kandungan terperinci Go dan MongoDB: Membina API CRUD daripada Scratch. Untuk maklumat lanjut, sila ikut artikel berkaitan lain di laman web China PHP!