3 חבילות Go-Based GraphQL עבור ה-API הבא שלך

קוראים כמוך עוזרים לתמוך ב-MUO. כאשר אתה מבצע רכישה באמצעות קישורים באתר שלנו, אנו עשויים להרוויח עמלת שותף.

GraphQL הוא מפרט מבוסס HTTP שפותר את רוב הבעיות שתיתקל בהן בזמן בניית RESTful ממשקי API. זה מתאים לבניית ממשקי API מורכבים מכיוון שאתה יכול להשתמש בנקודת קצה אחת כדי לגשת לנתונים מסכימות רבות.

GraphQL מפחית בעיות כמו שליפת יתר ותת אחזור ב-REST. אתה יכול לבנות לקוח שמבקש שדות ספציפיים מבלי לבצע קריאות API נוספות.

ישנן מספר חבילות Go שתוכלו לנצל מהן לבניית יישומים מבוססי GraphQL, משרתים ועד ממשקי API.

1. חבילת gqlgen

gqlgen (מחולל GraphQL) היא חבילה עשירה בתכונות ובטוחה לסוגים להפקה ובנייה של שרתי GraphQL וממשקי API.

חבילת gqlgen נוקטת בגישה של schema-first, שבאמצעותה אתה משתמש ב-GraphQL SDL כדי להגדיר את הסכימה שלך. לאחר מכן הוא מייצר את קוד ה-boilerplate שתוכל להתאים להגדרת שרת ה-GraphQL וה-API שלך.

gqlgen היא אחת מחבילות GraphQL השלמות יותר ב המערכת האקולוגית של Go. אתה יכול ליצור תיעוד ודוגמאות עם החבילה וליצור שאילתות, מוטציות ומנויים.

gqlgen מבטיח כריכות סוגים, הטמעות, ממשקים, תשומות שנוצרו ו-enums. החבילה מספקת גם פונקציונליות למעקב פתוח, ווים לרישום שגיאות, טעינת נתונים, במקביל ומורכבות מוגברת של שאילתות.

לאחר הגדרת סכימת ה-GraphQL שלך - כפי שהיית עושה עם כל ספריה ראשית - תשתמש באפליקציית שורת הפקודה gqlgen כדי ליצור את קוד ה-boilerplate מהסכימה בפרויקט שלך.

ליצור tools.go קובץ בספריית העבודה שלך והוסף את שורות הקוד האלה כדי לכלול את gqlgen חֲבִילָה:

// +כלים לבנות
חֲבִילָה כלים
ייבוא ​​_ "github.com/99designs/gqlgen"

ה tools.go הקובץ מציין את כלי הבנייה עבור gqlgen חֲבִילָה.

הפעל את הפקודות האלה בספריית העבודה שלך כדי להתקין את חבילת gqlgen והתלות שלה:

ללכת התקן github.com/99designs/gqlgen@latest
ללכת mod מסודר

אתה יכול לאתחל פרויקט GraphQL חדש כאשר אתה מפעיל את חבילת GraphQL עם ה init פקודה כטיעון:

ללכת הפעל github.com/99designs/gqlgen init

תצטרך לקבל את הסכימה שלך ב-a schema.graphql קובץ הממוקם בספריית העבודה שלך כדי לאתחל פרויקט.

הפעל את server.go קובץ כדי להפעיל את שרת GraphQL שלך לאחר הוספת פונקציונליות לאפליקציית GraphQL שלך:

ללכת להפעיל שרת.ללכת

2. חבילת graphql-go

חבילת graphql-go היא ספריית GraphQL פופולרית שמטרתה לספק את השלם מפרט טיוטה של ​​GraphQL לבניית שירותי GraphQL ב-Go.

חבילת graphql-go נוקטת בגישת סוגי זמן הריצה; יש לך אפשרות להכריז על הסכימה שלך בקוד Go, והחבילה בודקת בזמן ריצה.

אתה יכול ליישם שאילתות, מוטציות ומינויים וליצור דוגמאות עם החבילה, אבל אין פונקציונליות ל-enums שנוצרו, קלט או מעקב פתוח.

graphql-go כולל ממשק API מינימלי עם תמיכה גם בחבילות מובנות וגם בחבילות פופולריות של צד שלישי. יש לו תמיכה עבור OpenTelemetry ו OpenTracing סטנדרטים, בדיקת סוג סכימה מול פותרים, ביצוע מקביל של פותרים ותכונות רבות אחרות.

אם אתה מכיר בניית שירותים RESTful ב-Go with the http חֲבִילָה, תמצא את חבילת graphql-go קלה לשימוש.

הפעל את הפקודות האלה בספריית העבודה שלך כדי להוסיף את חבילת graphql-go והתלות שלה לפרוייקט שלך:

ללכת קבל github.com/graph-gophers/graphql-ללכת

הנה דוגמה להפעלת שרת GraphQL פשוט:

חֲבִילָה רָאשִׁי
יְבוּא (
 "עֵץ"
 "נטו/http"
graphql "github.com/graph-gophers/graphql-ללכת"
 "github.com/graph-gophers/graphql-ללכת/relay"
)
סוּג שאילתא struct{}
func(_ *שאילתא)שלום()חוּט { לַחֲזוֹר "שלום עולם!" }
funcרָאשִׁי() {
 schemaExample := `
סוּג שאילתא {
 שלום: מחרוזת!
 }
`
schema := graphql. MustParseSchema (schemaExample, &שאילתה{})
 http. Handle("/query", &relay. מטפל{סכימה: סכמה})
 עֵץ. קטלני (http. ListenAndServe(":8080", אֶפֶס))
}

ה שלום שיטת ה שאילתא struct הוא פותר עבור נקודת הקצה GraphQL שמחזירה שלום עולם. ה schemaExample משתנה הוא הגדרת הסכימה, והשרת יפעל ביציאה 8080 עם ה- http של החבילה ListenAndServe שיטה.

3. חבילת הרעם

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

Thunder מספק בטיחות סוג עם כריכות סוגים ותכונות אחרות, כולל בניית סכימה מבוססת השתקפות, ביצוע ואצווה מקבילים מובנים, עורך GraphiQL מובנה וסכימות מפוצלות עבור GraphQL גדול יותר שרתים.

בחבילת Thunder אין פונקציונליות להטמעה, ממשקים, תקצירים או תשומות שנוצרו, פדרציה, מעקב פתוח או שגיאות מותאמות אישית. עם זאת, היא אחת הקלות לשימוש בהשוואה לחבילות פופולריות אחרות והיא חבילת התחלה מצוינת אם אין לך ניסיון ב-GraphQL.

תצטרך להפעיל פקודה זו במסוף של ספריית העבודה שלך כדי להתקין את חבילת Thunder והתלות שלה:

ללכת קבל github.com/samsarahq/thunder/graphql

תצטרך להכריז על מודל struct עבור הסכימה, לכתוב את הפותרים ולהפעיל את השרת כדי להפעיל שרת GraphQL פשוט עם חבילת Thunder.

יְבוּא (
 "הֶקשֵׁר"
 "נטו/http"
 "זְמַן"
"github.com/samsarahq/thunder/graphql"
 "github.com/samsarahq/thunder/graphql/graphiql"
 "github.com/samsarahq/thunder/graphql/introspection"
 "github.com/samsarahq/thunder/graphql/schemabuilder"
 "github.com/samsarahq/thunder/reactive"
)
סוּג הודעה struct {
 כותרת חוּט
 גוּף חוּט
 נוצר בזמנו. זְמַן
}
// שרת הוא שרת graphql שלנו.
סוּג שרת struct {
 פוסטים []פוסטים
}
// registerQuery רושם את סוג שאילתת השורש.
func(s *שרת)registerQuery(סכימה *בונה סכמות. סכֵימָה) {
 obj := סכימה. שאילתא()
obj. FieldFunc("פוסטים", func() []הודעה {
לַחֲזוֹר s.פוסטים
 })
}
// registerMutation רושם את סוג מוטציית השורש.
func(s *שרת)registerMutation(סכימה *בונה סכמות. סכֵימָה) {
 obj := סכימה. מוּטָצִיָה()
obj. FieldFunc("echo", func(טיעונים struct{ הודעה חוּט })חוּט {
לַחֲזוֹר args. הוֹדָעָה
 })
}
// registerPost רושם את סוג הפוסט.
func(s *שרת)הרשם פוסט(סכימה *בונה סכמות. סכֵימָה) {
 obj := סכימה. Object("פוסט", פוסט{})
obj. FieldFunc("גיל", func(הקשר של ctx. הקשר, p *פוסט)חוּט {
 תְגוּבָתִי. InvalidateAfter (ctx, 5*זְמַן. שְׁנִיָה)
לַחֲזוֹר זְמַן. מאז (עמ' CreatedAt).String()
 })
}
// schema בונה את סכימת graphql.
func(s *שרת)סכֵימָה() *graphql.סכֵימָה {
 בונה := בונה סכמות. NewSchema()
 s.registerQuery (בונה)
 s.registerMutation (בונה)
 s.registerPost (בונה)
לַחֲזוֹר בּוֹנֶה. MustBuild()
}
funcרָאשִׁי() {
// הצג שרת, בנה שרת והגש את הסכימה ביציאה 3030.
 שרת := &שרת{
 פוסטים: []פוסט{
 {כותרת: "פוסט ראשון!", גוף: "הייתי כאן ראשון!", CreatedAt: time. עַכשָׁיו()},
 {כותרת: "graphql", גוף: "שמעת על רעם?", CreatedAt: time. עַכשָׁיו()},
 },
 }
schema := server.schema()
 הִסתַכְּלוּת פְּנִימִית. AddIntrospectionToSchema (סכימה)
// חשיפת סכימה ו-graphiql.
 http. Handle("/graphql", graphql. מטפל (סכימה)
 http. Handle("/graphiql/", http. StripPrefix("/graphiql/", graphiql. Handler()))
 http. ListenAndServe(":3030", אֶפֶס)
}

ה הודעה struct הוא המודל של סכימת GraphQL, וה- שרת struct הוא מופע השרת. ה registerQuery, registerMutation, ו הרשם פוסט שיטות הן פונקציות פותר עבור שאילתות, מוטציות ואחסון נתונים.

ה רָאשִׁי הפונקציה מתחילה עם שרת GraphQL ביציאה 3030 ועורך GraphQL.

אתה יכול לבצע שאילתות בממשקי API של GraphQL תוך כדי שימוש בחבילות מובנות

GraphQL מבוססת HTTP, ואתה יכול לצרוך ממשקי API של GraphQL עם המובנה http חבילה וחבילות אחרות הדומות לממשקי API של RESTful. ישנן גם חבילות באקוסיסטם של Go שיאפשרו לך לצרוך ממשקי API של GraphQL במהירות.