Goలో GraphQL API ఎండ్‌పాయింట్‌లను ఎలా వినియోగించాలి

గ్రాఫ్ క్వెరీ లాంగ్వేజ్ (GraphQL) అనేది GraphQL APIలతో పరస్పర చర్య చేయడానికి ఒక భాష మరియు స్పెసిఫికేషన్, ఇది వెబ్ అంతటా కమ్యూనికేషన్ కోసం HTTP-ఆధారిత క్లయింట్-సర్వర్ ఆర్కిటెక్చర్.

Facebook REST ఆర్కిటెక్చరల్ స్టాండర్డ్‌కి ప్రత్యామ్నాయంగా GraphQLని విడుదల చేసింది. GraphQL RESTతో ఉన్న చాలా సమస్యలను స్థితిలేని మరియు క్యాచీబుల్ పద్ధతిలో పరిష్కరిస్తుంది. ఇది ఊహించిన అవుట్‌పుట్(లు) లేదా ఇన్‌పుట్(లు)ను వివరించే సరళమైన మరియు స్పష్టమైన సింటాక్స్‌ను అందిస్తుంది మరియు అభ్యర్థనకు సరిపోయే డేటాను API ప్రసారం చేస్తుంది.

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

GraphQL అనేది స్పెసిఫికేషన్ కాబట్టి, మీరు Goతో సహా ఏదైనా సర్వర్-సైడ్ ప్రోగ్రామింగ్ భాషలో GraphQL APIలను రూపొందించవచ్చు మరియు వినియోగించవచ్చు.

Goలో GraphQL APIలతో ప్రారంభించడం

GraphQL అనేది HTTP ఆర్కిటెక్చర్‌పై ఆధారపడి ఉంటుంది , మరియు గో దాని అంతర్నిర్మితంలో HTTP కార్యాచరణను అందిస్తుంది http ప్యాకేజీ.

మీరు ఉపయోగించవచ్చు http ప్యాకేజీకి Goలో RESTful APIలను వినియోగించుకోండి , ఇతర లక్షణాలతో పాటు. GraphQL కోసం, మీరు GraphQL APIల సర్వర్‌లకు ప్రశ్నలు మరియు ఉత్పరివర్తనలు చేయవచ్చు http ప్యాకేజీ మరియు ఇతర అంతర్నిర్మిత ప్యాకేజీలు.

గో HTTP ప్యాకేజీ యొక్క స్థూలదృష్టి విభాగం

వంటి GraphQL క్లయింట్ ప్యాకేజీలు మెషిన్‌బాక్స్ లేదా shurCooL యొక్క GraphQL APIలతో పరస్పర చర్య చేసే ప్రక్రియను మరింత సులభతరం చేస్తుంది.

Mac లో imessage పనిచేయడం లేదు

మీరు ఉపయోగించవచ్చు http GraphQL APIతో పరస్పర చర్య చేయడానికి ఎలాంటి డిపెండెన్సీలు లేకుండా ప్యాకేజీ. ప్రారంభించడానికి మీ Go ఫైల్‌లో ఈ ప్యాకేజీలను దిగుమతి చేయండి:

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

మీరు ఉపయోగిస్తారు బైట్లు అభ్యర్థన కోసం కొత్త బఫర్‌ని సృష్టించడానికి ప్యాకేజీ మరియు ది json JSON అభ్యర్థన శరీరానికి మ్యాప్‌ను మార్షల్ చేయడానికి ప్యాకేజీ. మీరు ఉపయోగించవచ్చు ioutil ప్రతిస్పందన బాడీని చదవడానికి, మరియు సమయం అభ్యర్థన కోసం సమయ పరిమితిని సెట్ చేయడానికి ప్యాకేజీ.

Goతో GraphQL APIలను ప్రశ్నిస్తోంది

అనేక ఉచిత పబ్లిక్ GraphQL APIలు ఉన్నాయి, మీరు మీ అప్లికేషన్‌లను ప్రశ్నించవచ్చు మరియు విలీనం చేయవచ్చు. ఈ కథనం కోసం, మీరు ప్రపంచవ్యాప్తంగా ఉన్న దేశాలపై డేటాను ప్రశ్నించడానికి Apollo GraphQL యొక్క దేశాల APIని ప్రశ్నిస్తారు.

నెట్‌ఫ్లిక్స్‌లో పరిమిత సిరీస్ అంటే ఏమిటి

అన్ని GraphQL కార్యకలాపాలు సాధారణంగా POST అభ్యర్థనలు ఎందుకంటే అవి తప్పనిసరిగా పేలోడ్ (అభ్యర్థన శరీరం) కలిగి ఉండాలి. చాలా GraphQL APIలు JSON అభ్యర్థన శరీరాన్ని కంటెంట్ రకంగా అంగీకరిస్తాయి మరియు JSONతో పని చేయడానికి మ్యాప్‌లు మరియు స్ట్రక్ట్‌లను ఉపయోగించడం కోసం Go కార్యాచరణను అందిస్తుంది .

APIని ప్రశ్నించడానికి మీరు GraphQL స్కీమా నిర్మాణాన్ని అధ్యయనం చేయాలి. ఆపరేషన్ (ప్రశ్న లేదా మ్యుటేషన్) కీలకం మరియు డేటా మ్యాప్ విలువ అయితే తప్ప ప్రశ్న సాధారణ GraphQL ప్రశ్న వలె ఉంటుంది.

మీరు అభ్యర్థన కోసం JSONలో మార్షల్ చేసే JSON మ్యాప్ ఉదాహరణను ఎలా ప్రకటించవచ్చో ఇక్కడ ఉంది.

jsonMapInstance := map[string]string { 
    "query": ` 
        {  
            countries { 
                name, 
                phone, 
                currency, 
                code, 
                emoji 
            } 
        } 
    `, 
}

ది jsonMapInstance వేరియబుల్ అనేది అభ్యర్థన యొక్క శరీరానికి సంబంధించిన మ్యాప్ ఉదాహరణ. విలువ అనేది మీరు API నుండి ఆశించే ప్రశ్న డేటా యొక్క స్ట్రింగ్. ఈ సందర్భంలో, మీరు APIల నుండి ఆశించే ప్రశ్న డేటా దేశాలు స్కీమా ఉన్నాయి పేరు , ఫోన్ , కరెన్సీ , కోడ్ , మరియు ఎమోజి పొలాలు.

మీరు ఉపయోగించవచ్చు మార్షల్ యొక్క పద్ధతి json JSONకు మ్యాప్ ఉదాహరణను ఎన్కోడ్ చేయడానికి ప్యాకేజీ. ది మార్షల్ పద్ధతి ఎన్‌కోడ్ చేసిన JSONని మరియు ఎన్‌కోడింగ్ సమస్య ఉన్న కేసుల కోసం ఎర్రర్‌ను అందిస్తుంది.

jsonResult, err := json.Marshal(jsonMapInstance) 
  
if err != nil { 
    fmt.Printf("There was an error marshaling the JSON instance %v", err) 
}

మీరు మ్యాప్‌ను JSONకి ఎన్‌కోడ్ చేసిన తర్వాత, మీరు POST అభ్యర్థనను APIకి పంపవచ్చు. దీనితో మీరు కొత్త అభ్యర్థన ఉదాహరణను సృష్టించవచ్చు కొత్త అభ్యర్థన అభ్యర్థన రకం, URL మరియు JSON బఫర్‌ని తీసుకునే పద్ధతి.

నా గ్రాఫిక్స్ కార్డ్ విండోస్ 10 అంటే ఏమిటి

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

newRequest, err := http.NewRequest("POST", "https://countries.trevorblades.com/graphql", bytes.NewBuffer(jsonResult)) 
newRequest.Header.Set("Content-Type", "application/json")

దీనితో మీ అభ్యర్థన కోసం మీరు సాధారణ HTTP క్లయింట్‌ని సృష్టించవచ్చు క్లయింట్ HTTP ప్యాకేజీ యొక్క పద్ధతి. ది క్లయింట్ పద్ధతితో మీ అభ్యర్థన కోసం సమయ పరిమితిని సెట్ చేయడానికి కూడా మిమ్మల్ని అనుమతిస్తుంది సమయం ప్యాకేజీ.

 
client := &http.Client{Timeout: time.Second * 5} 
response, err := client.Do(newRequest) 
  
if err != nil { 
    fmt.Printf("There was an error executing the request%v", err) 
}

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

మీరు API అభ్యర్థన యొక్క ప్రతిస్పందనను దీనితో చదవవచ్చు ioutil ప్యాకేజీలు అన్నీ చదవండి పద్ధతి. ఇది అవుట్‌పుట్ స్ట్రీమ్‌ని తీసుకుంటుంది మరియు మీరు హ్యాండిల్ చేయగల ఎర్రర్‌తో డేటా యొక్క బైట్ స్లైస్‌ను అందిస్తుంది.

responseData, err := ioutil.ReadAll(response.Body) 
  
if err != nil { 
    fmt.Printf("Data Read Error%v", err) 
}

అంతర్నిర్మిత స్ట్రింగ్ ఫంక్షన్‌తో, మీరు బైట్ స్లైస్ ప్రతిస్పందనను స్ట్రింగ్ రకానికి మార్చవచ్చు.

fmt.Println(string(responseData))

API అభ్యర్థన ఫలితాన్ని చూపే ప్రతిస్పందన ఇక్కడ ఉంది:

GraphQL API ప్రశ్న నుండి అవుట్‌పుట్ దేశాలు మరియు వారు అభ్యర్థించిన ఫీల్డ్‌ల జాబితాను చూపుతుంది.

RESTful APIలను వినియోగించడం GraphQL APIలను వినియోగించడం లాంటిది

REST మరియు GraphQL APIలు రెండూ HTTP ప్రోటోకాల్‌ను ఉపయోగిస్తున్నందున, ప్రతి ఒక్కటి వినియోగించడం చాలా సారూప్య ప్రక్రియ, మరియు మీరు వీటిని ఉపయోగించవచ్చు http రెండు సందర్భాలలో ప్యాకేజీ.

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