Certains points qui doivent être clairs sur la communication TCP:
La communication TCP est axée sur la connexion et vous devez d'abord démarrer le serveur, puis démarrer le client.
Le client et le serveur doivent créer des objets Socket. Le client doit spécifier le socket serveur (port IP +) et le serveur doit spécifier le port de service.
Socket client_socket = new socket ("192.168.100.17", 8888); // Socket client (la prise de la classe de socket est une prise connectée) Serversocket écoute_socket = new serversocket (8888); // Prise de serveur, pour le moment, c'est la prise d'écoute (l'adresse et le port ont été liés ())Le serveur doit utiliser la méthode Accept () pour convertir la prise d'écoute en une prise connectée. Cette prise d'écoute peut générer plusieurs prises connectées, afin que vous puissiez également écouter les demandes d'autres clients après la connexion. Par conséquent, l'accès simultané doit être implémenté en utilisant le multithreading ici. Après avoir obtenu la prise connectée, vous pouvez obtenir beaucoup d'informations client, telles que l'adresse IP du client, le port où la demande est envoyée, etc.
Socket server_scocket = socket.accept (); socket server_scocket2 = socket.accept (); socket server_scocket3 = socket.accept ();
Pour implémenter des connexions simultanées sur le serveur, utilisez à peu près le code suivant: où ThreadTask est un objet de tâche de thread.
public static void main (String [] args) lève ioException {serversocket écouter_sock = new serversocket (8888); // Un seul est tenu d'écouter la prise, donc bien que (vrai) en dehors de la tâche {// chaque fois qu'une connexion est établie, un thread est ouvert. Socket conn_sock = écouter_sock.accept (); // Lorsqu'aucune nouvelle connexion n'est disponible, le thread principal principal bloque ce nouveau thread (nouveau threadTask (Conn_sock)). Start (); }}Le client doit obtenir le flux de sortie en fonction de la prise connectée, et le serveur doit obtenir le flux d'entrée en fonction de la prise. Bien sûr, comme il y a une prise connectée, vous pouvez obtenir le flux d'entrée et le flux de sortie à n'importe quelle extrémité.
OutputStream send_stream = client_socket.getOutputStream (); // Le client obtient le flux de sortie inputstream recv_stream = server_socket.getInputStream ();
Le serveur doit fermer activement la prise connectée et la prise d'écoute doit être fermée à l'endroit approprié.
Le serveur doit être responsable de le recevoir en continu.
Client simple:
Importer java.io.ioException; import java.io.outputStream; import java.net.socket; public class tcpClient {public static void main (String [] args) {// 1. Créer un socket de socket client c_sock = null; OutputStream client_outStream = null; try {c_sock = new socket ("192.168.0.124", 8888); // 2. Obtenez un flux de sortie client_outstream = c_sock.getOutputStream (); // 3. Output data client_outstream.write ("bonjour, je viens" .getBytes ()); } catch (ioException e) {e.printStackTrace (); } enfin {if (c_sock! = null) {try {c_sock.close (); } catch (ioException e) {e.printStackTrace (); }}}}}}Côté serveur simple:
Importer java.io.bufferedReader; import java.io.ioException; import java.io.inputStream; import java.io.inputStreamReader; import java.net.serversocket; import java.net.socket; public class tcpsserver {public static void main (string [] args) {// 1. Créer un socket static socket (string [] args) {// 1. essayez {écouter_sock = new serversocket (8888); } catch (ioException i) {i.printStackTrace (); } Socket server_sock = null; InputStream in_sock = null; while (true) {try {// 2. Établir une connexion avec le client, générer une prise connectée et obtenir l'adresse IP du client Server_sock = écouter_sock.accept (); String client_ip = server_sock.getinetAddress (). GethostAddress (); System.out.println ("Client:" + client_ip + "connecté"); // 3. Obtenez le flux d'entrée en fonction de la prise connectée et lisez les données envoyées par le client in_sock = server_sock.getInputStream (); BufferedReader bufr = new BufferedReader (new inputStreamReader (in_sock)); Chaîne line = null; while ((line = bufr.readline ())! = null) {System.out.println (line); } // 4. Fermez le socket connecté server_sock.close (); } catch (ioException e) {e.printStackTrace (); }}}}Ce qui suit est la fonction de téléchargement de fichiers TCP:
En plus du flux de sortie de socket, le client a également le flux d'entrée qui lit les fichiers locaux et le flux d'entrée de socket pour lire les informations de rétroaction du serveur.
Le serveur dispose également de trois flux: les flux d'entrée et de sortie de socket et écrivent pour télécharger des fichiers cibles.
Une fois que le client a lu toutes les données du fichier local, il doit utiliser le socket ShutdownOutput () pour informer le serveur que le flux de sortie de la prise a atteint la fin.
Afin de fournir des fonctions de téléchargement pour plusieurs personnes, le serveur doit utiliser plusieurs threads pour implémenter des connexions simultanées.
Client:
Importer java.io.bufferedReader; import java.io.fileInputStream; import java.io.ioexception; import java.io.inputStream; import java.io.inputstreamreader; import java.io.outputStream; import java.net.socket; classe publique uploadclient {public static Void Main (string) [] {// to tooDoDice {public static Void Main (String) [] {// to tooDoDoDo {Public Static Void Main (String) Méthode générée automatiquement Stub String Server_addr = "192.168.0.124"; int server_port = 8888; Socket send_sock = null; FileInputStream local_read = null; essayez {// 1. Socket client send_sock = new socket (server_addr, server_port); // 2. Obtenez le flux de sortie du pipeline de connexion outstream Send_stream = send_sock.getOutputStream (); // 3. Le flux d'entrée d'octet lit les données de fichiers locaux et utilise le flux de sortie du socket pour envoyer local_read = new FileInputStream ("d: /myjava/net/sql.docx"); octet [] buf = nouveau octet [1024]; int len = 0; while ((len = local_read.read (buf))! = -1) {send_stream.write (buf, 0, len); } // 4. Marquez le flux de sortie jusqu'à la fin Send_sock.shutdownoutput (); // 5. Recevez des données de rétroaction du serveur, telles que le téléchargement de réussite, la défaillance de téléchargement, etc. InputStream recv_stream = send_sock.getInputStream (); BufferedReader ack_recv = new BufferedReader (new inputStreamReader (recv_stream)); Chaîne line = null; while ((line = ack_recv.readline ())! = null) {System.out.println (line); }} catch (ioException i) {i.printStackTrace (); } enfin {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 (); }}}}}}Côté serveur:
Importer java.io.file; import java.io.fileoutputStream; import java.io.ioException; import java.io.inputStream; import java.io.outputStream; importation java.net.serversocket; = new serversocket (8888); // Un seul est nécessaire pour écouter la prise, donc bien que (vrai) {// chaque fois qu'une connexion est établie, un thread est démarré. Socket conn_sock = écouter_sock.accept (); // Lorsqu'aucune nouvelle connexion n'est disponible, le thread principal principal bloque ici un nouveau thread (nouveau Uploader (Conn_sock)). Start (); }}} Class Uploader implémente Runnable {Private File dest_dir = new File ("d: / temp"); // Téléchargez le socket privé Conn_sock = null; // connecter socket inputstream recv_stream = null; FileoutputStream dest_stream = null; Uploader (socket Conn_sock) lève ioException {this.conn_sock = Conn_sock; } public void run () {try {if (! dest_dir.exists ()) {dest_dir.mkDirs (); } // 1. Obtenez le flux d'entrée connectant le pipeline recv_stream = Conn_sock.getInputStream (); // Client IP String client_ip = Conn_sock.getInTAddress (). GethostAddress (); System.out.println (client_ip + "..... connecté"); // 2. L'emplacement de téléchargement du fichier, c'est-à-dire la cible de sortie, est nommé d'après IP. Si le fichier existe déjà, créez un nouveau fichier avec des supports et des numéros, tels que "192.168.100.23 (1) .txt" Fichier dest_file = nouveau fichier (dest_dir, client_ip + ".docx"); int count = 1; while (dest_file.exists ()) {dest_file = nouveau fichier (dest_dir, client_ip + "(" + count + ")" + ".docx"); Count ++; } // 3. Lisez les données et écrivez dans le fichier cible dest_stream = new FileOutputStream (dest_file); octet [] buf = nouveau octet [1024]; int len = 0; while ((len = recv_stream.read (buf))! = -1) {dest_stream.write (buf, 0, len); } // 4. Informations de rétroaction au client OutputStream ACK_SEND = Conn_sock.getOutputStream (); Byte [] text = "Télécharger réussi!". GetBytes (); ack_send.write (texte); } catch (ioException e1) {e1.printStackTrace (); } enfin {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 (); }}}}}}Les exemples ci-dessus de la communication TCP et la fonction de téléchargement de fichiers simples de la programmation réseau Java sont tout le contenu que je partage avec vous. J'espère que vous pourrez vous faire référence et j'espère que vous pourrez soutenir Wulin.com plus.