ממשקי API של RESTful הם ארכיטקטורות פופולריות להעברת נתונים ברחבי האינטרנט. ממשקי API של RESTful משתמשים בדרך כלל ב-HTTP, מה שהופך אותם מתאימים למקרים שבהם חוסר מצב חשוב.
כמו כל שפה בצד השרת, אתה יכול לקיים אינטראקציה עם פרוטוקול HTTP ולבצע בקשות HTTP ב-Go.
תחילת העבודה לצרוך ממשקי API של RESTful ב-Go
ה http החבילה מספקת את רוב הפונקציונליות שתזדקק לאינטראקציה עם פרוטוקול ה-HTTP ב-Go. זה כולל ביצוע בקשות HTTP, ואתה לא בהכרח צריך תלות חיצונית, כמו ג'ין או מסד נתונים.
אתה יכול להשתמש ב http חבילה לצרוך ממשקי API ולאחזור דפים עבורם גירוד אינטרנט ב-Go.
ייבא את החבילות האלה כדי להתחיל לבצע בקשות HTTP ב-Go.
יְבוּא (
"בייטים"
"קידוד/json"
"fmt"
"io/ioutil"
"נטו/http"
)
אתה תשתמש ב- בתים חבילה כדי לתפעל פרוסות בתים, ה json חבילה לעיצוב נתוני בקשה, ה fmt חבילה לכתיבה לפלט סטנדרטי, ה יוטיל חבילה עבור קלט ופלט, ואת http חבילה לשליחת בקשות.
בקשת GET פשוטה ב-Go
טיפוסי לקבל מבקש נתוני קריאה משרת ועשויים לספק פרמטרים לנתונים בהתאם לאופי ולמפרט של ה-API.
במדריך זה, תלמד כיצד לצרוך ממשקי API של RESTful באמצעות שירות הבקשות והתגובה הפשוטות של httpbin.
הנה דוגמה לביצוע בקשת HTTP עם Go:
כתובת אתר := "https://httpbin.org/get"
תגובה, טעות := http. קבל (כתובת אתר)
אם טעות != אֶפֶס {
fmt. Printf("היתה שגיאה בבקשת ה-API %s", err. שְׁגִיאָה())
} אַחֵר {
// ממשיך [1] ...
}
ה כתובת אתר משתנה הוא נקודת הקצה שאליה אתה שולח את הבקשה. ה לקבל השיטה לוקחת את כתובת האתר, מבצעת את לקבל בקשה, ומחזירה את התגובה, כולל הכותרות והגוף שלה.
אתה יכול לטפל בכל שגיאה מהבקשה בהתאם לדרישות שלך. אם אין שגיאות, תוכל להמשיך ולחלץ את המידע הדרוש לך מה- לקבל בַּקָשָׁה.
} אַחֵר {
//... [1] המשיך
responseData, err := ioutil. ReadAll (תגובה. גוּף)
אם טעות != אֶפֶס {
fmt. Printf("אירעה שגיאה בניתוח גוף הבקשה %s", err. שְׁגִיאָה())
} אַחֵר {
// ממשיך [2] ...
}
}
התגובה היא גוּף השדה מחזיק את גוף התגובה. משתמש ב תקרא הכל שיטת ה יוטיל חבילה, תוכל לקרוא את גוף התגובה ולטפל בשגיאות אפשריות.
} אַחֵר {
//... [2] המשיך
fmt. Println(חוּט(responseData))
}
ה אַחֵר הצהרה מדפיסה את גוף התגובה למסוף שלך אם אין שגיאות מפעולת הקריאה.
הנה התוצאה של לקבל בקשה לנקודת הקצה של httpbin.
בקשת POST פשוטה ב-Go
בקשות POST טיפוסיות מספקות עומסי נתונים לשרת, והשרת מחזיר תגובה בהתאם לפעולה.
להלן מבנה פשוט לקידוד מטען JSON לשרת כחלק מבקשת ה-POST.
סוּג JSON struct {
מידע חוּט
הוֹדָעָה חוּט
}
ה JSON למבנה יש את מידע ו הוֹדָעָה שדות מחרוזת, ואתחול מופע struct עבור הבקשה.
כתובת אתר := "https://httpbin.org/post"
jsonInstance := JSON {
info: "מצפה להצלחה",
הודעה: "הבקשה צריכה לַחֲזוֹר ",
}
ה כתובת אתר המשתנה מאחסן את נקודת הקצה של בקשת POST מאתר httpbin. ה jsonInstance משתנה הוא מופע של מבנה JSON שבו אתה יכול להשתמש כדי לאחסן ולשלוח נתונים מובנים.
אתה יכול להשתמש ב מַרשַׁל שיטה מה json חבילה לפורמט JSON עבור הבקשה.
jsonData, טעות := json. מרשל (jsonInstance)
אם טעות != אֶפֶס {
fmt. Println("הייתה שגיאה עם ה-JSON", שגיאה. שְׁגִיאָה())
} אַחֵר {
// ממשיך [1] ...
}
ה מַרשַׁל השיטה גם מחזירה שגיאה שאתה יכול לטפל בה. אם אין שגיאות בפעולת המרת JSON, תוכל להמשיך לבצע את בקשת ה-POST.
אתה יכול להשתמש ב הודעה שיטה להגשת בקשות POST. ה הודעה השיטה לוקחת את נקודת הקצה של כתובת האתר, את סוג התוכן של הבקשה ומאגר של המטען. זה מחזיר את התגובה ושגיאה.
} אַחֵר {
//... המשך [1]
תגובה, טעות := http. פוסט (כתובת אתר, "application/json", בתים. NewBuffer (jsonData))
אם טעות != אֶפֶס {
fmt. Println("היתה שגיאה בבקשה", err. שְׁגִיאָה())
} אַחֵר {
// ממשיך [2] ...
}
}
שוב, אתה יכול לקרוא את גוף התגובה באמצעות ה תקרא הכל שיטת ה יוטיל חֲבִילָה:
} אַחֵר {
//... המשך [2]
נתונים, טעות := ioutil. ReadAll (תגובה. גוּף)
אם טעות != אֶפֶס {
fmt. Println("היתה שגיאה בקריאת גוף הבקשה", err. שְׁגִיאָה())
} אַחֵר {
fmt. Println(חוּט(נתונים))
}
}
ה Println הצהרה מפלטת את התוצאה של בקשת ה-HTTP למסוף שלך.
בתור ה תיעוד httpbin מציין, נקודת קצה זו של POST מחזירה את נתוני הבקשה שאתה שולח לה.
קל לבנות אפליקציות אינטרנט ב-Go
אתה יכול לבנות יישומי אינטרנט עם פונקציונליות שונות ב-Go ללא תלות.
ה http החבילה כוללת את הפונקציות שתזדקק למרבית הפעולות שלך. אתה יכול להשתמש בחבילה זו עם אחרים כמו json חבילה עבור פעולות JSON, ה הֶקשֵׁר חבילה לאיתות, וחבילת התבנית לתבנית. ישנן חבילות רבות אחרות בספרייה הסטנדרטית.
