כיצד ליצור ממשק 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 קוֹבֶץ. כל החבילות המותאמות אישית יגיעו ממודול אב זה. אז כל חבילה מותאמת אישית מיובאת מקבלת את הטופס:

יְבוּא(חֲבִילָה CRUD_API/חֲבִילָה-שם ספרייה)

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

ללכת לקבל github.com/gin-gonic/gin

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

ללכת לקבל go.mongodb.org/mongo-driver/mongo

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

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

Mongo_URL = "mongodb://127.0.0.1:27017"

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

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

חֲבִילָה מאגר מידע
יְבוּא (
"הֶקשֵׁר"
"fmt"
"עֵץ"
"זְמַן"
"go.mongodb.org/mongo-driver/mongo"
"go.mongodb.org/mongo-driver/mongo/options"
)
func ConnectDB() *מונגו. לָקוּחַ {
	Mongo_URL := "mongodb://127.0.0.1:27017"
	לקוח, טעות := מונגו. NewClient (אפשרויות. Client().ApplyURI(Mongo_URL))
אם שגיאה != אפס {
עֵץ.קָטלָנִי(לִטְעוֹת)
	}
ctx, בטל := הקשר. WithTimeout (הקשר. רקע(), 10 * זמן. שְׁנִיָה)
	טעות = לקוח. התחבר (ctx)
	defer cancel()
אם שגיאה != אפס {
עֵץ.קָטלָנִי(לִטְעוֹת)
	}
fmt. Println("מחובר ל-mongoDB")
לַחֲזוֹר לָקוּחַ
}

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

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

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

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

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

חֲבִילָה getcollection
יְבוּא (
"go.mongodb.org/mongo-driver/mongo"
)
funcGetCollection(לָקוּחַ *מונגו.לָקוּחַ, שם אוסףחוּט) *מונגו.אוסף {
	אוסף := לקוח. מאגר מידע("myGoappDB").אוסף("פוסטים")
לַחֲזוֹר אוסף
}

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

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

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

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

חֲבִילָה דֶגֶם
יְבוּא (
"go.mongodb.org/mongo-driver/bson/primitive"
)
סוּג מבנה פוסט {
תְעוּדַת זֶהוּתפְּרִימִיטִיבִיזיהוי אובייקט
	מחרוזת כותרת
	מחרוזת מאמרים
}

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

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

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

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

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

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

חֲבִילָה מסלולים
יְבוּא (
	getcollection "CRUD_API/אוסף"
	מאגר מידע "CRUD_API/מסדי נתונים"
	דֶגֶם "CRUD_API/דגם"
"הֶקשֵׁר"
"עֵץ"
"net/http"
"זְמַן"
"github.com/gin-gonic/gin"
"go.mongodb.org/mongo-driver/bson/primitive"
)
func CreatePost(ג *ג'ין. הֶקשֵׁר){
var DB = מסד נתונים. ConnectDB()
	var postCollection = getcollection. GetCollection (DB, "פוסטים")
	ctx, בטל := הקשר. WithTimeout (הקשר. רקע(), 10*זמן. שְׁנִיָה)
	פוסט := חָדָשׁ(דֶגֶם. פוסטים)
	defer cancel()
אם שגיאה := ג. BindJSON(&הודעה); טעות != אפס {
 ג. JSON(http. StatusBadRequest, ג'ין. H{"הוֹדָעָה": טעות})
עֵץ.קָטלָנִי(לִטְעוֹת)
לַחֲזוֹר
	}
postPayload := דגם. פוסטים{
תְעוּדַת זֶהוּת: פְּרִימִיטִיבִי.NewObjectID(),
כותרת: הודעה.כותרת,
מאמר: הודעה.מאמר,
	}
תוצאה, שגיאה := postCollection. InsertOne (ctx, postPayload)
אם שגיאה != אפס {
 ג. JSON(http. StatusInternalServerError, ג'ין. H{"הוֹדָעָה": טעות})
לַחֲזוֹר
	}
ג. JSON(http. StatusCreated, ג'ין. H{"הוֹדָעָה": "פורסם בהצלחה", "נתונים": מפה[string]ממשק{}{"נתונים": תוצאה}})
}

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

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

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

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

חֲבִילָה מסלולים
יְבוּא (
	getcollection "CRUD_API/אוסף"
	מאגר מידע "CRUD_API/מסדי נתונים"
	דֶגֶם "CRUD_API/דגם"
"הֶקשֵׁר"
"net/http"
"זְמַן"
"github.com/gin-gonic/gin"
"go.mongodb.org/mongo-driver/bson"
"go.mongodb.org/mongo-driver/bson/primitive"
)
func ReadOnePost(ג *ג'ין. הֶקשֵׁר){
	ctx, בטל := הקשר. WithTimeout (הקשר. רקע(), 10*זמן. שְׁנִיָה)
var DB = מסד נתונים. ConnectDB()
	var postCollection = getcollection. GetCollection (DB, "פוסטים")
postId := ג. פארם("postId")
var מודל תוצאות. פוסטים
defer cancel()
objId, _ := פרימיטיבי. ObjectIDFromHex (postId)
טעות := postCollection. FindOne (ctx, bson. M{"תְעוּדַת זֶהוּת": objId}).Decode(&תוֹצָאָה)
res := מפה[מחרוזת]מִמְשָׁק{}{"data": result}
אם שגיאה != אפס {
 ג. JSON(http. StatusInternalServerError, ג'ין. H{"הוֹדָעָה": טעות})
לַחֲזוֹר
	}
ג. JSON(http. StatusCreated, ג'ין. H{"הוֹדָעָה": "הַצלָחָה!", "נתונים": res})
}

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

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

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

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

חֲבִילָה מסלולים
יְבוּא (
	getcollection "CRUD_API/אוסף"
	מאגר מידע "CRUD_API/מסדי נתונים"
	דֶגֶם "CRUD_API/דגם"
"הֶקשֵׁר"
"net/http"
"זְמַן"
"github.com/gin-gonic/gin"
"go.mongodb.org/mongo-driver/bson"
"go.mongodb.org/mongo-driver/bson/primitive"
)
func UpdatePost(ג *ג'ין. הֶקשֵׁר){
	ctx, בטל := הקשר. WithTimeout (הקשר. רקע(), 10 * זמן. שְׁנִיָה)
var DB = מסד נתונים. ConnectDB()
	var postCollection = getcollection. GetCollection (DB, "פוסטים")
postId := ג. פארם("postId")
var דגם פוסט. פוסטים
defer cancel()
objId, _ := פרימיטיבי. ObjectIDFromHex (postId)
אם שגיאה := ג. BindJSON(&הודעה); טעות != אפס {
 ג. JSON(http. StatusInternalServerError, ג'ין. H{"הוֹדָעָה": טעות})
לַחֲזוֹר
	}
ערוך := bson. M{"כותרת": הודעה. כותרת, "מאמר": הודעה. מאמר}
תוצאה, שגיאה := postCollection. UpdateOne (ctx, bson. M{"תְעוּדַת זֶהוּת": objId}, bson. M{"$סט": ערוך})
res := מפה[מחרוזת]מִמְשָׁק{}{"data": result}
אם שגיאה != אפס {
 ג. JSON(http. StatusInternalServerError, ג'ין. H{"הוֹדָעָה": טעות})
לַחֲזוֹר
	}
אם תוצאה. MatchedCount < 1 {
 ג. JSON(http. StatusInternalServerError, ג'ין. H{"הוֹדָעָה": "נתונים לא'לא קיים"})
לַחֲזוֹר
	}
ג. JSON(http. StatusCreated, ג'ין. H{"הוֹדָעָה": "הנתונים עודכנו בהצלחה!", "נתונים": res})
}

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

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

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

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

חֲבִילָה מסלולים
יְבוּא (
	getcollection "CRUD_API/אוסף"
	מאגר מידע "CRUD_API/מסדי נתונים"
"הֶקשֵׁר"
"net/http"
"זְמַן"
"github.com/gin-gonic/gin"
"go.mongodb.org/mongo-driver/bson"
"go.mongodb.org/mongo-driver/bson/primitive"
)
func מחק פוסט(ג *ג'ין. הֶקשֵׁר){
	ctx, בטל := הקשר. WithTimeout (הקשר. רקע(), 10*זמן. שְׁנִיָה)
var DB = מסד נתונים. ConnectDB()
	postId := ג. פארם("postId")
var postCollection = getcollection. GetCollection (DB, "פוסטים") 
	defer cancel()
	objId, _ := פרימיטיבי. ObjectIDFromHex (postId) 
	תוצאה, שגיאה := postCollection. DeleteOne (ctx, bson. M{"תְעוּדַת זֶהוּת": objId}) 
	res := מפה[מחרוזת]מִמְשָׁק{}{"data": result}
אם שגיאה != אפס {
 ג. JSON(http. StatusInternalServerError, ג'ין. H{"הוֹדָעָה": טעות})
לַחֲזוֹר
	}
אם תוצאה. DeletedCount < 1 {
 ג. JSON(http. StatusInternalServerError, ג'ין. H{"הוֹדָעָה": "אין נתונים למחוק"})
לַחֲזוֹר
	}
ג. JSON(http. StatusCreated, ג'ין. H{"הוֹדָעָה": "המאמר נמחק בהצלחה", "נתונים": res})
}

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

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

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

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

חֲבִילָה רָאשִׁי
יְבוּא (
 מסלולים "CRUD_API/מסלולים"
"github.com/gin-gonic/gin"
)
func רָאשִׁי(){
 נתב := ג'ין.בְּרִירַת מֶחדָל()
נתב. הודעה("/", מסלולים. CreatePost)
// נקרא בתור localhost: 3000/getOne/{id}
 נתב. לקבל("getOne/:postId", מסלולים. ReadOnePost)
// נקרא כמארח מקומי: 3000/עדכון/{תְעוּדַת זֶהוּת}
 נתב. לָשִׂים("/update/:postId", מסלולים. UpdatePost)
// נקרא כמארח מקומי: 3000/לִמְחוֹק/{תְעוּדַת זֶהוּת}
 נתב. לִמְחוֹק("/לִמְחוֹק/:postId", מסלולים. מחק פוסט)
נתב. לָרוּץ("מארח מקומי: 3000")
}

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

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

ללכתלָרוּץרָאשִׁי.ללכת

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

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

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