జావాలో సాకెట్ ప్రోగ్రామింగ్ గురించి తెలుసుకోండి

సాకెట్ ప్రోగ్రామింగ్ విభిన్నంగా నడుస్తున్న అనువర్తనాల మధ్య కమ్యూనికేషన్ కోసం ఉపయోగించబడుతుంది . ఇది కనెక్షన్-ఆధారిత లేదా కనెక్షన్ లేనిది కావచ్చు. మొత్తంగా, సాకెట్ అనేది క్లయింట్ మరియు సర్వర్ మధ్య కనెక్షన్‌ను స్థాపించడానికి ఒక మార్గం. ఈ వ్యాసంలో, సాకెట్ ప్రోగ్రామింగ్ గురించి నేను మీకు చెప్తాను.

ఈ వ్యాసంలో క్రింద విషయాలు ఉన్నాయి:

• జావాలో సాకెట్ ప్రోగ్రామింగ్ అంటే ఏమిటి?
• జావాలో సాకెట్ అంటే ఏమిటి?
• క్లయింట్ సైడ్ ప్రోగ్రామింగ్
• సర్వర్ సైడ్ ప్రోగ్రామింగ్

జావాలో సాకెట్ ప్రోగ్రామింగ్ అంటే ఏమిటి?

సాకెట్ ప్రోగ్రామింగ్ ఒకదానితో ఒకటి కమ్యూనికేట్ చేయడానికి నెట్‌వర్క్‌లోని రెండు నోడ్‌లను కనెక్ట్ చేసే మార్గం. ఒకటి సాకెట్ (నోడ్) IP వద్ద ఒక నిర్దిష్ట పోర్టులో వింటుంది, మరొకటి సాకెట్ కనెక్షన్‌ను రూపొందించడానికి మరొకదానికి చేరుకుంటుంది.

సర్వర్ వినేవారిని ఏర్పరుస్తుంది సాకెట్ అయితే క్లయింట్ సర్వర్‌కు చేరుకుంటుంది. సాకెట్ మరియు సర్వర్ సాకెట్ కనెక్షన్-ఆధారిత సాకెట్ ప్రోగ్రామింగ్ కోసం ఉపయోగిస్తారు.

ఇప్పుడు సాకెట్ ప్రోగ్రామింగ్ యొక్క ప్రధాన భావనను అర్థం చేసుకుందాం, అంటే సాకెట్.

జావాలో సాకెట్ అంటే ఏమిటి?

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

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

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

క్లయింట్ సైడ్ ప్రోగ్రామింగ్

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

క్లయింట్ల అభ్యర్థనను ప్రారంభించడానికి, మీరు క్రింద పేర్కొన్న దశలను అనుసరించాలి:

1. కనెక్షన్‌ను ఏర్పాటు చేయండి

మొదటి దశ సాకెట్ కనెక్షన్‌ను ఏర్పాటు చేయడం. సాకెట్ కనెక్షన్ రెండు యంత్రాలు ఒకదానికొకటి నెట్‌వర్క్ స్థానం (IP చిరునామా) మరియు TCP పోర్ట్ గురించి సమాచారాన్ని కలిగి ఉన్నాయని సూచిస్తుంది.

దిగువ స్టేట్మెంట్ సహాయంతో మీరు సాకెట్ సృష్టించవచ్చు:

సాకెట్ సాకెట్ = కొత్త సాకెట్ (“127.0.0.1”, 5000)

• ఇక్కడ, మొదటి వాదన సర్వర్ యొక్క IP చిరునామా .

• రెండవ వాదన TCP పోర్ట్ . (ఇది సర్వర్‌లో ఏ అప్లికేషన్‌ను అమలు చేయాలో సూచించే సంఖ్య.)

2. కమ్యూనికేషన్

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

3. కనెక్షన్ మూసివేయడం

సర్వర్‌కు సందేశం పంపిన తర్వాత సాకెట్ కనెక్షన్ స్పష్టంగా మూసివేయబడుతుంది.

క్లయింట్ వైపు సాకెట్ కనెక్షన్‌ను అమలు చేయడానికి జావా ప్రోగ్రామ్‌ను ఎలా వ్రాయాలో ఇప్పుడు చూద్దాం.

// క్లయింట్‌సైడ్ దిగుమతి కోసం జావా ప్రోగ్రామ్ java.net. * దిగుమతి java.io. ip చిరునామా మరియు పోర్ట్ పబ్లిక్ క్లయింట్ (స్ట్రింగ్ చిరునామా, పూర్ణాంక పోర్ట్) పెట్టడానికి {// కనెక్షన్‌ను స్థాపించండి ప్రయత్నించండి {సాకెట్ = కొత్త సాకెట్ (చిరునామా, పోర్ట్) System.out.println ('కనెక్ట్') // టెర్మినల్ ఇన్పుట్ = క్రొత్త డేటాఇన్‌పుట్ స్ట్రీమ్ (సిస్టం.ఇన్) // అవుట్‌పుట్‌ను సాకెట్‌కి పంపుతుంది = కొత్త డేటాఆట్‌పుట్ స్ట్రీమ్ (సాకెట్.జెట్ఆట్పుట్ స్ట్రీమ్ ())} క్యాచ్ (తెలియని హోస్ట్ఎక్సెప్షన్ యు) {సిస్టమ్.అవుట్.ప్రింట్ల్న్ (యు)} క్యాచ్ (ఐఓఎక్సెప్షన్ ఐ) .println (i) input // స్ట్రింగ్ ఇన్పుట్ నుండి సందేశాన్ని చదవడానికి స్ట్రింగ్ లైన్ = '' // 'ఓవర్' ఇన్పుట్ అయ్యే వరకు చదవండి (! line.equals ('Over')) {try {line = input.readLine ( . i ) {System.out.println (i)}} పబ్లిక్ స్టాటిక్ శూన్య ప్రధాన (స్ట్రింగ్ అర్గ్స్ []) {క్లయింట్ క్లయింట్ = కొత్త క్లయింట్ ('127.0.0.1', 5000)}}

ఇప్పుడు, సర్వర్-సైడ్ ప్రోగ్రామింగ్‌ను అమలు చేసి, ఆపై అవుట్‌పుట్‌కు చేరుకుందాం.

సర్వర్ సైడ్ ప్రోగ్రామింగ్

సాధారణంగా, సర్వర్ దాని వస్తువును తక్షణం చేస్తుంది మరియు క్లయింట్ అభ్యర్థన కోసం వేచి ఉంటుంది. క్లయింట్ అభ్యర్థనను పంపిన తర్వాత, సర్వర్ ప్రతిస్పందనతో తిరిగి కమ్యూనికేట్ చేస్తుంది.

సర్వర్ వైపు అనువర్తనాన్ని కోడ్ చేయడానికి, మీకు రెండు సాకెట్లు అవసరం మరియు అవి క్రింది విధంగా ఉన్నాయి:

• TO సర్వర్‌సాకెట్ ఇది క్లయింట్ అభ్యర్థనల కోసం వేచి ఉంటుంది (క్లయింట్ కొత్త సాకెట్ () చేసినప్పుడు)

• సాదా పాతది సాకెట్ క్లయింట్‌తో కమ్యూనికేషన్ కోసం.

దీని తరువాత, మీరు ప్రతిస్పందనతో క్లయింట్‌తో కమ్యూనికేట్ చేయాలి.

కమ్యూనికేషన్

getOutputStream () సాకెట్ ద్వారా అవుట్పుట్ పంపడానికి పద్ధతి ఉపయోగించబడుతుంది.

కనెక్షన్‌ను మూసివేయండి

ప్రతిదీ పూర్తయిన తర్వాత సాకెట్‌ను అలాగే ఇన్‌పుట్ / అవుట్పుట్ స్ట్రీమ్‌లను మూసివేయడం ద్వారా కనెక్షన్‌ను మూసివేయడం చాలా ముఖ్యం.

సర్వర్ వైపు సాకెట్ కనెక్షన్‌ను అమలు చేయడానికి జావా ప్రోగ్రామ్‌ను ఎలా వ్రాయాలో ఇప్పుడు చూద్దాం.

// సర్వర్‌సైడ్ దిగుమతి కోసం జావా ప్రోగ్రామ్ java.net. * దిగుమతి java.io. పోర్ట్ పబ్లిక్ సర్వర్ (పూర్ణాంక పోర్ట్) {// సర్వర్‌ను ప్రారంభించి, కనెక్షన్ కోసం వేచి ఉంది {server = new ServerSocket (port) System.out.println ('సర్వర్ ప్రారంభమైంది') System.out.println ('క్లయింట్ కోసం వేచి ఉంది .. . (! line.equals ('ఓవర్')) 'ఓవర్' పంపే వరకు క్లయింట్ నుండి సందేశాన్ని చదువుతుంది {try {line = in.readUTF () System.out.println (line)} క్యాచ్ (IOException i). సిస్టమ్. out.println (i)}} System.out.println ('క్లోజింగ్ కనెక్షన్') // క్లోజ్ కనెక్షన్ సాకెట్.క్లోస్ () in.close ()} క్యాచ్ (IOException i) {System.out.println (i)}} పబ్లిక్ స్టాటిక్ శూన్య ప్రధాన (స్ట్రింగ్ అర్గ్స్ []) { సర్వర్ సర్వర్ = క్రొత్త సర్వర్ (5000)}}

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

నాగియోస్ దేనికి ఉపయోగిస్తారు

1. మీరు సర్వర్ సైడ్ స్క్రిప్ట్‌ను రన్ చేసినప్పుడు, అది ప్రారంభమవుతుంది మరియు క్లయింట్ ప్రారంభమయ్యే వరకు వేచి ఉంటుంది.

2. తరువాత, క్లయింట్ కనెక్ట్ అవుతుంది మరియు అభ్యర్థనను స్ట్రింగ్ రూపంలో ఇన్పుట్ చేస్తుంది.

3. క్లయింట్ అభ్యర్థనను పంపినప్పుడు, సర్వర్ తిరిగి స్పందిస్తుంది.

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

ఇది జావాలోని సాకెట్ ప్రోగ్రామింగ్ పై వ్యాసం చివరకి మనలను తీసుకువస్తుంది. నేను మీ జ్ఞానానికి కొంత వెలుగునిచ్చానని ఆశిస్తున్నాను సాకెట్ ప్రోగ్రామింగ్.

చూడండి ప్రపంచవ్యాప్తంగా విస్తరించి ఉన్న 250,000 మందికి పైగా సంతృప్తికరమైన అభ్యాసకుల నెట్‌వర్క్‌తో విశ్వసనీయ ఆన్‌లైన్ లెర్నింగ్ సంస్థ ఎడురేకా చేత. మీ ప్రయాణంలో అడుగడుగునా మీకు సహాయం చేయడానికి మేము ఇక్కడ ఉన్నాము, ఈ జావా ఇంటర్వ్యూ ప్రశ్నలతో పాటుగా, మేము జావా డెవలపర్‌గా ఉండాలనుకునే విద్యార్థులు మరియు నిపుణుల కోసం రూపొందించిన ఒక పాఠ్యాంశంతో ముందుకు వచ్చాము.

మాకు ప్రశ్న ఉందా? దయచేసి ఈ “జావాలోని సాకెట్ ప్రోగ్రామింగ్” వ్యాసంలోని వ్యాఖ్యల విభాగంలో పేర్కొనండి మరియు మేము వీలైనంత త్వరగా మిమ్మల్ని సంప్రదిస్తాము.