Cet article partage un exemple pour répondre aux besoins de la communication Web en ligne. En raison de la version Web de la fonction de chat en ligne implémentée par Java Socket, pour votre référence, le contenu spécifique est le suivant
Étapes de mise en œuvre:
1. Utilisez le composant AWT et le socket pour implémenter un simple client unique pour envoyer en continu des messages au serveur;
2. Combiné avec des threads, réalisez la connexion multi-client au serveur pour envoyer des messages;
3. Implémentez les messages clients de transfert de serveur à tous les clients et affichez-les sur le client en même temps;
4. Changez l'interface de fenêtre générée par le composant AWT en l'interface affichée par JSP ou HTML frontal, et modifiez le client implémenté par Java Socket en implémentation de technologie frontale.
Ici, nous implémentons d'abord la fonction simple de la première étape, la difficulté est:
1. Je n'ai jamais utilisé le composant AWT et je n'ai jamais utilisé d'événements d'écoute liés à Java;
2. Je n'ai pas utilisé de sockets pendant de longues périodes pour interagir entre le client et le serveur, et je n'ai pas vraiment développé la structure CSS.
Code pour implémenter la fonction :
Client de chat en ligne:
1. Générer le contac de l'interface de la fenêtre graphique
2. Ajoutez un événement proche au contour
3. Ajouter la zone d'entrée et la zone d'affichage du contenu au contour
4. Ajouter un événement de retour de chariot à la zone d'entrée
5. Établir une connexion au serveur et envoyer des données
package chat.chat; import java.awt.borderLayout; import java.awt.frame; Importer java.awt.TextArea; import java.awt.textfield; import java.awt.event.actionEvent; import java.awt.event.actionListener; Importer java.awt.event.windowAdapter; import java.awt.event.windowEvent; import java.io.dataOutputStream; Importer java.io.ioException; import java.net.socket; import java.net.unknownhostException; / ** * Client de chat en ligne 1. Générez l'interface de la fenêtre graphique Aperçu 2. Ajoutez un événement proche au contour 3. Ajoutez une zone de saisie et une zone d'affichage de contenu au contour 4. Ajoutez un événement de retour du chariot pour la zone de saisie * 5. Créez une connexion de serveur et envoyez des données * * @Author Tuzongxun123 * * * / public class ChatClient étend cadre {// user ère de saisie TextField private // zone d'affichage de contenu Private TextArea Taste = new TextArea (); Pobite privée socket = null; // Data Output Stream Private DataOutStream DataOutputStream = NULL; public static void main (string [] args) {new ChatClient (). launcFrame (); } / ** * Créez une fenêtre graphique simple * * @author: tuzongxun * @title: launcframe * @param * @return void * @Date 18 mai 2016 9:57:00 AM * @throws * / public void launcframe () {setLocation (300, 200); this.setSize (200, 400); Add (tftxt, borderlayout.south); ajouter (tarea, borderlayout.north); paquet(); // Écoutez l'événement de clôture de la fenêtre d'interface graphique this.addwindowListener (new WindowAdapter () {@Override public void windowClating (windowEvent e) {System.exit (0); disconnect ();}}); tftxt.addactionListener (new tfister ()); setVisible (true); connecter(); } / ** * Connectez-vous au serveur * * @author: tuzongxun * @title: connect * @param * @return void * @Date 18 mai 2016 9:56:49 AM * @throws * / public void connect () {try {// Créer un nouveau socket de connexion du serveur = new socket ("127.0.1", 8888); // Obtenir le flux de sortie du client DataOutStream = new DataOutputStream (socket.getOutputStream ()); System.out.println ("Connecter au serveur"); } catch (inconnuhostException e) {e.printStackTrace (); } catch (ioException e) {e.printStackTrace (); }} / ** * Fermer les ressources du client * * @Author: Tuzongxun * @Title: Disconnect * @param * @return void * @Date 18 mai 2016 9:57:46 AM * @throws * / public void déconnect () {try {dataoutputStream.close (); socket.close (); } catch (ioException e) {e.printStackTrace (); }} / ** * Envoyez un message au serveur * * @author: tuzongxun * @title: sendMessage * @param @param text * @return void * @Date le 18 mai 2016 9:57:56 AM * @throws * / private void SendMessage (String Text) {try {dataUtStream.WriteUtf (text); dataOutputStream.flush (); } catch (ioException e1) {e1.printStackTrace (); }} / ** * Zone d'entrée de fenêtre graphique pour écouter l'événement de retour de voiture * * @author tuzongxun123 * * / classe privée tflister implémente ActionListener {@Override public void ActionPerformed (actionEvent e) {String text = tftxt.getText (). Trim (); taxa.setText (texte); tftxt.setText (""); // Envoi des données au serveur SendMessage (texte); }}} Serveur:
package chat.chat; import java.io.datainputStream; Importer java.io.eofException; Importer java.io.ioException; import java.net.bindexception; import java.net.serversocket; import java.net.socket; / ** * Java utilise des composants Socket et AWT pour simplement implémenter la fonction de chat en ligne. Le serveur peut réaliser que le serveur envoie en continu des messages au serveur après avoir connecté un client * mais ne prend pas en charge plusieurs clients pour se connecter en même temps. La raison en est qu'après avoir obtenu la connexion client dans le code, il continuera d'écouter les entrées du client en boucle, provoquant un blocage * afin que le serveur ne puisse pas écouter un autre client deux fois. Si vous souhaitez l'implémenter, vous devez utiliser Asynchronous ou Multithread * * @author Tuzongxun123 * * / classe publique Chatserver {public static void main (String [] args) {// Si le serveur est démarré avec succès booléen isStart = false; // socket serversocket ss = null; // socket client socket socket = null; // Server Lire le flux de données du client Stream DatainputStream dataRainputStream = null; essayez {// start Server ss = new serversocket (8888); } catch (bindException e) {System.out.println ("Le port est déjà utilisé"); // fermer le programme System.exit (0); } catch (exception e) {e.printStackTrace (); } essayez {isStart = true; while (isStart) {boolean isConnect = false; // démarrer le socket d'écoute = ss.accept (); System.out.println ("One Client Connect"); isConnect = true; while (isConnect) {// Obtenez le flux de saisie du client datainputStream = new DataRainputStream (socket.getInputStream ()); // Lire les données passées par le Client String Message = dataAnputStream.ReadUtf (); System.out.println ("Le client dit:" + message); }}} catch (eofException e) {System.out.println ("Client fermé!"); } catch (exception e) {e.printStackTrace (); } Enfin {// Fermez la ressource connexe Try {DatAnputStream.Close (); socket.close (); } catch (ioException e) {e.printStackTrace (); }}}}Continuez, en fonction d'une connexion client unique, la deuxième étape nécessite ici l'implémentation de plusieurs connexions client, qui nécessite l'utilisation de threads. Chaque fois qu'un nouveau client se connecte, le serveur doit démarrer un nouveau thread pour le traitement, résolvant ainsi le problème du blocage dans les lectures de boucle précédentes.
Il existe généralement deux méthodes pour écrire des threads: intégrer le thread ou implémenter l'interface Runnable. En principe, si Runnable peut être implémenté, il ne sera pas hérité car la façon d'implémenter l'interface est plus flexible.
Le code client n'a pas changé par rapport à l'avant et est devenu un serveur, donc seul le code du serveur est publié ici:
Java utilise des composants Socket et AWT et multi-threading pour simplement implémenter le serveur de fonctions de chat en ligne:
Une fois que plusieurs clients sont connectés, les messages sont envoyés en permanence au serveur. Par rapport à la première version, l'accent est mis sur l'utilisation du multi-threading. Le serveur n'a pas encore implémenté la fonction de transfert. Le client ne peut voir que les informations saisies par elle-même dans la fenêtre graphique et ne peut pas voir les messages envoyés par d'autres clients.
package chat.chat; import java.io.datainputStream; Importer java.io.eofException; Importer java.io.ioException; import java.net.bindexception; import java.net.serversocket; import java.net.socket; import java.net.socketException; / ** * * * @author tuzongxun123 * * / classe publique ChatServer {public static void main (String [] args) {new ChatServer (). start (); } // si le serveur est démarré avec succès booléen privé isStart = false; // socket serveur private serversocket ss = null; // socket client socket privé socket = null; public void start () {try {// start Server ss = new serversocket (8888); } catch (bindException e) {System.out.println ("Le port est utilisé"); // fermer le programme System.exit (0); } catch (exception e) {e.printStackTrace (); } essayez {isStart = true; while (isStart) {// commence à écouter socket = ss.accept (); System.out.println ("One Client Connect"); // Démarrer le client client client Client = nouveau client (socket); nouveau thread (client) .start (); }} catch (exception e) {e.printStackTrace (); } Enfin {// Fermez le service try {ss.close (); } catch (ioException e) {e.printStackTrace (); }}} / ** * Thread client * * @author tuzongxun123 * * / classe Le client implémente Runnable {// socket client private socket socket = null; // Client Input Stream Private DatAnputStream DataRainputStream = NULL; booléen privé isConnect = false; Client public (socket socket) {this.socket = socket; essayez {isConnect = true; // Obtenir le flux de saisie du client DataRainPutStream = new DataRainputStream (socket.getInputStream ()); } catch (ioException e) {e.printStackTrace (); }} @Override public void run () {isConnect = true; try {while (isConnect) {// Lisez les données passées par le message du client Message = DataAnputStream.readUtf (); System.out.println ("Le client dit:" + message); }} catch (eofException e) {System.out.println ("Client fermé!"); } catch (socketException e) {System.out.println ("Le client est fermé !!!"); } catch (exception e) {e.printStackTrace (); } Enfin {// Fermez la ressource pertinente try {datainputStream.close (); socket.close (); } catch (ioException e) {e.printStackTrace (); }}}}}Ce qui précède introduit principalement la fonction de l'utilisation de threads pour permettre au serveur de recevoir des demandes multi-clients. Ici, le client doit recevoir des messages multi-clients tout en transmettant des messages à chaque client connecté, et le client doit être en mesure de les afficher dans la zone d'affichage du contenu, réalisant ainsi un simple chat en ligne en ligne.
Lors de la mise en œuvre du transfert du client, il n'y a rien de plus que d'augmenter le flux de sortie; Avant, le client ne l'envoyait mais ne l'a pas reçu, il doit donc également modifier le client pour recevoir des messages de serveur de manière circulaire, il doit donc également implémenter le multi-threading.
Lors de la mise en œuvre de cette fonction, je me suis souvenu accidentellement de la fonction de générer des codes de vérification au hasard, j'ai donc eu une inspiration soudaine pour générer un nom de manière aléatoire pour chaque client, de sorte que lors de la sortie, il ressemble plus à un chat de groupe, non seulement une sortie de message, mais peut également voir de qui il s'agit.
Après avoir mis en œuvre ces fonctions, vous pouvez essentiellement avoir un chat de groupe en ligne en même temps pour plusieurs personnes. Étant donné qu'il existe une méthode principale dans le code, vous pouvez faire du serveur et du client en packages JAR exécutables. Vous pouvez vous référer à un autre article de blog: Utilisez Eclipse pour créer un package JAR JAVA exécutable de programme Java.
Double-cliquez ensuite sur le fichier JAR correspondant sur le bureau pour démarrer le serveur et le client, et vous n'avez plus besoin de compter sur Eclipse pour s'exécuter.
Le code client modifié est le suivant:
package chat.chat; import java.awt.borderLayout; import java.awt.frame; Importer java.awt.TextArea; import java.awt.textfield; import java.awt.event.actionEvent; import java.awt.event.actionListener; Importer java.awt.event.windowAdapter; import java.awt.event.windowEvent; import java.io.datainputStream; import java.io.dataOutputStream; Importer java.io.ioException; import java.net.socket; import java.net.unknownhostException; import java.util.random; / ** * Étapes du client de chat en ligne: * 1. Générer le contour de l'interface de la fenêtre graphique * 2. Ajoutez un événement proche pour le contour * 3. Ajoutez une zone d'entrée et une zone d'affichage de contenu dans le contour * 4. Ajoutez un événement de retour du chariot pour la zone d'entrée * 5. Établir une connexion de serveur et envoyer des données * * @author tuzongxun123 * * / classe publique ChatClient étend le trame {/ ** * * / private static final SerialVersionUID = 1l; // zone d'entrée utilisateur Private TextField tftxt = new TextField (); // zone d'affichage de contenu Private TextArea Taste = new TextArea (); Pobite privée socket = null; // Data Output Stream Private DataOutStream DataOutputStream = NULL; // Data Input Stream Private DatAnputStream DataRainputStream = NULL; booléen privé isConnect = false; Thread treceive = nouveau thread (new ReceiVetHread ()); String name = ""; public static void main (String [] args) {chatClient chatClient = new ChatClient (); ChatClient.CreateName (); chatClient.LauncFrame (); } / ** * Créez une fenêtre graphique simple * * @author: tuzongxun * @title: launcframe * @param * @return void * @Date 18 mai 2016 9:57:00 AM * @throws * / public void launcframe () {setLocation (300, 200); this.setSize (200, 400); Add (tftxt, borderlayout.south); ajouter (tarea, borderlayout.north); // déterminer la taille optimale de la trame en fonction de la disposition de la fenêtre et de la taille préférée du pack de composants (); // Écoutez l'événement de clôture de la fenêtre d'interface graphique this.addwindowListener (new WindowAdapter () {@Override public void windowClating (windowEvent e) {System.exit (0); disconnect ();}}); tftxt.addactionListener (new tfister ()); // Définissez la fenêtre pour voir setVisible (true); connecter(); // Démarrez le thread qui accepte le message treceive.start (); } / ** * Connectez-vous au serveur * * @author: tuzongxun * @title: connect * @param * @return void * @Date 18 mai 2016 9:56:49 AM * @throws * / public void connect () {try {// Créer un nouveau socket de connexion du serveur = new socket ("127.0.1", 8888); // Obtenir le flux de sortie du client DataOutStream = new DataOutputStream (socket.getOutputStream ()); DatAnputStream = new DatAnputStream (socket.getInputStream ()); System.out.println ("Connecter au serveur"); isConnect = true; } catch (inconnuhostException e) {e.printStackTrace (); } catch (ioException e) {e.printStackTrace (); }} // générer un nom de client aléatoire public void createName () {string [] str1 = {"a", "b", "c", "d", "e", "f", "g", "h", "i", "j", "k", "l", "m", "n" "w", "x", "y", "z", "1", "2", "3", "4", "5", "6", "7", "8", "9", "0", "a", "b", "c", "d", "e", "f", "g" "P", "q", "r", "s", "t", "u", "v", "w", "x", "y", "z"}; Random ran = nouveau aléatoire (); pour (int i = 0; i <6; i ++) {// long num = math.round (math.random () * (str1.length - 0) + 0); // int n = (int) num; int n = ran.nextint (str1.length); if (n <str1.length) {String str = str1 [n]; name = name + str; System.out.println (nom); } else {i--; continuer; }} this.setTitle (name); } / ** * Fermer les ressources du client * * @author: tuzongxun * @Title: Disconnect * @param * @return void * @Date 18 mai 2016 9:57:46 AM * @throws * / public void Disconnect () {try {isConnect = false; // stop thread treceive.join (); } catch (InterruptedException e) {e.printStackTrace (); } enfin {try {if (dataOutputStream! = null) {dataOutputStream.close (); } if (socket! = null) {socket.close (); socket = null; }} catch (ioException e) {e.printStackTrace (); }}} / ** * Envoyez un message au serveur * * @Author: Tuzongxun * @Title: SendMessage * @param @param text * @return void * @Date 18 mai 2016 9:57:56 AM * @throws * / private void sendMessage (String Text) {Try {dataoutPutStream.WriteUtf (Name + ":" + Text); dataOutputStream.flush (); } catch (ioException e1) {e1.printStackTrace (); }} / ** * Zone d'entrée de fenêtre graphique Événement de rendement du chariot * * @author tuzongxun123 * * / classe privée tflister implémente ActionListener {@Override public void ActionPerformed (ActionEvent e) {String text = tftxt.getText (). Trim (); // effacer les informations sur la zone d'entrée tftxt.seTText (""); // Envoyez les données au serveur après avoir appuyé sur le chariot vers SendMessage (texte); }} classe privée receivethread implémente runnable {@Override public void run () {try {while (isConnect) {string message = datainputStream.readutf (); System.out.println (message); String txt = taxa.getText (); if (txt! = null &&! "". equals (txt.trim ())) {message = taxa.getText () + "/ n" + message; } taxa.setText (message); }} catch (ioException e) {e.printStackTrace (); }}}} Le code du serveur modifié est le suivant:
package chat.chat; import java.io.datainputStream; import java.io.dataOutputStream; Importer java.io.eofException; Importer java.io.ioException; import java.net.bindexception; import java.net.serversocket; import java.net.socket; import java.net.socketException; import java.util.arraylist; Importer java.util.list; / ** * Java utilise des composants Socket et AWT et multi-threading pour simplement implémenter le serveur de fonctions de chat en ligne: * Le serveur implémente que les informations du client reçu sont transmises à tous les clients connectés, et permet au client de lire ces informations et de les afficher dans la zone d'affichage du contenu. * * @author tuzongxun123 * * / classe publique ChatServer {public static void main (String [] args) {new ChatServer (). start (); } // si le serveur est démarré avec succès booléen privé isStart = false; // socket serveur private serversocket ss = null; // socket client socket privé socket = null; // Enregistrer la liste de collecte des clients <Simité> CLIENTS = new ArrayList <Simité> (); public void start () {try {// Démarrer le serveur ss = new serversocket (8888); } catch (bindException e) {System.out.println ("Le port est utilisé"); // fermer le programme System.exit (0); } catch (exception e) {e.printStackTrace (); } essayez {isStart = true; while (isStart) {// démarrer le socket d'écoute = ss.accept (); System.out.println ("One Client Connect"); // Démarrer le client client client = nouveau client (socket); nouveau thread (client) .start (); clients.add (client); }} catch (exception e) {e.printStackTrace (); } Enfin {// Fermez le service try {ss.close (); } catch (ioException e) {e.printStackTrace (); }}} / ** * Thread client * * @author tuzongxun123 * * / classe privée Le client implémente Runnable {// socket client socket private socket = null; // Client Input Stream Private DatAnputStream DataRainputStream = NULL; // Client Output Stream Private DataOutStream DataOutputStream = NULL; booléen privé isConnect = false; Client public (socket socket) {this.socket = socket; essayez {isConnect = true; // Obtenir le flux de saisie du client DataRainPutStream = new DataRainputStream (socket.getInputStream ()); // Obtenir le flux de sortie du client DataOutStream = new DataOutputStream (socket.getOutputStream ()); } catch (ioException e) {e.printStackTrace (); }} / ** * Envoi en vrac (vers l'avant) des données au client * * @author: tuzongxun * @title: sendMessageToClients * @param @param message * @return void * @Date 18 mai 2016 11:28:10 AM * @throws * / public void SendMessageToClient (STRING Message) {Try {DataUtPutStream.writef (Message); } catch (socketException e) {} catch (ioException e) {e.printStackTrace (); }} @Override public void run () {isConnect = true; Client C = NULL; try {while (isConnect) {// Lisez les données passées par le message du client Message = DataAnputStream.readUtf (); System.out.println ("Le client dit:" + message); pour (int i = 0; i <clients.size (); i ++) {c = clients.get (i); C.SendMessageToClients (message); }}} catch (eofException e) {System.out.println ("Client fermé!"); } catch (socketException e) {if (c! = null) {clients.Remove (c); } System.out.println ("Le client est fermé !!!"); } catch (exception e) {e.printStackTrace (); } Enfin {// Fermez la ressource pertinente try {if (dataRAnputStream! = null) {dataRainputStream.close (); } if (socket! = null) {socket.close (); socket = null; }} catch (ioException e) {e.printStackTrace (); }}}}}}}}}}}}}}}}}}}}Présenons-le d'abord à vous, puis mettez-le pour vous en cas de nouveau contenu.
En ce qui concerne la réalisation de la fonction de chat en ligne Web, vous pouvez également vous référer aux articles suivants pour l'apprentissage:
Java implémente un partage de fonction de salle de chat tcppsocket simple
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 vous pourrez continuer à faire attention à un contenu plus excitant de Wulin.com.