Java écrit un serveur et un client qui peuvent télécharger des fichiers. Le contenu spécifique est le suivant
Côté serveur
class Server {public static void main (string [] args) lève une exception {// créer le socket serveur serveSocket ss = new serversocket (10005); // reçoit le socket client fileLoadersocket = ss.accept (); // imprime la chaîne d'informations de connexion ip = fileLoadersocket.getInTaddress (). GethostAddress (); System.out.println (IP + "... CONNEECT"); // Recevez le fichier et enregistrez InputStream dans = fileLoadersocket.getInputStream (); // Instancier l'objet FileSave OutputStream FileSave = new FileOutputStream ("E: //3.mp3"); // Créer un byte Buf Buf [] buf = nouveau octet [1024]; int len = 0; // défendez si la fin du fichier est lue ((len = in.read (buf))! = -1) {filesave.write (buf, 0, len); // Refresh filesave.flush (); } // return File Copying Informations BufferedWriter out = new BufferedWriter (new OutputStreamWriter (fileLoadersocket.getOutputStream ())); out.write ("Fichier Télécharger réussi"); // rafraîchir Out.flush (); // Resource Close Ss.close (); fileLoadersocket.close (); fileSave.close (); }}Client:
classe Client {public static void main (String [] args) lève une exception {// Créer un socket socket socket fileLoadersocket = new socket ("168.168.168.94", 10005); // Lisez le fichier localement à partir du client et écrivez dans le flux de sortie du socket OutputStream Out = FileLoadersocket.getOutputStream (); // Instancier l'objet fileReader inputStream fileRead = new FileInputStream ("g: //2.mp3"); // Créer un byte de tableau [] buf = nouveau octet [1024]; int len = 0; // juger si la fin du fichier est lue ((Len = fileRered.read (buf))! = -1) {out.write (buf, 0, len); } // Dites au serveur que le fichier a été transféré fileLoadersocket.shutdownoutput (); // Obtenez les commentaires des informations du serveur BufferedReader dans = new BufferedReader (new InputStreamReader (FileLoadersocket.GetInputStream ())); String serverback = in.readline (); System.out.println (serverback); // Resource Close FileLoadersocket.Close (); fileRead.close (); }}Le programme suivant est copié directement d'ailleurs pour apprendre la référence:
Programmation Java Socket
Pour la programmation Java Socket, il y a deux concepts, l'un est Serversocket et l'autre est socket. Le serveur et le client sont connectés via Socket, puis il peut communiquer. Tout d'abord, Serversocket écoutera un port sur le serveur. Lorsqu'il est constaté que le client a une prise pour essayer d'y connecter, il acceptera la demande de connexion de la prise et établira en même temps une prise correspondante sur le serveur pour communiquer avec elle. De cette façon, il y a deux sockets, un sur le client et un sur le serveur.
La communication entre les prises est en fait très simple. Lorsque le serveur écrit quelque chose dans le flux de sortie de socket, le client peut lire le contenu correspondant via le flux d'entrée de socket. La prise et la prise sont connectées dans deux directions, afin que le client puisse également écrire des choses dans le flux de sortie de socket correspondant, puis le flux d'entrée de socket correspondant du serveur peut lire le contenu correspondant. Voici quelques exemples de communication côté serveur avec les clients:
1. Écriture et lecture du client du client
Code Java de serveur
public class Server {public static void main (String args []) lève ioException {// Pour simplicité, toutes les informations d'exception sont jetées int port = 8899; // Définir un SERVERSOCKET Écoutant sur le port 8899 Serversocket Server = new Serversocket (port); // Le serveur essaie de recevoir des demandes de connexion d'autres sockets. La méthode d'acceptation du serveur est une prise de blocage Socket = Server.Accept (); // Après avoir établi une connexion avec le client, nous pouvons obtenir le socket de l'entrée et lire les informations envoyées par le client. Reader Reader = new inputStreamReader (socket.getInputStream ()); char à chars [] = nouveau char [64]; int len; StringBuilder sb = new StringBuilder (); while ((len = reader.read (chars))! = -1) {sb.append (new String (chars, 0, len)); } System.out.println ("From Client:" + SB); Reader.Close (); socket.close (); server.close (); }}Le fonctionnement du serveur pour lire les données de l'entrée du socket bloque également. Si les données ne sont pas lues à partir du flux d'entrée, le programme y restera jusqu'à ce que le client écrit des données dans le flux de sortie de la prise ou ferme le flux de sortie de la prise. Bien sûr, il en va de même pour les prises clients. Une fois l'opération terminée, n'oubliez pas de fermer les ressources correspondantes avant la fin du programme entier, c'est-à-dire, fermez le flux et la prise IO correspondantes.
Code Java client
Client de classe publique {public static void main (String args []) lève une exception {// pour simplicité, toutes les exceptions sont jetées directement String host = "127.0.0.1"; // L'adresse IP du serveur à connecter est int port = 8899; // Le port d'écoute correspondant du serveur à connecter // La connexion est établie avec le serveur Client = new socket (hôte, port); // Après avoir établi la connexion, vous pouvez écrire des données sur le serveur écrivain = new OutputStreamWriter (client.getOutputStream ()); writer.write ("Hello Server."); writer.flush (); // Rappelez-vous Flush Writer.close (); client.close (); }}Lorsque vous écrivez des données dans le flux de sortie de socket, vous devez faire attention à une chose. Si le programme ne correspond pas à l'arrêt du flux de sortie après l'opération d'écriture, mais effectue d'autres opérations de blocage (telles que les données de lecture du flux d'entrée), n'oubliez pas de la rincer. Ce n'est que de cette manière que le serveur peut recevoir les données envoyées par le client, sinon elle peut provoquer illimité l'attente. Ce problème sera mentionné plus tard lorsque vous parlez du client et du serveur qui lira et écrivant en même temps.
2. Le client et le serveur lisent et écrivent en même temps
Comme mentionné précédemment, les prises communiquent de manière bidirectionnelle, qui peuvent à la fois recevoir des données et envoyer des données.
Code Java de serveur
public class Server {public static void main (String args []) lève ioException {// Pour simplicité, toutes les informations d'exception sont jetées int port = 8899; // Définir un SERVERSOCKET Écoutant sur le port 8899 Serversocket Server = new Serversocket (port); // Le serveur essaie de recevoir des demandes de connexion d'autres sockets. La méthode d'acceptation du serveur est une prise de blocage Socket = Server.Accept (); // Après avoir établi une connexion avec le client, nous pouvons obtenir le socket de l'entrée et lire les informations envoyées par le client. Reader Reader = new inputStreamReader (socket.getInputStream ()); char à chars [] = nouveau char [64]; int len; StringBuilder sb = new StringBuilder (); while ((len = reader.read (chars))! = -1) {sb.append (new String (chars, 0, len)); } System.out.println ("From Client:" + SB); // Écrivez une phrase après avoir lu It It Writer = new OutputStreamWriter (socket.getOutputStream ()); writer.write ("Hello Client."); écrivain.flush (); écrivain.close (); Reader.Close (); socket.close (); server.close (); }}Dans le code ci-dessus, nous lisons d'abord les données envoyées par le client à partir du flux d'entrée, puis écrivons les données dans le flux de sortie vers le client, puis fermons le fichier de ressource correspondant. En fait, le code ci-dessus peut ne pas s'exécuter dans la façon dont nous avons supposé à l'avance, car la lecture des données du flux d'entrée est une opération de blocage. Lorsque les données sont lues dans la boucle ci-dessus, le corps de la boucle sera exécuté, sinon il sera bloqué, de sorte que les opérations d'écriture suivantes ne seront jamais exécutées. La boucle while s'arrêtera à moins que la prise correspondante du client ne soit fermée et bloquée. La solution à cette situation où elle peut ne jamais être exécutée est que la boucle While doit être sautée conditionnellement. En regardant le code ci-dessus, la seule chose qui change est la longueur Len et les données lues. Len n'est plus utilisable, et la seule chose qui peut être utilisée est les données lues. Dans ce cas, nous sommes généralement d'accord sur une étiquette d'extrémité. Lorsque les données envoyées par le client contient une certaine balise de fin, cela signifie que les données actuelles ont été envoyées et, à l'heure actuelle, nous pouvons nous dérouler. Ensuite, le code amélioré ressemblera à ceci:
Code java
public class Server {public static void main (String args []) lève ioException {// Pour simplicité, toutes les informations d'exception sont jetées int port = 8899; // Définir un SERVERSOCKET Écoutant sur le port 8899 Serversocket Server = new Serversocket (port); // Le serveur essaie de recevoir des demandes de connexion d'autres sockets. La méthode d'acceptation du serveur est une prise de blocage Socket = Server.Accept (); // Après avoir établi une connexion avec le client, nous pouvons obtenir le socket de l'entrée et lire les informations envoyées par le client. Reader Reader = new inputStreamReader (socket.getInputStream ()); char à chars [] = nouveau char [64]; int len; StringBuilder sb = new StringBuilder (); Chaîne temporaire; INT INDEX; while ((Len = reader.read (chars))! = -1) {temp = new String (Chars, 0, len); if ((index = temp.Indexof ("eof"))! = -1) {// La réception est terminée lorsque EOF est rencontré SB.APPEND (Temp.SubString (0, index)); casser; } sb.append (temp); } System.out.println ("From Client:" + SB); // Écrivez une phrase après la lecture de l'écrivain = new OutputStreamWriter (socket.getOutputStream ()); writer.write ("Hello Client."); écrivain.flush (); écrivain.close (); Reader.Close (); socket.close (); server.close (); }}Dans le code ci-dessus, lorsque le serveur lit la marque de fin envoyée par le client, c'est-à-dire "EOF", la réception de données sera terminée et la boucle sera résiliée, afin que le code suivant puisse continuer.
Code Java client
Client de classe publique {public static void main (String args []) lève une exception {// pour simplicité, toutes les exceptions sont jetées directement String host = "127.0.0.1"; // L'adresse IP du serveur à connecter int port = 8899; // Le port d'écoute correspondant du serveur à connecter // La connexion est établie avec le serveur Client = new socket (hôte, port); // Après avoir établi la connexion, vous pouvez écrire des données sur le serveur écrivain = new OutputStreamWriter (client.getOutputStream ()); writer.write ("Hello Server."); écrivain.flush (); // Lire après avoir écrit Reader Reader = new inputStreamReader (client.getInputStream ()); char à chars [] = nouveau char [64]; int len; StringBuffer sb = new StringBuffer (); while ((len = reader.read (chars))! = -1) {sb.append (new String (chars, 0, len)); } System.out.println ("From Server:" + SB); écrivain.close (); Reader.Close (); client.close (); }}Dans le code ci-dessus, nous avons d'abord envoyé un élément de données au serveur, puis lu les données renvoyées par le serveur. Comme le serveur précédent, cela peut entraîner la collaboration du programme tout le temps et ne jamais sauter de la boucle while. Ce code est combiné avec le premier code du serveur, il suffit d'analyser que le serveur y recevra toujours des données et ne sautera jamais de la boucle while, il n'y aura donc pas de serveur ultérieur pour retourner des données au client, et le client ne sera pas en mesure de recevoir des données renvoyées par le serveur. La solution est affichée dans le deuxième code du serveur. Une fois que le client a envoyé les données, écrivez une marque de fin dans le flux de sortie pour indiquer au serveur que les données ont été envoyées. Le serveur envoie également une marque pour dire au client après le retour des données. Ensuite, le code client modifié doit ressembler à ceci:
Code java
Client de classe publique {public static void main (String args []) lève une exception {// pour simplicité, toutes les exceptions sont jetées directement String host = "127.0.0.1"; // L'adresse IP du serveur à connecter est int port = 8899; // Le port d'écoute correspondant du serveur à connecter // La connexion est établie avec le serveur Client = new socket (hôte, port); // Après avoir établi la connexion, vous pouvez écrire des données sur le serveur écrivain = new OutputStreamWriter (client.getOutputStream ()); writer.write ("Hello Server."); écrivain.write ("eof"); écrivain.flush (); // Lire après avoir écrit Reader Reader = new inputStreamReader (client.getInputStream ()); char à chars [] = nouveau char [64]; int len; StringBuffer sb = new StringBuffer (); Chaîne temporaire; 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)); casser; } SB.APPEND (nouvelle chaîne (Chars, 0, Len)); } System.out.println ("From Server:" + SB); écrivain.close (); Reader.Close (); client.close (); }}Le formulaire le plus courant que nous utilisons dans la vie quotidienne est que le client envoie des données au serveur, et le serveur reçoit les données et renvoie les résultats correspondants au client. Cependant, il n'y a plus une telle relation un à un entre le client et le serveur, mais la situation où plusieurs clients correspondent au même serveur que celle ci-dessous.
3. Plusieurs clients se connectent au même serveur
Pour les deux exemples mentionnés ci-dessus, le serveur se termine après avoir reçu la demande d'un client et ne peut pas recevoir de demandes d'autres clients, ce qui ne peut souvent pas répondre à nos exigences. Habituellement, nous faisons ceci:
Code java
public class Server {public static void main (String args []) lève ioException {// Pour simplicité, toutes les informations d'exception sont jetées int port = 8899; // Définir un SERVERSOCKET Écoutant sur le port 8899 Serversocket Server = new Serversocket (port); tandis que (true) {// le serveur essaie de recevoir des demandes de connexion d'autres sockets. La méthode d'acceptation du serveur est une prise de blocage Socket = Server.Accept (); // Après avoir établi une connexion avec le client, nous pouvons obtenir le socket de l'entrée et lire les informations envoyées par le client. Reader Reader = new inputStreamReader (socket.getInputStream ()); char à chars [] = nouveau char [64]; int len; StringBuilder sb = new StringBuilder (); Chaîne temporaire; INT INDEX; while ((Len = reader.read (chars))! = -1) {temp = new String (Chars, 0, len); if ((index = temp.Indexof ("eof"))! = -1) {// La réception est terminée lorsque EOF est rencontré SB.APPEND (Temp.SubString (0, index)); casser; } sb.append (temp); } System.out.println ("From Client:" + SB); // Écrivez une phrase après la lecture de l'écrivain = new OutputStreamWriter (socket.getOutputStream ()); writer.write ("Hello Client."); écrivain.flush (); écrivain.close (); Reader.Close (); socket.close (); }}} Dans le code ci-dessus, nous avons utilisé une boucle morte, où le Serversocket appelle sa méthode d'acceptation pour essayer de recevoir une demande de connexion du client. Lorsque la demande n'est pas reçue, le programme bloquera ici jusqu'à ce qu'il reçoive la demande de connexion du client, puis communiquera avec le client qui a établi la connexion. Après cela, il exécutera ensuite le corps de la boucle et essaiera de recevoir à nouveau une nouvelle demande de connexion. De cette façon, notre Serversocket peut recevoir des demandes de connexion à tous les clients et communiquez avec eux. Cela implémente un mode de communication simple avec plusieurs clients sur un seul serveur.
Dans l'exemple ci-dessus, bien qu'un serveur soit implémenté pour communiquer avec plusieurs clients, il y a toujours un problème. Dans l'exemple ci-dessus, notre serveur gère la demande de connexion du client de manière synchrone. Chaque fois que nous recevons une demande de connexion du client, nous devons d'abord communiquer avec le client actuel avant de pouvoir traiter la prochaine demande de connexion. Cela affectera sérieusement les performances du programme lorsqu'il y aura plus de concurrence. Pour cette raison, nous pouvons le changer en traitement asynchrone suivant de la communication avec le client:
Code java
public class Server {public static void main (String args []) lève ioException {// Pour simplicité, toutes les informations d'exception sont jetées int port = 8899; // Définir un SERVERSOCKET Écoutant sur le port 8899 Serversocket Server = new Serversocket (port); tandis que (true) {// le serveur essaie de recevoir des demandes de connexion d'autres sockets. La méthode d'acceptation du serveur est une prise de blocage Socket = Server.Accept (); // Chaque fois qu'une prise est reçue, un nouveau thread est établi pour le gérer un nouveau thread (nouvelle tâche (socket)). Start (); }} / ** * * / La tâche de classe statique implémente Runnable {private socket socket; tâche publique (socket socket) {this.socket = socket; } public void run () {try {handlesocket (); } catch (exception e) {e.printStackTrace (); }} / ** * Communiquez avec le socket client * @throws exception * / private void handlesocket () lève l'exception {Reader Reader = new InputStreamReader (socket.getInputStream ()); char à chars [] = nouveau char [64]; int len; StringBuilder sb = new StringBuilder (); Chaîne temporaire; INT INDEX; while ((Len = reader.read (chars))! = -1) {temp = new String (Chars, 0, len); if ((index = temp.Indexof ("eof"))! = -1) {// La réception est terminée lorsque EOF est rencontré SB.APPEND (Temp.SubString (0, index)); casser; } sb.append (temp); } System.out.println ("From Client:" + SB); // Écrivez une phrase après la lecture de l'écrivain = new OutputStreamWriter (socket.getOutputStream ()); writer.write ("Hello Client."); écrivain.flush (); écrivain.close (); Reader.Close (); socket.close (); }}} Dans le code ci-dessus, chaque fois que le Serversocket reçoit une nouvelle demande de connexion de socket, un nouveau thread sera généré pour communiquer avec le socket actuel, qui atteindra le traitement asynchrone de la communication avec le socket client.
Lorsque vous recevez des données de Socket's InputStream, la lecture un peu comme celle ci-dessus est trop compliquée. Parfois, nous utiliserons BufferedReader pour lire une ligne à la fois, comme:
Code java
public class Server {public static void main (String args []) lève ioException {// Pour simplicité, toutes les informations d'exception sont jetées int port = 8899; // Définir un SERVERSOCKET Écoutant sur le port 8899 Serversocket Server = new Serversocket (port); tandis que (true) {// le serveur essaie de recevoir des demandes de connexion d'autres sockets. La méthode d'acceptation du serveur est une prise de blocage Socket = Server.Accept (); // Chaque fois qu'une prise est reçue, un nouveau thread est établi pour le gérer un nouveau thread (nouvelle tâche (socket)). Start (); }} / ** * * / La tâche de classe statique implémente Runnable {private socket socket; tâche publique (socket socket) {this.socket = socket; } public void run () {try {handlesocket (); } catch (exception e) {e.printStackTrace (); }} / ** * Communiquez avec le socket client * @throws exception * / private void handlesocket () lève une exception {BufferedReader br = new BufferedReader (new InputStreamReader (socket.getInputStream ())); StringBuilder sb = new StringBuilder (); Chaîne temporaire; INT INDEX; while ((temp = br.readline ())! = null) {System.out.println (temp); if ((index = temp.indexof ("eof"))! = -1) {// terminer la réception lorsque eof est rencontré sb.append (temp.substring (0, index)); casser; } sb.append (temp); } System.out.println ("From Client:" + SB); // Écrivez une phrase après la lecture de l'écrivain = new OutputStreamWriter (socket.getOutputStream ()); writer.write ("Hello Client."); écrivain.write ("eof / n"); écrivain.flush (); écrivain.close (); br.close (); socket.close (); }}}À l'heure actuelle, il convient de noter que la méthode de lecture de BufferedReader lit une ligne à la fois. Cette méthode est bloquée. Le programme ne continuera pas à s'exécuter avant de lire une ligne de données. Alors, quand Readline Lire une ligne? La méthode Readline ne pensera pas qu'elle a été lu une ligne tant que le programme rencontre une nouvelle ligne ou le caractère final du flux correspondant. Il mettra fin à son blocage et permettra au programme de continuer à s'exécuter. Par conséquent, lorsque nous utilisons la ligne de lecture de BufferedReader pour lire les données, nous devons nous rappeler d'écrire des ruptures de ligne dans le flux de sortie correspondant (il sera automatiquement marqué comme fin après la fin du flux, et la ligne de lecture peut être reconnue). Après avoir écrit les ruptures de ligne, nous devons nous rappeler de rincer si le flux de sortie n'est pas fermé immédiatement, afin que les données soient vraiment écrites à partir du tampon. Correspondant au code ci-dessus, notre programme client doit être écrit comme ceci:
Code java
Client de classe publique {public static void main (String args []) lève une exception {// pour simplicité, toutes les exceptions sont jetées directement String host = "127.0.0.1"; // L'adresse IP du serveur à connecter est int port = 8899; // Le port d'écoute correspondant du serveur à connecter // La connexion est établie avec le serveur Client = new socket (hôte, port); // Après avoir établi la connexion, vous pouvez écrire des données sur le serveur écrivain = new OutputStreamWriter (client.getOutputStream ()); writer.write ("Hello Server."); écrivain.write ("eof / n"); écrivain.flush (); // Lire après avoir écrit BufferedReader br = new BufferedReader (new inputStreamReader (client.getInputStream ())); StringBuffer sb = new StringBuffer (); Chaîne temporaire; INT INDEX; while ((temp = br.readline ())! = null) {if ((index = temp.indexof ("eof"))! = -1) {sb.append (temp.substring (0, index)); casser; } sb.append (temp); } System.out.println ("From Server:" + SB); écrivain.close (); br.close (); client.close (); }}4. Réglez l'heure du délai d'expiration
Supposons qu'il existe une telle exigence que notre client doit obtenir des informations XX à partir du serveur via Socket, puis l'afficher à l'utilisateur sur la page. Nous savons que Socket bloque lors de la lecture des données, et si vous ne lisez pas les données, le programme continuera de bloquer là-bas. Lors de la synchronisation de la demande, nous ne devons pas permettre une telle situation. Cela nous oblige à contrôler l'interruption de blocage une fois que la demande atteint un certain temps afin que le programme puisse continuer à s'exécuter. Socket nous fournit une méthode SetSoTimeout () pour définir l'heure du délai d'expiration des données reçues en millisecondes. Lorsque le délai de délai d'exécution est supérieur à 0 et après cette époque, le socket n'a pas reçu les données renvoyées, le socket lancera un sockettimeoutException.
Supposons que nous devons contrôler notre client pour interrompre et bloquer avant de lire les données pendant 10 secondes après avoir commencé à lire les données, nous pouvons le faire:
Code java
Client de classe publique {public static void main (String args []) lève une exception {// pour simplicité, toutes les exceptions sont jetées directement String host = "127.0.0.1"; // L'adresse IP du serveur à connecter est int port = 8899; // Le port d'écoute correspondant du serveur à connecter // La connexion est établie avec le serveur Client = new socket (hôte, port); // Après avoir établi la connexion, vous pouvez écrire des données sur le serveur écrivain = new OutputStreamWriter (client.getOutputStream ()); writer.write ("Hello Server."); écrivain.write ("eof / n"); écrivain.flush (); // Lire après avoir écrit BufferedReader br = new BufferedReader (new inputStreamReader (client.getInputStream ())); // Définit le délai d'attente sur 10 secondes Client.SetSoTimeout (10 * 1000); StringBuffer sb = new StringBuffer (); Chaîne temporaire; INT INDEX; try {while ((temp = br.readline ())! = null) {if ((index = temp.indexof ("eof"))! = -1) {sb.append (temp.substring (0, index)); casser; } sb.append (temp); }} catch (sockettimeoutexception e) {System.out.println ("Data Read Timeout."); } System.out.println ("From Server:" + SB); écrivain.close (); br.close (); client.close (); }}5. Recevoir du code brouillé de données
Pour de tels cas lorsque le serveur ou le client reçoit du code chinois brouillé, c'est généralement parce que le codage utilisé lorsque les données sont envoyées sont incompatibles avec le codage utilisé lorsque les données sont reçues. Par exemple, il y a un code de serveur comme celui-ci:
Code java
public class Server {public static void main (String args []) lève ioException {// Pour simplicité, toutes les informations d'exception sont jetées int port = 8899; // Définir un SERVERSOCKET Écoutant sur le port 8899 Serversocket Server = new Serversocket (port); tandis que (true) {// le serveur essaie de recevoir des demandes de connexion d'autres sockets. La méthode d'acceptation du serveur est une prise de blocage Socket = Server.Accept (); // Chaque fois qu'une prise est reçue, un nouveau thread est établi pour le gérer un nouveau thread (nouvelle tâche (socket)). Start (); }} / ** * * / La tâche de classe statique implémente Runnable {private socket socket; tâche publique (socket socket) {this.socket = socket; } public void run () {try {handlesocket (); } catch (exception e) {e.printStackTrace (); }} / ** * Communiquez avec le socket client * @throws exception * / private void handlesocket () lève l'exception {buttereDeader br = new BufferedReader (new inputStreamReader (socket.getInputStream (), "gbk")); StringBuilder sb = new StringBuilder (); Chaîne temporaire; INT INDEX; while ((temp = br.readline ())! = null) {System.out.println (temp); if ((index = temp.Indexof ("eof"))! = -1) {// fin réception lorsque eof est rencontré sb.append (temp.substring (0, index)); casser; } sb.append (temp); } System.out.println ("Client:" + SB); // Écrivez une phrase après la lecture de l'écrivain = new OutputStreamWriter (socket.getOutputStream (), "UTF-8"); writer.write ("Hello, client."); écrivain.write ("eof / n"); écrivain.flush (); écrivain.close (); br.close (); socket.close (); }}}Je suis un peu confus quand je l'ai utilisé ici pour les tests. Dans le code de serveur ci-dessus, nous définissons clairement l'utilisation de l'encodage GBK pour lire les données lors de la définition du flux d'entrée, et spécifions clairement que l'utilisation du codage UTF-8 pour envoyer des données lors de la définition du flux de sortie. Si le client n'envoie pas de données dans le codage GBK lors de l'envoi de données sur le client, les données reçues par le serveur sont susceptibles d'être brouillées; De même, si le client n'envoie pas de codage de données lors de l'envoi de données sur le serveur, c'est-à-dire un codage UTF-8 pour recevoir des données, il est également très probable que des données brouillées se produisent. Par conséquent, pour le code serveur ci-dessus, afin de permettre à notre programme de lire les données envoyées par l'autre partie sans code brouillé, notre client devrait être comme ceci:
Code java
Client de classe publique {public static void main (String args []) lève une exception {// pour simplicité, toutes les exceptions sont jetées directement String host = "127.0.0.1"; // L'adresse IP du serveur à connecter int port = 8899; // Le port d'écoute correspondant du serveur à connecter // La connexion est établie avec le serveur Client = new socket (hôte, port); // Après avoir établi la connexion, vous pouvez écrire des données sur le serveur écrivain = new OutputStreamWriter (client.getOutputStream (), "gbk"); writer.write ("Hello, Server."); écrivain.write ("eof / n"); écrivain.flush (); // Lire après avoir écrit BufferedReader br = new BuffereDReader (new inputStreamReader (client.getInputStream (), "utf-8")); // Définit le délai d'attente sur 10 secondes Client.SetSoTimeout (10 * 1000); StringBuffer sb = new StringBuffer (); Chaîne temporaire; INT INDEX; try {while ((temp = br.readline ())! = null) {if ((index = temp.indexof ("eof"))! = -1) {sb.append (temp.substring (0, index)); casser; } sb.append (temp); }} catch (sockettimeoutexception e) {System.out.println ("Data Read Timeout."); } System.out.println ("Server:" + SB); écrivain.close (); br.close (); client.close (); }}Cet article a été compilé dans "Résumé des techniques d'opération de téléchargement Java", et tout le monde est le bienvenu pour apprendre et lire.
Ce qui précède est tout le contenu de cet article. J'espère que cela sera utile à l'apprentissage de tous et j'espère que tout le monde soutiendra davantage Wulin.com.