UDP సాకెట్

మేము నెట్‌వర్కింగ్ గురించి మాట్లాడేటప్పుడు, OSI మోడల్‌ను పేర్కొనకుండా ఉండలేము.

ఈ మోడల్ పరంగా, ఈ రోజు మనం రవాణా పొరపై చాలా ఆసక్తి కలిగి ఉన్నాము (4).

ఇది "పాయింట్ A నుండి పాయింట్ B వరకు" డేటాను కదిలించడంతో మేము పని చేసే స్థాయి. సరైన క్రమాన్ని కొనసాగిస్తూ, గమ్యస్థానానికి సందేశం బట్వాడా చేయబడిందని నిర్ధారించడం రవాణా పొర యొక్క ప్రధాన పని. రెండు అత్యంత సాధారణ రవాణా లేయర్ ప్రోటోకాల్‌లు: TCP మరియు UDP. వారు వివిధ మార్గాల్లో సంభావితంగా పని చేస్తారు, కానీ ప్రతి ఒక్కటి నిర్దిష్ట సమస్యలను పరిష్కరించడానికి అనుమతించే దాని స్వంత ప్రయోజనాలను కలిగి ఉంటాయి.

ముందుగా, TCP ఎలా పనిచేస్తుందో చూద్దాం.

TCP (ట్రాన్స్‌మిషన్ కంట్రోల్ ప్రోటోకాల్) అనేది నెట్‌వర్క్ ప్రోటోకాల్, ఇది డేటా మార్పిడికి ముందు హోస్ట్‌ల మధ్య కనెక్షన్ ఏర్పాటు చేయబడిందని నిర్ధారిస్తుంది.

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

ప్రసారం చేయబడిన ప్యాకెట్లు ఆర్డర్ చేయబడతాయి మరియు నిర్దిష్ట ప్యాకెట్‌తో సమస్యలు ఉంటే (అంటే ప్యాకెట్ వచ్చిందని స్వీకరించే పక్షం నిర్ధారించలేదు), అప్పుడు ప్యాకెట్ మళ్లీ పంపబడుతుంది. ఫలితంగా, బదిలీ రేటు సాపేక్షంగా తక్కువగా ఉంది, ఎందుకంటే కఠినమైన పర్యవేక్షణ మరియు సరైన క్రమాన్ని నిర్ధారించడానికి ఎక్కువ సమయం అవసరం.

ఇక్కడే దాని "సోదరుడు", UDP ప్రోటోకాల్ వస్తుంది. TCP వలె కాకుండా, UDP ప్రతి ప్యాకెట్ యొక్క ఆర్డర్ మరియు స్థితిని నిజంగా పట్టించుకోదు. ఇది డెలివరీ నిర్ధారణ లేకుండా డేటాను పంపుతుంది. ఇంకా ఏమిటంటే, ఇది కనెక్షన్‌ని ఏర్పాటు చేయదు మరియు ఏ విధంగానూ కనెక్షన్ స్థితిపై ఆధారపడదు.

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

డేటా ఎలా ప్రసారం చేయబడుతుందో కూడా తేడాలు ఉన్నాయి. TCPలో, డేటా ప్రసారం చేయబడుతుంది, అంటే డేటాకు సరిహద్దులు లేవు. UDPలో, డేటా డేటాగ్రామ్‌లుగా ప్రసారం చేయబడుతుంది మరియు సరిహద్దులను కలిగి ఉంటుంది మరియు గ్రహీత డేటా యొక్క సమగ్రతను తనిఖీ చేస్తుంది, కానీ సందేశం విజయవంతంగా అందుకుంటే మాత్రమే.

సారాంశం చేద్దాం:

జావాలో, UDP ద్వారా ప్రసారం చేయబడిన డేటాగ్రామ్‌లతో పని చేయడానికి, మేము DatagramSocket మరియు DatagramPacket తరగతుల వస్తువులను ఉపయోగిస్తాము.

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

తరగతి సాకెట్ పారామితులను యాక్సెస్ చేయడానికి మరియు నిర్వహించడానికి అనేక పద్ధతులను కలిగి ఉంది (మేము వాటిని కొంచెం తరువాత పరిశీలిస్తాము), అలాగే డేటాగ్రామ్‌లను స్వీకరించడానికి మరియు పంపే పద్ధతులు:

DatagramPacket అనేది డేటాగ్రామ్ ప్యాకేజీని సూచించే తరగతి. కనెక్షన్‌లెస్ ప్యాకెట్ డెలివరీ సేవను అమలు చేయడానికి డేటాగ్రామ్ ప్యాకెట్‌లు ఉపయోగించబడతాయి. ఆ ప్యాకెట్‌లో ఉన్న సమాచారం ఆధారంగా ప్రతి సందేశం ఒక యంత్రం నుండి మరొక యంత్రానికి మళ్లించబడుతుంది. ఒక యంత్రం నుండి మరొక యంత్రానికి పంపబడిన బహుళ ప్యాకెట్‌లు వేర్వేరుగా మళ్లించబడవచ్చు మరియు ఏ క్రమంలోనైనా చేరవచ్చు. ప్యాకెట్ల డెలివరీకి హామీ లేదు.

కన్స్ట్రక్టర్లు:

UDP విధానం కనెక్షన్‌ని ఏర్పాటు చేయలేదని మేము గుర్తుచేసుకున్నాము. గ్రహీత వాటిని ఆశిస్తున్నారనే ఆశతో ప్యాకెట్లు పంపబడతాయి. కానీ మీరు DatagramSocket క్లాస్ యొక్క కనెక్ట్ (InetAddress addr, int port) పద్ధతిని ఉపయోగించి కనెక్షన్‌ని ఏర్పాటు చేసుకోవచ్చు .

చిరునామా మరియు పోర్ట్ ఆధారంగా హోస్ట్‌తో వన్-వే కనెక్షన్ ఏర్పాటు చేయబడింది: డేటాగ్రామ్‌లను పంపడానికి లేదా స్వీకరించడానికి. డిస్‌కనెక్ట్() పద్ధతిని ఉపయోగించి కనెక్షన్‌ని ముగించవచ్చు .

డేటాను స్వీకరించడానికి DatagramSocket ఆధారంగా సర్వర్ కోడ్‌ని వ్రాయడానికి ప్రయత్నిద్దాం :

import java.io.IOException;
import java.net.DatagramPacket;
import java.net.DatagramSocket;

class Recipient {

   public static void main(String[] args) {
       try {
           DatagramSocket ds = new DatagramSocket(1050);

           while (true) {
               DatagramPacket pack = new DatagramPacket(new byte[5], 5);
               ds.receive(pack);
               System.out.println(new String(pack.getData()));
           }
       } catch (IOException e) {
           e.printStackTrace();
       }
   }
}

మేము పోర్ట్ 1050లో వినడానికి DatagramSocket ఆబ్జెక్ట్‌ని సృష్టిస్తాము. అది సందేశాన్ని స్వీకరించినప్పుడు, అది దానిని కన్సోల్‌కు ప్రింట్ చేస్తుంది. మేము "హలో" అనే పదాన్ని ప్రసారం చేస్తాము, కాబట్టి మేము బఫర్ పరిమాణాన్ని ఐదు బైట్‌లకు పరిమితం చేస్తాము.

ఇప్పుడు మేము పంపినవారి తరగతిని సృష్టిస్తాము:

import java.io.IOException;
import java.net.DatagramPacket;
import java.net.DatagramSocket;
import java.net.InetAddress;

class Sender {
   private String host;
   private int port;

   Sender(String host, int port) {
       this.host = host;
       this.port = port;
   }

   private void sendMessage(String mes) {
       try {
           byte[] data = mes.getBytes();
           InetAddress address = InetAddress.getByName(host);
           DatagramPacket pack = new DatagramPacket(data, data.length, address, port);
           DatagramSocket ds = new DatagramSocket();
           ds.send(pack);
           ds.close();
       } catch (IOException e) {
           System.err.println(e);
       }
   }

   public static void main(String[] args) {
   Sender sender = new Sender("localhost", 1050);
   String message = "Hello";

   Timer timer = new Timer();
   timer.scheduleAtFixedRate(new TimerTask() {
       @Override
       public void run() {
           sender.sendMessage(message);
       }
   }, 1000, 1000);
}

}

sendMessage పద్ధతిలో , మేము DatagramPacket మరియు DatagramSocket ని సృష్టించి , మా సందేశాన్ని పంపుతాము. సందేశం పంపిన తర్వాత DatagramSocketను మూసివేయడానికి క్లోజ్() పద్ధతిని ఉపయోగించబడుతుందని గమనించండి .

ప్రతి సెకను గ్రహీత కన్సోల్ పంపినవారు పంపిన ఇన్‌కమింగ్ "హలో" సందేశాన్ని ప్రదర్శిస్తుంది. మా కమ్యూనికేషన్ అంతా సరిగ్గా పని చేస్తుందని దీని అర్థం.