Golang's Gin ve MongoDB ile CRUD API Nasıl Oluşturulur

Golang's Gin ve MongoDB ile CRUD API Nasıl Oluşturulur

Golang, birçok uygulamaya sahip, en çok ödeme yapan, talep gören programlama dillerinden biridir. Gin, Revel ve gorilla/mux gibi çerçevelerle eşleştirildiğinde Go ile kolayca bir API oluşturabilirsiniz.





Gin HTTP çerçevesini kullanarak Golang'da nasıl CRUD API oluşturacağınızı öğrenin.



GÜNÜN YAPILAN VİDEOSU

İlk Kurulum ve Kurulum

Golang'ı kullanmaya başlayın Henüz yapmadıysanız, bilgisayarınıza yükleyerek.





Kurulduktan sonraki adım, makinenizde bir proje kök klasörü oluşturmak ve bu kök dizinde bir Go modülünü başlatmaktır.

Bunu yapmak için açın bir CLI , proje kök klasörünüze gidin ve çalıştırın:



go mod init module_name

Modül adınızı göreceksiniz (ör. CRUD_API ) ve sürümünü açtığınızda go.mod dosya. Tüm özel paketler bu ana modülden gelecektir. Böylece, içe aktarılan herhangi bir özel paket şu şekli alır:

wifi üzerinden birinin telefonuna nasıl erişilir 
import(package CRUD_API/package-directory-name)

Ardından, CRUD API'sini oluşturmak için gerekli paketleri kurun. Bu durumda, kullanın cin gonik API uç noktalarını yönlendirmek için:



go get github.com/gin-gonic/gin

Şimdi verileri depolamak için MongoDB Sürücüsünü kurun:

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

MongoDB'ye Git Nasıl Bağlanır

Golang'ı veritabanına bağlamak için tek ihtiyacınız olan MongoDB URI'niz. MongoDB Atlas'a yerel olarak bağlanıyorsanız, genellikle şöyle görünür:



Mongo_URL = "mongodb://127.0.0.1:27017"

Şimdi proje kök dizininizde yeni bir klasör oluşturun ve onu çağırın veritabanları . Bu klasörün içinde bir Go dosyası oluşturun ve adlandırın veritabanı.go .

Bu, veritabanı paketinizdir ve gerekli kitaplıkları içe aktararak başlar:

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 
}

Veritabanı bağlantı dizesi gibi ortam değişkenlerini bir .env dosya dotenv paketini kullanma . Bu, kodunuzu daha taşınabilir hale getirir ve bir MongoDB bulut kümesi örneği , örneğin.

bu ConnectDB işlevi bir bağlantı kurar ve yeni bir MongoDB İstemci nesnesi döndürür.

Veritabanı Koleksiyonu Oluştur

MongoDB, verileri, temel alınan veritabanı verilerine bir arabirim sağlayan Koleksiyonlarda depolar.

Koleksiyon getirme işlevini işlemek için yeni bir klasör oluşturarak başlayın, Toplamak , proje kökünüzde. Şimdi yeni bir Go dosyası oluşturun, getCollection.go , bu koleksiyonu veritabanından alır:

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 
}

Bu işlev, Koleksiyonu MongoDB veritabanından alır. Veritabanı adı, bu durumda, myGoappDB , ile birlikte Gönderiler koleksiyonu olarak.

Veritabanı Modelini Oluşturun

Kök dizininizin içinde yeni bir klasör oluşturun ve onu arayın model . Bu klasör, veritabanı modelinizi işler.

Bu klasörün içinde yeni bir Go dosyası oluşturun ve onu arayın model.go . Bu durumda modeliniz, başlığına sahip bir blog yazısıdır:

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

Go ile bir CRUD API Oluşturma

Sırada CRUD API oluşturma var. Bu bölüme başlamak için, proje kök dizininizde uç noktalarınızı işlemek için yeni bir klasör oluşturun. Bunu aramak rotalar .

projektörle yapılabilecek güzel şeyler

Her eylem için bu klasörde ayrı bir Go dosyası oluşturun. Örneğin, onları adlandırabilirsiniz oluştur. git , oku. git , update.go , ve sil.go . Bu işleyicileri rotalar paket.

Go'da POST Bitiş Noktası Nasıl Oluşturulur

Veritabanına veri yazmak için POST uç noktasını tanımlayarak başlayın.

İçeri rotalar/create.go , şunları ekleyin:

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

Bu kod, projenin özel modüllerini içe aktararak başlar. Daha sonra dahil olmak üzere üçüncü taraf paketleri içe aktarır. Cin ve MongoDB Sürücüsü .

Daha öte, koleksiyon sonrası veritabanı koleksiyonunu tutar. Özellikle, c.BindJSON('gönder') her model alanını şu şekilde çağıran bir JSONified model örneğidir: yük sonrası ; bu veritabanına giriyor.

GET Uç Noktası Nasıl Oluşturulur

GET uç noktası, rotalar/read.go , benzersiz kimliği aracılığıyla veritabanından tek bir belge okur. Ayrıca, özel ve üçüncü taraf paketleri içe aktararak başlar:

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

bu gönderiler değişken bir parametre bildirimidir. Bir belgenin nesne kimliğini şu şekilde alır: nesne .

Yine de, sonuç daha sonra döndürülen belgeyi şu şekilde tutan veritabanı modelinin bir örneğidir. res .

evimin tarihini bul

PUT Uç Noktası Nasıl Oluşturulur

PUT işleyicisi, rotalar/güncelleme.go , POST işleyicisine benzer. Bu sefer, mevcut bir gönderiyi benzersiz nesne kimliğiyle günceller:

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

Model örneğinin bir JSON biçimi ( İleti ) veritabanından her model alanını çağırır. Sonuç değişkeni MongoDB'yi kullanır $ayar nesne kimliği tarafından çağrılan gerekli bir belgeyi güncellemek için operatör.

bu sonuç.EşleşenSayı koşul, veritabanında kayıt yoksa veya iletilen kimlik geçersizse kodun çalışmasını engeller.

DELETE Uç Noktası Oluşturma

DELETE uç noktası, sil.go , bir URL parametresi olarak iletilen nesne kimliğine dayalı olarak bir belgeyi kaldırır:

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

Bu kod, kullanarak bir kaydı siler. Birini Sil işlev. Ayrıca şunları kullanır: sonuç.DeletedCount veritabanı boşsa veya nesne kimliği geçersizse kodun çalışmasını engelleyen özellik.

API Runner Dosyasını Oluşturun

Son olarak, bir ana.go proje kök dizininizin içinde. Nihai proje yapınız şöyle görünmelidir:

Golang CRUD proje yapısı

Bu dosya, her uç nokta için yönlendirici yürütmesini işler:

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

Bu dosya, diğer dosyaları çalıştıran ana pakettir. Rota işleyicilerini içe aktararak başlar. Sonraki yönlendirici değişken, bir cin HTTP eylemlerini çağrıştıran ve her uç noktayı rotalar paket.

CRUD projeniz devam ediyor yerel ana bilgisayar: 3000 . Sunucuyu çalıştırmak ve CRUD API'sini test edin , temel dizininizde aşağıdaki komutu çalıştırın:

go run main.go

Golang CRUD Projenizi Kullanılabilir Bir Ürüne Dönüştürün

Go ile başarıyla bir CRUD API oluşturdunuz; Tebrikler! Bu küçük bir proje olsa da, Go'da normal HTTP isteklerini yürütmek için ne gerektiğini gördünüz.

Bunu, kullanıcılara değer sağlayan daha pratik bir uygulamaya genişleterek daha yaratıcı olabilirsiniz. Go, çeşitli kullanım durumları için uygun bir programlama dilidir.