Dieser Artikel teilt ein Beispiel, um die Anforderungen der Online -Webkommunikation zu erfüllen. Aufgrund der Webversion der von Java Socket implementierten Online -Chat -Funktion als Referenz lautet der spezifische Inhalt wie folgt
Implementierungsschritte:
1. Verwenden Sie AWT -Komponente und Socket, um einen einfachen einzelnen Client zu implementieren, um Nachrichten kontinuierlich an den Server zu senden.
2. In Kombination mit Threads verwalten Sie eine mehrstufige Verbindung zum Server, um Nachrichten zu senden.
3. Implementieren Sie die Server -Weiterleitungs -Client -Nachrichten an alle Clients und zeigen Sie sie gleichzeitig im Client an.
4. Ändern Sie die von der AWT-Komponente generierte Fensterschnittstelle in die von Front-End JSP oder HTML angezeigte Schnittstelle und ändern Sie den von Java Socket implementierten Client in die Implementierung der Front-End-Technologie.
Hier implementieren wir zunächst die einfache Funktion des ersten Schritts. Die Schwierigkeit ist:
1. Ich habe die AWT-Komponente noch nie verwendet und habe noch nie Java-bezogene Hörereignisse verwendet.
2. Ich habe seit langem Steckdose keine Steckdosen verwendet, um zwischen dem Client und dem Server zu interagieren, und ich habe die CSS -Struktur nicht wirklich entwickelt.
Code zum Implementieren der Funktion :
Online -Chat -Client:
1. Generieren Sie die Grafikfensterschnittstelle umrissen
2. Fügen Sie dem Umriss eine enge Veranstaltung hinzu
3. Fügen Sie dem Umriss Eingabebereich und Inhaltsanzeige hinzu
4. Fügen Sie dem Eingabebereich ein Wagenrückgabeereignis hinzu
5. Stellen Sie eine Serververbindung her und senden Sie Daten
Paketchat.Chat; Import Java.awt.BorderLayout; import Java.awt.frame; import Java.awt.textarea; import Java.awt.textfield; import Java.awt.event.ActionEvent; import Java.awt.event.ActionListener; Import Java.awt.event.Windowadapter; Import Java.awt.event.WindowEvent; importieren java.io.dataoutputStream; importieren java.io.ioException; importieren java.net.socket; Importieren Sie java.net.unnownhostException; / ** * Online -Chat -Client 1. Erstellen Sie den Umriss der grafischen Fensterschnittstelle 2. Fügen Sie der Umrisse ein Schließereignis hinzu. // Inhaltsanzeige private textarea taste = new textarea (); privater Socket Socket = Null; // Datenausgabe Stream Private DataOutputStream DataOutputStream = NULL; public static void main (String [] args) {new chatclient (). Launcframe (); } / ** * Erstellen Sie ein einfaches grafisches Fenster * * @Author: tuzongxun * @title: LauncFrame * @param * @return void * @date 18. Mai 2016 9:57:00 Uhr * @throws * / public void launcframe () {setLocation (300, 200); this.setsize (200, 400); add (tftxt, borderLayout.South); add (tarea, borderLayout.north); Pack(); // Hören Sie sich das Schließereignis des grafischen Schnittstellenfensters an. tftxt.addactionListener (new tflister ()); setvisible (wahr); verbinden(); } / ** * Verbindung zum Server * * * @Author: tuzongxun * @title: connect * @param * @return void * @date 18. Mai 2016 9:56:49 AM * @Throws * / public void Connect () {try {// Erstellen Sie eine neue Serververbindungs -Socket ("127.0.1.1.1", 8888); // Client -Ausgabe -Stream dataOutputStream = new DataOutputStream (socket.getOutputStream ()); System.out.println ("Verbindung zum Server herstellen"); } catch (unbekannteHostException e) {e.printstacktrace (); } catch (ioException e) {e.printstacktrace (); }} / ** * Client -Ressourcen schließen * * @Author: tuzongxun * @title: disconnect * @param * @return void * @date 18. Mai 2016 9:57:46 am * @throws * / public void disconnect () {try {DataOutputStream.CLOSE (); socket.close (); } catch (ioException e) {e.printstacktrace (); }} / ** * Senden Sie eine Nachricht an den Server * * @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.write.write.writef (textf (text); DataOutputStream.flush (); } catch (ioException e1) {e1.printstacktrace (); }} / ** * Grafikfenster Eingabebereich zum Anhören von Wagenrückgabeereignis * * @Author Tuzongxun123 * * / private class Tflister implementiert actionListener {@Override public void actionPerformed (actionEvent e) {String text = tftxt.getText (). Trim (); Taxa.SetText (Text); tftxt.setText (""); // Daten an den Server SendMessage (Text) senden; }}} Server:
Paketchat.Chat; importieren java.io.datainputstream; importieren java.io.eofexception; importieren java.io.ioException; importieren java.net.bindException; importieren java.net.serversocket; importieren java.net.socket; /*** Java verwendet Socket- und AWT -Komponenten, um einfach die Online -Chat -Funktion zu implementieren. Der Server kann die Serververbindung erkennen, um Nachrichten kontinuierlich an den Server zu senden, nachdem ein Client verbunden ist*, unterstützt jedoch nicht mehrere Clients, um gleichzeitig eine Verbindung herzustellen. Der Grund dafür ist, dass nach der Erfassung der Clientverbindung im Code die Client -Eingänge immer wieder geschleudert werden, sodass der Server einen anderen Client nicht zweimal anhören kann. Wenn Sie es implementieren möchten, müssen Sie Asynchronous oder Multithreads * @Author Tuzongxun123 * */ public Class Chatserver {public static void main (String [] args) {// Ob der Server erfolgreich mit boolean istart = false gestartet werden; // Server Socket ServerSocket SS = NULL; // Client Socket Socket Socket = NULL; // Server lesen Client -Dateneingangsstrom DataNputStream DataNputStream = NULL; Versuchen Sie {// starten Server SS = New ServerSocket (8888); } catch (bindException e) {System.out.println ("Port ist bereits verwendet"); // das Programmsystem schließen.exit (0); } catch (Ausnahme e) {e.printstacktrace (); } try {isStart = true; während (isStart) {boolean isConnect = false; // Starten Sie den Hör -Socket = ss.accept (); System.out.println ("ein Client Connect"); isconnect = true; while (isconnect) {// den Client -Eingangsstrom DataNputStream = new DataNputStream (socket.getInputStream ()) abrufen; // Lesen Sie die von der Client -String -Message = DataNputStream.readutf () übergebenen Daten; System.out.println ("Client sagt:" + meldung); }}} catch (eOfException e) {System.out.println ("Client geschlossen!"); } catch (Ausnahme e) {e.printstacktrace (); } endlich {// Schließen Sie die zugehörige Ressource try {dataNputStream.close (); socket.close (); } catch (ioException e) {e.printstacktrace (); }}}}Weiter, basierend auf einer einzelnen Clientverbindung erfordert der zweite Schritt hier die Implementierung mehrerer Clientverbindungen, für die die Verwendung von Threads erforderlich ist. Immer wenn ein neuer Client eine Verbindung herstellt, muss der Server einen neuen Thread für die Verarbeitung starten und so das Problem der Blockierung in früheren Schleifenlesungen löst.
In der Regel gibt es zwei Methoden zum Schreiben von Threads: Integration von Thread oder Implementierung der Runnable -Schnittstelle. Wenn es Runnable implementieren kann, wird es im Prinzip nicht vererbt, da die Art und Weise, wie die Schnittstelle implementiert ist, flexibler ist.
Der Client -Code hat sich im Vergleich zu zuvor nicht geändert und ist ein Server geworden. Daher wird hier nur der Servercode veröffentlicht:
Java verwendet Socket- und AWT-Komponenten und Multi-Threading, um einfach den Online-Chat-Funktionserver zu implementieren:
Nachdem mehrere Clients verbunden sind, werden Nachrichten kontinuierlich an den Server gesendet. Im Vergleich zur ersten Version liegt der Fokus auf der Verwendung von Multi-Threading. Der Server hat die Weiterleitungsfunktion noch nicht implementiert. Der Kunde kann nur die Informationen im Grafikfenster selbst sehen und nicht die von anderen Clients gesendeten Nachrichten sehen.
Paketchat.Chat; importieren java.io.datainputstream; importieren java.io.eofexception; importieren java.io.ioException; importieren java.net.bindException; importieren java.net.serversocket; importieren java.net.socket; importieren java.net.socketException; / ** * * * @Author TuzongXun123 * */ public class chatserver {public static void main (String [] args) {new chatserver (). start (); } //, ob der Server erfolgreich gestartet wird, privat boolean isStart = false; // Server Socket Private ServerSocket SS = NULL; // Client Socket Private Socket Socket = NULL; public void start () {try {// start server ss = new ServerSocket (8888); } catch (bindException e) {System.out.println ("Port wird verwendet"); // das Programmsystem schließen.exit (0); } catch (Ausnahme e) {e.printstacktrace (); } try {isStart = true; while (isStart) {// starten Sie Hören von Socket = ss.accept (); System.out.println ("ein Client Connect"); // Client Thread client Client = New Client (Socket) starten; neuer Thread (Client) .Start (); }} catch (Ausnahme e) {e.printstacktrace (); } endlich {// schließen den Dienst try {ss.close (); } catch (ioException e) {e.printstacktrace (); }}} / ** * Client -Thread * * @Author Tuzongxun123 * * / Client implementiert Runnable {// Client Socket Private Socket Socket = NULL; // Client -Eingabestream Private DataNputStream DataNputStream = NULL; privat boolean isconnect = false; public Client (Socket Socket) {this.socket = Socket; Versuchen Sie {isconnect = true; // Client -Eingabestream datainputStream = new DataNputStream (socket.getInputStream ()) erhalten; } catch (ioException e) {e.printstacktrace (); }} @Override public void run () {isconnect = true; Versuchen Sie {while (isConnect) {// Lesen Sie die von der Client -String -Meldung übergebenen Daten = DataNputStream.readutf (); System.out.println ("Client sagt:" + meldung); }} catch (eOfException e) {System.out.println ("Client geschlossen!"); } catch (socketException e) {System.out.println ("Client ist geschlossen !!!"); } catch (Ausnahme e) {e.printstacktrace (); } endlich {// Schließen Sie die entsprechende Ressource -Try {dataNputStream.close (); socket.close (); } catch (ioException e) {e.printstacktrace (); }}}}}In der obigen wird hauptsächlich die Funktion der Verwendung von Threads vorgestellt, damit der Server mehrstufige Anforderungen empfangen kann. Hier muss der Client mehrstufige Nachrichten empfangen, während sie Nachrichten an jeden verbundenen Client weiterleitet, und der Kunde muss in der Lage sein, sie im Inhaltsanzeigebereich anzuzeigen, wodurch ein einfacher Online-Gruppenchat erkannt wird.
Bei der Implementierung der Client -Weiterleitung ist es nichts anderes, als den Ausgangsstrom zu erhöhen. Vorher hat der Client es nur gesendet, aber nicht empfangen, daher muss er auch den Client so ändern, dass er Servermeldungen auf kreisförmige Weise empfangen, sodass er auch Multi-Threading implementieren muss.
Bei der Implementierung dieser Funktion erinnerte ich mich versehentlich an die Funktion, nach dem Zufallsprinzip von Verifizierungscodes zu generieren. Daher hatte ich eine plötzliche Inspiration, für jeden Client zufällig einen Namen zu generieren, sodass es beim Ausgabe eher wie ein Gruppenchat aussieht, sondern auch die Ausgabe von Nachrichten, sondern auch sehen kann, wer es ist.
Nach der Implementierung dieser Funktionen können Sie im Grunde genommen gleichzeitig einen Gruppenchat online für mehrere Personen veranstalten. Da im Code eine Hauptmethode vorhanden ist, können Sie sowohl den Server als auch den Client in ausführbare JAR -Pakete machen. Sie können auf einen anderen Blog -Beitrag von mir verweisen: Verwenden Sie Eclipse, um ein ausführbares JAR -Paket für ausführbare Java -Programme zu erstellen.
Doppelklicken Sie dann auf die entsprechende JAR-Datei auf dem Desktop, um den Server und den Client zu starten, und Sie müssen sich nicht mehr auf Eclipse verlassen, um auszuführen.
Der geänderte Client -Code lautet wie folgt:
Paketchat.Chat; Import Java.awt.BorderLayout; import Java.awt.frame; import Java.awt.textarea; import Java.awt.textfield; import Java.awt.event.ActionEvent; import Java.awt.event.ActionListener; Import Java.awt.event.Windowadapter; Import Java.awt.event.WindowEvent; importieren java.io.datainputstream; importieren java.io.dataoutputStream; importieren java.io.ioException; importieren java.net.socket; Importieren Sie java.net.unnownhostException; import Java.util.random; /** * Online -Chat -Client Schritte: * 1. Generieren Sie den Umriss der grafischen Fensterschnittstelle*2. Fügen Sie eine enge Veranstaltung für den Umriss*3 hinzu. Fügen Sie in der Umriss*4 einen Eingabebereich und einen Inhaltsanzeigebereich hinzu. Fügen Sie ein Wagenrückgabeereignis für den Eingabebereich*5 hinzu. Stellen Sie eine Serververbindung fest und senden Sie Daten * * @Author Tuzongxun123 * */ Public Class Chatclient erweitert den Frame {/ ** * */ private statische endgültige lange Serialversionuid = 1L; // Benutzereingabebereich private TextField tftxt = new textField (); // Inhaltsanzeige private textarea taste = new textarea (); privater Socket Socket = Null; // Datenausgabe Stream Private DataOutputStream DataOutputStream = NULL; // Dateneingabe Stream Private DataNputStream DataNputStream = NULL; privat boolean isconnect = false; Thread Treceive = neuer Thread (neuer Empfangsread ()); String name = ""; public static void main (String [] args) {chatclient chatclient = new chatclient (); chatclient.createName (); chatclient.launcframe (); } / ** * Erstellen Sie ein einfaches grafisches Fenster * * @Author: tuzongxun * @title: LauncFrame * @param * @return void * @date 18. Mai 2016 9:57:00 Uhr * @throws * / public void launcframe () {setLocation (300, 200); this.setsize (200, 400); add (tftxt, borderLayout.South); add (tarea, borderLayout.north); // Bestimmen Sie die optimale Größe des Rahmens entsprechend dem Layout im Fenster und der bevorzugten Kennzeichnung der Komponentenpackungen (); // Hören Sie sich das Schließereignis des grafischen Schnittstellenfensters an. tftxt.addactionListener (new tflister ()); // Setzen Sie das Fenster, um setVisible (true) zu sehen. verbinden(); // Starten Sie den Thread, der die Nachricht treceive.start () akzeptiert; } / ** * Verbindung zum Server * * * @Author: tuzongxun * @title: connect * @param * @return void * @date 18. Mai 2016 9:56:49 AM * @Throws * / public void Connect () {try {// Erstellen Sie eine neue Serververbindungs -Socket ("127.0.1.1.1", 8888); // Client -Ausgabe -Stream dataOutputStream = new DataOutputStream (socket.getOutputStream ()); DataNputStream = new DataNputStream (Socket.GetInputStream ()); System.out.println ("Verbindung zum Server herstellen"); isconnect = true; } catch (unbekannteHostException e) {e.printstacktrace (); } catch (ioException e) {e.printstacktrace (); } } // Generate random client name public void createName() { String[] str1 = { "a", "b", "c", "d", "e", "f", "g", "h", "i", "j", "k", "l", "m", "n", "o", "p", "q", "r", "s", "t", "u", "v", "w", "x", "y", "z", "1", "2", "3", "4", "5", "6", "7", "8", "9", "0", "a", "B", "C", "D", "E", " "P", "Q", "R", "S", "T", "U", "V", "W", "X", "Y", "Z"}; Random ran = new random (); für (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 (Name); } else {i--; weitermachen; }} this.settitle (Name); } / ** * Client -Ressourcen schließen * * @author: tuzongxun * @title: trucnect * @param * @return void * @date 18. Mai 2016 9:57:46 AM * @Throws * / public void disconnect () {try {isconnect = false; // Thread treceive.join () anhalten; } catch (interruptedException e) {e.printstacktrace (); } endlich {try {if (dataOutputStream! = null) {dataOutputStream.close (); } if (socket! = null) {socket.close (); Socket = null; }} catch (ioException e) {e.printstacktrace (); }}} / ** * Senden Sie eine Nachricht an den Server * * @Author: tuzongxun * @title: sendMessage * @param @param text * @return void * @date 18. Mai 2016 9:57:56 AM * @Throws * / private void sendMessage (String text) {try {dataOutStream.writ (name DataOutputStream.flush (); } catch (ioException e1) {e1.printstacktrace (); }} / ** * Grafikfenster Eingabebereich Hörwagen -Rückgabeereignis * * @Author Tuzongxun123 * * / private class tflister implements actionListener {@Override public void actionPerformed (actionEvent e) {String text = tftxt.gettext (). Trim (); // Die Eingabebereicheninformationen tftxt.setText ("") löschen; // Senden Sie die Daten nach dem Drücken des Wagens nach SendMessage (Text) an den Server. }} private classempfangsread implements runnable {@Override public void run () {try {while (isConnect) {String message = dataNputStream.readutf (); System.out.println (Nachricht); String txt = keyword.getText (); if (txt! } Taxa.setText (Nachricht); }} catch (ioException e) {e.printstacktrace (); }}}} Der geänderte Servercode lautet wie folgt:
Paketchat.Chat; importieren java.io.datainputstream; importieren java.io.dataoutputStream; importieren java.io.eofexception; importieren java.io.ioException; importieren java.net.bindException; importieren java.net.serversocket; importieren java.net.socket; importieren java.net.socketException; Import Java.util.ArrayList; importieren java.util.list; /** * Java verwendet Socket- und AWT-Komponenten und Multi-Threading, um einfach den Online-Chat-Funktionserver zu implementieren: * Der Server implementiert, dass die empfangenen Clientinformationen an alle verbundenen Clients weitergeleitet werden, und ermöglicht es dem Client, diese Informationen zu lesen und im Inhaltsanzeigebereich anzuzeigen. * * @Author Tuzongxun123 * */ public class chatserver {public static void main (String [] args) {new chatServer (). start (); } //, ob der Server erfolgreich gestartet wird, privat boolean isStart = false; // Server Socket Private ServerSocket SS = NULL; // Client Socket Private Socket Socket = NULL; // Client -Sammlungsliste <Clients> Clients = new ArrayList <Client> () speichern; public void start () {try {// starten Sie den Server SS = New ServerSocket (8888); } catch (bindException e) {System.out.println ("Port wird verwendet"); // das Programmsystem schließen.exit (0); } catch (Ausnahme e) {e.printstacktrace (); } try {isStart = true; while (isStart) {// starten Sie den Hör -Socket = ss.accept (); System.out.println ("ein Client Connect"); // Starten Sie den Client -Thread Client client = new client (Socket); neuer Thread (Client) .Start (); Clients.Add (Client); }} catch (Ausnahme e) {e.printstacktrace (); } endlich {// schließen den Dienst try {ss.close (); } catch (ioException e) {e.printstacktrace (); }}} / ** * Client -Thread * * @Author TuzongXun123 * * / private class Client Implements Runnable {// Client Socket Private Socket Socket = null; // Client -Eingabestream Private DataNputStream DataNputStream = NULL; // Client -Ausgabe Stream Private DataOutputStream DataOutputStream = NULL; privat boolean isconnect = false; public Client (Socket Socket) {this.socket = Socket; Versuchen Sie {isconnect = true; // Client -Eingabestream datainputStream = new DataNputStream (socket.getInputStream ()) erhalten; // Client -Ausgabe -Stream dataOutputStream = new DataOutputStream (socket.getOutputStream ()); } catch (ioException e) {e.printstacktrace (); } } /** * Bulk send (forward) data to the client* * @author: tuzongxun * @Title: sendMessageToClients * @param @param message * @return void * @date May 18, 2016 11:28:10 AM * @throws */ public void sendMessageToClients(String message) { try { dataOutputStream.writeUTF(message); } catch (socketException e) {} catch (ioException e) {e.printstacktrace (); }} @Override public void run () {isconnect = true; Client C = NULL; Versuchen Sie {while (isConnect) {// Lesen Sie die von der Client -String -Meldung übergebenen Daten = DataNputStream.readutf (); System.out.println ("Der Client sagt:" + meldung); für (int i = 0; i <Clients.size (); i ++) {c = clients.get (i); C.SendMessAgetoclients (Nachricht); }}} catch (eOfException e) {System.out.println ("Client geschlossen!"); } catch (socketException e) {if (c! = null) {Clients.remove (c); } System.out.println ("Client ist geschlossen !!!"); } catch (Ausnahme e) {e.printstacktrace (); } endlich {// Schließen Sie die relevante Ressource -Try {if (DataNputStream! = null) {datainputStream.close (); } if (socket! = null) {socket.close (); Socket = null; }} catch (ioException e) {e.printstacktrace (); }}}}}}}}}}}}}}}}}}}}}}}}Lassen Sie es uns zuerst Ihnen vorstellen und dann für Sie aktualisieren, wenn neue Inhalte vorhanden sind.
In Bezug auf die Realisierung der Web -Online -Chat -Funktion können Sie auch auf die folgenden Lernartikel verweisen:
Java implementiert eine einfache TCPSocket -Chatroom -Funktionsfreigabe
Das obige ist der gesamte Inhalt dieses Artikels. Ich hoffe, es wird für das Lernen aller hilfreich sein und ich hoffe, Sie können weiterhin auf aufregende Inhalte von Wulin.com achten.