Golang, birçok uygulama ile 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 CRUD API oluşturmayı öğrenin.
İlk Kurulum ve Kurulum
Henüz yapmadıysanız , bilgisayarınıza yükleyerek Golang’ı kullanmaya başlayın .
Kurulduktan sonraki adım, makinenizde bir proje kök klasörü oluşturmak ve bu kök dizinde bir Go modülü başlatmaktır.
Bunu yapmak için bir CLI açın , proje kök klasörünüze gidin ve şunu çalıştırın:
go mod init module_name
go.mod dosyasını açtığınızda modül adınızı (örn . CRUD_API ) ve sürümünü göreceksiniz. Tüm özel paketler bu ana modülden gelecektir. Dolayısıyla, içe aktarılan herhangi bir özel paket şu biçimi alır:
import(package CRUD_API/package-directory-name)
Ardından, CRUD API’sini oluşturmak için gerekli paketleri kurun. Bu durumda, API uç noktalarını yönlendirmek için Gin Gonic’i kullanın:
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
Go’ya MongoDB’ye Nasıl Bağlanılır
Tek ihtiyacınız olan, Golang’ı veritabanına bağlamak için MongoDB URI’nizdir. Yerel olarak MongoDB Atlas’a 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 veritabanları olarak adlandırın . Bu klasörün içinde bir Go dosyası oluşturun ve database.go olarak adlandırın .
Bu sizin 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
}
Dotenv paketini kullanarak bir .env dosyasındaki veritabanı bağlantı dizesi gibi ortam değişkenlerini gizlemek en iyi uygulamadır . Bu, kodunuzu daha taşınabilir hale getirir ve örneğin bir MongoDB bulut kümesi örneği kullanırken kullanışlı olur .
ConnectDB işlevi bir bağlantı kurar ve yeni bir MongoDB Client 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 , proje kökünüzde Collection adlı yeni bir klasör oluşturarak başlayın . Şimdi koleksiyonu veritabanından alan getCollection.go adlı yeni bir Go dosyası oluşturun :
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. Bu durumda veritabanı adı, koleksiyonu Posts olan myGoappDB’dir .
Veritabanı Modeli Oluşturma
Kök dizininizde yeni bir klasör oluşturun ve onu model olarak adlandırın . Bu klasör, veritabanı modelinizi işler.
Bu klasörün içinde yeni bir Go dosyası oluşturun ve onu model.go olarak adlandırın . Bu durumda modeliniz, şu başlığı taşıyan bir blog gönderisidir:
package model
import (
“go.mongodb.org/mongo-driver/bson/primitive”
)
type Post struct {
ID primitive.ObjectID
Title string
Article string
}
Go ile CRUD API Oluşturma
Sırada CRUD API oluşturma var. Bu bölümle başlamak için, uç noktalarınızı işlemek için proje kök dizininizde yeni bir klasör oluşturun. Rotalar olarak adlandırın .
Her eylem için bu klasörde ayrı bir Go dosyası oluşturun. Örneğin, bunları create.go , read.go , update.go ve delete.go olarak adlandırabilirsiniz . Bu işleyicileri rota paketi olarak dışa aktaracaksınız .
Go’da POST Uç Noktası Nasıl Oluşturulur
Veritabanına veri yazmak için POST uç noktasını tanımlayarak başlayın.
route/create.go içine şunu 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 Gin ve MongoDB Driver dahil olmak üzere üçüncü taraf paketleri içe aktarır .
Ayrıca postCollection , veritabanı koleksiyonunu tutar. Özellikle c.BindJSON(“post”) , her model alanını postPayload olarak çağıran JSONified bir model örneğidir ; bu veri tabanına gider.
GET Uç Noktası Nasıl Oluşturulur
route/read.go içindeki GET uç noktası, 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})
}
postId değişkeni bir parametre bildirimidir. Bir belgenin nesne kimliğini objId olarak alır .
Ancak sonuç , daha sonra döndürülen belgeyi res olarak tutan veritabanı modelinin bir örneğidir .
PUT Uç Noktası Nasıl Oluşturulur
route/update.go içindeki PUT işleyicisi, POST işleyicisine benzer. Bu kez, mevcut bir gönderiyi benzersiz nesne kimliğine göre 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 ( post ) bir JSON biçimi, veritabanından her bir model alanını çağırır. Sonuç değişkeni , nesne kimliği tarafından çağrılan gerekli bir belgeyi güncellemek için MongoDB $set operatörünü kullanır.
Result.MatchedCount koşulu, veritabanında kayıt yoksa veya iletilen kimlik geçersizse kodun çalışmasını engeller .
DELETE Uç Noktası Oluşturma
delete.go içindeki DELETE uç noktası, 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, DeleteOne işlevini kullanarak bir kaydı siler . Ayrıca , veritabanı boşsa veya nesne kimliği geçersizse kodun çalışmasını önlemek için result.DeletedCount özelliğini kullanır.
API Çalıştırıcı Dosyasını Oluşturun
Son olarak, projenizin kök dizininde bir main.go oluşturun. 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. Sırada, HTTP eylemlerini çağrıştıran ve her uç noktayı, route paketinden işlev adına göre çağıran bir cin örneği olan yönlendirici değişkeni var.
CRUD projeniz localhost:3000 üzerinde çalışır . Sunucuyu çalıştırmak ve CRUD API’sini test etmek için 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 bir CRUD API’sini başarıyla oluşturdunuz; Tebrikler! Bu küçük bir proje olsa da, Go’da normal HTTP isteklerini yürütmek için neler gerektiğini gördünüz.
Bunu, kullanıcılara değer sunan daha pratik bir uygulamaya genişleterek daha yaratıcı olabilirsiniz. Go, çeşitli kullanım durumları için uygun bir programlama dilidir.