כיצד ליצור ממשק API של CRUD עם הג'ין של Golang ו-MongoDB

גולנג היא אחת משפות התכנות המשתלמות ביותר, המבוקשות, עם יישומים רבים. בשילוב עם מסגרות כמו Gin, Revel ו-gorilla/mux, אתה יכול בקלות ליצור API עם Go.

למד כיצד ליצור ממשק API של CRUD בגולאנג באמצעות מסגרת Gin HTTP.

---

---

איפור של סרטון היום

התקנה ראשונית והתקנה

התחל עם Golang על ידי התקנתו במחשב שלך אם עדיין לא עשית זאת.

לאחר ההתקנה, השלב הבא הוא ליצור תיקיית שורש של הפרויקט במחשב שלך ולאתחל מודול Go בספריית השורש הזו.

כדי לעשות זאת, פתח CLI , נווט אל תיקיית השורש של הפרויקט שלך והפעל:

go mod init module_name 

תראה את שם המודול שלך (למשל. CRUD_API ) והגרסה שלו כשאתה פותח את go.mod קוֹבֶץ. כל החבילות המותאמות אישית יגיעו ממודול אב זה. אז כל חבילה מותאמת אישית מיובאת מקבלת את הטופס:

import(package CRUD_API/package-directory-name)

לאחר מכן, התקן את החבילות הדרושות ליצירת ה-API של CRUD. במקרה זה, השתמש ג'ין גוני כדי לנתב את נקודות הקצה של ה-API:

---

---

go get github.com/gin-gonic/gin 

כעת התקן את מנהל ההתקן של MongoDB לאחסון נתונים:

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

כיצד להתחבר עבור אל MongoDB

כל מה שאתה צריך הוא ה-MongoDB URI שלך כדי לחבר את Golang עם מסד הנתונים. זה בדרך כלל נראה כך אם אתה מתחבר ל- MongoDB Atlas באופן מקומי:

---

---

Mongo_URL = "mongodb://127.0.0.1:27017"

כעת צור תיקיה חדשה בספריית השורש של הפרויקט שלך וקרא לה מסדי נתונים . צור קובץ Go בתוך תיקיה זו ותן לו שם database.go .

זוהי חבילת מסד הנתונים שלך, והיא מתחילה בייבוא ​​הספריות הנדרשות:

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 
} 

מומלץ להסתיר משתני סביבה כמו מחרוזת חיבור מסד הנתונים ב-a .env קוֹבֶץ באמצעות חבילת dotenv . זה הופך את הקוד שלך לנייד יותר ומגיע שימושי בעת שימוש ב-a מופע אשכול ענן של MongoDB , לדוגמה.

ה ConnectDB הפונקציה יוצרת חיבור ומחזירה אובייקט MongoDB Client חדש.

צור אוסף מסד נתונים

MongoDB מאחסן נתונים באוספים, המספקים ממשק לנתוני מסד הנתונים הבסיסיים.

כדי לטפל בפונקציונליות שליפת האוסף, התחל ביצירת תיקיה חדשה, אוסף , בשורש הפרויקט שלך. כעת צור קובץ Go חדש, getCollection.go , שמקבל את האוסף ממסד הנתונים:

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 
} 

פונקציה זו מקבלת את האוסף ממסד הנתונים של MongoDB. שם מסד הנתונים, במקרה זה, הוא myGoappDB , עם פוסטים כאוסף שלה.

צור את מודל מסד הנתונים

צור תיקיה חדשה בתוך ספריית השורש שלך וקרא לה דֶגֶם . תיקיה זו מטפלת במודל מסד הנתונים שלך.

צור קובץ Go חדש בתוך התיקיה הזו וקרא לו model.go . הדגם שלך, במקרה זה, הוא פוסט בבלוג עם הכותרת שלו:

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

יצירת ממשק API של CRUD עם Go

הבא הוא יצירת CRUD API. כדי להתחיל בסעיף זה, צור תיקיה חדשה בתוך ספריית השורש של הפרויקט שלך כדי לטפל בנקודות הקצה שלך. קורא לזה מסלולים .

צור קובץ Go נפרד בתיקייה זו עבור כל פעולה. לדוגמה, אתה יכול לתת להם שמות create.go , read.go , update.go , ו delete.go . אתה תייצא את המטפלים האלה בתור מסלולים חֲבִילָה.

כיצד ליצור את נקודת הקצה של POST ב-Go

התחל בהגדרת נקודת הקצה של POST לכתיבת נתונים למסד הנתונים.

בְּתוֹך routes/create.go , הוסף את הדברים הבאים:

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

קוד זה מתחיל בייבוא ​​המודולים המותאמים אישית של הפרויקט. לאחר מכן הוא מייבא חבילות של צד שלישי כולל ג'ין ו מנהל התקן MongoDB .

נוסף, postCollection מחזיק את אוסף מסד הנתונים. במיוחד, c.BindJSON('פוסט') הוא מופע מודל JSONified הקורא לכל שדה מודל בשם postPayload ; זה נכנס למסד הנתונים.

כיצד ליצור את נקודת הקצה של GET

נקודת הקצה של GET, ב routes/read.go , קורא מסמך בודד ממסד הנתונים באמצעות המזהה הייחודי שלו. זה מתחיל גם בייבוא ​​חבילות מותאמות אישית וחבילות של צד שלישי:

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

ה פוסטים משתנה הוא הצהרת פרמטר. הוא מקבל מזהה אובייקט של מסמך כ objId .

למרות זאת, תוֹצָאָה הוא מופע של מודל מסד הנתונים, שמחזיק מאוחר יותר את המסמך המוחזר כ מילואים .

כיצד ליצור את נקודת הקצה של PUT

מטפל ה-PUT, ב routes/update.go , דומה למטפל POST. הפעם, הוא מעדכן פוסט קיים לפי מזהה האובייקט הייחודי שלו:

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

פורמט JSON של מופע המודל ( הודעה ) קורא לכל שדה מודל ממסד הנתונים. משתנה התוצאה משתמש ב- MongoDB $סט מפעיל כדי לעדכן מסמך נדרש שנקרא על ידי מזהה האובייקט שלו.

קוד מרכז העזרה של דיסני פלוס 83

ה result.MatchedCount condition מונע מהקוד לפעול אם אין רשומה במסד הנתונים או שהמזהה המועבר אינו חוקי.

יצירת נקודת קצה DELETE

נקודת הקצה DELETE, ב delete.go , מסיר מסמך על סמך מזהה האובייקט שהועבר כפרמטר כתובת אתר:

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

קוד זה מוחק רשומה באמצעות ה DeleteOne פוּנקצִיָה. הוא גם משתמש ב- result.DeletedCount מאפיין כדי למנוע מהקוד לפעול אם מסד הנתונים ריק או שמזהה האובייקט אינו חוקי.

צור את קובץ ה-API Runner

לבסוף, צור א main.go בתוך ספריית השורש של הפרויקט שלך. מבנה הפרויקט הסופי שלך צריך להיראות כך:

קובץ זה מטפל בביצוע הנתב עבור כל נקודת קצה:

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

קובץ זה הוא החבילה הראשית שמריצה קבצים אחרים. זה מתחיל בייבוא ​​מטפלי המסלול. הבא הוא נתב משתנה, א ג'ין מופע שמעורר את פעולות ה-HTTP וקורא לכל נקודת קצה בשם הפונקציה שלה מה- מסלולים חֲבִילָה.

פרויקט ה-CRUD שלך ממשיך מארח מקומי: 3000 . כדי להפעיל את השרת ו בדוק את CRUD API , הפעל את הפקודה הבאה בספריית הבסיס שלך:

go run main.go

הפוך את פרויקט Golang CRUD שלך למוצר שמיש

יצרת בהצלחה ממשק API של CRUD עם Go; מזל טוב! אמנם מדובר בפרויקט קטן, אבל ראית מה נדרש כדי לבצע בקשות HTTP רגילות ב-Go.

אתה יכול להיות יצירתי יותר על ידי הרחבת זה ליישום מעשי יותר המספק ערך למשתמשים. Go היא שפת תכנות מתאימה למגוון מקרי שימוש.