HttpRequestకి శరీరాన్ని జోడిస్తోంది

3.1 బాడీ పబ్లిషర్స్

GET అభ్యర్థనలతో పాటు , PUT మరియు POST అభ్యర్థనలు కూడా ఉన్నాయని మీరు మరచిపోలేదని నేను ఆశిస్తున్నాను , మీరు అభ్యర్థనకు జోడించాల్సిన అవసరం వచ్చినప్పుడు request body, అంటే అభ్యర్థన బాడీ.

దీని కోసం తరగతికి HttpRequestప్రత్యేక అంతర్గత తరగతి ఉంది BodyPublisher. ఇది సాంకేతికంగా బహుళ అమలులను కలిగి ఉన్న ఇంటర్‌ఫేస్ అయినప్పటికీ, మేము క్రింద చర్చిస్తాము

మరియు మేము సరళమైన వాటితో ప్రారంభిస్తాము - అభ్యర్థన శరీరం లేకపోవడం. అవును, అది జరుగుతుంది.

HttpRequest request = HttpRequest.newBuilder()
   .uri(new URI("https://codegym.cc"))
   .POST(HttpRequest.BodyPublishers.noBody())
   .build();

సాధారణ మరియు అందమైన.

3.2 ఆఫ్ స్ట్రింగ్()

రెండవ అత్యంత సాధారణ ఎంపిక ఏమిటంటే కొన్ని స్ట్రింగ్‌ను అభ్యర్థన అంశంగా పాస్ చేయడం. ఇది చాలా సరళంగా చేయబడుతుంది:

HttpRequest request = HttpRequest.newBuilder()
   .uri(new URI("https://codegym.cc"))
   .headers("Content-Type", "text/plain;charset=UTF-8")
   .POST(HttpRequest.BodyPublishers.ofString("Hello"))
   .build();

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

HttpRequest request = HttpRequest.newBuilder()
   .uri(new URI("https://codegym.cc"))
   .POST(HttpRequest.BodyPublishers.ofString("Hello", Charset. US-ASCII)))
   .build();

3.3 ఆఫ్ ఫైల్()

చివరగా, మీరు POST అభ్యర్థనకు ఫైల్‌ను జోడించాలనుకోవచ్చు . మీ అవతార్‌లు సాధారణంగా సర్వర్‌కి ఈ విధంగా అప్‌లోడ్ చేయబడతాయి. దీన్ని చేయడానికి, మీరు పద్ధతికి కాల్ చేయాలి , స్థానిక ఫైల్‌ను ofFile()ఎక్కడ బదిలీ చేయాలి :Path

Path avatar = Path.of("c://avatar.jpeg");
 
HttpRequest request = HttpRequest.newBuilder()
   .uri(new URI("https://codegym.cc"))
   .headers("Content-Type", "image/jpeg")
   .POST(HttpRequest.BodyPublishers.ofFile(avatar))
   .build();

3.4 బైట్అర్రే()

సర్వర్‌కు బైట్‌ల సమితిని పంపడం అనేది మరొక సాధారణ దృశ్యం. ఉదాహరణకు, మీరు కొంత వస్తువును బైట్‌ల సెట్‌గా సీరియల్ చేసారు, ఏదైనా గుప్తీకరించారు లేదా కొంత డేటా బఫర్‌ని పంపాలనుకుంటున్నారు. దీనికి ఒక పద్ధతి అవసరం .ofByteArray().

ఈ పద్ధతి బైట్‌ల శ్రేణిని పారామీటర్‌గా తీసుకుంటుంది. ఉదాహరణ:

byte[] data = "My Secret Message".getBytes();
byte[] dataEncripted = SuperEncriptor.encript(data);
 
HttpRequest request = HttpRequest.newBuilder()
   .uri(new URI("https://codegym.cc"))
   .headers("Content-Type", "application/octet-stream")
   .POST(HttpRequest.BodyPublishers.ofByteArray(dataEncripted))
   .build();

3.5 ఇన్‌పుట్ స్ట్రీమ్()

చివరగా, చివరిది కాని ఆసక్తికరమైన దృష్టాంతం POST అభ్యర్థనకుInputStream జోడించబడింది .

దీని కోసం ఒక ప్రత్యేక ఫంక్షన్ ఉంది ofInputStream(). మరియు ఆమె చాలా తెలివైనది. ఇది స్ట్రీమ్ నుండి స్ట్రీమ్‌కు డేటా బదిలీని నిర్వహించడానికి మిమ్మల్ని అనుమతిస్తుంది, ఇంకా తెరవని POS అభ్యర్థనకు డేటా స్ట్రీమ్‌ను జోడించవచ్చు.

మీరు ఫంక్షన్‌కి ఒక ఫంక్షన్‌ను పాస్ చేయాలి ofInputStream(), దాని ఫలితంగా స్ట్రీమ్‌ను తిరిగి అందిస్తుంది InputStream.

ఉదాహరణ:

byte[] data = "My Secret Message".getBytes();
//wrapping an array of bytes into a stream.
InputStream is = new ByteArrayInputStream(data);
 
HttpRequest request = HttpRequest.newBuilder()
   .uri(new URI("https://codegym.cc"))
   .headers("Content-Type", "application/octet-stream")
   .POST(HttpRequest.BodyPublishers.ofInputStream (() -> is;))
   .build();

నేను ఇక్కడ తోటకి కంచె వేయడానికి బాధపడలేదు, కానీ మీరు సూత్రాన్ని అర్థం చేసుకున్నారని నేను భావిస్తున్నాను. ఎందుకు అలా చేశారు? మీరు దాదాపు ఎల్లప్పుడూ ఉపయోగించవచ్చు ofByteArray(). కానీ మీరు డేటాను అసమకాలికంగా పంపాలనుకుంటే లేదా మీరు ప్రత్యేకంగా సంక్లిష్టమైన దృష్టాంతాన్ని అమలు చేయాలనుకుంటే, మీరు ఈ పద్ధతిని ఉపయోగించవచ్చు.