Java stellt zwei Klassen für das TCP-Protokoll bereit, die bei der clientseitigen Programmierung bzw. der serverseitigen Programmierung verwendet werden. Bevor die Anwendung mit der Kommunikation beginnt, muss zunächst eine Verbindung hergestellt werden, die vom Client-Programm initiiert wird, und das serverseitige Programm muss immer auf die spezifische Portnummer des Hosts warten und auf die Verbindung des Clients warten. Im Client müssen wir nur Socket-Instanzen verwenden, während der Server sowohl ServerSocket-Instanzen als auch Socket-Instanzen verarbeiten muss, die sowohl OutputStream als auch InpuStream zum Senden und Empfangen von Daten verwenden.
Der beste Weg, ein Wissen zu erlernen, besteht darin, es zu verwenden. Durch die vorherigen Hinweise wissen wir bereits, wie wir die Adressinformationen des Hosts erhalten. Jetzt verwenden wir ein einfaches Programm, um zunächst die Socket-Programmierung mithilfe des TCP-Protokolls zu erlernen Schicht.
TCP-Serverseite
Bei der Socket-Programmierung ist die Serverseite viel komplizierter als die Clientseite. Die Aufgabe des Servers besteht darin, ein Kommunikationsterminal einzurichten und passiv auf die Verbindung des Clients zu warten. Das folgende Beispiel eines serverseitigen Programms wird verwendet, um die von der Konsoleneingabe erhaltene Portnummer abzuhören und die vom Client gesendete Nachricht zurückzusenden.
Kopieren Sie den Codecode wie folgt:
importjava.net.*;
importjava.text.MessageFormat;
importjava.io.*;
publicclassTCPEchoServer{
privatestaticfinalintBUFSIZE=32;
publicstaticvoidmain(String[]args)throwsIOException{
//TODOAuto-generatedmethodstub
//Holen Sie sich die zu überwachende Portnummer von der Konsole
if(args.length!=1)
thrownewIllegalArgumentException("Parameter(s):<Port>");
//Holen Sie sich die Portnummer
intservPort=Integer.parseInt(args[0]);
//Instanziieren Sie eine ServerSocket-Objektinstanz
ServerSocketservSocket=newServerSocket(servPort);
System.out.println(MessageFormat.format("Mit dem Abhören beginnen, Portnummer: {0}",args[0]));
//Gesamtanzahl der Bytes der ursprünglich empfangenen Daten
intrecvMsgSize;
//Puffer zum Empfangen von Daten
byte[]receiveBuf=newbyte[BUFSIZE];
// Schleifeniteration, Abhören der Portnummer und Verarbeiten neuer Verbindungsanforderungen
while(true){
//Blockieren und warten, jedes Mal, wenn eine Anfrage empfangen wird, eine neue Verbindungsinstanz erstellen
SocketclntSocket=servSocket.accept();
//Holen Sie sich die SocketAddress des verbundenen Clients
SocketAddressclientAddress=clntSocket.getRemoteSocketAddress();
//Drucken Sie die Adressinformationen des Verbindungsclients aus
System.out.println("Handlingclientat"+clientAddress);
//Objekt, das Daten vom Client empfängt
InputStreamin=clntSocket.getInputStream();
//Objekt, das Daten an den Client sendet
OutputStreamout=clntSocket.getOutputStream();
// Nachdem Sie die vom Client gesendeten Daten gelesen haben, senden Sie sie an den Client
while((recvMsgSize=in.read(receiveBuf))!=-1){
out.write(receiveBuf,0,recvMsgSize);
}
//Wenn der Client die Verbindung schließt, schließen Sie die Verbindung
System.out.println("Client schließt Verbindung");
clntSocket.close();
}
}
}
TCP-Client
Bei der Socket-Programmierung muss der Client zunächst etwas an den Server senden und dann passiv auf die Antwort des Servers warten. Im folgenden Beispiel senden wir Informationen an den Server, warten auf die vom Server gesendete Nachricht und drucken sie aus.
Kopieren Sie den Codecode wie folgt:
importjava.io.*;
importjava.net.Socket;
importjava.net.SocketException;
publicclassTCPEchoClient{
publicstaticvoidmain(String[]args)throwsIOException{
//TODOAuto-generatedmethodstub
//Bestimmen Sie, ob die von der Konsole empfangenen Parameter korrekt sind
if((args.length<2)||(args.length>3))
thrownewIllegalArgumentException(
"Parameter(s):<Server><Word>[<Port>]]");
//Serveradresse abrufen
Stringserver=args[0];
//Erhalten Sie die Informationen, die gesendet werden müssen
byte[]data=args[1].getBytes();
//Wenn drei Slave-Parameter vorhanden sind, erhalten Sie die Portnummer zum Senden von Informationen. Die Standardportnummer ist 8099.
intservPort=(args.length==3)?Integer.parseInt(args[2]):8099;
//Instanziieren Sie eine Socket-Instanz basierend auf der Serveradresse und der Portnummer
Socketsocket=newSocket(server,servPort);
System.out.println("Connectedtoserver...sendingechostring");
// Den Eingabestream dieses Sockets zurückgeben, bei dem es sich um das vom Server empfangene Datenobjekt handelt
InputStreamin=socket.getInputStream();
// Den Ausgabestream dieses Sockets zurückgeben, bei dem es sich um das an den Server gesendete Datenobjekt handelt
OutputStreamout=socket.getOutputStream();
//Sende die von der Konsole empfangenen Daten an den Server
out.write(data);
//Der Zähler, der Daten empfängt, schreibt den anfänglichen Offset der Daten
inttotalBytesRcvd=0;
//Initialisiere die Gesamtzahl der Bytes der empfangenen Daten
intbytesRcvd;
while(totalBytesRcvd<data.length){
//Wenn der Server die Verbindung schließt, gibt er -1 zurück. Die Lesemethode gibt die Gesamtzahl der Bytes der empfangenen Daten zurück.
if((bytesRcvd=in.read(data,totalBytesRcvd,data.length
-totalBytesRcvd))==-1)
thrownewSocketException("Die Verbindung zum Server wurde geschlossen");
totalBytesRcvd+=bytesRcvd;
}
//Drucken Sie die vom Server gesendeten Daten
System.out.println("Received:"+newString(data));
//Verbindung schließen
socket.close();
}
}
Starten Sie zunächst den Server und überwachen Sie Port 8099:
Führen Sie dann das Client-Programm aus und senden Sie eine Nachricht an den Server:
Wenn wir noch einmal auf unsere serverseitige Konsole schauen, können wir die Adressinformationen der vorherigen Clientverbindung sehen: