मैं टीसीपी की व्याख्या करने के लिए जा रहा हूँ:
मूल अवधारणा आप एक मशीन पर एक "सर्वर" चलाने के लिए होता है। वह सर्वर ग्राहकों को कनेक्शन के लिए इंतजार कर देता है। प्रत्येक कनेक्शन एक बंदरगाह पर चला जाता है (आप जानते हैं, मुझे उम्मीद है ...)।
हमेशा 1024 से ऊपर बंदरगाहों उपयोग करें, क्योंकि 1025 की तुलना में कम बंदरगाहों समय मानक प्रोटोकॉल के लिए आरक्षित की सबसे अधिक कर रहे हैं (HTTP (80), एफ़टीपी (21) की तरह, टेलनेट, ...)
हालांकि, जावा में एक सर्वर बनाने इस तरह से किया जाता है:
ServerSocket server = new ServerSocket(8888); // 8888 is the port the server will listen on.
"सॉकेट" वह शब्द है जिसे आप शायद खोज रहे हैं यदि आप शोध करना चाहते हैं।
और एक सर्वर आप इस बारे में करने के लिए अपने ग्राहक कनेक्ट करने के लिए:
Socket connectionToTheServer = new Socket("localhost", 8888); // First param: server-address, Second: the port
लेकिन अब, वहाँ अभी भी एक कनेक्शन नहीं है।सर्वर को प्रतीक्षा क्लाइंट को स्वीकार करना है (जैसा कि मैंने ऊपर देखा है):
Socket connectionToTheClient = server.accept();
हो गया! आपका कनेक्शन स्थापित है! संचार फाइल-आईओ की तरह ही है। केवल एक चीज आपको ध्यान में रखना है कि आपको यह तय करना होगा कि आप बफर को फ्लश करना चाहते हैं और वास्तव में सॉकेट के माध्यम से डेटा भेजना चाहते हैं। है अच्छा
OutputStream out = yourSocketHere.getOutputStream();
PrintStream ps = new PrintStream(out, true); // Second param: auto-flush on write = true
ps.println("Hello, Other side of the connection!");
// Now, you don't have to flush it, because of the auto-flush flag we turned on.
-पाठ पढ़ने के लिए BufferedReader (सबसे अच्छा *) विकल्प:
पाठ लिखने के लिए एक PrintStream का उपयोग करना बहुत आसान है
InputStream in = yourSocketHere.getInputStream();
BufferedReader br = new BufferedReader(new InputStreamReader(in));
String line = br.readLine();
System.out.println(line); // Prints "Hello, Other side of the connection!", in this example (if this would be the other side of the connection.
उम्मीद है कि आप इस के साथ नेटवर्किंग के साथ शुरू कर सकते हैं जानकारी!
पीएस: बेशक, सभी नेटवर्किंग कोड को IOExceptions के लिए प्रयास किया जाना चाहिए।
संपादित करें: मैं लिखना भूल गया कि यह हमेशा सबसे अच्छा विकल्प क्यों नहीं है। एक BufferedReader एक बफर का उपयोग करता है और बफर में जितना हो सके उतना पढ़ सकता है। लेकिन कभी-कभी आप नहीं चाहते कि BufferedReader नई लाइन के बाद बाइट चुरा लेता है और उन्हें अपने बफर में डाल देता है।
लघु उदाहरण:
InputStream in = socket.getInputStream();
BufferedReader br = new BufferedReader(new InputStreamReader(in));
// The other side says hello:
String text = br.readLine();
// For whatever reason, you want to read one single byte from the stream,
// That single byte, just after the newline:
byte b = (byte) in.read();
लेकिन BufferedReader पहले से ही उस बाइट है, तो आपको अपने बफर में, पढ़ना चाहते हैं। तो in.read() को कॉल करने से पाठक के बफर में अंतिम बाइट पर बाइट वापस आ जाएगा।
तो, इस स्थिति में सबसे अच्छा समाधान DataInputStream का उपयोग करें और पता है कि कैसे लंबी स्ट्रिंग हो सकता है और केवल बाइट्स की संख्या पढ़ सकते हैं और उन्हें एक स्ट्रिंग में बदल जाएगा अपनी खुद की जिस तरह से यह प्रबंधन करने के लिए है। या: आप
DataInputStream.readLine()
का उपयोग इस विधि एक बफर का उपयोग नहीं करता है और एक नई पंक्ति के लिए बाइट और चेक द्वारा बाइट पढ़ता है। तो यह विधि अंतर्निहित इनपुटस्ट्रीम से बाइट चोरी नहीं करती है।
संपादित करें: आप अपना खुद का प्रोटोकॉल विकसित कर सकते हैं जिसमें आप जावा रिफ्लेक्सियन का उपयोग करके विधि कॉल का अनुरोध कर सकते हैं। उदाहरण के लिए:
String className = ...;
String methodName = ...;
Class[] methodParamTypes = ...;
Object[] methodParams = ...;
Class cl = Class.forName(className);
Method me = cl.getDelcaredMethod(methodName, methodParamTypes);
Object returnValue = me.invoke(this, methodParams);
बार जब आप अपने वस्तु है आप इसे क्रमबद्धता के सिलसिले के दूसरे पक्ष को भेज सकते हैं: ObjectOuputStreams और ObjectInputStreams। इन दो वर्गों के साथ आप एक धारा के माध्यम से वस्तुओं को लिख और पढ़ सकते हैं।
Object obj = ...; // Your object you want to write through the stream. (Needs to implement java.io.Serializable)
ObjectOutputStream oos = new ObjectOuptputStream(socket.getOutputStream());
oos.writeObject(oos);
oos.reset(); // (***)
// Don't close it! Otherwise the connection will be closed as well.
और कनेक्शन के दूसरे पक्ष पर:
ObjectInputStream ois = new ObjectInputStream(socket.getInputStream());
Object object = ois.readObject(); // Read the object
// Don't close it!
// Then cast it to whatever you want.
(***): के बारे में reset() और जब यह उपयोग करने के लिए अधिक जानकारी के लिए my question की जाँच करें।
मैं जेएमएस निर्माता/उपभोक्ता दृष्टिकोण की कोशिश करने का सुझाव देने जा रहा था लेकिन आप कुछ सादा चाहते हैं। –