మేము నెట్వర్కింగ్ గురించి మాట్లాడేటప్పుడు, OSI మోడల్ను పేర్కొనకుండా ఉండలేము.
ఈ మోడల్ పరంగా, ఈ రోజు మనం రవాణా పొరపై చాలా ఆసక్తి కలిగి ఉన్నాము (4).
ఇది "పాయింట్ A నుండి పాయింట్ B వరకు" డేటాను కదిలించడంతో మేము పని చేసే స్థాయి. సరైన క్రమాన్ని కొనసాగిస్తూ, గమ్యస్థానానికి సందేశం బట్వాడా చేయబడిందని నిర్ధారించడం రవాణా పొర యొక్క ప్రధాన పని. రెండు అత్యంత సాధారణ రవాణా లేయర్ ప్రోటోకాల్లు: TCP మరియు UDP. వారు వివిధ మార్గాల్లో సంభావితంగా పని చేస్తారు, కానీ ప్రతి ఒక్కటి నిర్దిష్ట సమస్యలను పరిష్కరించడానికి అనుమతించే దాని స్వంత ప్రయోజనాలను కలిగి ఉంటాయి.
ముందుగా, TCP ఎలా పనిచేస్తుందో చూద్దాం.
TCP (ట్రాన్స్మిషన్ కంట్రోల్ ప్రోటోకాల్) అనేది నెట్వర్క్ ప్రోటోకాల్, ఇది డేటా మార్పిడికి ముందు హోస్ట్ల మధ్య కనెక్షన్ ఏర్పాటు చేయబడిందని నిర్ధారిస్తుంది.
ఇది చాలా నమ్మదగిన ప్రోటోకాల్, ఎందుకంటే ఇది మరొక డేటా ప్యాకెట్ను పంపిన ప్రతిసారీ, మునుపటి ప్యాకెట్ స్వీకరించబడిందో లేదో తనిఖీ చేయాలి.
ప్రసారం చేయబడిన ప్యాకెట్లు ఆర్డర్ చేయబడతాయి మరియు నిర్దిష్ట ప్యాకెట్తో సమస్యలు ఉంటే (అంటే ప్యాకెట్ వచ్చిందని స్వీకరించే పక్షం నిర్ధారించలేదు), అప్పుడు ప్యాకెట్ మళ్లీ పంపబడుతుంది. ఫలితంగా, బదిలీ రేటు సాపేక్షంగా తక్కువగా ఉంది, ఎందుకంటే కఠినమైన పర్యవేక్షణ మరియు సరైన క్రమాన్ని నిర్ధారించడానికి ఎక్కువ సమయం అవసరం.
ఇక్కడే దాని "సోదరుడు", UDP ప్రోటోకాల్ వస్తుంది. TCP వలె కాకుండా, UDP ప్రతి ప్యాకెట్ యొక్క ఆర్డర్ మరియు స్థితిని నిజంగా పట్టించుకోదు. ఇది డెలివరీ నిర్ధారణ లేకుండా డేటాను పంపుతుంది. ఇంకా ఏమిటంటే, ఇది కనెక్షన్ని ఏర్పాటు చేయదు మరియు ఏ విధంగానూ కనెక్షన్ స్థితిపై ఆధారపడదు.
దీని ఉద్దేశ్యం కేవలం ఒక చిరునామాకు డేటాను పంపడం. మరియు ఇది ప్రోటోకాల్ యొక్క ప్రధాన ప్రతికూలత, తక్కువ విశ్వసనీయతకు దారితీస్తుంది, ఎందుకంటే ఇది కేవలం డేటా ముక్కలను కోల్పోతుంది. అదనంగా, గ్రహీత తప్పనిసరిగా డేటా క్రమం లేకుండా రావచ్చు అనే వాస్తవం కోసం సిద్ధంగా ఉండాలి. ప్రోటోకాల్ డేటాను పంపడానికి పరిమితం కావడం వల్ల ప్రోటోకాల్కు ప్రయోజనం, అధిక బదిలీ రేటు కూడా ఉంది.
డేటా ఎలా ప్రసారం చేయబడుతుందో కూడా తేడాలు ఉన్నాయి. TCPలో, డేటా ప్రసారం చేయబడుతుంది, అంటే డేటాకు సరిహద్దులు లేవు. UDPలో, డేటా డేటాగ్రామ్లుగా ప్రసారం చేయబడుతుంది మరియు సరిహద్దులను కలిగి ఉంటుంది మరియు గ్రహీత డేటా యొక్క సమగ్రతను తనిఖీ చేస్తుంది, కానీ సందేశం విజయవంతంగా అందుకుంటే మాత్రమే.
సారాంశం చేద్దాం:
TCP అనేది డేటా నష్టాన్ని నిరోధించే నమ్మకమైన మరియు ఖచ్చితమైన ప్రోటోకాల్. సందేశం ఎల్లప్పుడూ గరిష్ట ఖచ్చితత్వంతో పంపిణీ చేయబడుతుంది లేదా డెలివరీ చేయబడదు. ఇన్కమింగ్ డేటా ఇప్పటికే ఆర్డర్ చేయబడుతుంది కాబట్టి స్వీకర్తకు డేటాను ఆర్డర్ చేయడానికి లాజిక్ అవసరం లేదు. | UDP నమ్మదగినది కాదు, కానీ ఇది వేగవంతమైన డేటా బదిలీ ప్రోటోకాల్. ఈ ప్రోటోకాల్తో పని చేయడానికి పంపే మరియు స్వీకరించే పార్టీలకు కొంత అదనపు తర్కం అవసరం. అయితే నెట్వర్క్లో ఆడే కంప్యూటర్ గేమ్ లేదా మొబైల్ గేమ్ ఉదాహరణను ఉపయోగించి ఇది ఎలా పనిచేస్తుందో చూద్దాం. 5 సెకన్ల క్రితం రావాల్సిన వాటి గురించి మేము ఇకపై పట్టించుకోకపోవచ్చు మరియు కొన్ని ప్యాకెట్లు సమయానికి రాకపోతే మేము వాటిని దాటవేయవచ్చు — గేమ్ ఆలస్యం కావచ్చు, కానీ మీరు ఇప్పటికీ ఆడవచ్చు! |
జావాలో, UDP ద్వారా ప్రసారం చేయబడిన డేటాగ్రామ్లతో పని చేయడానికి, మేము DatagramSocket మరియు DatagramPacket తరగతుల వస్తువులను ఉపయోగిస్తాము.
డేటాను మార్పిడి చేయడానికి, పంపినవారు మరియు రిసీవర్ డేటాగ్రామ్ సాకెట్లను సృష్టిస్తారు, అనగా DatagramSocket తరగతికి సంబంధించిన సందర్భాలు. తరగతి అనేక కన్స్ట్రక్టర్లను కలిగి ఉంది. సృష్టించిన సాకెట్ ఎక్కడ కనెక్ట్ అవుతుందో వాటి మధ్య వ్యత్యాసం:
డేటాగ్రామ్సాకెట్ () | స్థానిక మెషీన్లో అందుబాటులో ఉన్న ఏదైనా పోర్ట్కి కనెక్ట్ చేస్తుంది |
డేటాగ్రామ్సాకెట్ (ఇంట్ పోర్ట్) | స్థానిక మెషీన్లో పేర్కొన్న పోర్ట్కి కనెక్ట్ చేస్తుంది |
DatagramSocket(int పోర్ట్, InetAddress addr) | స్థానిక మెషీన్లోని చిరునామాలో పేర్కొన్న పోర్ట్కు కనెక్ట్ చేస్తుంది (addr) |
తరగతి సాకెట్ పారామితులను యాక్సెస్ చేయడానికి మరియు నిర్వహించడానికి అనేక పద్ధతులను కలిగి ఉంది (మేము వాటిని కొంచెం తరువాత పరిశీలిస్తాము), అలాగే డేటాగ్రామ్లను స్వీకరించడానికి మరియు పంపే పద్ధతులు:
పంపండి (డేటాగ్రామ్ ప్యాకెట్ ప్యాక్) | ప్యాకెట్లలోకి ప్యాక్ చేసిన డేటాగ్రామ్లను పంపుతుంది |
స్వీకరించండి (డేటాగ్రామ్ ప్యాకెట్ ప్యాక్) | ప్యాకెట్లలో ప్యాక్ చేయబడిన డేటాగ్రామ్లను స్వీకరిస్తుంది |
DatagramPacket అనేది డేటాగ్రామ్ ప్యాకేజీని సూచించే తరగతి. కనెక్షన్లెస్ ప్యాకెట్ డెలివరీ సేవను అమలు చేయడానికి డేటాగ్రామ్ ప్యాకెట్లు ఉపయోగించబడతాయి. ఆ ప్యాకెట్లో ఉన్న సమాచారం ఆధారంగా ప్రతి సందేశం ఒక యంత్రం నుండి మరొక యంత్రానికి మళ్లించబడుతుంది. ఒక యంత్రం నుండి మరొక యంత్రానికి పంపబడిన బహుళ ప్యాకెట్లు వేర్వేరుగా మళ్లించబడవచ్చు మరియు ఏ క్రమంలోనైనా చేరవచ్చు. ప్యాకెట్ల డెలివరీకి హామీ లేదు.
కన్స్ట్రక్టర్లు:
డేటాగ్రామ్ప్యాకెట్(బైట్[] బఫ్, పూర్ణాంక పొడవు) | పొడవు గల ప్యాకెట్లను ఆమోదించడానికి DatagramPacket ని సృష్టిస్తుంది . |
DatagramPacket(బైట్[] బఫ్, పూర్ణాంక పొడవు, InetAddress చిరునామా, పూర్ణాంక పోర్ట్) | పేర్కొన్న హోస్ట్లోని పేర్కొన్న పోర్ట్ నంబర్కు పొడవు పొడవు ప్యాకెట్లను పంపడానికి డేటాగ్రామ్ ప్యాకెట్ను సృష్టిస్తుంది . |
డేటాగ్రామ్ప్యాకెట్(బైట్[] బఫ్, పూర్ణాంక ఆఫ్సెట్, పూర్ణాంక పొడవు) | బఫర్లో ఆఫ్సెట్ను పేర్కొంటూ పొడవు పొడవు గల ప్యాకెట్లను ఆమోదించడానికి డేటాగ్రామ్ప్యాకెట్ను సృష్టిస్తుంది . |
DatagramPacket(బైట్[] బఫ్, పూర్ణాంక ఆఫ్సెట్, పూర్ణాంక పొడవు, InetAddress చిరునామా, పూర్ణాంక పోర్ట్) | పేర్కొన్న హోస్ట్లో పేర్కొన్న పోర్ట్ నంబర్కు ఆఫ్సెట్ ఆఫ్సెట్తో పొడవు పొడవు గల ప్యాకెట్లను పంపడానికి డేటాగ్రామ్ ప్యాకెట్ను సృష్టిస్తుంది . |
డేటాగ్రామ్ప్యాకెట్(బైట్[] బఫ్, పూర్ణాంక ఆఫ్సెట్, పూర్ణాంక పొడవు, సాకెట్ చిరునామా చిరునామా) | పేర్కొన్న హోస్ట్లో పేర్కొన్న పోర్ట్ నంబర్కు ఆఫ్సెట్ ఆఫ్సెట్తో పొడవు పొడవు గల ప్యాకెట్లను పంపడానికి డేటాగ్రామ్ ప్యాకెట్ను సృష్టిస్తుంది . |
డేటాగ్రామ్ప్యాకెట్(బైట్[] బఫ్, పూర్ణాంక పొడవు, సాకెట్ అడ్రస్ చిరునామా) | పేర్కొన్న హోస్ట్లోని పేర్కొన్న పోర్ట్ నంబర్కు పొడవు పొడవు ప్యాకెట్లను పంపడానికి డేటాగ్రామ్ ప్యాకెట్ను సృష్టిస్తుంది . |
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ను మూసివేయడానికి క్లోజ్() పద్ధతిని ఉపయోగించబడుతుందని గమనించండి .
ప్రతి సెకను గ్రహీత కన్సోల్ పంపినవారు పంపిన ఇన్కమింగ్ "హలో" సందేశాన్ని ప్రదర్శిస్తుంది. మా కమ్యూనికేషన్ అంతా సరిగ్గా పని చేస్తుందని దీని అర్థం.
GO TO FULL VERSION