Einige Erfahrungen mit der Java-Netzwerkprogrammierung

Ich habe kürzlich Java-Netzwerkprogrammierung gelernt, aber ich habe es nie ernsthaft verstanden. In den letzten Tagen wurde ich plötzlich interessiert und hatte das Gefühl, dass es sehr magisch war. Ich wollte plötzlich wissen, wie die konkrete Situation war.

Socket, auch allgemein als „Socket“ bekannt, wird zur Beschreibung von IP-Adressen und Ports verwendet und ist das Handle einer Kommunikationskette. Hosts im Internet führen im Allgemeinen mehrere Dienstsoftware aus und stellen mehrere Dienste gleichzeitig bereit. Jeder Dienst öffnet einen Socket und ist an einen Port gebunden. Verschiedene Ports entsprechen unterschiedlichen Diensten.

Die Steckdose ist einer Telefonsteckdose sehr ähnlich. Am Beispiel eines nationalen Telefonnetzes entsprechen die beiden Teilnehmer des Telefongesprächs zwei miteinander kommunizierenden Prozessen, und die Vorwahl ist die Netzwerkadresse eines Switches in einer Einheit in der Region, die einem Host entspricht Der Host weist jedem Benutzer eine bürointerne Nummer zu, die der Socket-Nummer entspricht. Bevor ein Benutzer einen Anruf tätigt, muss er zunächst über ein Telefon verfügen, was einer Beantragung eines Sockets entspricht. Gleichzeitig muss er die Nummer des anderen Teilnehmers kennen, was einem festen Socket des anderen Teilnehmers entspricht. Rufen Sie dann den anderen Teilnehmer an, was einer Verbindungsanfrage entspricht (wenn sich der andere Teilnehmer nicht im selben Gebiet befindet, müssen Sie auch die Ortsvorwahl des anderen Teilnehmers wählen, was der Angabe einer Netzwerkadresse entspricht). Wenn der andere Teilnehmer anwesend und inaktiv ist (was bedeutet, dass der andere Kommunikationshost eingeschaltet ist und Verbindungsanfragen entgegennehmen kann), heben Sie den Telefonhörer ab, und die beiden Teilnehmer können offiziell sprechen, was einer erfolgreichen Verbindung entspricht. Der Prozess eines Anrufs zwischen den beiden Parteien besteht darin, dass eine Partei ein Signal an das Telefon sendet und die andere Partei das Signal vom Telefon empfängt. Dies entspricht dem Senden von Daten an den Socket und dem Empfangen von Daten vom Socket. Nachdem der Anruf beendet ist, entspricht das Auflegen des Telefons durch einen Teilnehmer dem Schließen des Sockets und dem Abbrechen der Verbindung.

Im Telefonsystem kann der durchschnittliche Benutzer nur die Existenz des lokalen Telefons und der Telefonnummer des anderen Teilnehmers spüren, den Prozess der Sprachübertragung und die technischen Details Das gesamte Telefonsystem ist für ihn alle transparent, dies ist auch dem Socket-Mechanismus sehr ähnlich. Socket nutzt Internet-Kommunikationsfunktionen, um die Prozesskommunikation zu erreichen, kümmert sich jedoch nicht um die Details der Kommunikationsfunktionen. Solange die Kommunikationsfunktionen ausreichende Kommunikationsfunktionen bereitstellen können, ist es zufrieden.
Die oben genannten Definitionen und Erklärungen sind in der Baidu-Enzyklopädie enthalten, aber sie sind recht einfach zu verstehen, im Gegensatz zu den vorherigen Erklärungen, die sehr schwer zu verstehen waren. Es gab zu viele Fachbegriffe und es war sehr schwer zu verstehen.

Schritte zur Implementierung der Socket-Kommunikation:
1. Erstellen Sie ServerSocket und Socket
2. Öffnen Sie den mit dem Socket verbundenen Eingabe-/Ausgabestream
3. Befolgen Sie das Protokoll (normalerweise TCP/ UDP) Lese- und Schreibvorgänge auf Socket
4. Schließen Sie den Eingabe-/Ausgabestream und schließen Sie Socket

Socket-Programmierung

Einer ist ServerSocket und der andere ist Socket. Über Socket wird eine Verbindung zwischen dem Server und dem Client hergestellt, und dann können sie kommunizieren. Erstens überwacht ServerSocket einen bestimmten Port auf der Serverseite. Wenn es feststellt, dass der Client über einen Socket verfügt, und versucht, eine Verbindung zu diesem herzustellen, akzeptiert es die Verbindungsanforderung des Sockets und richtet auf der Serverseite einen entsprechenden Socket für die Kommunikation ein damit. Auf diese Weise gibt es zwei Sockets, einen für den Client und einen für den Server.
Die Kommunikation zwischen Sockets ist eigentlich sehr einfach. Der Server schreibt Dinge in den Socket-Ausgabestream, und der Client kann den entsprechenden Inhalt über den Socket-Eingabestream lesen. Zwischen Socket und Socket besteht eine bidirektionale Verbindung, sodass der Client auch Dinge in den entsprechenden Socket-Ausgabestream schreiben kann und dann der entsprechende Socket-Eingabestream auf dem Server den entsprechenden Inhalt lesen kann.

Das Folgende ist ein Beispiel für das Lesen und Schreiben des Clients und das Lesen und Schreiben des Servers

Servercode

public class Server {
public static void main(String args[]) throws IOException {
      //定义一个ServerSocket监听在端口8888上  
      int port = 8888; 
      int i=1; //连接计数
      //server尝试接收其他Socket的连接请求，
      ServerSocket server = new ServerSocket(port);  
      //server的accept方法是阻塞式的 ,即等待着客户端的请求
      Socket socket = server.accept();  
      System.out.println("连接"+i++);
      //跟客户端建立好连接，我们就可以获取socket的InputStream，从中读取客户端发过来的信息。  
      Reader reader = new InputStreamReader(socket.getInputStream());    
      char chars[] = new char[64];  
      int len;  
      StringBuilder sb = new StringBuilder();  
      String temp;  
      int index;  
      while ((len=reader.read(chars)) != -1) {  
         temp = new String(chars, 0, len);  
         if ((index = temp.indexOf("eof")) != -1) { //遇到eof时就结束接收  
            sb.append(temp.substring(0, index));  
            break;  
         }  
         sb.append(temp);  
      }  
      System.out.println("from client: " + sb);  
      //读完后写数据 
      Writer writer = new OutputStreamWriter(socket.getOutputStream());  
      writer.write("Hello Client:我是服务端输入数据"); 
      //释放资源
      writer.flush();  
      writer.close(); 
      reader.close();  
      socket.close();  
      server.close(); 
   }  
}

Ausgabe

Hinweis

• Der Betrieb des Servers zum Lesen von Daten aus dem InputStream des Sockets blockiert auch, wenn keine Daten aus dem Eingabestream gelesen werden Das Datenprogramm bleibt dort, bis der Client Daten in den Ausgabestream des Sockets schreibt oder den Ausgabestream des Sockets schließt. Das Gleiche gilt natürlich auch für den Socket des Clients.

• Lesen Sie die vom Client gesendeten Daten aus dem Eingabestream, schreiben Sie die Daten dann in den Ausgabestream an den Client und schließen Sie dann die entsprechende Ressourcendatei. Tatsächlich wird der obige Code möglicherweise nicht wie erwartet ausgeführt, da das Lesen von Daten aus dem Eingabestream eine blockierende Operation ist. In der obigen while-Schleife wird der Schleifenkörper ausgeführt, wenn die Daten gelesen werden, andernfalls wird er blockiert, sodass nachfolgende Operationen ausgeführt werden In dieser Situation vereinbaren wir normalerweise eine Endmarkierung. Wenn die vom Client gesendeten Daten eine Endmarkierung enthalten, bedeutet dies, dass die aktuellen Daten gesendet wurden die Schleife.

• 在上述代码中，当服务端读取到客户端发送的结束标记，即“eof”时就会结束数据的接收，终止循环，这样后续的代码又可以继续进行了。

客户端代码

public class Client {
 public static void main(String args[]) throws Exception {  
      //为了简单起见，所有的异常都直接往外抛  
      String host = "192.168.74.1";  //要连接的服务端IP地址  
      int port = 8888;   //要连接的服务端对应的监听端口  
      //与服务端建立连接  
      Socket client = new Socket(host, port);  
      //建立连接后就可以往服务端写数据了  
      Writer writer = new OutputStreamWriter(client.getOutputStream());  
      writer.write("Hello ,我是客户端输入数据");
      writer.write("eof"); 
      writer.flush();//写完后要记得flush  
      //读取来自服务端数据
      Reader reader = new InputStreamReader(client.getInputStream());  
      char chars[] = new char[64];  
      int len;  
      StringBuffer sb = new StringBuffer();  
      String temp;  
      int index;  
      while ((len=reader.read(chars)) != -1) {  
         temp = new String(chars, 0, len);  
         if ((index = temp.indexOf("eof")) != -1) {  
            sb.append(temp.substring(0, index));  
            break;  
         }  
         sb.append(new String(chars, 0, len));  
      }  
      System.out.println("from server: " + sb);
      writer.close(); 
      reader.close();  
      client.close();  
   }  
}

输出

注意点

• 过程：先是给服务端发送了一段数据，之后读取服务端返回来的数据，跟之前的服务端一样在读的过程中有可能导致程序一直挂在那里，永远跳不出while循环,解决方法和服务端一样，用一个结束标志。

• 对于客户端往Socket的输出流里面写数据传递给服务端要注意一点，如果写操作之后程序不是对应着输出流的关闭，而是进行其他阻塞式的操作（比如从输入流里面读数据），记住要flush一下，只有这样服务端才能收到客户端发送的数据，否则可能会引起两边无限的互相等待。在稍后讲到客户端和服务端同时读和写的时候会说到这个问题。

Das obige ist der detaillierte Inhalt vonEinige Erfahrungen mit der Java-Netzwerkprogrammierung. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!