Einige Punkte, die über die TCP -Kommunikation klar sein müssen:
Die TCP-Kommunikation ist verbindungsorientiert und Sie müssen zuerst den Server starten und dann den Client starten.
Sowohl der Client als auch der Server müssen Socket -Objekte erstellen. Der Client muss den Server -Socket (IP+-Port) angeben, und der Server muss den Service -Port angeben.
Socket Client_socket = New Socket ("192.168.100.17", 8888); // Client -Socket (die Socket der Socket -Klasse ist eine angeschlossene Socket) ServerSocket Listen_Socket = New ServerSocket (8888); // Server -Socket, zu diesem Zeitpunkt ist es der Hörbuchse (die Adresse und der Port wurden gebunden ())Der Server muss die Methode Accept () verwenden, um den Hörbuchsen in einen angeschlossenen Socket umzuwandeln. Diese Hörbuchse kann mehrere angeschlossene Sockets generieren, sodass Sie nach der Verbindung auch Anforderungen anderer Kunden anhören können. Daher sollte der gleichzeitige Zugriff hier unter Verwendung von Multithreading implementiert werden. Nachdem Sie den angeschlossenen Socket erhalten haben, können Sie viele Clientinformationen erhalten, z. B. die IP -Adresse des Kunden, den Port, an dem die Anfrage gesendet wird, usw.
Socket server_scoket = socket.accept (); socket server_scoket2 = socket.accept (); socket server_scoket3 = socket.accept ();
Um gleichzeitige Verbindungen auf dem Server zu implementieren, verwenden Sie den folgenden Code grob: wobei ThreadTask ein Thread -Task -Objekt ist.
public static void main (String [] args) löst ioException {serversocket listen_sock = new ServerSocket (8888) aus; // Nur einer ist erforderlich, um den Socket anzuhören. Während (wahr) außerhalb der Aufgabe {// jedes Mal, wenn eine Verbindung hergestellt wird, wird ein Thread geöffnet. Socket conn_sock = listen_sock.accept (); // Wenn keine neue Verbindung eingeht, blockiert der Haupt -Haupt -Thread diesen neuen Thread (neuer ThreadTask (conn_sock)). Start (); }}Der Client muss den Ausgabestream basierend auf dem angeschlossenen Socket abrufen, und der Server muss den Eingabestream basierend auf dem Socket abrufen. Da es einen angeschlossenen Socket gibt, können Sie den Eingabestream und den Ausgangsstrom an jedem Ende erhalten.
OutputStream send_stream = client_socket.getOutputStream (); // Der Client erhält den Ausgabestream inputStream recv_stream = server_socket.getInputStream ();
Der Server sollte den angeschlossenen Socket aktiv schließen, und der Hörsteck sollte an der entsprechenden Stelle geschlossen werden.
Der Server sollte dafür verantwortlich sein, ihn kontinuierlich zu empfangen.
Einfacher Kunde:
Java.io.ioException importieren; import Java.io.outputStream; importieren Sie java.net.socket; public class tcpclient {public static void main (String [] args) {// 1. Erstellen von Client Socket C_Sock = Null; OutputStream client_outstream = null; try {c_sock = new Socket ("192.168.0.124", 8888); // 2. Ausgabe Stream client_outstream = c_sock.getOutputStream (); // 3. Ausgabe data client_outstream.write ("Hallo, ich komme" .GetByTes ()); } catch (ioException e) {e.printstacktrace (); } endlich {if (c_sock! = null) {try {c_sock.close (); } catch (ioException e) {e.printstacktrace (); }}}}}}Einfache Serverseite:
importieren java.io.bufufferedReader; import java.io.ioxception; import Java.io.inputStream; Import Java.io.inputStreamReader; Import Java.net.Serversocket; Java.net.Socket; Public Class TCpServer {öffentlich statische statische void -Haupthörer [] Argumente [] args. Null; try {listen_sock = new ServerSocket (8888); } catch (ioException i) {i.printstacktrace (); } Socket server_sock = null; InputStream in_sock = null; while (true) {try {// 2. Stellen Sie eine Verbindung mit dem Client her, generieren Sie einen angeschlossenen Socket und erhalten Sie die Client -IP -Adress -Adresse Server_Sock = listen_sock.accept (); String client_ip = server_sock.getInetaddress (). GethostadDress (); System.out.println ("Client:" + client_ip + "Connected"); // 3.. Erhalten Sie den Eingabestream basierend auf dem angeschlossenen Socket und lesen Sie die vom Client in Insock = server_sock.getInputStream () gesendeten Daten; BufferedReader buf = new bufferedReader (neuer InputStreamReader (IN_SOCK)); String line = null; while ((line = buffr.readline ())! = null) {System.out.println (Zeile); } // 4. Schließen Sie den angeschlossenen Socket server_sock.close (); } catch (ioException e) {e.printstacktrace (); }}}}Im Folgenden finden Sie die Funktion "TCP -Datei Upload":
Zusätzlich zum Socket -Ausgangsstrom verfügt der Client über den Eingabestream, der lokale Dateien liest, und den Eingangsstrom in Socket, um Feedback -Informationen vom Server zu lesen.
Der Server verfügt außerdem über drei Streams: Socket -Eingangs- und Ausgabestreams und schreiben Sie an Zieldateien hoch.
Nachdem der Client alle Daten aus der lokalen Datei gelesen hat, muss er den Shutdownoutput () des Socket verwenden, um den Server darüber zu informieren, dass der Ausgabestrom des Socket das Ende erreicht hat.
Um Hochladen von Funktionen für mehrere Personen bereitzustellen, muss der Server mehrere Threads verwenden, um gleichzeitige Verbindungen zu implementieren.
Kunde:
Importieren Sie Java.io.BufferedReader; Import Java.io.fileinputStream; Import Java.io.ioException; Import Java.io.inputStream; Importieren Sie Java.io.inputStreamReader; importieren Sie Java.io.o.outputStream; Automatisch generierte Methode Stub String server_addr = "192.168.0.124"; int server_port = 8888; Socket send_sock = null; FileInputStream local_read = null; try {// 1. Client -Socket send_sock = new Socket (server_addr, server_port); // 2. Holen Sie sich den Ausgabestream der Verbindungspipeline Ausgabestream send_stream = send_sock.getOutputStream (); // 3.. byte [] buf = neues byte [1024]; int len = 0; while ((len = local_read.read (buf))! = -1) {send_stream.write (buf, 0, len); } // 4. Markieren Sie den Ausgabestream bis zum Ende send_sock.shutdownoutput (); // 5. Feedback -Daten vom Server empfangen, z. B. ein erfolgreiches Hochladen, ein Upload -Fehler usw. inputStream recv_stream = send_sock.getInputStream (); BufferedReader ack_recv = neuer bufferedReader (neuer InputStreamReader (recv_stream)); String line = null; while ((line = ack_recv.readline ())! = null) {System.out.println (Zeile); }} catch (ioException i) {i.printstacktrace (); } endlich {if (send_sock! = null) {try {send_sock.close (); local_read.close (); } catch (ioException i1) {i1.printstacktrace (); }} if (local_read! = null) {try {local_read.close (); } catch (ioException i2) {i2.printstacktrace (); }}}}}}Serverseite:
import Java.io.file; Import Java.io.fileOutputStream; Import Java.io.ioxception; import Java.io.inputStream; Import Java.io.outputStream; Importieren Sie Java.net. listen_sock = new serversocket (8888); // Nur einer ist erforderlich, um den Socket anzuhören. Während (wahr) {// jedes Mal, wenn eine Verbindung hergestellt wird, wird ein Thread gestartet. Socket conn_sock = listen_sock.accept (); // Wenn keine neue Verbindung eingeht, ist der Hauptfadenblöcke hier neuer Thread (neuer Uploader (conn_sock)). Start (); }}} class Uploader implementiert runnable {private file dest_dir = new Datei ("d:/temp"); // Verzeichnis private Socket hochladen conn_sock = null; // Socket InputStream recv_stream = null anschließen; FileOutputStream dest_stream = null; Uploader (Socket conn_sock) löst IOException {this.conn_sock = conn_sock aus; } public void run () {try {if (! dest_dir.exists ()) {dest_dir.mkdirs (); } // 1. Nehmen Sie den Eingabestream ab, der die Pipeline recv_stream = conn_sock.getInputStream () verbindet; // Client IP String client_ip = conn_sock.getInetadDress (). GethostadDress (); System.out.println (Client_ip + "..... verbunden"); // 2. Der Hochladen des Hochladens der Datei, dh das Ausgabeziel, ist nach IP benannt. Wenn die Datei bereits vorhanden ist, erstellen Sie eine neue Datei mit Klammern und Nummern wie "192.168.100.23 (1) .txt" Datei dest_file = neue Datei (dest_dir, client_ip + ".docx"); int count = 1; while (dest_file.exists ()) {dest_file = new Datei (dest_dir, client_ip + "(" + count + ")" + ".docx"); zählen ++; } // 3.. Daten lesen und in die Zieldatei dest_stream = new FileOutputStream (dest_file) schreiben; byte [] buf = neues byte [1024]; int len = 0; while ((len = recv_stream.read (buf))! = -1) {dest_stream.write (buf, 0, len); } // 4. Feedback -Informationen zum Client OutputStream ACK_Send = conn_sock.getOutputStream (); byte [] text = "erfolgreich hochladen!". getBytes (); ACK_Send.Write (Text); } catch (ioException e1) {e1.printstacktrace (); } endlich {if (dest_stream! = null) {try {dest_stream.close (); } catch (ioException i) {i.printstacktrace (); }} if (conn_sock! = null) {try {conn_sock.close (); } catch (ioException i) {i.printstacktrace (); }}}}}}Die obigen Beispiele für TCP -Kommunikation und einfache Datei -Upload -Funktion der Java -Netzwerkprogrammierung sind alle Inhalte, die ich mit Ihnen teile. Ich hoffe, Sie können Ihnen eine Referenz geben und ich hoffe, Sie können wulin.com mehr unterstützen.