Cara Membuat API CRUD Dengan Gin dan MongoDB Golang

Cara Membuat API CRUD Dengan Gin dan MongoDB Golang

Golang adalah salah satu bahasa pemrograman yang paling banyak diminati dengan banyak aplikasi. Saat dipasangkan dengan kerangka kerja seperti Gin, Revel, dan gorila/mux, Anda dapat dengan mudah membuat API dengan Go.





Pelajari cara membuat CRUD API di Golang menggunakan kerangka kerja HTTP Gin.



VIDEO MAKEUSEOF HARI INI

Pengaturan dan Instalasi Awal

Mulailah dengan Golang dengan menginstalnya di komputer Anda jika Anda belum melakukannya.





Setelah terinstal, langkah selanjutnya adalah membuat folder root proyek di mesin Anda dan menginisialisasi modul Go di direktori root tersebut.

Untuk melakukan ini, buka sebuah CLI , navigasikan ke folder root proyek Anda dan jalankan:



go mod init module_name

Anda akan melihat nama modul Anda (mis. CRUD_API ) dan versinya saat Anda membuka go.mod mengajukan. Semua paket khusus akan berasal dari modul induk ini. Jadi setiap paket kustom yang diimpor berbentuk:

import(package CRUD_API/package-directory-name)

Selanjutnya, instal paket yang diperlukan untuk membuat CRUD API. Dalam hal ini, gunakan Gin Gonic untuk merutekan titik akhir API:



go get github.com/gin-gonic/gin

Sekarang instal Driver MongoDB untuk menyimpan data:

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

Bagaimana Menghubungkan Pergi ke MongoDB

Yang Anda butuhkan hanyalah URI MongoDB Anda untuk menghubungkan Golang dengan database. Biasanya terlihat seperti ini jika Anda terhubung ke MongoDB Atlas secara lokal:



Mongo_URL = "mongodb://127.0.0.1:27017"

Sekarang buat folder baru di direktori root proyek Anda dan beri nama database . Buat file Go di dalam folder ini dan beri nama database.go .

Ini adalah paket database Anda, dan ini dimulai dengan mengimpor 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 
}

Praktik terbaik untuk menyembunyikan variabel lingkungan seperti string koneksi database di a .env mengajukan menggunakan paket dotenv . Ini membuat kode Anda lebih portabel dan berguna saat menggunakan a Contoh kluster awan MongoDB , Misalnya.

cara merekam audio di chrome

Itu ConnectDB fungsi membuat koneksi dan mengembalikan objek Klien MongoDB baru.

Buat Koleksi Basis Data

MongoDB menyimpan data dalam Koleksi, yang menyediakan antarmuka ke data basis data yang mendasarinya.

Untuk menangani fungsionalitas pengambilan koleksi, mulailah dengan membuat folder baru, Koleksi , di root proyek Anda. Sekarang buat file Go baru, getCollection.go , yang mendapatkan koleksi dari database:

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 dari database MongoDB. Nama database, dalam hal ini, adalah myGoappDB , dengan Postingan sebagai koleksinya.

Buat Model Basis Data

Buat folder baru di dalam direktori root Anda dan beri nama model . Folder ini menangani model database Anda.

Buat file Go baru di dalam folder itu dan beri nama model.go . Model Anda, dalam hal ini, adalah posting blog dengan judulnya:

package model 
  
import ( 
	"go.mongodb.org/mongo-driver/bson/primitive" 
) 
  
type Post struct { 
	ID      primitive.ObjectID 
	Title   string 
	Article string 
}

Membuat CRUD API Dengan Go

Selanjutnya adalah pembuatan CRUD API. Untuk memulai dengan bagian ini, buat folder baru di dalam direktori root proyek Anda untuk menangani titik akhir Anda. Sebut saja rute .

Buat file Go terpisah di folder ini untuk setiap tindakan. Misalnya, Anda dapat menamainya create.go , baca.go , update.go , dan hapus.go . Anda akan mengekspor penangan ini sebagai rute kemasan.

Cara Membuat Titik Akhir POST di Go

Mulailah dengan mendefinisikan titik akhir POST untuk menulis data ke dalam database.

Dalam route/create.go , tambahkan berikut ini:

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

Kode ini dimulai dengan mengimpor modul kustom proyek. Itu kemudian mengimpor paket pihak ketiga termasuk Gin dan Driver MongoDB .

Lebih jauh, pascaKoleksi menyimpan koleksi database. Terutama, c.BindJSON('posting') adalah contoh model JSONified yang memanggil setiap bidang model sebagai pascaPayload ; ini masuk ke database.

Cara Membuat Titik Akhir GET

Titik akhir GET, dalam rute/baca.go , membaca satu dokumen dari database melalui ID uniknya. Itu juga dimulai dengan mengimpor paket khusus 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}) 
}

Itu posting variabel adalah deklarasi parameter. Itu mendapat ID objek dokumen sebagai objId .

Namun, hasil adalah turunan dari model database, yang kemudian menyimpan dokumen yang dikembalikan sebagai res .

Cara Membuat Titik Akhir PUT

Pengendali PUT, di route/update.go , mirip dengan penangan POST. Kali ini, ia memperbarui posting yang 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 dari contoh model ( pos ) memanggil setiap bidang model dari database. Variabel hasil menggunakan MongoDB $set operator untuk memperbarui dokumen yang diperlukan yang dipanggil oleh ID objeknya.

Itu hasil.MatchCount kondisi mencegah kode berjalan jika tidak ada catatan dalam database atau ID yang diteruskan tidak valid.

Membuat Titik Akhir DELETE

Titik akhir DELETE, dalam hapus.go , menghapus dokumen berdasarkan ID objek yang diteruskan sebagai parameter URL:

cara menghubungkan wii ke tv dengan hdmi 
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}) 
}

Kode ini menghapus catatan menggunakan HapusSatu fungsi. Ini juga menggunakan result.DeletedCount properti untuk mencegah kode berjalan jika database kosong atau ID objek tidak valid.

Buat File Pelari API

Terakhir, buat main.go di dalam direktori root proyek Anda. Struktur proyek akhir Anda akan terlihat seperti ini:

Struktur proyek CRUD Golang

File ini menangani eksekusi router 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") 
}

File ini adalah paket utama yang menjalankan file lain. Ini dimulai dengan mengimpor penangan rute. Berikutnya adalah router variabel, gin contoh yang membangkitkan tindakan HTTP dan memanggil setiap titik akhir dengan nama fungsinya dari rute kemasan.

Proyek CRUD Anda berjalan terus host lokal: 3000 . Untuk menjalankan server dan menguji CRUD API , jalankan perintah berikut di direktori dasar Anda:

go run main.go

Ubah Proyek CRUD Golang Anda Menjadi Produk yang Dapat Digunakan

Anda telah berhasil membuat CRUD API dengan Go; Selamat! Meskipun ini adalah proyek kecil, Anda telah melihat apa yang diperlukan untuk mengeksekusi permintaan HTTP reguler di Go.

Anda bisa menjadi lebih kreatif dengan mengembangkannya menjadi aplikasi yang lebih praktis yang memberikan nilai bagi pengguna. Go adalah bahasa pemrograman yang cocok untuk berbagai kasus penggunaan.