UDP சாக்கெட்

நாம் நெட்வொர்க்கிங் பற்றி பேசும் போது, ​​OSI மாதிரியை குறிப்பிடாமல் இருக்க முடியாது.

இந்த மாதிரியைப் பொறுத்தவரை, இன்று நாம் போக்குவரத்து அடுக்கில் மிகவும் ஆர்வமாக உள்ளோம் (4).

"புள்ளி A முதல் புள்ளி B வரை" நகரும் தரவுகளுடன் நாம் செயல்படும் நிலை இதுவாகும். போக்குவரத்து அடுக்கின் முக்கிய பணி, சரியான வரிசையை பராமரிக்கும் போது, ​​இலக்குக்கு ஒரு செய்தி வழங்கப்படுவதை உறுதி செய்வதாகும். இரண்டு பொதுவான போக்குவரத்து அடுக்கு நெறிமுறைகள்: TCP மற்றும் UDP. அவை வெவ்வேறு வழிகளில் கருத்தியல் ரீதியாக செயல்படுகின்றன, ஆனால் ஒவ்வொன்றும் அதன் சொந்த நன்மைகளைக் கொண்டுள்ளன, அவை குறிப்பிட்ட சிக்கல்களைத் தீர்க்க அனுமதிக்கின்றன.

முதலில், TCP எவ்வாறு செயல்படுகிறது என்பதைப் பார்ப்போம்.

TCP (டிரான்ஸ்மிஷன் கண்ட்ரோல் புரோட்டோகால்) என்பது ஒரு பிணைய நெறிமுறை ஆகும், இது தரவு பரிமாற்றத்திற்கு முன் ஹோஸ்ட்களுக்கு இடையே ஒரு இணைப்பு நிறுவப்படுவதை உறுதி செய்கிறது.

இது மிகவும் நம்பகமான நெறிமுறையாகும், ஏனென்றால் ஒவ்வொரு முறையும் மற்றொரு தரவு பாக்கெட்டை அனுப்பும் போது, ​​முந்தைய பாக்கெட் பெறப்பட்டதா என்பதை சரிபார்க்க வேண்டும்.

அனுப்பப்பட்ட பாக்கெட்டுகள் ஆர்டர் செய்யப்படுகின்றன, மேலும் ஒரு குறிப்பிட்ட பாக்கெட்டில் சிக்கல்கள் இருந்தால் (அதாவது பாக்கெட் வந்துள்ளதை பெறும் தரப்பு உறுதிப்படுத்தவில்லை), பின்னர் பாக்கெட் மீண்டும் அனுப்பப்படும். இதன் விளைவாக, பரிமாற்ற விகிதம் ஒப்பீட்டளவில் குறைவாக உள்ளது, ஏனெனில் கடுமையான கண்காணிப்பு மற்றும் சரியான வரிசையை உறுதி செய்வதற்கு அதிக நேரம் தேவைப்படுகிறது.

இங்குதான் அதன் "சகோதரர்", UDP நெறிமுறை வருகிறது. TCP போலல்லாமல், UDP உண்மையில் ஒவ்வொரு பாக்கெட்டின் வரிசை மற்றும் நிலையைப் பற்றி கவலைப்படுவதில்லை. இது டெலிவரி உறுதிப்படுத்தல் இல்லாமல் தரவை அனுப்புகிறது. மேலும் என்னவென்றால், இது ஒரு இணைப்பை நிறுவவில்லை மற்றும் எந்த வகையிலும் ஒரு இணைப்பு நிலையை சார்ந்து இல்லை.

ஒரு முகவரிக்கு தரவுகளை அனுப்புவதே இதன் நோக்கம். இது நெறிமுறையின் முக்கிய குறைபாடு, குறைந்த நம்பகத்தன்மைக்கு வழிவகுக்கிறது, ஏனெனில் இது தரவுகளின் துண்டுகளை வெறுமனே இழக்க நேரிடும். கூடுதலாக, தரவு ஒழுங்கற்றதாக வரக்கூடும் என்பதற்கு பெறுநர் தயாராக இருக்க வேண்டும். நெறிமுறை தரவை அனுப்புவதற்கு மட்டுப்படுத்தப்பட்டிருப்பதால், நெறிமுறைக்கு ஒரு நன்மையும், அதிக பரிமாற்ற வீதமும் உள்ளது.

தரவு எவ்வாறு அனுப்பப்படுகிறது என்பதில் வேறுபாடுகள் உள்ளன. TCP இல், தரவு ஸ்ட்ரீம் செய்யப்படுகிறது, அதாவது தரவுக்கு எல்லைகள் இல்லை. UDP இல், தரவு டேட்டாகிராம்களாக அனுப்பப்படுகிறது மற்றும் எல்லைகளைக் கொண்டுள்ளது, மேலும் பெறுநர் தரவின் ஒருமைப்பாட்டைச் சரிபார்க்கிறார், ஆனால் செய்தி வெற்றிகரமாகப் பெறப்பட்டால் மட்டுமே.

சுருக்கமாகக் கூறுவோம்:

ஜாவாவில், UDP மூலம் அனுப்பப்படும் டேட்டாகிராம்களுடன் பணிபுரிய, DatagramSocket மற்றும் DatagramPacket வகுப்புகளின் பொருள்களைப் பயன்படுத்துகிறோம் .

தரவைப் பரிமாறிக்கொள்ள, அனுப்புநரும் பெறுநரும் டேட்டாகிராம் சாக்கெட்டுகளை உருவாக்குகிறார்கள், அதாவது டேட்டாகிராம்சாக்கெட் வகுப்பின் நிகழ்வுகள். வகுப்பில் பல கட்டமைப்பாளர்கள் உள்ளனர். அவற்றுக்கிடையேயான வேறுபாடு என்னவென்றால், உருவாக்கப்பட்ட சாக்கெட் இணைக்கப்படும் இடம்:

சாக்கெட் அளவுருக்களை அணுகுவதற்கும் நிர்வகிப்பதற்கும் வகுப்பில் பல முறைகள் உள்ளன (அவற்றை சிறிது நேரம் கழித்து பார்ப்போம்), அத்துடன் டேட்டாகிராம்களைப் பெறுவதற்கும் அனுப்புவதற்கும் உள்ள முறைகள்:

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);
}

}

செண்ட்மெசேஜ் முறையில் , டேட்டாகிராம் பாக்கெட் மற்றும் டேட்டாகிராம்சாக்கெட் ஆகியவற்றை உருவாக்கி , எங்கள் செய்தியை அனுப்புகிறோம். செய்தி அனுப்பப்பட்ட பிறகு DatagramSocket ஐ மூடுவதற்கு close() முறை பயன்படுத்தப்படுகிறது என்பதை நினைவில் கொள்ளவும் .

ஒவ்வொரு நொடியும் பெறுநரின் கன்சோல் அனுப்பியவர் அனுப்பிய உள்வரும் "ஹலோ" செய்தியைக் காட்டுகிறது. இதன் பொருள் எங்கள் தொடர்பு அனைத்தும் சரியாக வேலை செய்கிறது.