Goతో RESTful APIలను వినియోగించడం

RESTful APIలు వెబ్ అంతటా డేటా బదిలీ కోసం ప్రసిద్ధ ఆర్కిటెక్చర్‌లు. RESTful APIలు సాధారణంగా HTTPని ఉపయోగిస్తాయి, అవి స్థితిలేనితనం ముఖ్యమైన సందర్భాల్లో అనుకూలంగా ఉంటాయి.

ఏదైనా సర్వర్ సైడ్ లాంగ్వేజ్ లాగా, మీరు HTTP ప్రోటోకాల్‌తో పరస్పర చర్య చేయవచ్చు మరియు Goలో HTTP అభ్యర్థనలను చేయవచ్చు.

---

---

Goలో RESTful APIలను వినియోగించడం ప్రారంభించడం

ది http గోలో HTTP ప్రోటోకాల్‌తో పరస్పర చర్య చేయడానికి మీకు అవసరమైన చాలా కార్యాచరణను ప్యాకేజీ అందిస్తుంది. ఇందులో HTTP అభ్యర్థనలు చేయడం మరియు మీకు అవసరం లేదు జిన్ లేదా డేటాబేస్ వంటి బాహ్య డిపెండెన్సీలు .

రోజు యొక్క వీడియోను తయారు చేయండి

మీరు ఉపయోగించవచ్చు http APIలను వినియోగించడానికి మరియు పేజీలను పొందేందుకు ప్యాకేజీ గోలో వెబ్ స్క్రాపింగ్ .

Goలో HTTP అభ్యర్థనలను చేయడం ప్రారంభించడానికి ఈ ప్యాకేజీలను దిగుమతి చేయండి.

import ( 
    "bytes" 
    "encoding/json" 
    "fmt" 
    "io/ioutil" 
    "net/http" 
) 

మీరు ఉపయోగిస్తారు బైట్లు బైట్ ముక్కలను మార్చటానికి ప్యాకేజీ, ది json అభ్యర్థన డేటాను ఫార్మాట్ చేయడానికి ప్యాకేజీ, ది fmt ప్రామాణిక అవుట్‌పుట్‌కు వ్రాయడానికి ప్యాకేజీ, ది ioutil ఇన్‌పుట్ మరియు అవుట్‌పుట్ కోసం ప్యాకేజీ, మరియు http అభ్యర్థనలను పంపడానికి ప్యాకేజీ.

గోలో ఒక సాధారణ GET అభ్యర్థన

సాధారణ పొందండి సర్వర్ నుండి డేటాను చదవమని అభ్యర్థిస్తుంది మరియు API యొక్క స్వభావం మరియు స్పెసిఫికేషన్ ఆధారంగా డేటా కోసం పారామితులను అందించవచ్చు.

---

---

ఈ ట్యుటోరియల్‌లో, మీరు httpbin యొక్క సాధారణ అభ్యర్థన మరియు ప్రతిస్పందన సేవను ఉపయోగించి RESTful APIలను ఎలా వినియోగించాలో నేర్చుకుంటారు.

Goతో HTTP అభ్యర్థన చేయడానికి ఇక్కడ ఒక ఉదాహరణ ఉంది:

---

---

url := "https://httpbin.org/get" 
response, err := http.Get(url) 
  
if err != nil { 
    fmt.Printf("There was an error from the API request %s", err.Error()) 
} else { 
    // continues [1] ... 
} 

ది url వేరియబుల్ అనేది మీరు అభ్యర్థనను పంపుతున్న ముగింపు స్థానం. ది పొందండి పద్ధతి URLను తీసుకుంటుంది, అమలు చేస్తుంది పొందండి అభ్యర్థన, మరియు దాని శీర్షికలు మరియు అంశంతో సహా ప్రతిస్పందనను అందిస్తుంది.

మీరు మీ అవసరాలను బట్టి అభ్యర్థన నుండి ఏవైనా లోపాలను నిర్వహించవచ్చు. లోపాలు లేకుంటే, మీరు నుండి మీకు అవసరమైన సమాచారాన్ని సేకరించేందుకు కొనసాగవచ్చు పొందండి అభ్యర్థన.

ఎవరైనా మిమ్మల్ని గూగుల్ చేసారో లేదో తెలుసుకోవచ్చు

} else { 
    // ... [1] continued 
    responseData, err := ioutil.ReadAll(response.Body) 
  
    if err != nil { 
        fmt.Printf("There was an error from parsing the request body %s", err.Error()) 
    } else { 
       // continues [2] ... 
   } 
} 

స్పందన యొక్క శరీరం ఫీల్డ్ ప్రతిస్పందన యొక్క శరీరాన్ని కలిగి ఉంటుంది. ఉపయోగించి అన్నీ చదవండి యొక్క పద్ధతి ioutil ప్యాకేజీ, మీరు ప్రతిస్పందన బాడీని చదవవచ్చు మరియు సాధ్యమయ్యే లోపాలను నిర్వహించవచ్చు.

} else { 
    // ... [2] continued 
    fmt.Println(string(responseData)) 
} 

ది లేకపోతే రీడ్ ఆపరేషన్ నుండి లోపాలు లేకుంటే స్టేట్‌మెంట్ మీ కన్సోల్‌కి ప్రతిస్పందన బాడీని ప్రింట్ చేస్తుంది.

యొక్క ఫలితం ఇక్కడ ఉంది పొందండి httpbin యొక్క ముగింపు బిందువుకు అభ్యర్థన.

72 dpi ని 300 dpi కి మార్చండి

గోలో ఒక సాధారణ పోస్ట్ అభ్యర్థన

సాధారణ POST అభ్యర్థనలు సర్వర్‌కు డేటా పేలోడ్‌లను అందిస్తాయి మరియు సర్వర్ ఆపరేషన్‌పై ఆధారపడి ప్రతిస్పందనను అందిస్తుంది.

POST అభ్యర్థనలో భాగంగా సర్వర్‌కు JSON పేలోడ్‌ను ఎన్‌కోడ్ చేయడానికి ఇక్కడ ఒక సాధారణ నిర్మాణం ఉంది.

type JSON struct { 
    info    string 
    message string 
} 

ది JSON struct కలిగి ఉంది సమాచారం మరియు సందేశం స్ట్రింగ్ ఫీల్డ్‌లు, మరియు మీరు అభ్యర్థన కోసం నిర్మాణ ఉదాహరణను ప్రారంభిస్తారు.

url := "https://httpbin.org/post" 
  
jsonInstance := JSON { 
    info:    "expecting success", 
    message: "the request should return ", 
} 

ది url వేరియబుల్ httpbin వెబ్‌సైట్ నుండి POST అభ్యర్థన ముగింపు పాయింట్‌ను నిల్వ చేస్తుంది. ది jsonInstance వేరియబుల్ అనేది నిర్మాణాత్మక డేటాను నిల్వ చేయడానికి మరియు పంపడానికి మీరు ఉపయోగించగల JSON struct యొక్క ఉదాహరణ.

మీరు ఉపయోగించవచ్చు మార్షల్ నుండి పద్ధతి json అభ్యర్థన కోసం JSONను ఫార్మాట్ చేయడానికి ప్యాకేజీ.

jsonData, err := json.Marshal(jsonInstance) 
if err != nil { 
    fmt.Println("there was an error with the JSON", err.Error()) 
} else { 
    // continues [1] ... 
} 

ది మార్షల్ పద్ధతి మీరు నిర్వహించగల లోపాన్ని కూడా అందిస్తుంది. JSON మార్షలింగ్ ఆపరేషన్‌లో లోపాలు లేకుంటే, మీరు POST అభ్యర్థన చేయడానికి కొనసాగవచ్చు.

మీరు ఉపయోగించవచ్చు పోస్ట్ చేయండి POST అభ్యర్థనలు చేయడానికి పద్ధతి. ది పోస్ట్ చేయండి పద్ధతి URL ఎండ్‌పాయింట్, అభ్యర్థన యొక్క కంటెంట్ రకం మరియు పేలోడ్ యొక్క బఫర్‌ను తీసుకుంటుంది. ఇది ప్రతిస్పందన మరియు లోపాన్ని అందిస్తుంది.

} else { 
    // ... continued [1] 
    response, err := http.Post(url, "application/json", bytes.NewBuffer(jsonData)) 
  
    if err != nil { 
        fmt.Println("there was an error with the request", err.Error()) 
    } else { 
        // continues [2] ... 
    } 
} 

మళ్ళీ, మీరు ఉపయోగించి ప్రతిస్పందన బాడీని చదవవచ్చు అన్నీ చదవండి యొక్క పద్ధతి ioutil ప్యాకేజీ:

} else { 
    // ... continued [2] 
    data, err := ioutil.ReadAll(response.Body) 
  
    if err != nil { 
        fmt.Println("there was an error reading the request body", err.Error()) 
    } else { 
        fmt.Println(string(data)) 
    } 
} 

ది Println ప్రకటన మీ కన్సోల్‌కు HTTP అభ్యర్థన ఫలితాన్ని అందిస్తుంది.

గా httpbin డాక్యుమెంటేషన్ నిర్దేశిస్తుంది, ఈ POST ముగింపు పాయింట్ మీరు పంపిన అభ్యర్థన డేటాను అందిస్తుంది.

గోలో వెబ్ యాప్‌లను రూపొందించడం సులభం

మీరు డిపెండెన్సీలు లేకుండా గోలో వివిధ కార్యాచరణలతో వెబ్ అప్లికేషన్‌లను రూపొందించవచ్చు.

ది http ప్యాకేజీలో మీ చాలా కార్యకలాపాలకు అవసరమైన విధులు ఉన్నాయి. మీరు ఈ ప్యాకేజీని వంటి ఇతరులతో ఉపయోగించవచ్చు json JSON కార్యకలాపాల కోసం ప్యాకేజీ, ది సందర్భం సిగ్నలింగ్ కోసం ప్యాకేజీ, మరియు టెంప్లేటింగ్ కోసం టెంప్లేట్ ప్యాకేజీ. ప్రామాణిక లైబ్రరీలో అనేక ఇతర ప్యాకేజీలు ఉన్నాయి.