HttpClientతో అభ్యర్థన చేయడం

4.1 పంపు() పద్ధతి, బాడీ హ్యాండ్లర్స్

మీరు http అభ్యర్థనను ఎలా రూపొందించాలో నేర్చుకోవడం పూర్తి చేసారు , కాబట్టి మీరు అత్యంత ముఖ్యమైన విషయానికి వెళ్లవచ్చు - ఈ అభ్యర్థనను పంపడం. సరళమైన సందర్భంలో, దీన్ని చేయడం సులభం:

HttpRequest request = HttpRequest.newBuilder(new URI("https://codegym.cc")).build();
 
   HttpClient client = HttpClient.newBuilder()
        .version(Version.HTTP_1_1)
        .build();
 
   HttpResponse<String> response = client.send(request, BodyHandlers.ofString());
   System.out.println(response.statusCode() );
   System.out.println(response.body() ); 

మరియు ఇవి ఏమిటి BodyHandlers? మీరు ఏమనుకుంటున్నారు? మీరు ఒక అభ్యర్థనను పంపారు, అంటే మీరు సమాధానం అందుకోవాలి - http response. మరియు ఈ ప్రతిస్పందన కలిగి ఉండవచ్చు response body: స్ట్రింగ్, ఫైల్, బైట్‌ల శ్రేణి, ఇన్‌పుట్ స్ట్రీమ్.

అవును, అవును, అది నిజమే. response bodyఅభ్యర్థనను రూపొందించేటప్పుడు, మీరు ప్రతిస్పందన రకాన్ని పేర్కొనాలి . మొత్తం 8 ముక్కలు ఉండవచ్చు:

• BodyHandlers.ofByteArray
• BodyHandlers.ofString
• BodyHandlers.ofFile
• BodyHandlers.discarding
• BodyHandlers.replacing
• BodyHandlers.ofLines
• BodyHandlers.fromLineSubscriber

BodyHandlersమీరు ఏ పద్ధతికి ఉత్తీర్ణత సాధించారనే దానిపై ఆధారపడి send(), ఇది అటువంటి ఫలిత రకాన్ని అందిస్తుంది. ఉదాహరణ:

// response body is ignored
HttpResponse<Void> response = client.send(request, BodyHandlers.discarding());

// response body is a string
 HttpResponse<String>response = client.send(request, BodyHandlers.ofString());

// response body is a file
HttpResponse<Path> response = client.send(request, BodyHandlers.ofFile(Paths.get("readme.txt")));

// response body is an InputStream
HttpResponse<InputStream> response = client.send(request, BodyHandlers.ofInputStream());

ఒక ఫైల్ మీకు ప్రతిస్పందనగా పంపబడితే, BodyHandlers.ofFile()మీరు స్థానిక ఫైల్ పేరును పద్ధతికి పంపాలి, ఇక్కడ అది HttpClient ఆబ్జెక్ట్ ద్వారా సేవ్ చేయబడుతుంది.

4.2 ఫాలో రీడైరెక్ట్స్() పద్ధతి

301అలాగే, అభ్యర్థనను పంపుతున్నప్పుడు, సర్వర్ పంపితే లేదా ప్రతిస్పందనగా 302(తాత్కాలిక లేదా శాశ్వత దారి మళ్లింపు) HttpClient ఏమి చేయాలో మీరు పేర్కొనవచ్చు . సర్వర్ ఒక కోడ్‌ను పంపిందని ఊహించుకోండి 302మరియు మీరు వీటిని చేయాలి: ఈ పరిస్థితిని ట్రాక్ చేయండి, ప్రతిస్పందన నుండి కొత్త URLని పొందండి మరియు అభ్యర్థనను కొత్త చిరునామాకు పంపండి.

నేను దీన్ని చాలా ఇష్టపడను, ప్రత్యేకించి ఈ పరిస్థితి సర్వసాధారణం మరియు అన్ని http క్లయింట్‌లలో చాలా కాలంగా స్వయంచాలకంగా ఉంది. అలాగే ఈ HttpClientలో మీరు అభ్యర్థనను పంపేటప్పుడు మీరు ఎంచుకున్న రీడైరెక్ట్ మోడ్‌ని పేర్కొనాలి.

HttpResponse response = HttpClient.newBuilder()
  .followRedirects( HttpClient.Redirect.ALWAYS )
  .build()
  .send(request, BodyHandlers.ofString());

దారి మళ్లింపు కోసం 3 ఎంపికలు మాత్రమే ఉన్నాయి:

• ఎల్లప్పుడూ - ఎల్లప్పుడూ;
• ఎప్పుడూ - ఎప్పుడూ;
• సాధారణం - ఎల్లప్పుడూ, HTTPS తప్ప -> HTTP.

మీరు చూడగలిగినట్లుగా, ఇక్కడ చాలా ఎంపికలు లేవు, కానీ అది కలిగి ఉండకపోవడం కంటే అనుకూలీకరించే సామర్థ్యాన్ని కలిగి ఉండటం ఎల్లప్పుడూ మంచిది.

4.4 ప్రాక్సీ() పద్ధతి

ఒక జంట మరింత ఉపయోగకరమైన, కానీ తరచుగా ఉపయోగించని ఎంపికలు ఉన్నాయి. మీకు అవసరమైనంత వరకు మీకు అవి ఖచ్చితంగా అవసరం లేదు :)

మొదటిది ప్రాక్సీ. సాధారణ జీవితంలో, మీరు వాటిని తరచుగా ఎదుర్కోరు, కానీ చాలా పెద్ద సంస్థలు వాటిలో సంక్లిష్టమైన ఇంటర్నెట్ ట్రాఫిక్ భద్రతా వ్యవస్థను కలిగి ఉంటాయి మరియు అందువల్ల వివిధ ప్రాక్సీ సెట్టింగ్‌లు ఉన్నాయి.

బాగా, వాస్తవానికి, అటువంటి కార్పొరేషన్ యొక్క ప్రేగులలో ఎక్కడో పని చేసే మీ సాఫ్ట్‌వేర్, ఏదో ఒకరోజు అది ప్రాక్సీని ఉపయోగించాల్సిన అవసరం ఉందనే వాస్తవాన్ని ఎదుర్కొంటుంది. అందువల్ల, అటువంటి ఎంపిక ఇక్కడ కూడా ఉండటం మంచిది.

ప్రాక్సీని సెటప్ చేయడం చాలా సులభం - ఒక ఉదాహరణ:

HttpResponse<String> response = HttpClient.newBuilder()
  .proxy( ProxySelector.getDefault())
  .build()
  .send(request, BodyHandlers.ofString());

డిఫాల్ట్ ప్రాక్సీ ఇక్కడ ఎంచుకోబడింది, కానీ మీరు మీ స్వంతంగా సెట్ చేసుకోవచ్చు:

HttpResponse response = HttpClient.newBuilder()
  .proxy(ProxySelector.of(new InetSocketAddress("proxy.microsoft.com", 80)))
  .build()
  .send(request, BodyHandlers.ofString());

ప్రాక్సీతో సరిగ్గా ఎలా పని చేయాలో, మేము పరిగణించము, ఎందుకంటే ఇది ఈ కోర్సు యొక్క పరిధిలో చేర్చబడలేదు.

4.5 ప్రమాణీకరణ ()

మరియు మరొక ముఖ్యమైన అంశం. HTTP ప్రోటోకాల్ ప్రమాణీకరణకు మద్దతు ఇస్తుంది. సరిగ్గా ప్రోటోకాల్ స్థాయిలో.

ఇప్పుడు ఈ విధానం దాదాపు ఉపయోగించబడలేదు, కానీ సుమారు 20 సంవత్సరాల క్రితం ఇది సాధారణం. Http అభ్యర్థన ఇలా ఉంది:

http://username@example.com/

లేదా ఇలా కూడా:

http://username:password@example.com/

ఇది మెయిల్ కాదు. ఇది ఖచ్చితంగా లింక్. మరియు అవును, మీరు అలా అనుకోలేదు. లాగిన్ మరియు పాస్‌వర్డ్ కూడా నేరుగా http అభ్యర్థనలో పేర్కొనవచ్చు. అవును, ఇప్పుడు కూడా మీరు చేయగలరు. అందుకే సాధారణంగా ఇప్పుడు ఎవరూ ఇలా చేయరు అని రాస్తున్నాను. కానీ అలాంటి అవకాశం ఉంది.

Authenticator auth = new Authenticator() {
    @Override
    protected PasswordAuthentication getPasswordAuthentication() {
    return new PasswordAuthentication(
     "username",
        "password".toCharArray());
    }
};

HttpResponse<String> response = HttpClient.newBuilder()
  .authenticator(auth).build()
  .send(request, BodyHandlers.ofString());

ఇది ఆసక్తికరంగా ఉంది! “password"అది చెప్పే కోడ్‌లో కాకుండా ఎందుకో తెలుసా "password".toCharArray()?

ఎందుకంటే కన్స్ట్రక్టర్ యొక్క రెండవ పరామితి PasswordAuthentication కాదు String, కానీ CharArray.

మరియు రెండవ పరామితి ఎందుకు కాదు String, అవునా CharArray?

ఎందుకంటే మీ స్వంత అప్లికేషన్‌లో కూడా భద్రతా ప్రయోజనాల కోసం అన్ని పాస్‌వర్డ్‌లను మొత్తం స్ట్రింగ్‌గా నిల్వ చేయడానికి అనుమతించబడదు . అంటే, మీ అప్లికేషన్ దాని మెమరీలో పాస్‌వర్డ్‌ను స్ట్రింగ్‌గా నిల్వ చేయకూడదు. ఎవరైనా డ్యాంప్-మెమరీ చేస్తే, పాస్‌వర్డ్‌ని దాని నుండి బయటకు తీయలేరు ...

కానీ అదే సమయంలో, పాస్‌వర్డ్‌ను అసురక్షిత HTTP ప్రోటోకాల్‌లో సగం ప్రపంచవ్యాప్తంగా ప్రసారం చేయవచ్చు :) :) :)

బాగా. ప్రపంచం పరిపూర్ణమైనది కాదు.

మీరు దిగువ లింక్‌లలో ఈ అంశం గురించి మరింత చదవవచ్చు:

HTTP ప్రమాణీకరణ

HTTP ప్రమాణీకరణను అర్థం చేసుకోవడం