Cara Membuat API CRUD Dengan Gin dan MongoDB Golang

Cara Membuat API CRUD Dengan Gin dan MongoDB Golang

Golang ialah salah satu bahasa pengaturcaraan dalam permintaan dengan bayaran tertinggi dengan banyak aplikasi. Apabila dipasangkan dengan rangka kerja seperti Gin, Revel dan gorila/mux, anda boleh membuat API dengan mudah dengan Go.





Ketahui cara membuat API CRUD di Golang menggunakan rangka kerja HTTP Gin.





MAKEUSEOF VIDEO OF THE DAY

Persediaan dan Pemasangan Awal

Mulakan dengan Golang dengan memasangnya pada komputer anda jika anda belum melakukannya.





Setelah dipasang, langkah seterusnya ialah mencipta folder akar projek pada mesin anda dan memulakan modul Go dalam direktori akar itu.

Untuk melakukan ini, buka sebuah CLI , navigasi ke folder akar projek anda dan jalankan:



go mod init module_name 

Anda akan melihat nama modul anda (cth. CRUD_API ) dan versinya apabila anda membuka go.mod fail. Semua pakej tersuai akan datang daripada modul induk ini. Jadi mana-mana pakej tersuai yang diimport mengambil bentuk:

import(package CRUD_API/package-directory-name)

Seterusnya, pasang pakej yang diperlukan untuk mencipta API CRUD. Dalam kes ini, gunakan Gin Gonic untuk menghalakan titik akhir API:





go get github.com/gin-gonic/gin 

Sekarang pasang Pemacu MongoDB untuk menyimpan data:

go get go.mongodb.org/mongo-driver/mongo

Cara Menyambung Pergi ke MongoDB

Apa yang anda perlukan ialah URI MongoDB anda untuk menyambungkan Golang dengan pangkalan data. Ia biasanya kelihatan seperti ini jika anda menyambung ke MongoDB Atlas secara tempatan:





Mongo_URL = "mongodb://127.0.0.1:27017"

Sekarang buat folder baharu dalam direktori akar projek anda dan panggilnya pangkalan data . Buat fail Go di dalam folder ini dan namakannya pangkalan data.go .

Ini ialah pakej pangkalan data anda, dan ia bermula dengan mengimport perpustakaan yang diperlukan:

package database 

import (
"context"
"fmt"
"log"
"time"
"go.mongodb.org/mongo-driver/mongo"
"go.mongodb.org/mongo-driver/mongo/options"
)

func ConnectDB() *mongo.Client {
Mongo_URL := "mongodb://127.0.0.1:27017"
client, err := mongo.NewClient(options.Client().ApplyURI(Mongo_URL))

if err != nil {
log.Fatal(err)
}

ctx, cancel := context.WithTimeout(context.Background(), 10 * time.Second)
err = client.Connect(ctx)
defer cancel()

if err != nil {
log.Fatal(err)
}

fmt.Println("Connected to mongoDB")
return client
}

Amalan terbaik untuk menyembunyikan pembolehubah persekitaran seperti rentetan sambungan pangkalan data dalam a .env fail menggunakan pakej dotenv . Ini menjadikan kod anda lebih mudah alih dan berguna apabila menggunakan a Contoh gugusan awan MongoDB , sebagai contoh.

google play on amazon fire 10

The ConnectDB fungsi mewujudkan sambungan dan mengembalikan objek Pelanggan MongoDB baharu.

Buat Koleksi Pangkalan Data

MongoDB menyimpan data dalam Collections, yang menyediakan antara muka kepada data pangkalan data asas.

Untuk mengendalikan fungsi pengambilan koleksi, mulakan dengan mencipta folder baharu, Koleksi , dalam akar projek anda. Sekarang buat fail Go baharu, getCollection.go , yang mendapat koleksi daripada pangkalan data:

package getcollection 

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

func GetCollection(client *mongo.Client, collectionName string) *mongo.Collection {
collection := client.Database("myGoappDB").Collection("Posts")
return collection
}

Fungsi ini mendapatkan Koleksi daripada pangkalan data MongoDB. Nama pangkalan data, dalam kes ini, ialah myGoappDB , dengan Catatan sebagai koleksinya.

Cipta Model Pangkalan Data

Buat folder baharu di dalam direktori akar anda dan panggilnya model . Folder ini mengendalikan model pangkalan data anda.

Buat fail Go baharu di dalam folder itu dan panggilnya model.go . Model anda, dalam kes ini, ialah catatan blog dengan tajuknya:

package model 

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

type Post struct {
ID primitive.ObjectID
Title string
Article string
}

Mencipta API CRUD Dengan Go

Seterusnya ialah penciptaan API CRUD. Untuk bermula dengan bahagian ini, buat folder baharu dalam direktori akar projek anda untuk mengendalikan titik akhir anda. Sebut saja laluan .

Buat fail Go yang berasingan dalam folder ini untuk setiap tindakan. Sebagai contoh, anda boleh menamakan mereka create.go , baca.pergi , kemas kini.pergi , dan delete.go . Anda akan mengeksport pengendali ini sebagai laluan pakej.

Cara Mencipta Titik Akhir POST dalam Go

Mulakan dengan menentukan titik akhir POST untuk menulis data ke dalam pangkalan data.

Dalam route/create.go , tambahkan yang berikut:

package routes 

import (
getcollection "CRUD_API/Collection"
database "CRUD_API/databases"
model "CRUD_API/model"
"context"
"log"
"net/http"
"time"
"github.com/gin-gonic/gin"
"go.mongodb.org/mongo-driver/bson/primitive"
)

func CreatePost(c *gin.Context) {
var DB = database.ConnectDB()
var postCollection = getcollection.GetCollection(DB, "Posts")
ctx, cancel := context.WithTimeout(context.Background(), 10*time.Second)
post := new(model.Posts)
defer cancel()

if err := c.BindJSON(&post); err != nil {
c.JSON(http.StatusBadRequest, gin.H{"message": err})
log.Fatal(err)
return
}

postPayload := model.Posts{
Id: primitive.NewObjectID(),
Title: post.Title,
Article: post.Article,
}

result, err := postCollection.InsertOne(ctx, postPayload)

if err != nil {
c.JSON(http.StatusInternalServerError, gin.H{"message": err})
return
}

c.JSON(http.StatusCreated, gin.H{"message": "Posted successfully", "Data": map[string]interface{}{"data": result}})
}

Kod ini bermula dengan mengimport modul tersuai projek. Ia kemudian mengimport pakej pihak ketiga termasuk Gin dan Pemacu MongoDB .

Selanjutnya, postCollection memegang koleksi pangkalan data. Terutamanya, c.BindJSON('siaran') ialah contoh model JSONified yang memanggil setiap medan model sebagai postPayload ; ini masuk ke dalam pangkalan data.

Cara Mencipta Titik Akhir GET

Titik akhir GET, dalam route/read.go , membaca satu dokumen daripada pangkalan data melalui ID uniknya. Ia juga bermula dengan mengimport pakej tersuai dan pihak ketiga:

package routes 

import (
getcollection "CRUD_API/Collection"
database "CRUD_API/databases"
model "CRUD_API/model"
"context"
"net/http"
"time"
"github.com/gin-gonic/gin"
"go.mongodb.org/mongo-driver/bson"
"go.mongodb.org/mongo-driver/bson/primitive"
)

func ReadOnePost(c *gin.Context) {
ctx, cancel := context.WithTimeout(context.Background(), 10*time.Second)
var DB = database.ConnectDB()
var postCollection = getcollection.GetCollection(DB, "Posts")

postId := c.Param("postId")
var result model.Posts

defer cancel()

objId, _ := primitive.ObjectIDFromHex(postId)

err := postCollection.FindOne(ctx, bson.M{"id": objId}).Decode(&result)

res := map[string]interface{}{"data": result}

if err != nil {
c.JSON(http.StatusInternalServerError, gin.H{"message": err})
return
}

c.JSON(http.StatusCreated, gin.H{"message": "success!", "Data": res})
}

The jawatan pembolehubah ialah pengisytiharan parameter. Ia mendapat ID objek dokumen sebagai objId .

Walau bagaimanapun, hasil ialah contoh model pangkalan data, yang kemudiannya memegang dokumen yang dikembalikan sebagai semula .

Cara Mencipta Titik Akhir PUT

Pengendali PUT, masuk route/update.go , adalah serupa dengan pengendali POST. Kali ini, ia mengemas kini siaran sedia ada dengan ID objek uniknya:

package routes 

import (
getcollection "CRUD_API/Collection"
database "CRUD_API/databases"
model "CRUD_API/model"
"context"
"net/http"
"time"
"github.com/gin-gonic/gin"
"go.mongodb.org/mongo-driver/bson"
"go.mongodb.org/mongo-driver/bson/primitive"
)

func UpdatePost(c *gin.Context) {
ctx, cancel := context.WithTimeout(context.Background(), 10 * time.Second)
var DB = database.ConnectDB()
var postCollection = getcollection.GetCollection(DB, "Posts")

postId := c.Param("postId")
var post model.Posts

defer cancel()

objId, _ := primitive.ObjectIDFromHex(postId)

if err := c.BindJSON(&post); err != nil {
c.JSON(http.StatusInternalServerError, gin.H{"message": err})
return
}

edited := bson.M{"title": post.Title, "article": post.Article}

result, err := postCollection.UpdateOne(ctx, bson.M{"id": objId}, bson.M{"$set": edited})

res := map[string]interface{}{"data": result}

if err != nil {
c.JSON(http.StatusInternalServerError, gin.H{"message": err})
return
}

if result.MatchedCount < 1 {
c.JSON(http.StatusInternalServerError, gin.H{"message": "Data doesn't exist"})
return
}

c.JSON(http.StatusCreated, gin.H{"message": "data updated successfully!", "Data": res})
}

Format JSON bagi contoh model ( jawatan ) memanggil setiap medan model daripada pangkalan data. Pembolehubah hasil menggunakan MongoDB $set operator untuk mengemas kini dokumen yang diperlukan yang dipanggil oleh ID objeknya.

The hasil.MatchedCount syarat menghalang kod daripada dijalankan jika tiada rekod dalam pangkalan data atau ID yang diluluskan tidak sah.

Mencipta Titik Akhir DELETE

Titik akhir DELETE, dalam delete.go , mengalih keluar dokumen berdasarkan ID objek yang diluluskan sebagai parameter URL:

cara membetulkan windows bsod 10
package routes 

import (
getcollection "CRUD_API/Collection"
database "CRUD_API/databases"
"context"
"net/http"
"time"
"github.com/gin-gonic/gin"
"go.mongodb.org/mongo-driver/bson"
"go.mongodb.org/mongo-driver/bson/primitive"
)

func DeletePost(c *gin.Context) {
ctx, cancel := context.WithTimeout(context.Background(), 10*time.Second)
var DB = database.ConnectDB()
postId := c.Param("postId")

var postCollection = getcollection.GetCollection(DB, "Posts")
defer cancel()
objId, _ := primitive.ObjectIDFromHex(postId)
result, err := postCollection.DeleteOne(ctx, bson.M{"id": objId})
res := map[string]interface{}{"data": result}

if err != nil {
c.JSON(http.StatusInternalServerError, gin.H{"message": err})
return
}

if result.DeletedCount < 1 {
c.JSON(http.StatusInternalServerError, gin.H{"message": "No data to delete"})
return
}

c.JSON(http.StatusCreated, gin.H{"message": "Article deleted successfully", "Data": res})
}

Kod ini memadamkan rekod menggunakan DeleteOne fungsi. Ia juga menggunakan result.DeletedCount harta untuk menghalang kod daripada berjalan jika pangkalan data kosong atau ID objek tidak sah.

Buat Fail Pelari API

Akhir sekali, buat a main.go di dalam direktori akar projek anda. Struktur projek akhir anda sepatutnya kelihatan seperti ini:

  Struktur projek CRUD Golang

Fail ini mengendalikan pelaksanaan penghala untuk setiap titik akhir:

package main 

import (
routes "CRUD_API/routes"
"github.com/gin-gonic/gin"
)

func main() {
router := gin.Default()

router.POST("/", routes.CreatePost)

// called as localhost:3000/getOne/{id}
router.GET("getOne/:postId", routes.ReadOnePost)

// called as localhost:3000/update/{id}
router.PUT("/update/:postId", routes.UpdatePost)

// called as localhost:3000/delete/{id}
router.DELETE("/delete/:postId", routes.DeletePost)

router.Run("localhost: 3000")
}

Fail ini ialah pakej utama yang menjalankan fail lain. Ia bermula dengan mengimport pengendali laluan. Seterusnya ialah penghala pembolehubah, a gin contoh yang membangkitkan tindakan HTTP dan memanggil setiap titik akhir dengan nama fungsinya daripada laluan pakej.

Projek CRUD anda berjalan localhost:3000 . Untuk menjalankan pelayan dan menguji API CRUD , jalankan arahan berikut dalam direktori asas anda:

go run main.go

Jadikan Projek CRUD Golang Anda Menjadi Produk Boleh Guna

Anda telah berjaya mencipta API CRUD dengan Go; tahniah! Walaupun ini adalah projek kecil, anda telah melihat perkara yang diperlukan untuk melaksanakan permintaan HTTP biasa dalam Go.

Anda boleh menjadi lebih kreatif dengan mengembangkan ini menjadi aplikasi yang lebih praktikal yang memberikan nilai kepada pengguna. Go ialah bahasa pengaturcaraan yang sesuai untuk pelbagai kes penggunaan.