כיצד לבצע בקשות HTTP ב-Go

אחד העקרונות הבסיסיים השולטים בתפקוד ה-World Wide Web הוא החלפת בקשות ותגובות. כאשר אתה שולח בקשה לגשת לדף אינטרנט, השרת מגיב עם נתונים מתאימים.

פרוטוקולים פופולריים השולטים בסוגים שונים של תקשורת אינטרנט כוללים HTTP (פרוטוקול העברת היפרטקסט), FTP (פרוטוקול העברת קבצים), ו SMTP (פרוטוקול העברת דואר פשוט).

HTTP הוא הפרוטוקול שבו תשתמש בדרך כלל כשאתה מציג אתר אינטרנט או משתמש באפליקציה התומכת באינטרנט. אתה יכול גם לעבוד עם בקשות HTTP משפות תכנות רבות, כולל Go.

מהי בקשת HTTP?

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

יש מספר סוגים של בקשת HTTP, כולל GET, POST, PUT, DELETE, HEAD, OPTIONS ו-CONNECT. ארבעת סוגי השיטה הראשונים הם הנפוצים ביותר; הם משקפים את פעולות ה-CRUD לקרוא, ליצור, לעדכן ולמחוק בהתאמה.

סוג בקשת PUT משמש לעתים קרובות לסירוגין עם סוג בקשת PATCH. הם משיגים את אותה מטרה, הם פשוט שונים בנתונים שהם מצפים שהבקשה תכלול.

שליחת בקשות באמצעות שיטות HTTP נפוצות

Go's מובנה http חֲבִילָה מספק קבוצה של פונקציות ומבנים שבהם אתה יכול להשתמש כדי ליצור שרתי אינטרנט ולנהל בקשות HTTP. זוהי חבילה חזקה מאוד וכל מסגרות האינטרנט של Go נבנות עליה בצורה זו או אחרת. זוהי חבילת משנה של Go's נֶטוֹ חֲבִילָה.

כדי ליצור בקשת HTTP ב-Go, אתה יכול להשתמש ב- http. בקשה חדשה() לתפקד ולהגדיר את השיטה המתאימה, כתובת האתר, הכותרות וגוף הבקשה. לאחר יצירת הבקשה, תוכל להשתמש ב-Go net/http של החבילה http. לָקוּחַ{} מבנה כדי להפעיל אותו ולקבל את התגובה.

משתמשים בדוגמאות הקוד הבאות reqres.in, ממשק API זמין לציבור לבדיקת בקשות HTTP. אתה יכול להשתמש בו כדי לבדוק בקשות GET, POST, PUT ו-DELETE בתוכניות ה-Go שלך.

בקשת POST

הקוד שלהלן הוא פונקציה ששולחת בקשת POST אל /api/users נקודת קצה של reqres.in כדי ליצור משתמש חדש עם שם ועבודה.

חֲבִילָה רָאשִׁי
יְבוּא (
"בייטים"
"קידוד/json"
"fmt"
"io"
"נטו/http"
)
funcצור משתמש(שם, עבודה חוּט) {
 fmt. Println("יוצר משתמש...")
 apiUrl := " https://reqres.in/api/users"
 userData := []בייט(`{"name":"` + שם + `","job":"` + עבודה + `"}`)
// צור בקשת http חדשה
 בקשה, שגיאה := http. בקשה חדשה("הודעה", apiUrl, בתים. NewBuffer (UserData))
 בַּקָשָׁה. כּוֹתֶרֶת. מַעֲרֶכֶת("סוג תוכן", "application/json; charset=utf-8")
// שלח את הבקשה
 לקוח := &http. לָקוּחַ{}
 תגובה, שגיאה := לקוח. עשה (בקש)
אם שגיאה != אֶפֶס {
 fmt. Println (שגיאה)
 }
 responseBody, שגיאה := io. ReadAll (תגובה. גוּף)
אם שגיאה != אֶפֶס {
 fmt. Println (שגיאה)
 }
 formattedData := formatJSON(responseBody)
 fmt. Println("סטטוס:", תגובה. סטָטוּס)
 fmt. Println("גוף התגובה:", formattedData)
// נקה זיכרון לאחר ביצוע
לִדחוֹת תְגוּבָה. גוּף. סגור()
}

formatJSON היא פונקציה מותאמת אישית שאתה יכול לכתוב כדי לעצב את נתוני הפלט. כך תוכל ליישם את זה:

// פונקציה לעיצוב נתוני JSON
funcformatJSON(נתונים []בייט)חוּט {
var החוצה בתים. בַּלָם
 טעות := json. כניסה(&out, נתונים, "", " ")
אם טעות != אֶפֶס {
 fmt. Println (שגיאה)
 }
 ד := החוצה. Bytes()
לַחֲזוֹרחוּט(ד)
}

אתה יכול להתקשר ל צור משתמש() פונקציה בתוכנית כזו:

funcרָאשִׁי() {
 fmt. Println("מבצע בקשת POST...")
 צור משתמש("טים אומולנה", "סוֹפֵר")
}

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

קבל בקשה

הקוד הבא הוא פונקציה ששולחת בקשת GET לאחזר משתמש משרת reqres.in באמצעות המזהה הייחודי שלו.

// main.go
funcgetUser(תְעוּדַת זֶהוּת חוּט) {
 fmt. Println("מקבל משתמש לפי תעודת זהות...")
// בקש GET ל-API כדי לקבל משתמש לפי מזהה
 apiUrl := " https://reqres.in/api/users/" + מזהה
 בקשה, שגיאה := http. בקשה חדשה("לקבל", apiUrl, אֶפֶס)
אם שגיאה != אֶפֶס {
 fmt. Println (שגיאה)
 }
 בַּקָשָׁה. כּוֹתֶרֶת. מַעֲרֶכֶת("סוג תוכן", "application/json; charset=utf-8")
 לקוח := &http. לָקוּחַ{}
 תגובה, שגיאה := לקוח. עשה (בקש)
אם שגיאה != אֶפֶס {
 fmt. Println (שגיאה)
 }
 responseBody, שגיאה := io. ReadAll (תגובה. גוּף)
אם שגיאה != אֶפֶס {
 fmt. Println (שגיאה)
 }
 formattedData := formatJSON(responseBody)
 fmt. Println("סטטוס:", תגובה. סטָטוּס)
 fmt. Println("גוף התגובה:", formattedData)
// נקה זיכרון לאחר ביצוע
לִדחוֹת תְגוּבָה. גוּף. סגור()
}

בקשת GET לא שולחת נתונים לשרת ולכן היא לא מקבלת או שולחת גוף בקשה לשרת כאשר היא נעשית. כך תיראה קריאה לדוגמה לפונקציה שלמעלה:

funcרָאשִׁי() {
 fmt. Println("מגיש בקשת GET...")
 getUser("2")
}

תְפוּקָה:

בקשת PUT

בקשת ה-PUT דומה מאוד לבקשת POST מכיוון שהיא גם שולחת נתונים לשרת. ההבדל העיקרי הוא ש-POST יוצר משאב חדש בעוד PUT מעדכן משאב קיים.

הנה יישום של בקשת PUT:

// main.go
funcupdateUser(שם, עבודה, תעודת זהות חוּט) {
 fmt. Println("מעדכן משתמש...")
// בקש PUT ל-API לעדכון משתמש
 apiUrl := " https://reqres.in/api/users/" + מזהה
 userData := []בייט(`{"name":"` + שם + `","job":"` + עבודה + `"}`)
// צור בקשת http PUT חדשה
 בקשה, שגיאה := http. בקשה חדשה("לָשִׂים", apiUrl, בתים. NewBuffer (UserData))
 בַּקָשָׁה. כּוֹתֶרֶת. מַעֲרֶכֶת("סוג תוכן", "application/json; charset=utf-8")
// גוף הפונקציה שנותר מפונקציית createUser...
// שלח בקשה, קבל תגובה ונקה זיכרון...
}

מהקוד הזה, אתה יכול לראות את ההבדלים היחידים בין בקשת ה-PUT לבקשת ה-POST שלמעלה הם שם השיטה וכתובת האתר. בעת שימוש ב-PUT לעדכון נתונים קיימים, תצטרך לצרף את המזהה לכתובת ה-URL של הבקשה. קריאה לדוגמה לפונקציה זו תיראה כך:

func main() {
// עדכן את הערך עם המזהה 2.
 updateUser("טים ניושם", "כותב צוות", "2")
}

הקוד למעלה מעדכן את המשתמש ומפיק את הפלט הבא:

מחק בקשה

השתמש בשיטת הבקשה DELETE כדי לבצע פעולת מחיקה בשרת אינטרנט. בקשת מחיקה מוחקת את המשאב שזוהה על ידי ה-URI. בקשת מחיקה ב-Go נראית כך:

funcמחק משתמש(תְעוּדַת זֶהוּת חוּט) {
 fmt. Println("מוחק משתמש...")
// בקש MELETE ל-API למחיקת משתמש
 apiUrl := " https://reqres.in/api/users/" + מזהה
// צור בקשת http חדשה
 בקשה, שגיאה := http. בקשה חדשה("לִמְחוֹק", apiUrl, אֶפֶס)
 בַּקָשָׁה. כּוֹתֶרֶת. מַעֲרֶכֶת("סוג תוכן", "application/json; charset=utf-8")
 לקוח := &http. לָקוּחַ{}
 תגובה, שגיאה := לקוח. עשה (בקש)
אם שגיאה != אֶפֶס {
 fmt. Println (שגיאה)
 }
 fmt. Println("סטטוס:", תגובה. סטָטוּס)
}

בקשת DELETE לא מקבלת ולא מחזירה גוף, ומכאן הסיבה שאין צורך לנתח או לעצב את גוף הבקשה והתגובה של JSON. התגובה מחזירה רק סטטוס כדי לציין הצלחה או כישלון. כך נראית קריאה לדוגמה לפונקציה עם הפלט שלה:

funcרָאשִׁי() {
 fmt. Println("מבצע בקשת מחיקה...")
 מחק משתמש("2")
}

תְפוּקָה:

חסוך זמן על ידי שימוש ב- http. הודעה() ו http. לקבל() שיטות מה net/http חבילה להכנה הודעה ו לקבל בקשות ישירות, ללא צורך להשתמש ב- בקשה חדשה() פונקציה ואת לָקוּחַ{} מבנה ליצור ולהגיש את הבקשה בנפרד. בדוק את תיעוד net/http למידע נוסף.

ביצוע בקשות HTTP באפליקציות Go

ה http חבילה ב-Go מספקת את כל הדרוש כדי לבצע בקשות HTTP ולטפל בתגובות ביישומי Go. הפונקציות והמבנים המסופקים על ידי החבילה מאפשרים לך ליצור ולשלוח סוגים שונים של בקשות כמו GET, POST, PUT, DELETE ועוד רבות אחרות.

זה מקל על בניית יישומי אינטרנט ב-Go שיכולים לקיים אינטראקציה עם שירותי אינטרנט וממשקי API אחרים. דרך טובה להגיע המוכר יותר עם ביצוע בקשות HTTP ב-Go הוא על ידי בניית אפליקציה שמבצעת בקשות ל- REST API אחר של שלך.