यूडीपी सॉकेट

जब हम नेटवर्किंग की बात करते हैं, तो हम OSI मॉडल का उल्लेख करने से चूक नहीं सकते।

इस मॉडल के संदर्भ में, आज हम ट्रांसपोर्ट लेयर (4) में सबसे अधिक रुचि रखते हैं।

यह वह स्तर है जिस पर हम "बिंदु A से बिंदु B" पर जाने वाले डेटा के साथ काम करते हैं। परिवहन परत का मुख्य कार्य यह सुनिश्चित करना है कि सही अनुक्रम बनाए रखते हुए संदेश को गंतव्य तक पहुँचाया जाए। दो सबसे आम परिवहन परत प्रोटोकॉल हैं: टीसीपी और यूडीपी। वे अलग-अलग तरीकों से वैचारिक रूप से काम करते हैं, लेकिन प्रत्येक के अपने फायदे हैं जो उन्हें विशिष्ट समस्याओं को हल करने की अनुमति देते हैं।

सबसे पहले, आइए देखें कि टीसीपी कैसे काम करता है।

टीसीपी (ट्रांसमिशन कंट्रोल प्रोटोकॉल) एक नेटवर्क प्रोटोकॉल है जो यह सुनिश्चित करता है कि डेटा के आदान-प्रदान से पहले मेजबानों के बीच एक कनेक्शन स्थापित हो।

यह एक बहुत ही विश्वसनीय प्रोटोकॉल है, क्योंकि हर बार जब यह एक और डेटा पैकेट भेजता है, तो उसे यह जांचना चाहिए कि पिछला पैकेट प्राप्त हुआ था।

प्रेषित पैकेटों का आदेश दिया जाता है, और यदि किसी निश्चित पैकेट के साथ समस्याएँ होती हैं (अर्थात प्राप्त करने वाली पार्टी यह पुष्टि नहीं करती है कि पैकेट आ गया है), तो पैकेट को फिर से भेज दिया जाता है। नतीजतन, अंतरण दर अपेक्षाकृत कम है, क्योंकि सख्त निगरानी और सही क्रम सुनिश्चित करने के लिए अधिक समय की आवश्यकता होती है।

यह वह जगह है जहां इसका "भाई", यूडीपी प्रोटोकॉल आता है। टीसीपी के विपरीत, यूडीपी वास्तव में प्रत्येक पैकेट के क्रम और स्थिति की परवाह नहीं करता है। यह केवल डिलीवरी की पुष्टि के बिना डेटा भेजता है। क्या अधिक है, यह कोई कनेक्शन स्थापित नहीं करता है और किसी भी तरह से कनेक्शन की स्थिति पर निर्भर नहीं करता है।

इसका उद्देश्य केवल एक पते पर डेटा भेजना है। और यह प्रोटोकॉल के मुख्य नुकसान, कम विश्वसनीयता को जन्म देता है, क्योंकि यह केवल डेटा के टुकड़े खो सकता है। इसके अतिरिक्त, प्राप्तकर्ता को इस तथ्य के लिए तैयार रहना चाहिए कि डेटा क्रम से बाहर आ सकता है। उस ने कहा, प्रोटोकॉल का एक फायदा भी है, एक उच्च अंतरण दर, इस तथ्य के कारण कि प्रोटोकॉल डेटा भेजने तक सीमित है।

डेटा को स्वयं कैसे प्रसारित किया जाता है, इसमें भी अंतर हैं। टीसीपी में, डेटा स्ट्रीम किया जाता है, जिसका अर्थ है कि डेटा की कोई सीमा नहीं है। UDP में, डेटा को डेटाग्राम के रूप में प्रेषित किया जाता है और इसकी सीमाएँ होती हैं, और प्राप्तकर्ता डेटा की अखंडता की जाँच करता है, लेकिन केवल तभी जब संदेश सफलतापूर्वक प्राप्त होता है।

आइए संक्षेप करते हैं:

जावा में, UDP पर प्रसारित डेटाग्राम के साथ काम करने के लिए, हम DatagramSocket और DatagramPacket कक्षाओं की वस्तुओं का उपयोग करते हैं।

डेटा का आदान-प्रदान करने के लिए, प्रेषक और रिसीवर डेटाग्राम सॉकेट बनाते हैं, यानी डेटाग्राम सॉकेट वर्ग के उदाहरण। क्लास में कई कंस्ट्रक्टर हैं। उनके बीच का अंतर वह है जहां बनाया गया सॉकेट कनेक्ट होगा:

कक्षा में सॉकेट मापदंडों तक पहुँचने और प्रबंधित करने के लिए कई तरीके हैं (हम उन्हें थोड़ी देर बाद देखेंगे), साथ ही डेटाग्राम प्राप्त करने और भेजने के तरीके:

डेटाग्रामपैकेट एक वर्ग है जो डेटाग्राम पैकेज का प्रतिनिधित्व करता है। कनेक्शन रहित पैकेट वितरण सेवा को लागू करने के लिए डेटाग्राम पैकेट का उपयोग किया जाता है। प्रत्येक संदेश केवल उस पैकेट में निहित जानकारी के आधार पर एक मशीन से दूसरी मशीन पर भेजा जाता है। एक मशीन से दूसरी मशीन में भेजे गए कई पैकेट अलग-अलग रूट किए जा सकते हैं और किसी भी क्रम में आ सकते हैं। पैकेट की डिलीवरी की गारंटी नहीं है।

निर्माता:

हमें याद है कि यूडीपी दृष्टिकोण एक संबंध स्थापित नहीं करता है। पैकेट इस उम्मीद पर भेजे जाते हैं कि प्राप्तकर्ता उनसे उम्मीद कर रहा है। लेकिन आप DatagramSocket वर्ग के कनेक्ट (InetAddress addr, int port) विधि का उपयोग करके एक कनेक्शन स्थापित कर सकते हैं।

एक पते और पोर्ट के आधार पर होस्ट के साथ एक तरफ़ा कनेक्शन स्थापित किया जाता है: या तो डेटाग्राम भेजने या प्राप्त करने के लिए। डिस्कनेक्ट () विधि का उपयोग करके कनेक्शन को समाप्त किया जा सकता है ।

आइए डेटा प्राप्त करने के लिए डेटाग्राम सॉकेट के आधार पर सर्वर कोड लिखने का प्रयास करें :

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 पर सुनने के लिए एक डेटाग्राम सॉकेट ऑब्जेक्ट बनाते हैं। जब यह एक संदेश प्राप्त करता है, तो यह इसे कंसोल पर प्रिंट करता है। हम "हैलो" शब्द प्रसारित करेंगे, इसलिए हम बफर आकार को पाँच बाइट्स तक सीमित करते हैं।

अब हम प्रेषक वर्ग बनाएंगे:

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 बनाते हैं और अपना संदेश भेजते हैं। ध्यान दें कि संदेश भेजे जाने के बाद डेटाग्राम सॉकेट को बंद करने के लिए क्लोज () विधि का उपयोग किया जाता है।

प्रत्येक सेकेंड प्राप्तकर्ता का कंसोल प्रेषक द्वारा भेजे गए आने वाले "हैलो" संदेश को प्रदर्शित करता है। इसका मतलब है कि हमारा संचार सही ढंग से काम कर रहा है।