Go HTTP క్లయింట్‌కు సొంత ప్రాక్సీ ఇవ్వండి

Go డిఫాల్ట్ transportను క్లోన్ చేసి, ఎంచుకున్న IPకి ProxyURL అమర్చండి. ఇతర క్లయింట్‌ల ప్రాక్సీ ప్రవర్తన మార్చవద్దు.

Go HTTP క్లయింట్ transport ప్రాక్సీని ఎంచుకుంటుంది. డిఫాల్ట్ క్లయింట్‌ను వాడే ఇతరులు ప్రస్తుత మార్గాన్ని ఉంచుకునేలా ప్రామాణిక transportను మార్చే ముందు క్లోన్ చేయండి.

package main

import (
    "fmt"
    "io"
    "log"
    "net/http"
    "net/url"
    "time"
)

func main() {
    proxyURL, err := url.Parse("http://203.0.113.10:8080")
    if err != nil {
        log.Fatal(err)
    }

    transport := http.DefaultTransport.(*http.Transport).Clone()
    transport.Proxy = http.ProxyURL(proxyURL)
    defer transport.CloseIdleConnections()

    client := &http.Client{
        Transport: transport,
        Timeout:   15 * time.Second,
    }

    response, err := client.Get("https://example.com/")
    if err != nil {
        log.Fatal(err)
    }
    defer response.Body.Close()

    fmt.Println(response.StatusCode)
    if _, err := io.Copy(io.Discard, response.Body); err != nil {
        log.Fatal(err)
    }
}

చిరునామా డాక్యుమెంటేషన్ కోసం ఉదాహరణ మాత్రమే. HTTP ప్రాక్సీ జాబితా నుంచి ఎంచుకున్న అభ్యర్థి వంటి నిజమైన HTTP ప్రాక్సీ IP, పోర్టుతో మార్చండి. ఉదాహరణ Go ప్రామాణిక లైబ్రరీ మాత్రమే వాడుతుంది; ఈ HTTP ప్రాక్సీ అభ్యర్థనకు SOCKS ప్యాకేజీ లేదా మొత్తం ప్రాసెస్‌కు వర్తించే ఎన్విరాన్‌మెంట్ వేరియబుల్ అవసరం లేదు.

DefaultTransportను నేరుగా ఎందుకు మార్చకూడదు?

డిఫాల్ట్ transport ఉమ్మడిగా వాడబడుతుంది. మార్చితే మీ ప్రాక్సీని ఎప్పుడూ కోరని కోడ్ ప్రవర్తన కూడా మారవచ్చు; అభ్యర్థనలు దాన్ని వాడుతుండగా మార్చడం నివారించదగిన సమకాలీన సమస్యలకు కారణమవుతుంది. ప్రత్యేక transport మార్గాన్ని ఈ క్లయింట్ కాన్ఫిగరేషన్‌లో భాగం చేస్తుంది.

http.ProxyURL ఇచ్చిన URLనే ఎప్పుడూ ఎంచుకునే సెలెక్టర్‌ను తిరిగి ఇస్తుంది. ఇది ప్రాక్సీ వేరియబుల్స్, బైపాస్ నియమాలు పరిగణించే డిఫాల్ట్ ఎన్విరాన్‌మెంట్ సెలెక్టర్‌కు భిన్నం. HTTP జాబితాలో ఒక నిర్దిష్ట ఎంట్రీని పరీక్షించడమే ఉద్దేశమైతే, స్పష్టమైన సెలెక్టర్ ఈ అస్పష్టతను తొలగిస్తుంది.

ప్రతిస్పందన మూసి క్లయింట్‌ను మళ్లీ వాడండి

ఉదాహరణ ప్రతిస్పందన బాడీని పూర్తిగా చదివి మూస్తుంది. చివరిదాకా చదవడం transportకు వీలున్నప్పుడు కనెక్షన్ మళ్లీ వాడటంలో సహాయపడుతుంది. ఒకే ప్రాక్సీ ద్వారా పలుమార్లు అభ్యర్థించే ప్రోగ్రామ్‌లో ప్రతి సారి కొత్త జంట సృష్టించకుండా క్లయింట్, transportను ఉంచండి.

క్లయింట్ సమయ పరిమితి సాకెట్ తెరవడానికే కాదు; ప్రతిస్పందన బాడీ చదవడం సహా అభ్యర్థన జీవితచక్రాన్ని కూడా పరిమితం చేస్తుంది. Get తిరిగొచ్చిన తర్వాత కూడా చదివే దోషాలు నిర్వహించాలి. 403 వంటి స్థితి Go transport దోషం కాదు, కాబట్టి StatusCodeను err నుంచి వేరుగా తనిఖీ చేయండి.

సంబంధిత వ్యాసాలు