1.1 HttpClient పరిచయం
JDK 11తో ప్రారంభించి, Java ప్లాట్ఫారమ్ డెవలపర్లు http అభ్యర్థనలు చేయడానికి JDKకి శక్తివంతమైన కొత్త సాధనాన్ని జోడించారు, ది java.net.http
. ఇది నాలుగు కీలక తరగతులను కలిగి ఉంది:
- HttpClient
- HttpRequest
- HttpResponse
- వెబ్ సాకెట్
ఇవి చాలా శక్తివంతమైన తరగతులు, వీటిని ఉపయోగించి సాధ్యమయ్యే అన్ని రకాల అభ్యర్థనలను నిర్వహించడానికి మిమ్మల్ని అనుమతిస్తాయి HTTP
మరియు HTTP/2
.WebSocket
అదనంగా, మీరు సమకాలిక మరియు అసమకాలిక http అభ్యర్థనలు రెండింటినీ చేయడానికి ఈ తరగతులను ఉపయోగించవచ్చు.
http అభ్యర్థన చేయడం క్రింది భాగాలను కలిగి ఉంటుంది:
- ఒక వస్తువును సృష్టించండి
HttpClient
- ఒక వస్తువును సృష్టించండి
HttpRequest
send()
లేదా పద్ధతిని ఉపయోగించి అభ్యర్థనను పంపడంsendAsync()
- ప్రతిస్పందన ప్రాసెసింగ్
HttpResponse
అటువంటి అభ్యర్థనకు ఉదాహరణ:
HttpClient client = HttpClient.newBuilder()
.version(Version.HTTP_1_1)
.followRedirects(Redirect.NORMAL)
.connectTimeout(Duration.ofSeconds(20))
.proxy(ProxySelector.of(new InetSocketAddress("proxy.example.com", 80)))
.authenticator(Authenticator.getDefault())
.build();
HttpResponse<String> response = client.send(request, BodyHandlers.ofString());
System.out.println(response.statusCode());
System.out.println(response.body());
1.2 డిక్లరేటివ్ విధానం
ఎగువ ఉదాహరణలో, మీరు కోడ్ రాయడానికి డిక్లరేటివ్ విధానం అని పిలవబడే ఉదాహరణను చూస్తారు. ఉదాహరణ యొక్క మొదటి భాగాన్ని పరిశీలిద్దాం:
HttpClient client = HttpClient.newBuilder()
.version(Version.HTTP_1_1)
.followRedirects(Redirect.NORMAL)
.connectTimeout(Duration.ofSeconds(20))
.proxy(ProxySelector.of(new InetSocketAddress("proxy.example.com", 80)))
.authenticator(Authenticator.getDefault())
.build();
క్లాసిక్ శైలిలో వ్రాసిన ఈ కోడ్ ఎలా ఉంటుంది:
HttpClient client = HttpClient.new();
client.setVersion(Version.HTTP_1_1);
client.setFollowRedirects(Redirect.NORMAL);
client.setConnectTimeout(Duration.ofSeconds(20));
client.setProxy(ProxySelector.of(new InetSocketAddress("proxy.example.com", 80)));
client.setAuthenticator(Authenticator.getDefault());
కోడ్లో డిక్లరేటివ్ విధానాన్ని ఉపయోగిస్తున్నప్పుడు, రెండు విషయాలు మారతాయి. ముందుగా , అన్ని తరగతి పద్ధతులు HttpClient
వారి స్వంత వస్తువును తిరిగి ఇస్తాయి , ఇది గొలుసుల రూపంలో కోడ్ని నిర్వహించడానికి మిమ్మల్ని అనుమతిస్తుంది.
క్లాసిక్ కోడ్: |
---|
|
గొలుసుగా: |
|
మేము ప్రతి పద్ధతిని ప్రత్యేక పంక్తికి బదిలీ చేస్తాము (ఇది ఒక పొడవైన ప్రకటన) |
|
రెండవది , ఉపసర్గ పద్ధతుల నుండి తీసివేయబడుతుంది set
, ఇది కోడ్ను మరింత కాంపాక్ట్గా వ్రాయడానికి మిమ్మల్ని అనుమతిస్తుంది:
ఉంది |
---|
|
అయింది |
|
ఇటువంటి కోడ్ చదవడం సులభం, అయితే రాయడం కష్టం.
మరియు మరొక ముఖ్యమైన అంశం. ఈ ఉదాహరణలో, బిల్డర్ నమూనా ఉపయోగించబడింది. ఒక వస్తువును సృష్టించడం సంక్లిష్టమైన ప్రక్రియ అయిన సందర్భాలు ఉన్నాయి. అందువల్ల, వారు దానిని అధికారికీకరించడానికి ఇష్టపడతారు: ఇది షరతులతో కూడిన పద్ధతి కాల్తో ప్రారంభమవుతుంది begin()
మరియు షరతులతో కూడిన పద్ధతి కాల్తో ముగుస్తుంది end()
.
మేము విశ్లేషించిన ఉదాహరణలో, పద్ధతి HttpClient.newBuilder()
ఒక వస్తువును అందిస్తుంది HttpClient.Builder
(ఇది తరగతి యొక్క అంతర్గత యుటిలిటీ క్లాస్ HttpClient
). ఈ రకమైన అన్ని పద్ధతులు version()
ఈ సేవా వస్తువుపై మాత్రమే పిలువబడతాయి. బాగా, పద్ధతి యొక్క కాల్ build()
వస్తువు యొక్క నిర్మాణం యొక్క ముగింపును సూచిస్తుంది మరియు వస్తువును తిరిగి ఇస్తుంది HttpClient
.
GO TO FULL VERSION