जावा में नेटवर्क एप्लिकेशन कैसे बनाएं (चित्रों के साथ)

2024 लेखक: Gilbert Ryder | [email protected]. अंतिम बार संशोधित: 2023-12-16 17:32

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

इस लेख में, आप एक ऐसा एप्लिकेशन सेटअप करेंगे जो आपके कंप्यूटर को खुद से जोड़ेगा और अनिवार्य रूप से इसे पागल बना देगा - खुद से बात करें। आप जावा में नेटवर्किंग के लिए सबसे व्यापक रूप से उपयोग की जाने वाली दो धाराओं और उनके कार्य करने के तरीके के बीच अंतर भी जानेंगे।

डेटा और ऑब्जेक्ट स्ट्रीम

कोड में गोता लगाने से पहले, लेख में प्रयुक्त दो धाराओं के बीच के अंतर को अलग करने की आवश्यकता है।

डेटा स्ट्रीम

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

ऑब्जेक्ट स्ट्रीम

ऑब्जेक्ट स्ट्रीम आदिम डेटा प्रकारों और लागू करने वाली वस्तुओं को संसाधित करता है

serializable

इंटरफेस। ऑब्जेक्ट स्ट्रीम पर भेजा गया डेटा स्वचालित रूप से क्रमबद्ध और deserialized है जो जटिल डेटा को स्थानांतरित करना आसान बनाता है। लेकिन, ऑब्जेक्ट स्ट्रीम केवल जावा में लिखे गए सर्वर और क्लाइंट के साथ संचार कर सकते हैं। भी,

ऑब्जेक्टऑटपुटस्ट्रीम

आरंभीकरण पर, एक शीर्षलेख भेजता है

आगत प्रवाह

दूसरे पक्ष का, जो प्रारंभ होने पर, शीर्षलेख प्राप्त होने तक निष्पादन को अवरुद्ध करता है।

कदम

चरण 1. एक वर्ग बनाएँ।

एक वर्ग बनाएं और उसे नाम दें जैसा आप चाहते हैं। इस लेख में, इसका नाम होगा

NetworkAppउदाहरण

पब्लिक क्लास NetworkAppExample { }

चरण 2. एक मुख्य विधि बनाएँ।

एक मुख्य विधि बनाएं और घोषित करें कि यह अपवादों को फेंक सकता है

अपवाद

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

सार्वजनिक वर्ग NetworkAppExample {सार्वजनिक स्थैतिक शून्य मुख्य (स्ट्रिंग तर्क) अपवाद फेंकता है {}}

चरण 3. सर्वर पता घोषित करें।

यह उदाहरण स्थानीय होस्ट पते और एक मनमाना पोर्ट नंबर का उपयोग करेगा। पोर्ट नंबर 0 से 65535 (समावेशी) की सीमा में होना चाहिए। हालाँकि, पोर्ट नंबर 0 से 1023 (समावेशी) की सीमा से बचने के लिए क्योंकि वे आरक्षित सिस्टम पोर्ट हैं।

सार्वजनिक वर्ग NetworkAppExample {सार्वजनिक स्थैतिक शून्य मुख्य (स्ट्रिंग तर्क) अपवाद फेंकता है {स्ट्रिंग होस्ट = "लोकलहोस्ट"; इंट पोर्ट = 10430; } }

चरण 4. एक सर्वर बनाएँ।

सर्वर पते और पोर्ट के लिए बाध्य है और आने वाले कनेक्शन के लिए सुनता है। जावा में,

सर्वर सॉकेट

सर्वर-साइड एंडपॉइंट का प्रतिनिधित्व करता है और इसका कार्य नए कनेक्शन स्वीकार कर रहा है।

सर्वर सॉकेट

डेटा पढ़ने और भेजने के लिए स्ट्रीम नहीं है क्योंकि यह सर्वर और क्लाइंट के बीच कनेक्शन का प्रतिनिधित्व नहीं करता है।

java.net. InetAddress आयात करें; आयात java.net. ServerSocket; सार्वजनिक वर्ग NetworkAppExample {सार्वजनिक स्थैतिक शून्य मुख्य (स्ट्रिंग तर्क) अपवाद फेंकता है {स्ट्रिंग होस्ट = "लोकलहोस्ट"; इंट पोर्ट = 10430; सर्वर सॉकेट सर्वर = नया सर्वर सॉकेट (पोर्ट, 50, InetAddress.getByName (होस्ट)); } }

चरण 5. सर्वर स्थापना लॉग करें।

लॉगिंग उद्देश्यों के लिए, कंसोल पर प्रिंट करें कि सर्वर शुरू हो गया है।

java.net. InetAddress आयात करें; आयात java.net. ServerSocket; सार्वजनिक वर्ग NetworkAppExample {सार्वजनिक स्थैतिक शून्य मुख्य (स्ट्रिंग तर्क) अपवाद फेंकता है {स्ट्रिंग होस्ट = "लोकलहोस्ट"; इंट पोर्ट = 10430; सर्वर सॉकेट सर्वर = नया सर्वर सॉकेट (पोर्ट, 50, InetAddress.getByName (होस्ट)); System.out.println ("सर्वर शुरू हुआ।"); } }

चरण 6. एक ग्राहक बनाएँ।

क्लाइंट सर्वर के पते और पोर्ट से जुड़ा होता है और कनेक्शन स्थापित होने के बाद पैकेट (संदेश) को सुनता है। जावा में,

सॉकेट

सर्वर से जुड़े क्लाइंट-साइड एंडपॉइंट या क्लाइंट से कनेक्शन (सर्वर से) का प्रतिनिधित्व करता है और दूसरे छोर पर पार्टी के साथ संवाद करने के लिए उपयोग किया जाता है।

java.net. InetAddress आयात करें; आयात java.net. ServerSocket; आयात java.net. Socket; सार्वजनिक वर्ग NetworkAppExample {सार्वजनिक स्थैतिक शून्य मुख्य (स्ट्रिंग तर्क) अपवाद फेंकता है {स्ट्रिंग होस्ट = "लोकलहोस्ट"; इंट पोर्ट = 10430; सर्वर सॉकेट सर्वर = नया सर्वर सॉकेट (पोर्ट, 50, InetAddress.getByName (होस्ट)); System.out.println ("सर्वर शुरू हुआ।"); सॉकेट क्लाइंट = नया सॉकेट (होस्ट, पोर्ट); } }

चरण 7. लॉग कनेक्शन का प्रयास।

लॉगिंग उद्देश्यों के लिए, कंसोल पर प्रिंट करें कि कनेक्शन का प्रयास किया गया है।

java.net. InetAddress आयात करें; आयात java.net. ServerSocket; आयात java.net. Socket; सार्वजनिक वर्ग NetworkAppExample {सार्वजनिक स्थैतिक शून्य मुख्य (स्ट्रिंग तर्क) अपवाद फेंकता है {स्ट्रिंग होस्ट = "लोकलहोस्ट"; इंट पोर्ट = 10430; सर्वर सॉकेट सर्वर = नया सर्वर सॉकेट (पोर्ट, 50, InetAddress.getByName (होस्ट)); System.out.println ("सर्वर शुरू हुआ।"); सॉकेट क्लाइंट = नया सॉकेट (होस्ट, पोर्ट); System.out.println ("सर्वर से कनेक्ट हो रहा है …"); } }

चरण 8. कनेक्शन स्थापित करें।

क्लाइंट तब तक कनेक्ट नहीं होंगे जब तक सर्वर सुनता और स्वीकार नहीं करता, दूसरे शब्दों में, कनेक्शन स्थापित करता है। जावा में, कनेक्शन का उपयोग करके स्थापित किया जाता है

स्वीकार करना()

उसकि विधि

सर्वर सॉकेट

कक्षा। क्लाइंट कनेक्ट होने तक विधि निष्पादन को अवरुद्ध कर देगी।

java.net. InetAddress आयात करें; आयात java.net. ServerSocket; आयात java.net. Socket; सार्वजनिक वर्ग NetworkAppExample {सार्वजनिक स्थैतिक शून्य मुख्य (स्ट्रिंग तर्क) अपवाद फेंकता है {स्ट्रिंग होस्ट = "लोकलहोस्ट"; इंट पोर्ट = 10430; सर्वर सॉकेट सर्वर = नया सर्वर सॉकेट (पोर्ट, 50, InetAddress.getByName (होस्ट)); System.out.println ("सर्वर शुरू हुआ।"); सॉकेट क्लाइंट = नया सॉकेट (होस्ट, पोर्ट); System.out.println ("सर्वर से कनेक्ट हो रहा है …"); सॉकेट कनेक्शन = सर्वर। स्वीकार (); } }

चरण 9. स्थापित कनेक्शन लॉग करें।

लॉगिंग उद्देश्यों के लिए, कंसोल पर प्रिंट करें कि सर्वर और क्लाइंट के बीच कनेक्शन स्थापित किया गया है।

java.net. InetAddress आयात करें; आयात java.net. ServerSocket; java.net. Socket आयात करें; सार्वजनिक वर्ग NetworkAppExample {सार्वजनिक स्थैतिक शून्य मुख्य (स्ट्रिंग तर्क) अपवाद फेंकता है {स्ट्रिंग होस्ट = "लोकलहोस्ट"; इंट पोर्ट = 10430; सर्वर सॉकेट सर्वर = नया सर्वर सॉकेट (पोर्ट, 50, InetAddress.getByName (होस्ट)); System.out.println ("सर्वर शुरू हुआ।"); सॉकेट क्लाइंट = नया सॉकेट (होस्ट, पोर्ट); System.out.println ("सर्वर से कनेक्ट हो रहा है …"); सॉकेट कनेक्शन = सर्वर। स्वीकार (); System.out.println ("कनेक्शन स्थापित।"); } }

चरण 10. संचार धाराएँ तैयार करें।

संचार धाराओं पर किया जाता है और, इस एप्लिकेशन में, सर्वर (क्लाइंट से) (कनेक्शन से) और क्लाइंट की कच्ची धाराओं को डेटा या ऑब्जेक्ट स्ट्रीम में जंजीर करने की आवश्यकता होती है। याद रखें, दोनों पक्षों को एक ही स्ट्रीम प्रकार का उपयोग करने की आवश्यकता है।

• डेटा स्ट्रीम

  आयात java.io. DataInputStream; आयात java.io. DataOutputStream; java.net. InetAddress आयात करें; आयात java.net. ServerSocket; java.net. Socket आयात करें; सार्वजनिक वर्ग NetworkAppExample {सार्वजनिक स्थैतिक शून्य मुख्य (स्ट्रिंग तर्क) अपवाद फेंकता है {स्ट्रिंग होस्ट = "लोकलहोस्ट"; इंट पोर्ट = 10430; सर्वर सॉकेट सर्वर = नया सर्वर सॉकेट (पोर्ट, 50, InetAddress.getByName (होस्ट)); System.out.println ("सर्वर शुरू हुआ।"); सॉकेट क्लाइंट = नया सॉकेट (होस्ट, पोर्ट); System.out.println ("सर्वर से कनेक्ट हो रहा है …"); सॉकेट कनेक्शन = सर्वर। स्वीकार (); System.out.println ("कनेक्शन स्थापित।"); डेटाऑटपुटस्ट्रीम क्लाइंटऑट = नया डेटाऑटपुटस्ट्रीम (क्लाइंट.गेटऑटपुटस्ट्रीम ()); डेटा इनपुटस्ट्रीम क्लाइंटइन = नया डेटा इनपुटस्ट्रीम (क्लाइंट.गेटइनपुटस्ट्रीम ()); डेटाऑटपुटस्ट्रीम सर्वरऑट = नया डेटाऑटपुटस्ट्रीम (कनेक्शन.गेटऑटपुटस्ट्रीम ()); डेटा इनपुटस्ट्रीम सर्वरइन = नया डेटा इनपुटस्ट्रीम (कनेक्शन। getInputStream ()); } }
  

• वस्तु धाराएं

  जब कई ऑब्जेक्ट स्ट्रीम का उपयोग किया जाता है, तो इनपुट स्ट्रीम को उसी क्रम में प्रारंभ किया जाना चाहिए जैसे आउटपुट स्ट्रीम

  ऑब्जेक्टऑटपुटस्ट्रीम

  दूसरे पक्ष को हेडर भेजता है और

  ऑब्जेक्ट इनपुटस्ट्रीम

  जब तक यह हेडर नहीं पढ़ता तब तक निष्पादन को रोकता है।

  आयात java.io. ObjectInputStream; आयात java.io. ObjectOutputStream; java.net. InetAddress आयात करें; आयात java.net. ServerSocket; java.net. Socket आयात करें; सार्वजनिक वर्ग NetworkAppExample {सार्वजनिक स्थैतिक शून्य मुख्य (स्ट्रिंग तर्क) अपवाद फेंकता है {स्ट्रिंग होस्ट = "लोकलहोस्ट"; इंट पोर्ट = 10430; सर्वर सॉकेट सर्वर = नया सर्वर सॉकेट (पोर्ट, 50, InetAddress.getByName (होस्ट)); System.out.println ("सर्वर शुरू हुआ।"); सॉकेट क्लाइंट = नया सॉकेट (होस्ट, पोर्ट); System.out.println ("सर्वर से कनेक्ट हो रहा है …"); सॉकेट कनेक्शन = सर्वर। स्वीकार (); System.out.println ("कनेक्शन स्थापित।"); ऑब्जेक्टऑटपुटस्ट्रीम क्लाइंटऑट = नया ऑब्जेक्टऑटपुटस्ट्रीम (क्लाइंट.गेटऑटपुटस्ट्रीम ()); ऑब्जेक्टऑटपुटस्ट्रीम सर्वरऑट = नया ऑब्जेक्टऑटपुटस्ट्रीम (कनेक्शन.गेटऑटपुटस्ट्रीम ()); ऑब्जेक्ट इनपुटस्ट्रीम क्लाइंटइन = नया ऑब्जेक्ट इनपुटस्ट्रीम (क्लाइंट.गेटइनपुटस्ट्रीम ()); ऑब्जेक्ट इनपुटस्ट्रीम सर्वरइन = नया ऑब्जेक्ट इनपुटस्ट्रीम (कनेक्शन। गेटइनपुटस्ट्रीम ()); } }
  

  उपरोक्त कोड में निर्दिष्ट आदेश को याद रखना आसान हो सकता है - पहले आउटपुट स्ट्रीम प्रारंभ करें और उसी क्रम में इनपुट स्ट्रीम प्रारंभ करें। हालाँकि, ऑब्जेक्ट स्ट्रीम को इनिशियलाइज़ करने का एक और क्रम निम्नलिखित है:

  ऑब्जेक्टऑटपुटस्ट्रीम क्लाइंटऑट = नया ऑब्जेक्टऑटपुटस्ट्रीम (क्लाइंट.गेटऑटपुटस्ट्रीम ()); ऑब्जेक्ट इनपुटस्ट्रीम सर्वरइन = नया ऑब्जेक्ट इनपुटस्ट्रीम (कनेक्शन। गेटइनपुटस्ट्रीम ()); ऑब्जेक्टऑटपुटस्ट्रीम सर्वरऑट = नया ऑब्जेक्टऑटपुटस्ट्रीम (कनेक्शन.गेटऑटपुटस्ट्रीम ()); ऑब्जेक्ट इनपुटस्ट्रीम क्लाइंटइन = नया ऑब्जेक्ट इनपुटस्ट्रीम (क्लाइंट.गेटइनपुटस्ट्रीम ());
  

चरण 11. लॉग इन करें कि संचार तैयार है।

लॉगिंग उद्देश्यों के लिए, कंसोल पर प्रिंट करें कि संचार तैयार है।

// कोड छोड़ा गया आयात java.net. InetAddress; आयात java.net. ServerSocket; आयात java.net. Socket; सार्वजनिक वर्ग NetworkAppExample {सार्वजनिक स्थैतिक शून्य मुख्य (स्ट्रिंग तर्क) अपवाद फेंकता है {स्ट्रिंग होस्ट = "लोकलहोस्ट"; इंट पोर्ट = 10430; सर्वर सॉकेट सर्वर = नया सर्वर सॉकेट (पोर्ट, 50, InetAddress.getByName (होस्ट)); System.out.println ("सर्वर शुरू हुआ।"); सॉकेट क्लाइंट = नया सॉकेट (होस्ट, पोर्ट); System.out.println ("सर्वर से कनेक्ट हो रहा है …"); सॉकेट कनेक्शन = सर्वर। स्वीकार (); System.out.println ("कनेक्शन स्थापित।"); // कोड छोड़ा गया System.out.println ("संचार तैयार है।"); } }

चरण 12. एक संदेश बनाएँ।

इस आवेदन में,

नमस्ते दुनिया

पाठ या तो सर्वर पर भेजा जाएगा

बाइट

या

डोरी

. उस प्रकार का एक चर घोषित करें जो उपयोग की गई धारा पर निर्भर करता है। उपयोग

बाइट

डेटा स्ट्रीम के लिए और

डोरी

वस्तु धाराओं के लिए।

• डेटा स्ट्रीम

  डेटा स्ट्रीम का उपयोग करके, वस्तुओं को आदिम डेटा प्रकारों में परिवर्तित करके क्रमांकन किया जाता है या a

  डोरी

  . इस मामले में,

  डोरी

  में परिवर्तित किया जाता है

  बाइट

  लिखित उपयोग के बजाय

  राइटबाइट्स ()

  यह दिखाने की विधि कि यह अन्य वस्तुओं, जैसे कि छवियों या अन्य फ़ाइलों के साथ कैसे किया जाएगा।

  आयात java.io. DataInputStream; आयात java.io. DataOutputStream; java.net. InetAddress आयात करें; आयात java.net. ServerSocket; java.net. Socket आयात करें; सार्वजनिक वर्ग NetworkAppExample {सार्वजनिक स्थैतिक शून्य मुख्य (स्ट्रिंग तर्क) अपवाद फेंकता है {स्ट्रिंग होस्ट = "लोकलहोस्ट"; इंट पोर्ट = 10430; सर्वर सॉकेट सर्वर = नया सर्वर सॉकेट (पोर्ट, 50, InetAddress.getByName (होस्ट)); System.out.println ("सर्वर शुरू हुआ।"); सॉकेट क्लाइंट = नया सॉकेट (होस्ट, पोर्ट); System.out.println ("सर्वर से कनेक्ट हो रहा है …"); सॉकेट कनेक्शन = सर्वर। स्वीकार (); System.out.println ("कनेक्शन स्थापित।"); डेटाऑटपुटस्ट्रीम क्लाइंटऑट = नया डेटाऑटपुटस्ट्रीम (क्लाइंट.गेटऑटपुटस्ट्रीम ()); डेटा इनपुटस्ट्रीम क्लाइंटइन = नया डेटा इनपुटस्ट्रीम (क्लाइंट.गेटइनपुटस्ट्रीम ()); डेटाऑटपुटस्ट्रीम सर्वरऑट = नया डेटाऑटपुटस्ट्रीम (कनेक्शन.गेटऑटपुटस्ट्रीम ()); डेटा इनपुटस्ट्रीम सर्वरइन = नया डेटा इनपुटस्ट्रीम (कनेक्शन। getInputStream ()); System.out.println ("संचार तैयार है।"); बाइट संदेशऑट = "हैलो वर्ल्ड"। गेटबाइट्स (); } }
  

• वस्तु धाराएं

  आयात java.io. ObjectInputStream; आयात java.io. ObjectOutputStream; java.net. InetAddress आयात करें; आयात java.net. ServerSocket; java.net. Socket आयात करें; सार्वजनिक वर्ग NetworkAppExample {सार्वजनिक स्थैतिक शून्य मुख्य (स्ट्रिंग तर्क) अपवाद फेंकता है {स्ट्रिंग होस्ट = "लोकलहोस्ट"; इंट पोर्ट = 10430; सर्वर सॉकेट सर्वर = नया सर्वर सॉकेट (पोर्ट, 50, InetAddress.getByName (होस्ट)); System.out.println ("सर्वर शुरू हुआ।"); सॉकेट क्लाइंट = नया सॉकेट (होस्ट, पोर्ट); System.out.println ("सर्वर से कनेक्ट हो रहा है …"); सॉकेट कनेक्शन = सर्वर। स्वीकार (); System.out.println ("कनेक्शन स्थापित।"); ऑब्जेक्टऑटपुटस्ट्रीम क्लाइंटऑट = नया ऑब्जेक्टऑटपुटस्ट्रीम (क्लाइंट.गेटऑटपुटस्ट्रीम ()); ऑब्जेक्टऑटपुटस्ट्रीम सर्वरऑट = नया ऑब्जेक्टऑटपुटस्ट्रीम (कनेक्शन.गेटऑटपुटस्ट्रीम ()); ऑब्जेक्ट इनपुटस्ट्रीम क्लाइंटइन = नया ऑब्जेक्ट इनपुटस्ट्रीम (क्लाइंट.गेटइनपुटस्ट्रीम ()); ऑब्जेक्ट इनपुटस्ट्रीम सर्वरइन = नया ऑब्जेक्ट इनपुटस्ट्रीम (कनेक्शन। गेटइनपुटस्ट्रीम ()); System.out.println ("संचार तैयार है।"); स्ट्रिंग संदेशऑट = "हैलो वर्ल्ड"; } }
  

चरण 13. संदेश भेजें।

आउटपुट स्ट्रीम में डेटा लिखें और यह सुनिश्चित करने के लिए स्ट्रीम फ्लश करें कि डेटा पूरी तरह से लिखा गया है।

• डेटा स्ट्रीम

  एक संदेश की लंबाई पहले भेजने की जरूरत है ताकि दूसरे पक्ष को पता चले कि उसे कितने बाइट्स पढ़ने की जरूरत है। लंबाई को एक आदिम पूर्णांक प्रकार के रूप में भेजे जाने के बाद, बाइट्स भेजे जा सकते हैं।

  आयात java.io. DataInputStream; आयात java.io. DataOutputStream; java.net. InetAddress आयात करें; आयात java.net. ServerSocket; आयात java.net. Socket; सार्वजनिक वर्ग NetworkAppExample {सार्वजनिक स्थैतिक शून्य मुख्य (स्ट्रिंग तर्क) अपवाद फेंकता है {स्ट्रिंग होस्ट = "लोकलहोस्ट"; इंट पोर्ट = 10430; सर्वर सॉकेट सर्वर = नया सर्वर सॉकेट (पोर्ट, 50, InetAddress.getByName (होस्ट)); System.out.println ("सर्वर शुरू हुआ।"); सॉकेट क्लाइंट = नया सॉकेट (होस्ट, पोर्ट); System.out.println ("सर्वर से कनेक्ट हो रहा है …"); सॉकेट कनेक्शन = सर्वर। स्वीकार (); System.out.println ("कनेक्शन स्थापित।"); डेटाऑटपुटस्ट्रीम क्लाइंटऑट = नया डेटाऑटपुटस्ट्रीम (क्लाइंट.गेटऑटपुटस्ट्रीम ()); डेटा इनपुटस्ट्रीम क्लाइंटइन = नया डेटा इनपुटस्ट्रीम (क्लाइंट.गेटइनपुटस्ट्रीम ()); डेटाऑटपुटस्ट्रीम सर्वरऑट = नया डेटाऑटपुटस्ट्रीम (कनेक्शन.गेटऑटपुटस्ट्रीम ()); डेटा इनपुटस्ट्रीम सर्वरइन = नया डेटा इनपुटस्ट्रीम (कनेक्शन। getInputStream ()); System.out.println ("संचार तैयार है।"); बाइट संदेशऑट = "हैलो वर्ल्ड"। गेटबाइट्स (); clientOut.writeInt (messageOut.length); क्लाइंटऑट.राइट (मैसेजऑट); क्लाइंटऑट। फ्लश (); } }
  

• वस्तु धाराएं

  आयात java.io. ObjectInputStream; आयात java.io. ObjectOutputStream; java.net. InetAddress आयात करें; आयात java.net. ServerSocket; आयात java.net. Socket; सार्वजनिक वर्ग NetworkAppExample {सार्वजनिक स्थैतिक शून्य मुख्य (स्ट्रिंग तर्क) अपवाद फेंकता है {स्ट्रिंग होस्ट = "लोकलहोस्ट"; इंट पोर्ट = 10430; सर्वर सॉकेट सर्वर = नया सर्वर सॉकेट (पोर्ट, 50, InetAddress.getByName (होस्ट)); System.out.println ("सर्वर शुरू हुआ।"); सॉकेट क्लाइंट = नया सॉकेट (होस्ट, पोर्ट); System.out.println ("सर्वर से कनेक्ट हो रहा है …"); सॉकेट कनेक्शन = सर्वर। स्वीकार (); System.out.println ("कनेक्शन स्थापित।"); ऑब्जेक्टऑटपुटस्ट्रीम क्लाइंटऑट = नया ऑब्जेक्टऑटपुटस्ट्रीम (क्लाइंट.गेटऑटपुटस्ट्रीम ()); ऑब्जेक्टऑटपुटस्ट्रीम सर्वरऑट = नया ऑब्जेक्टऑटपुटस्ट्रीम (कनेक्शन.गेटऑटपुटस्ट्रीम ()); ऑब्जेक्ट इनपुटस्ट्रीम क्लाइंटइन = नया ऑब्जेक्ट इनपुटस्ट्रीम (क्लाइंट.गेटइनपुटस्ट्रीम ()); ऑब्जेक्ट इनपुटस्ट्रीम सर्वरइन = नया ऑब्जेक्ट इनपुटस्ट्रीम (कनेक्शन। गेटइनपुटस्ट्रीम ()); System.out.println ("संचार तैयार है।"); स्ट्रिंग संदेशऑट = "हैलो वर्ल्ड"; क्लाइंटऑट.राइटऑब्जेक्ट (मैसेजऑट); क्लाइंटऑट। फ्लश (); } }
  

चरण 14. भेजे गए संदेश को लॉग करें।

लॉगिंग उद्देश्यों के लिए, कंसोल पर प्रिंट करें कि संदेश भेजा गया है।

• डेटा स्ट्रीम

  आयात java.io. DataInputStream; आयात java.io. DataOutputStream; java.net. InetAddress आयात करें; आयात java.net. ServerSocket; java.net. Socket आयात करें; सार्वजनिक वर्ग NetworkAppExample {सार्वजनिक स्थैतिक शून्य मुख्य (स्ट्रिंग तर्क) अपवाद फेंकता है {स्ट्रिंग होस्ट = "लोकलहोस्ट"; इंट पोर्ट = 10430; सर्वर सॉकेट सर्वर = नया सर्वर सॉकेट (पोर्ट, 50, InetAddress.getByName (होस्ट)); System.out.println ("सर्वर शुरू हुआ।"); सॉकेट क्लाइंट = नया सॉकेट (होस्ट, पोर्ट); System.out.println ("सर्वर से कनेक्ट हो रहा है …"); सॉकेट कनेक्शन = सर्वर। स्वीकार (); System.out.println ("कनेक्शन स्थापित।"); डेटाऑटपुटस्ट्रीम क्लाइंटऑट = नया डेटाऑटपुटस्ट्रीम (क्लाइंट.गेटऑटपुटस्ट्रीम ()); डेटा इनपुटस्ट्रीम क्लाइंटइन = नया डेटा इनपुटस्ट्रीम (क्लाइंट.गेटइनपुटस्ट्रीम ()); डेटाऑटपुटस्ट्रीम सर्वरऑट = नया डेटाऑटपुटस्ट्रीम (कनेक्शन.गेटऑटपुटस्ट्रीम ()); डेटा इनपुटस्ट्रीम सर्वरइन = नया डेटा इनपुटस्ट्रीम (कनेक्शन। getInputStream ()); System.out.println ("संचार तैयार है।"); बाइट संदेशऑट = "हैलो वर्ल्ड"। गेटबाइट्स (); clientOut.writeInt (messageOut.length); क्लाइंटऑट.राइट (मैसेजऑट); क्लाइंटऑट। फ्लश (); System.out.println ("सर्वर को संदेश भेजा गया:" + नया स्ट्रिंग (messageOut)); } }
  

• वस्तु धाराएं

  आयात java.io. ObjectInputStream; आयात java.io. ObjectOutputStream; java.net. InetAddress आयात करें; आयात java.net. ServerSocket; आयात java.net. Socket; सार्वजनिक वर्ग NetworkAppExample {सार्वजनिक स्थैतिक शून्य मुख्य (स्ट्रिंग तर्क) अपवाद फेंकता है {स्ट्रिंग होस्ट = "लोकलहोस्ट"; इंट पोर्ट = 10430; सर्वर सॉकेट सर्वर = नया सर्वर सॉकेट (पोर्ट, 50, InetAddress.getByName (होस्ट)); System.out.println ("सर्वर शुरू हुआ।"); सॉकेट क्लाइंट = नया सॉकेट (होस्ट, पोर्ट); System.out.println ("सर्वर से कनेक्ट हो रहा है …"); सॉकेट कनेक्शन = सर्वर। स्वीकार (); System.out.println ("कनेक्शन स्थापित।"); ऑब्जेक्टऑटपुटस्ट्रीम क्लाइंटऑट = नया ऑब्जेक्टऑटपुटस्ट्रीम (क्लाइंट.गेटऑटपुटस्ट्रीम ()); ऑब्जेक्टऑटपुटस्ट्रीम सर्वरऑट = नया ऑब्जेक्टऑटपुटस्ट्रीम (कनेक्शन.गेटऑटपुटस्ट्रीम ()); ऑब्जेक्ट इनपुटस्ट्रीम क्लाइंटइन = नया ऑब्जेक्ट इनपुटस्ट्रीम (क्लाइंट.गेटइनपुटस्ट्रीम ()); ऑब्जेक्ट इनपुटस्ट्रीम सर्वरइन = नया ऑब्जेक्ट इनपुटस्ट्रीम (कनेक्शन। गेटइनपुटस्ट्रीम ()); System.out.println ("संचार तैयार है।"); स्ट्रिंग संदेशऑट = "हैलो वर्ल्ड"; क्लाइंटऑट.राइटऑब्जेक्ट (मैसेजऑट); क्लाइंटऑट। फ्लश (); System.out.println ("सर्वर को संदेश भेजा गया:" + messageOut); } }
  

चरण 15. संदेश पढ़ें।

इनपुट स्ट्रीम से डेटा पढ़ें और उसे कन्वर्ट करें। चूंकि हम वास्तव में भेजे गए डेटा के प्रकार को जानते हैं, इसलिए हम या तो एक बना देंगे

डोरी

से

बाइट

या कास्ट

वस्तु

प्रति

डोरी

उपयोग की गई धारा के आधार पर, जाँच किए बिना।

• डेटा स्ट्रीम

  चूंकि लंबाई पहले भेजी गई थी और बाद में बाइट्स, उसी क्रम में पढ़ना होगा। यदि लंबाई शून्य है, तो पढ़ने के लिए कुछ भी नहीं है। ऑब्जेक्ट deserialized है जब बाइट्स को एक उदाहरण में वापस परिवर्तित किया जाता है, इस मामले में, of

  डोरी

  आयात java.io. DataInputStream; आयात java.io. DataOutputStream; java.net. InetAddress आयात करें; आयात java.net. ServerSocket; आयात java.net. Socket; सार्वजनिक वर्ग NetworkAppExample {सार्वजनिक स्थैतिक शून्य मुख्य (स्ट्रिंग तर्क) अपवाद फेंकता है {स्ट्रिंग होस्ट = "लोकलहोस्ट"; इंट पोर्ट = 10430; सर्वर सॉकेट सर्वर = नया सर्वर सॉकेट (पोर्ट, 50, InetAddress.getByName (होस्ट)); System.out.println ("सर्वर शुरू हुआ।"); सॉकेट क्लाइंट = नया सॉकेट (होस्ट, पोर्ट); System.out.println ("सर्वर से कनेक्ट हो रहा है …"); सॉकेट कनेक्शन = सर्वर। स्वीकार (); System.out.println ("कनेक्शन स्थापित।"); डेटाऑटपुटस्ट्रीम क्लाइंटऑट = नया डेटाऑटपुटस्ट्रीम (क्लाइंट.गेटऑटपुटस्ट्रीम ()); डेटा इनपुटस्ट्रीम क्लाइंटइन = नया डेटा इनपुटस्ट्रीम (क्लाइंट.गेटइनपुटस्ट्रीम ()); डेटाऑटपुटस्ट्रीम सर्वरऑट = नया डेटाऑटपुटस्ट्रीम (कनेक्शन.गेटऑटपुटस्ट्रीम ()); डेटा इनपुटस्ट्रीम सर्वरइन = नया डेटा इनपुटस्ट्रीम (कनेक्शन। getInputStream ()); System.out.println ("संचार तैयार है।"); बाइट संदेशऑट = "हैलो वर्ल्ड"। गेटबाइट्स (); clientOut.writeInt (messageOut.length); क्लाइंटऑट.राइट (मैसेजऑट); क्लाइंटऑट। फ्लश (); System.out.println ("सर्वर को संदेश भेजा गया:" + नया स्ट्रिंग (messageOut)); int लंबाई = serverIn.readInt (); अगर (लंबाई> 0) {बाइट संदेश में = नया बाइट [लंबाई]; serverIn.readFully (messageIn, 0, messageIn.length); } } }
  

• वस्तु धाराएं

  आयात java.io. ObjectInputStream; आयात java.io. ObjectOutputStream; java.net. InetAddress आयात करें; आयात java.net. ServerSocket; आयात java.net. Socket; सार्वजनिक वर्ग NetworkAppExample {सार्वजनिक स्थैतिक शून्य मुख्य (स्ट्रिंग तर्क) अपवाद फेंकता है {स्ट्रिंग होस्ट = "लोकलहोस्ट"; इंट पोर्ट = 10430; सर्वर सॉकेट सर्वर = नया सर्वर सॉकेट (पोर्ट, 50, InetAddress.getByName (होस्ट)); System.out.println ("सर्वर शुरू हुआ।"); सॉकेट क्लाइंट = नया सॉकेट (होस्ट, पोर्ट); System.out.println ("सर्वर से कनेक्ट हो रहा है …"); सॉकेट कनेक्शन = सर्वर। स्वीकार (); System.out.println ("कनेक्शन स्थापित।"); ऑब्जेक्टऑटपुटस्ट्रीम क्लाइंटऑट = नया ऑब्जेक्टऑटपुटस्ट्रीम (क्लाइंट.गेटऑटपुटस्ट्रीम ()); ऑब्जेक्टऑटपुटस्ट्रीम सर्वरऑट = नया ऑब्जेक्टऑटपुटस्ट्रीम (कनेक्शन.गेटऑटपुटस्ट्रीम ()); ऑब्जेक्ट इनपुटस्ट्रीम क्लाइंटइन = नया ऑब्जेक्ट इनपुटस्ट्रीम (क्लाइंट.गेटइनपुटस्ट्रीम ()); ऑब्जेक्ट इनपुटस्ट्रीम सर्वरइन = नया ऑब्जेक्ट इनपुटस्ट्रीम (कनेक्शन। गेटइनपुटस्ट्रीम ()); System.out.println ("संचार तैयार है।"); स्ट्रिंग संदेशऑट = "हैलो वर्ल्ड"; क्लाइंटऑट.राइटऑब्जेक्ट (मैसेजऑट); क्लाइंटऑट। फ्लश (); System.out.println ("सर्वर को संदेश भेजा गया:" + messageOut); स्ट्रिंग संदेशइन = (स्ट्रिंग) सर्वरइन.रीडऑब्जेक्ट (); } }
  

चरण 16. लॉग पढ़ें संदेश।

लॉगिंग उद्देश्यों के लिए, कंसोल पर प्रिंट करें कि संदेश प्राप्त हुआ है और इसकी सामग्री प्रिंट करें।

• डेटा स्ट्रीम

  आयात java.io. DataInputStream; आयात java.io. DataOutputStream; java.net. InetAddress आयात करें; आयात java.net. ServerSocket; आयात java.net. Socket; सार्वजनिक वर्ग NetworkAppExample {सार्वजनिक स्थैतिक शून्य मुख्य (स्ट्रिंग तर्क) अपवाद फेंकता है {स्ट्रिंग होस्ट = "लोकलहोस्ट"; इंट पोर्ट = 10430; सर्वर सॉकेट सर्वर = नया सर्वर सॉकेट (पोर्ट, 50, InetAddress.getByName (होस्ट)); System.out.println ("सर्वर शुरू हुआ।"); सॉकेट क्लाइंट = नया सॉकेट (होस्ट, पोर्ट); System.out.println ("सर्वर से कनेक्ट हो रहा है …"); सॉकेट कनेक्शन = सर्वर। स्वीकार (); System.out.println ("कनेक्शन स्थापित।"); डेटाऑटपुटस्ट्रीम क्लाइंटऑट = नया डेटाऑटपुटस्ट्रीम (क्लाइंट.गेटऑटपुटस्ट्रीम ()); डेटा इनपुटस्ट्रीम क्लाइंटइन = नया डेटा इनपुटस्ट्रीम (क्लाइंट.गेटइनपुटस्ट्रीम ()); डेटाऑटपुटस्ट्रीम सर्वरऑट = नया डेटाऑटपुटस्ट्रीम (कनेक्शन.गेटऑटपुटस्ट्रीम ()); डेटा इनपुटस्ट्रीम सर्वरइन = नया डेटा इनपुटस्ट्रीम (कनेक्शन। getInputStream ()); System.out.println ("संचार तैयार है।"); बाइट संदेशऑट = "हैलो वर्ल्ड"। गेटबाइट्स (); clientOut.writeInt (messageOut.length); क्लाइंटऑट.राइट (मैसेजऑट); क्लाइंटऑट। फ्लश (); System.out.println ("सर्वर को संदेश भेजा गया:" + नया स्ट्रिंग (messageOut)); int लंबाई = serverIn.readInt (); अगर (लंबाई> 0) {बाइट संदेश में = नया बाइट [लंबाई]; serverIn.readFully (messageIn, 0, messageIn.length); System.out.println ("क्लाइंट से प्राप्त संदेश:" + नया स्ट्रिंग (messageIn)); } } }
  

• वस्तु धाराएं

  आयात java.io. ObjectInputStream; आयात java.io. ObjectOutputStream; java.net. InetAddress आयात करें; आयात java.net. ServerSocket; आयात java.net. Socket; सार्वजनिक वर्ग NetworkAppExample {सार्वजनिक स्थैतिक शून्य मुख्य (स्ट्रिंग तर्क) अपवाद फेंकता है {स्ट्रिंग होस्ट = "लोकलहोस्ट"; इंट पोर्ट = 10430; सर्वर सॉकेट सर्वर = नया सर्वर सॉकेट (पोर्ट, 50, InetAddress.getByName (होस्ट)); System.out.println ("सर्वर शुरू हुआ।"); सॉकेट क्लाइंट = नया सॉकेट (होस्ट, पोर्ट); System.out.println ("सर्वर से कनेक्ट हो रहा है …"); सॉकेट कनेक्शन = सर्वर। स्वीकार (); System.out.println ("कनेक्शन स्थापित।"); ऑब्जेक्टऑटपुटस्ट्रीम क्लाइंटऑट = नया ऑब्जेक्टऑटपुटस्ट्रीम (क्लाइंट.गेटऑटपुटस्ट्रीम ()); ऑब्जेक्टऑटपुटस्ट्रीम सर्वरऑट = नया ऑब्जेक्टऑटपुटस्ट्रीम (कनेक्शन.गेटऑटपुटस्ट्रीम ()); ऑब्जेक्ट इनपुटस्ट्रीम क्लाइंटइन = नया ऑब्जेक्ट इनपुटस्ट्रीम (क्लाइंट.गेटइनपुटस्ट्रीम ()); ऑब्जेक्ट इनपुटस्ट्रीम सर्वरइन = नया ऑब्जेक्ट इनपुटस्ट्रीम (कनेक्शन। गेटइनपुटस्ट्रीम ()); System.out.println ("संचार तैयार है।"); स्ट्रिंग संदेशऑट = "हैलो वर्ल्ड"; क्लाइंटऑट.राइटऑब्जेक्ट (मैसेजऑट); क्लाइंटऑट। फ्लश (); System.out.println ("सर्वर को संदेश भेजा गया:" + messageOut); स्ट्रिंग संदेशइन = (स्ट्रिंग) सर्वरइन.रीडऑब्जेक्ट (); System.out.println ("क्लाइंट से प्राप्त संदेश:" + messageIn); } }
  

चरण 17. कनेक्शन डिस्कनेक्ट करें।

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

// कोड छोड़ा गया आयात java.net. InetAddress; आयात java.net. ServerSocket; आयात java.net. Socket; सार्वजनिक वर्ग NetworkAppExample {सार्वजनिक स्थैतिक शून्य मुख्य (स्ट्रिंग तर्क) अपवाद फेंकता है {स्ट्रिंग होस्ट = "लोकलहोस्ट"; इंट पोर्ट = 10430; सर्वर सॉकेट सर्वर = नया सर्वर सॉकेट (पोर्ट, 50, InetAddress.getByName (होस्ट)); System.out.println ("सर्वर शुरू हुआ।"); सॉकेट क्लाइंट = नया सॉकेट (होस्ट, पोर्ट); System.out.println ("सर्वर से कनेक्ट हो रहा है …"); सॉकेट कनेक्शन = सर्वर। स्वीकार (); System.out.println ("कनेक्शन स्थापित।"); // कोड छोड़ा गया System.out.println ("संचार तैयार है।"); // कोड छोड़ा गया clientOut.close (); सर्वरऑट.क्लोज़ (); } }

चरण 18. लॉग वियोग।

लॉगिंग उद्देश्यों के लिए, कंसोल कनेक्शन पर प्रिंट डिस्कनेक्ट कर दिया गया है।

// कोड छोड़ा गया आयात java.net. InetAddress; आयात java.net. ServerSocket; आयात java.net. Socket; सार्वजनिक वर्ग NetworkAppExample {सार्वजनिक स्थैतिक शून्य मुख्य (स्ट्रिंग तर्क) अपवाद फेंकता है {स्ट्रिंग होस्ट = "लोकलहोस्ट"; इंट पोर्ट = 10430; सर्वर सॉकेट सर्वर = नया सर्वर सॉकेट (पोर्ट, 50, InetAddress.getByName (होस्ट)); System.out.println ("सर्वर शुरू हुआ।"); सॉकेट क्लाइंट = नया सॉकेट (होस्ट, पोर्ट); System.out.println ("सर्वर से कनेक्ट हो रहा है …"); सॉकेट कनेक्शन = सर्वर। स्वीकार (); System.out.println ("कनेक्शन स्थापित।"); // कोड छोड़ा गया System.out.println ("संचार तैयार है।"); // कोड छोड़ा गया clientOut.close (); सर्वरऑट.क्लोज़ (); System.out.println ("कनेक्शन बंद हो गया।"); } }

चरण 19. सर्वर को समाप्त करें।

कनेक्शन काट दिए गए हैं, लेकिन सर्वर अभी भी चालू है और चल रहा है। जैसा

सर्वर सॉकेट

किसी भी स्ट्रीम से संबद्ध नहीं है, इसे कॉल करके स्पष्ट रूप से बंद करने की आवश्यकता है

बंद करे()

तरीका।

// कोड छोड़ा गया आयात java.net. InetAddress; आयात java.net. ServerSocket; आयात java.net. Socket; सार्वजनिक वर्ग NetworkAppExample {सार्वजनिक स्थैतिक शून्य मुख्य (स्ट्रिंग तर्क) अपवाद फेंकता है {स्ट्रिंग होस्ट = "लोकलहोस्ट"; इंट पोर्ट = 10430; सर्वर सॉकेट सर्वर = नया सर्वर सॉकेट (पोर्ट, 50, InetAddress.getByName (होस्ट)); System.out.println ("सर्वर शुरू हुआ।"); सॉकेट क्लाइंट = नया सॉकेट (होस्ट, पोर्ट); System.out.println ("सर्वर से कनेक्ट हो रहा है …"); सॉकेट कनेक्शन = सर्वर। स्वीकार (); System.out.println ("कनेक्शन स्थापित।"); // कोड छोड़ा गया System.out.println ("संचार तैयार है।"); // कोड छोड़ा गया clientOut.close (); सर्वरऑट.क्लोज़ (); System.out.println ("कनेक्शन बंद हो गया।"); सर्वर.क्लोज़ (); } }

चरण 20. लॉग सर्वर समाप्ति।

लॉगिंग उद्देश्यों के लिए, कंसोल सर्वर पर प्रिंट को समाप्त कर दिया गया है।

// कोड छोड़ा गया आयात java.net. InetAddress; आयात java.net. ServerSocket; आयात java.net. Socket; सार्वजनिक वर्ग NetworkAppExample {सार्वजनिक स्थैतिक शून्य मुख्य (स्ट्रिंग तर्क) अपवाद फेंकता है {स्ट्रिंग होस्ट = "लोकलहोस्ट"; इंट पोर्ट = 10430; सर्वर सॉकेट सर्वर = नया सर्वर सॉकेट (पोर्ट, 50, InetAddress.getByName (होस्ट)); System.out.println ("सर्वर शुरू हुआ।"); सॉकेट क्लाइंट = नया सॉकेट (होस्ट, पोर्ट); System.out.println ("सर्वर से कनेक्ट हो रहा है …"); सॉकेट कनेक्शन = सर्वर। स्वीकार (); System.out.println ("कनेक्शन स्थापित।"); // कोड छोड़ा गया System.out.println ("संचार तैयार है।"); // कोड छोड़ा गया clientOut.close (); सर्वरऑट.क्लोज़ (); System.out.println ("कनेक्शन बंद हो गया।"); सर्वर.क्लोज़ (); System.out.println ("सर्वर समाप्त हो गया।"); } }

चरण 21. संकलित करें और चलाएं।

लॉगिंग ने हमें यह जानने में सक्षम किया कि आवेदन सफल हुआ या नहीं। अपेक्षित उत्पादन:

सर्वर शुरू हुआ। सर्वर से कनेक्ट हो रहा है… कनेक्शन स्थापित हो गया है. संचार तैयार है। सर्वर को संदेश भेजा गया: हैलो वर्ल्ड क्लाइंट से प्राप्त संदेश: हैलो वर्ल्ड कनेक्शन बंद। सर्वर समाप्त।

यदि आपका आउटपुट ऊपर वाले की तरह नहीं है, जो होने की संभावना नहीं है, तो कुछ समाधान हैं:

• यदि आउटपुट लाइन पर रुक जाता है

  कनेक्शन स्थापित।

  और ऑब्जेक्ट स्ट्रीम का उपयोग किया जाता है, प्रत्येक को फ्लश करें

  ऑब्जेक्टऑटपुटस्ट्रीम

• आरंभीकरण के तुरंत बाद क्योंकि हेडर, किसी कारण से, नहीं भेजे गए थे।

• यदि आउटपुट प्रिंट करता है

  java.net. BindException: पता पहले से प्रयोग में है

• कोई भिन्न पोर्ट नंबर चुनें क्योंकि निर्दिष्ट किया गया पहले से ही उपयोग किया जा चुका है।

टिप्स

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

उदाहरण

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

सर्वर.जावा

java.io. IOException आयात करें; java.net. InetAddress आयात करें; आयात java.net. ServerSocket; आयात java.net. SocketException; आयात java.net. UnknownHostException; आयात java.util. ArrayList; आयात java.util. Collections; आयात java.util. List; /** * वर्ग {@code Server} एक नेटवर्क में एक सर्वर एंड-पॉइंट का प्रतिनिधित्व करता है। {@code Server} एक बार एक निश्चित IP * पते और पोर्ट से जुड़ जाने के बाद, क्लाइंट के साथ संबंध स्थापित करता है और उनके साथ संचार करने या उन्हें डिस्कनेक्ट करने में सक्षम होता है। *
* यह वर्ग थ्रेडसेफ है। * * @ संस्करण 1.0 * @ क्लाइंट देखें * @ कनेक्शन देखें * / पब्लिक क्लास सर्वर रननेबल {निजी सर्वर सॉकेट सर्वर लागू करता है; निजी सूची सम्बन्ध; निजी धागा धागा; निजी अंतिम वस्तु कनेक्शन लॉक = नई वस्तु (); /** * एक {@code सर्वर} का निर्माण करता है जो निर्दिष्ट होस्ट नाम पर क्लाइंट के साथ इंटरैक्ट करता है और आने वाले क्लाइंट की कतार की निर्दिष्ट * अनुरोधित अधिकतम लंबाई के साथ पोर्ट करता है। * * @param होस्ट होस्ट पता उपयोग करने के लिए। * @ अपरम पोर्ट पोर्ट नंबर उपयोग करने के लिए। * @ अपरम बैकलॉग आने वाले ग्राहकों की कतार की अधिकतम लंबाई का अनुरोध किया। * @ नेटवर्क अपवाद फेंकता है यदि सर्वर शुरू करते समय त्रुटि होती है। */ सार्वजनिक सर्वर (स्ट्रिंग होस्ट, इंट पोर्ट, इंट बैकलॉग) नेटवर्क अपवाद फेंकता है {कोशिश करें {सर्वर = नया सर्वर सॉकेट (पोर्ट, बैकलॉग, InetAddress.getByName (होस्ट)); } पकड़ें (अज्ञातहोस्ट अपवाद ई) {नया नेटवर्क अपवाद फेंकें ("होस्ट नाम हल नहीं किया जा सका:" + होस्ट, ई); } पकड़ें (IllegalArgumentException e) { नया NetworkException फेंकें ("पोर्ट नंबर 0 और 65535 के बीच होना चाहिए (समावेशी):" + पोर्ट); } पकड़ें (IOException e) { नया NetworkException फेंकें ("सर्वर प्रारंभ नहीं किया जा सका।", e); } कनेक्शन = Collections.synchronizedList (नया ArrayList ()); धागा = नया धागा (यह); थ्रेड.स्टार्ट (); } /** * एक {@code सर्वर} का निर्माण करता है जो निर्दिष्ट होस्ट नाम और पोर्ट पर क्लाइंट के साथ इंटरैक्ट करता है। * *@परम होस्ट होस्ट एड्रेस बाइंड करने के लिए। * @ अपरम पोर्ट पोर्ट नंबर बाइंड करने के लिए। * @ नेटवर्क अपवाद फेंकता है यदि सर्वर शुरू करते समय त्रुटियां होती हैं। */ सार्वजनिक सर्वर (स्ट्रिंग होस्ट, इंट पोर्ट) नेटवर्क अपवाद फेंकता है {यह (होस्ट, पोर्ट, 50); } /** * क्लाइंट से आने वाले कनेक्शन को सुनता है, स्वीकार करता है और पंजीकृत करता है। */ @ ओवरराइड सार्वजनिक शून्य रन () {जबकि (! सर्वर। बंद ()) {कोशिश करें {कनेक्शन। जोड़ें (नया कनेक्शन (सर्वर। स्वीकार ())); } कैच (सॉकेट एक्सेप्शन ई) { अगर (!e.getMessage().equals("Socket Closed")) { e.printStackTrace(); } } पकड़ें (नेटवर्क अपवाद | IOException e) { e.printStackTrace (); } } } /** * सभी पंजीकृत ग्राहकों को डेटा भेजता है। * * @param डेटा डेटा भेजने के लिए। * @IllegalStateException फेंकता है यदि सर्वर ऑफ़लाइन होने पर डेटा लिखने का प्रयास किया जाता है। * @ IllegalArgumentException फेंकता है यदि भेजने के लिए डेटा शून्य है। */ सार्वजनिक शून्य प्रसारण (ऑब्जेक्ट डेटा) {if (server.isClosed ()) {नया IllegalStateException फेंकें ("डेटा नहीं भेजा गया, सर्वर ऑफ़लाइन है।"); } अगर (डेटा == अशक्त) {नया IllegalArgumentException ("शून्य डेटा"); } सिंक्रनाइज़ (कनेक्शन लॉक) {के लिए (कनेक्शन कनेक्शन: कनेक्शन) {कोशिश करें {कनेक्शन। भेजें (डेटा); System.out.println ("क्लाइंट को सफलतापूर्वक भेजा गया डेटा।"); } पकड़ें (नेटवर्क अपवाद ई) { ई.प्रिंटस्टैकट्रेस (); } } } } /** * एक डिस्कनेक्शन संदेश भेजता है और निर्दिष्ट क्लाइंट को डिस्कनेक्ट करता है। * * @param कनेक्शन क्लाइंट डिस्कनेक्ट करने के लिए। * @ नेटवर्क अपवाद फेंकता है यदि कनेक्शन बंद करते समय त्रुटि होती है। */ सार्वजनिक शून्य डिस्कनेक्ट (कनेक्शन कनेक्शन) नेटवर्क अपवाद फेंकता है {अगर (कनेक्शन। हटाएं (कनेक्शन)) {कनेक्शन। बंद करें (); } } /** * सभी क्लाइंट को एक डिस्कनेक्शन संदेश भेजता है, उन्हें डिस्कनेक्ट करता है और सर्वर को समाप्त करता है। */सार्वजनिक शून्य बंद () नेटवर्क अपवाद फेंकता है {सिंक्रनाइज़ (कनेक्शन लॉक) {के लिए (कनेक्शन कनेक्शन: कनेक्शन) {कोशिश {कनेक्शन। बंद करें (); } पकड़ें (नेटवर्क अपवाद ई) { ई.प्रिंटस्टैकट्रेस (); } } } कनेक्शन। स्पष्ट (); कोशिश करें {सर्वर। बंद करें (); } पकड़ें (IOException e) {नया NetworkException फेंकें ("सर्वर बंद करते समय त्रुटि।"); } अंत में { थ्रेड.इंटरप्ट (); } } /** * देता है कि सर्वर ऑनलाइन है या नहीं। * *@रिटर्न ट्रू अगर सर्वर ऑनलाइन है। झूठा, अन्यथा। */ सार्वजनिक बूलियन ऑनलाइन है () {वापसी! सर्वर। बंद (); } /** * पंजीकृत ग्राहकों की एक सरणी देता है। */ सार्वजनिक कनेक्शन getConnections () {सिंक्रनाइज़ (कनेक्शन लॉक) {वापसी कनेक्शन। toArray (नया कनेक्शन [कनेक्शन। आकार ()]); } } } 

क्लाइंट.जावा

java.io. IOException आयात करें; आयात java.net. Socket; आयात java.net. UnknownHostException; /** * वर्ग {@code Client} एक नेटवर्क में क्लाइंट एंड-पॉइंट का प्रतिनिधित्व करता है। {@code Client}, एक बार एक निश्चित * सर्वर से कनेक्ट होने के बाद, केवल सर्वर के साथ संचार करने में सक्षम होने की गारंटी है। अन्य क्लाइंट डेटा प्राप्त करते हैं या नहीं * सर्वर कार्यान्वयन पर निर्भर करता है। *
* यह वर्ग थ्रेडसेफ है। * * @ संस्करण 1.0 * @ सर्वर देखें * @ कनेक्शन देखें * / पब्लिक क्लास क्लाइंट {निजी कनेक्शन कनेक्शन; /** * निर्दिष्ट होस्ट और पोर्ट पर सर्वर से जुड़े एक {@code क्लाइंट} का निर्माण करता है। * *@परम होस्ट होस्ट एड्रेस बाइंड करने के लिए। * @ अपरम पोर्ट पोर्ट नंबर बाइंड करने के लिए। * @ नेटवर्क अपवाद फेंकता है यदि सर्वर शुरू करते समय त्रुटि होती है। */ सार्वजनिक क्लाइंट (स्ट्रिंग होस्ट, इंट पोर्ट) नेटवर्क अपवाद फेंकता है {कोशिश करें {कनेक्शन = नया कनेक्शन (नया सॉकेट (होस्ट, पोर्ट)); } पकड़ें (अज्ञातहोस्ट अपवाद ई) {नया नेटवर्क अपवाद फेंकें ("होस्ट नाम हल नहीं किया जा सका:" + होस्ट, ई); } पकड़ें (IllegalArgumentException e) { नया NetworkException फेंकें ("पोर्ट नंबर 0 और 65535 के बीच होना चाहिए (समावेशी):" + पोर्ट); } पकड़ें (IOException e) { नया NetworkException फेंकें ("सर्वर प्रारंभ नहीं किया जा सका।", e); } } /** * दूसरे पक्ष को डेटा भेजता है। * * @param डेटा डेटा भेजने के लिए। * @ नेटवर्क अपवाद फेंकता है यदि आउटपुट स्ट्रीम में लिखना विफल रहता है। * @IllegalStateException फेंकता है यदि कनेक्शन बंद होने पर डेटा लिखने का प्रयास किया जाता है। * @ IllegalArgumentException फेंकता है यदि भेजने के लिए डेटा शून्य है। * @ असमर्थित ऑपरेशन अपवाद फेंकता है यदि असमर्थित डेटा प्रकार भेजने का प्रयास किया जाता है। */ सार्वजनिक शून्य भेजें (ऑब्जेक्ट डेटा) नेटवर्क अपवाद फेंकता है {कनेक्शन। भेजें (डेटा); } /** * सर्वर को एक डिस्कनेक्शन संदेश भेजता है, और उसके साथ कनेक्शन बंद कर देता है। */ सार्वजनिक शून्य बंद () NetworkException फेंकता है {connection.close (); } /** * लौटाता है कि क्लाइंट सर्वर से जुड़ा है या नहीं। * * @ रिटर्न सही है अगर क्लाइंट जुड़ा हुआ है। झूठा, अन्यथा। */ सार्वजनिक बूलियन ऑनलाइन है () {वापसी कनेक्शन। कनेक्ट किया गया (); } /** * क्लाइंट का {@link कनेक्शन} इंस्टेंस लौटाता है। */ सार्वजनिक कनेक्शन getConnection () {वापसी कनेक्शन; } }

कनेक्शन.जावा

आयात java.io. DataInputStream; आयात java.io. DataOutputStream; java.io. IOException आयात करें; आयात java.net. Socket; आयात java.net. SocketException; /** * वर्ग {@code Connection} या तो सर्वर से क्लाइंट के लिए कनेक्शन या नेटवर्क में क्लाइंट एंड-पॉइंट का प्रतिनिधित्व करता है * {@code कनेक्शन}, एक बार कनेक्ट होने के बाद, अन्य पार्टी या पार्टियों के साथ डेटा का आदान-प्रदान करने में सक्षम है, यह निर्भर करता है एक सर्वर पर * कार्यान्वयन। *
* यह वर्ग थ्रेडसेफ है। * * @ संस्करण 1.0 * @ सर्वर देखें * @ क्लाइंट देखें * / पब्लिक क्लास कनेक्शन रननेबल {निजी सॉकेट सॉकेट लागू करता है; निजी डेटाऑटपुटस्ट्रीम आउट; निजी डेटा इनपुटस्ट्रीम में; निजी धागा धागा; निजी अंतिम वस्तु राइटलॉक = नई वस्तु (); निजी अंतिम वस्तु रीडलॉक = नई वस्तु (); /** * निर्दिष्ट {@link Socket} की स्ट्रीम का उपयोग करके {@code Connection} का निर्माण करता है। * * @param सॉकेट से धाराएँ लाने के लिए सॉकेट।*/ सार्वजनिक कनेक्शन (सॉकेट सॉकेट) NetworkException फेंकता है {if (सॉकेट == नल) {नया IllegalArgumentException ("नल सॉकेट"); } this.socket = सॉकेट; कोशिश करें {बाहर = नया डेटाऑटपुटस्ट्रीम (सॉकेट.गेटऑटपुटस्ट्रीम ()); } पकड़ें (आईओएक्सप्शन ई) {नया नेटवर्क अपवाद फेंकें ("आउटपुट स्ट्रीम तक नहीं पहुंच सका।", ई); } कोशिश करें {in = new DataInputStream (सॉकेट.getInputStream ()); } पकड़ें (आईओएक्सप्शन ई) {नया नेटवर्क अपवाद फेंकें ("इनपुट स्ट्रीम तक नहीं पहुंच सका।", ई); } धागा = नया धागा (यह); थ्रेड.स्टार्ट (); } /** * दूसरे पक्ष के साथ संबंध होने पर संदेश पढ़ता है। */ @ ओवरराइड सार्वजनिक शून्य रन () {जबकि (! सॉकेट। बंद ()) {कोशिश {int पहचानकर्ता; बाइट बाइट्स; सिंक्रनाइज़ (रीडलॉक) {पहचानकर्ता = in.readInt (); int लंबाई = in.readInt (); अगर (लंबाई> 0) {बाइट्स = नया बाइट [लंबाई]; in.readFully (बाइट्स, 0, बाइट्स। लम्बाई); } और { जारी रखें; } } स्विच (पहचानकर्ता) {केस पहचानकर्ता। आंतरिक: स्ट्रिंग कमांड = नया स्ट्रिंग (बाइट्स); if (command.equals("disconnect")) {if (!socket.isClosed()) { System.out.println ("डिस्कनेक्शन पैकेट प्राप्त हुआ।"); कोशिश करें {बंद करें (); } पकड़ें (नेटवर्क अपवाद ई) {वापसी; } } } टूटना; केस आइडेंटिफ़ायर। टेक्स्ट: System.out.println ("संदेश प्राप्त हुआ:" + नया स्ट्रिंग (बाइट्स)); टूटना; डिफ़ॉल्ट: System.out.println ("अपरिचित डेटा प्राप्त हुआ।"); } } कैच (सॉकेट एक्सेप्शन ई) {if (!e.getMessage().equals("Socket Closed")) { e.printStackTrace(); } } कैच (IOException e) { e.printStackTrace (); } } } /** * दूसरे पक्ष को डेटा भेजता है। * * @param डेटा डेटा भेजने के लिए। * @ नेटवर्क अपवाद फेंकता है यदि आउटपुट स्ट्रीम में लिखना विफल रहता है। * @IllegalStateException फेंकता है यदि कनेक्शन बंद होने पर डेटा लिखने का प्रयास किया जाता है। * @ IllegalArgumentException फेंकता है यदि भेजने के लिए डेटा शून्य है। * @ असमर्थित ऑपरेशन अपवाद फेंकता है यदि असमर्थित डेटा प्रकार भेजने का प्रयास किया जाता है। */ सार्वजनिक शून्य भेजें (ऑब्जेक्ट डेटा) NetworkException फेंकता है {if (socket.isClosed ()) {नया IllegalStateException फेंकें ("डेटा नहीं भेजा गया, कनेक्शन बंद है।"); } अगर (डेटा == अशक्त) {नया IllegalArgumentException ("शून्य डेटा"); } अंतर पहचानकर्ता; बाइट बाइट्स; अगर (स्ट्रिंग का डेटा उदाहरण) {पहचानकर्ता = पहचानकर्ता। टेक्स्ट; बाइट्स = ((स्ट्रिंग) डेटा)। getBytes (); } और { नया UnsupportedOperationException फेंकें ("असमर्थित डेटा प्रकार:" + data.getClass ()); } कोशिश करें {सिंक्रनाइज़ (राइटलॉक) {out.writeInt (पहचानकर्ता); out.writeInt (बाइट्स। लम्बाई); आउट.राइट (बाइट्स); आउट.फ्लश (); } } पकड़ें (IOException e) { नया NetworkException फेंकें ("डेटा नहीं भेजा जा सका।", e); } } /** * दूसरे पक्ष को एक डिस्कनेक्शन संदेश भेजता है, और उसके साथ संबंध बंद कर देता है। */ सार्वजनिक शून्य बंद () NetworkException फेंकता है {if (socket.isClosed ()) {नया IllegalStateException फेंकें ("कनेक्शन पहले से ही बंद है।"); } कोशिश करें {बाइट संदेश = "डिस्कनेक्ट"। getBytes (); सिंक्रनाइज़ (राइटलॉक) {out.writeInt(Identifier. INTERNAL); out.writeInt(message.length); आउट.राइट (संदेश); आउट.फ्लश (); } } पकड़ें (IOException e) { System.out.println ("डिस्कनेक्शन संदेश नहीं भेजा जा सका।"); } कोशिश करें {सिंक्रनाइज़ (राइटलॉक) { आउट.क्लोज़ (); } } पकड़ें (IOException e) { नया NetworkException फेंकें ("कनेक्शन बंद करते समय त्रुटि।", e); } अंत में { थ्रेड.इंटरप्ट (); } } /** * लौटाता है कि दूसरे पक्ष से कनेक्शन जीवित है या नहीं। * * @ वापसी सही है अगर कनेक्शन जीवित है। झूठा, अन्यथा। */सार्वजनिक बूलियन कनेक्टेड है () {वापसी !socket.isClosed(); } }

पहचानकर्ता.जावा

/** * वर्ग {@code Identifier} में नेटवर्क पर भेजे गए डेटा * को क्रमबद्ध और अक्रमांकन करने के लिए {@link कनेक्शन} द्वारा उपयोग किए जाने वाले स्थिरांक होते हैं। * * @ संस्करण 1.0 * @ कनेक्शन देखें */ सार्वजनिक अंतिम श्रेणी पहचानकर्ता {/** * आंतरिक संदेशों के लिए पहचानकर्ता। */ सार्वजनिक स्थैतिक अंतिम int INTERNAL = 1; /** * टेक्स्ट संदेशों के लिए पहचानकर्ता। */सार्वजनिक स्थिर अंतिम इंट टेक्स्ट = 2; }

NetworkException.java

/** * वर्ग {@code NetworkException} नेटवर्क से संबंधित त्रुटि को इंगित करता है। */ पब्लिक क्लास नेटवर्कएक्सप्शन एक्सेप्शन को बढ़ाता है {/** * {@code NetworkException} को {@code null} के साथ इसके मैसेज के रूप में कंस्ट्रक्ट करता है। */ public NetworkException() { } /** * निर्दिष्ट संदेश के साथ एक {@code NetworkException} का निर्माण करता है। * * @परम संदेश त्रुटि का वर्णन करने के लिए एक संदेश। */ सार्वजनिक नेटवर्क अपवाद (स्ट्रिंग संदेश) {सुपर (संदेश); } /** * निर्दिष्ट संदेश और कारण के साथ एक {@code NetworkException} का निर्माण करता है। * * @param संदेश त्रुटि का वर्णन करने के लिए एक संदेश। * @ अपरम कारण त्रुटि का कारण है। */ सार्वजनिक नेटवर्क अपवाद (स्ट्रिंग संदेश, फेंकने योग्य कारण) {सुपर (संदेश, कारण); } /** * निर्दिष्ट कारण से एक {@code NetworkException} का निर्माण करता है। * *@परम कारण त्रुटि का कारण है। */ सार्वजनिक नेटवर्क अपवाद (फेंकने योग्य कारण) {सुपर (कारण); } }

उपयोगउदाहरण.जावा

/** * वर्ग {@code UseExample} {@link Server} और {@link Client} के उपयोग को दर्शाता है। यह उदाहरण प्रत्येक खंड को निष्पादित करने के लिए * {@link Thread#sleep(long)} का उपयोग करता है क्योंकि जल्दी से शुरू और बंद होने से कुछ * सेगमेंट निष्पादित नहीं होते हैं। * * @ संस्करण 1.0 * @ सर्वर देखें * @ क्लाइंट देखें * / सार्वजनिक वर्ग उपयोग उदाहरण {सार्वजनिक स्थैतिक शून्य मुख्य (स्ट्रिंग तर्क) अपवाद फेंकता है {स्ट्रिंग होस्ट = "लोकलहोस्ट"; इंट पोर्ट = 10430; सर्वर सर्वर = नया सर्वर (होस्ट, पोर्ट); क्लाइंट क्लाइंट = नया क्लाइंट (होस्ट, पोर्ट); थ्रेड.स्लीप (100L); client.send ("हैलो।"); server.broadcast ("अरे, दोस्त!"); थ्रेड.स्लीप (100L); सर्वर.डिस्कनेक्ट (सर्वर.getConnections () [0]); // या क्लाइंट.क्लोज़ () क्लाइंट-साइड सर्वर से डिस्कनेक्ट करने के लिए। क्लोज़ (); } }