खोज…


परिचय

सॉकेट एक निम्न-स्तरीय नेटवर्क इंटरफ़ेस है जो दो प्रोग्राम के बीच मुख्य रूप से क्लाइंट के बीच संबंध बनाने में मदद करता है जो एक ही मशीन पर चल सकता है या नहीं भी हो सकता है।

सॉकेट प्रोग्रामिंग सबसे व्यापक रूप से उपयोग की जाने वाली नेटवर्किंग अवधारणाओं में से एक है।

टिप्पणियों

इंटरनेट प्रोटोकॉल ट्रैफ़िक दो प्रकार के होते हैं -
1. टीसीपी - ट्रांसमिशन कंट्रोल प्रोटोकॉल 2. यूडीपी - उपयोगकर्ता डेटाग्राम प्रोटोकॉल

टीसीपी एक कनेक्शन-उन्मुख प्रोटोकॉल है।
यूडीपी एक कनेक्शन रहित प्रोटोकॉल है।

टीसीपी उन अनुप्रयोगों के लिए अनुकूल है जिन्हें उच्च विश्वसनीयता की आवश्यकता होती है, और ट्रांसमिशन समय अपेक्षाकृत कम महत्वपूर्ण है।

यूडीपी उन अनुप्रयोगों के लिए उपयुक्त है, जिन्हें गेम जैसे तेज, कुशल ट्रांसमिशन की आवश्यकता होती है। यूडीपी की स्टेटलेस प्रकृति उन सर्वरों के लिए भी उपयोगी है जो बड़ी संख्या में ग्राहकों से छोटे प्रश्नों का उत्तर देते हैं।

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

एक पूर्ण गारंटी है कि स्थानांतरित किया गया डेटा बरकरार है और उसी क्रम में आता है जिसमें इसे टीसीपी के मामले में भेजा गया था।
हालांकि इस बात की कोई गारंटी नहीं है कि भेजे गए संदेश या पैकेट यूडीपी में बिल्कुल पहुंचेंगे।

एक साधारण टीसीपी इको बैक सर्वर

हमारा TCP इको बैक सर्वर एक अलग थ्रेड होगा। यह एक शुरुआत के रूप में सरल है। आप इसे जो भी भेजेंगे लेकिन पूंजीकृत रूप में इसे वापस प्रतिध्वनित करेंगे।

public class CAPECHOServer extends Thread{

    // This class implements server sockets. A server socket waits for requests to come 
    // in over the network only when it is allowed through the local firewall
    ServerSocket serverSocket;
    
    public CAPECHOServer(int port, int timeout){
        try {
            // Create a new Server on specified port.
            serverSocket = new ServerSocket(port);
            // SoTimeout is basiacally the socket timeout.
            // timeout is the time until socket timeout in milliseconds
            serverSocket.setSoTimeout(timeout);
        } catch (IOException ex) {
            Logger.getLogger(CAPECHOServer.class.getName()).log(Level.SEVERE, null, ex);
        }
    }
    
    @Override
    public void run(){ 
        try {
            // We want the server to continuously accept connections
            while(!Thread.interrupted()){
                
            }
            // Close the server once done.
            serverSocket.close();
        } catch (IOException ex) {
            Logger.getLogger(CAPECHOServer.class.getName()).log(Level.SEVERE, null, ex);
        }
    }
    
}

अब कनेक्शन स्वीकार करने के लिए। चलो रन विधि को अपडेट करें।

@Override
public void run(){ 
    while(!Thread.interrupted()){
        try {
            // Log with the port number and machine ip
            Logger.getLogger((this.getClass().getName())).log(Level.INFO, "Listening for Clients at {0} on {1}", new Object[]{serverSocket.getLocalPort(), InetAddress.getLocalHost().getHostAddress()});
            Socket client = serverSocket.accept();  // Accept client conncetion
            // Now get DataInputStream and DataOutputStreams
            DataInputStream istream = new DataInputStream(client.getInputStream()); // From client's input stream
            DataOutputStream ostream = new DataOutputStream(client.getOutputStream());
            // Important Note
            /*
                The server's input is the client's output
                The client's input is the server's output
            */
            // Send a welcome message
            ostream.writeUTF("Welcome!");
            
            // Close the connection
            istream.close();
            ostream.close();
            client.close();
        } catch (IOException ex) {
            Logger.getLogger(CAPECHOServer.class.getName()).log(Level.SEVERE, null, ex);
        }
    }
    
    // Close the server once done
    
    try {
        serverSocket.close();
    } catch (IOException ex) {
        Logger.getLogger(CAPECHOServer.class.getName()).log(Level.SEVERE, null, ex);
    }
}

अब अगर आप टेलनेट खोल सकते हैं और कनेक्ट करने का प्रयास कर सकते हैं तो आपको एक वेलकम संदेश दिखाई देगा।

आपको अपने द्वारा निर्दिष्ट पोर्ट और आईपी एड्रेस से जुड़ना होगा।

आपको इसके समान परिणाम देखना चाहिए:

Welcome!

Connection to host lost.

खैर, कनेक्शन खो गया था क्योंकि हमने इसे समाप्त कर दिया था। कभी-कभी हमें अपने खुद के टीसीपी क्लाइंट को प्रोग्राम करना होता। इस मामले में, हमें उपयोगकर्ता से इनपुट का अनुरोध करने और इसे पूरे नेटवर्क में भेजने के लिए क्लाइंट की आवश्यकता है, पूंजीकृत इनपुट प्राप्त करें।

यदि सर्वर पहले डेटा भेजता है, तो क्लाइंट को पहले डेटा पढ़ना चाहिए।

public class CAPECHOClient extends Thread{

Socket server;
Scanner key; // Scanner for input

    public CAPECHOClient(String ip, int port){
        try {
            server = new Socket(ip, port);
            key = new Scanner(System.in);
        } catch (IOException ex) {
            Logger.getLogger(CAPECHOClient.class.getName()).log(Level.SEVERE, null, ex);
        }
    }
    
    @Override
    public void run(){
        DataInputStream istream = null;
        DataOutputStream ostream = null;
        try {
            istream = new DataInputStream(server.getInputStream()); // Familiar lines
            ostream = new DataOutputStream(server.getOutputStream());
            System.out.println(istream.readUTF());  // Print what the server sends
            System.out.print(">");
            String tosend = key.nextLine();
            ostream.writeUTF(tosend);   // Send whatever the user typed to the server
            System.out.println(istream.readUTF());  // Finally read what the server sends before exiting.
        } catch (IOException ex) {
            Logger.getLogger(CAPECHOClient.class.getName()).log(Level.SEVERE, null, ex);
        } finally {
            try {
                istream.close();
                ostream.close();
                server.close();
            } catch (IOException ex) {
                Logger.getLogger(CAPECHOClient.class.getName()).log(Level.SEVERE, null, ex);
            }
        }
    }
}

अब सर्वर को अपडेट करें

ostream.writeUTF("Welcome!");
            
String inString = istream.readUTF();    // Read what the user sent
String outString = inString.toUpperCase();  // Change it to caps
ostream.writeUTF(outString);
            
// Close the connection
istream.close();

और अब सर्वर और क्लाइंट को चलाएं, आपके पास इसके समान आउटपुट होना चाहिए

Welcome!
>


Modified text is an extract of the original Stack Overflow Documentation
के तहत लाइसेंस प्राप्त है CC BY-SA 3.0
से संबद्ध नहीं है Stack Overflow