Java schreibt einen Server und einen Client, mit dem Dateien hochgeladen werden können. Der spezifische Inhalt ist wie folgt
Serverseite
Klasse Server {public static void main (String [] args) löst eine Ausnahme aus {// Erstellen Sie das Server -Socket -ServerSocket SS = New ServerSocket (10005); // Erhalten Sie den Client Socket FileloaderSocket = ss.accept (); // Drucken Sie die Verbindungsinformationszeichenfolge ip = fileloloadersocket. System.out.println (IP + "... connceed"); // die Datei empfangen und InputStream in = fileloloadersocket.getInputStream () speichern; // Die Object Dateisave outputStream fileave = new FileOutputStream ("e: //3.mp3") instanziieren; // Erstellen Sie ein Array buf Byte [] buf = new Byte [1024]; int len = 0; // verteidigen Sie, ob das Ende der Datei gelesen wird ((len = in.read (buf))! = -1) {filesave.write (buf, 0, len); // Dateiave.flush () aktualisieren; } // Dateikopierinformationen BufferedWriter out = new bufferedWriter (neuer Ausgabestreamwriter (FileloaderSocket.getOutputStream ())); out.write ("Datei hochladen erfolgreich"); // out.flush (); // Ressourcen schließen ss.close (); fileLoaderSocket.CLOSE (); fileave.close (); }}Kunde:
Class Client {public static void main (String [] args) löst Ausnahme aus {// Socket Service Socket FileloLaderSocket = New Socket ("168.168.168.94", 10005); // Lesen Sie die Datei lokal vom Client durch und schreiben Sie in den Ausgabestream des Socket -Ausgangsstreams out = fileloloadersocket.getOutputStream (); // Das Objekt fileReader inputStream fileRead = new FileInputStream ("g: //2.mp3") instanziieren; // Erstellen Sie ein Array -Byte [] buf = neues Byte [1024]; int len = 0; // beurteilen, ob das Ende der Datei gelesen wird ((len = fileRead.read (buf))! = -1) {out.write (buf, 0, len); } // Sagen Sie dem Server, dass die Datei fileLoaderSocket.ShutDownoutput () übertragen wurde; // Erhalten Sie das Informationsfeedback vom Server BufferedReader in = New BufferedReader (neuer InputStreamReader (FileloaderSocket.getInputStream ())); String serverback = in.readline (); System.out.println (Serverback); // Ressourcen schließen fileloaderSocket.close (); fileRead.close (); }}Das folgende Programm wird direkt von anderer Stelle von Lernreferenz kopiert:
Java Socket -Programmierung
Für die Java -Socket -Programmierung gibt es zwei Konzepte, einer ist ServerSocket und der andere ist Socket. Der Server und der Client sind über Socket verbunden und können dann kommunizieren. Erstens hört ServerSocket einen Port auf dem Server an. Wenn festgestellt wird, dass der Kunde über einen Socket verfügt, der versucht, sich daran zu verbinden, akzeptiert er die Verbindungsanforderung des Socket und erstellt gleichzeitig einen entsprechenden Socket auf dem Server, um damit zu kommunizieren. Auf diese Weise gibt es zwei Sockets, eine auf dem Client und eine auf dem Server.
Die Kommunikation zwischen Steckdosen ist eigentlich sehr einfach. Wenn der Server etwas in den Socket -Ausgangsstrom schreibt, kann der Client den entsprechenden Inhalt über den Socket -Eingabestream lesen. Der Socket und der Socket sind in zwei Richtungen verbunden, sodass der Client auch Dinge in den entsprechenden Socket -Ausgangsstrom schreiben kann, und dann kann der entsprechende Socket -Eingabestream des Servers den entsprechenden Inhalt lesen. Hier sind einige Beispiele für die serverseitige Kommunikation mit Clients:
1. Client schreiben und Server lesen
Server Java -Code
public class Server {public static void main (String args []) löst IOException aus (// Für den Einfachheit) werden alle Ausnahmeinformationen int port = 8899 ausgeworfen; // Definieren Sie ein ServerSocket -Hören auf Port 8899 ServerSocket Server = New ServerSocket (Port); // Der Server versucht, Verbindungsanforderungen von anderen Sockets zu empfangen. Die Akzeptanzmethode des Servers ist ein blockierender Socket -Socket = server.accept (). // Nach der Erstellung einer Verbindung mit dem Client können wir den InputStream des Sockets erhalten und die vom Client gesendeten Informationen lesen. Reader reader = new InputStreamReader (Socket.getInputStream ()); char chars [] = new char [64]; Int len; StringBuilder sb = new StringBuilder (); while ((len = reader.read (chars))! = -1) {sb.append (neue Zeichenfolge (Zeichen, 0, len)); } System.out.println ("From Client:" + SB); reader.close (); socket.close (); server.close (); }}Der Betrieb des Servers zum Lesen von Daten aus dem InputStream des Sockets blockiert ebenfalls. Wenn die Daten nicht aus dem Eingabestream gelesen werden, bleibt das Programm dort, bis der Client Daten in den Ausgangsstream des Sockets schreibt oder den Ausgangsstrom des Sockets schließt. Das Gleiche gilt natürlich für Kundenbindungen. Denken Sie nach Abschluss des Betriebs daran, die entsprechenden Ressourcen vor Abschluss des gesamten Programms zu schließen, dh den entsprechenden IO -Stream und die Sockel.
Client Java -Code
Public Class Client {public static void main (String args []) löst eine Ausnahme aus. {// Für den Einfachheit halber werden alle Ausnahmen direkt ausgestattet String host = "127.0.0.1"; // Die IP -Adresse des angeschlossenen Servers ist int port = 8899; // Der entsprechende Hörport des Servers soll angeschlossen werden // Die Verbindung wird mit dem Server Socket Client = New Socket (Host, Port) hergestellt. // Nach dem Erstellen der Verbindung können Sie Daten an den Server Writer = New OutputStreamWriter (client.getOutputStream ()) schreiben. writer.write ("Hallo Server."); writer.flush (); // erinnere Flush writer.close (); client.close (); }}Beim Schreiben von Daten in den Socket -Ausgangsstrom sollten Sie auf eine Sache achten. Wenn das Programm nach dem Schreibvorgang nicht der Abschaltung des Ausgabestreams entspricht, sondern andere Blockierungsvorgänge (z. B. Daten aus dem Eingabestream) durchführt, denken Sie daran, es zu spülen. Nur auf diese Weise kann der Server die vom Client gesendeten Daten empfangen, andernfalls kann er unbegrenzt aufeinander warten. Dieses Problem wird später erwähnt, wenn Sie gleichzeitig über den Client und das Server lesen und schreiben.
2. Der Client und der Server lesen und schreiben gleichzeitig
Wie bereits erwähnt, kommunizieren Steckdosen auf Zwei-Wege-Weise, die sowohl Daten empfangen als auch Daten senden können.
Server Java -Code
public class Server {public static void main (String args []) löst IOException aus (// Für den Einfachheit) werden alle Ausnahmeinformationen int port = 8899 ausgeworfen; // Definieren Sie ein ServerSocket -Hören auf Port 8899 ServerSocket Server = New ServerSocket (Port); // Der Server versucht, Verbindungsanforderungen von anderen Sockets zu empfangen. Die Akzeptanzmethode des Servers ist ein blockierender Socket -Socket = server.accept (). // Nach der Erstellung einer Verbindung mit dem Client können wir den InputStream des Sockets erhalten und die vom Client gesendeten Informationen lesen. Reader reader = new InputStreamReader (Socket.getInputStream ()); char chars [] = new char [64]; Int len; StringBuilder sb = new StringBuilder (); while ((len = reader.read (chars))! = -1) {sb.append (neue Zeichenfolge (Zeichen, 0, len)); } System.out.println ("From Client:" + SB); // Schreiben Sie einen Satz nach dem Lesen von IT Writer writer = new outputStreamWriter (Socket.getOutputStream ()); writer.write ("Hallo Kunde."); writer.flush (); writer.close (); reader.close (); socket.close (); server.close (); }}Im obigen Code haben wir zunächst die vom Client aus dem Eingabestream gesendeten Daten gelesen und dann die Daten in den Ausgabestream an den Client schreiben und dann die entsprechende Ressourcendatei schließen. Tatsächlich kann der obige Code nicht so ausgeführt werden, wie wir im Voraus angenommen haben, da das Lesen von Daten aus dem Eingabestream ein Blockierungsvorgang ist. Wenn Daten in der obigen Schleife gelesen werden, wird die Schleifenkörper ausgeführt, sonst wird sie blockiert, so dass die nachfolgenden Schreibvorgänge niemals ausgeführt werden. Die while -Schleife stoppt, es sei denn, der entsprechende Sockel des Clients ist geschlossen und blockiert. Die Lösung für diese Situation, in der sie möglicherweise niemals ausgeführt werden kann, ist, dass die Schleife bedingt herausgesprungen werden muss. Wenn man sich den obigen Code ansieht, ist das einzige, was sich ändert, die Länge, die Len und die gelesenen Daten. Len ist nicht mehr verwendbar, und das einzige, was verwendet werden kann, sind die Daten, die gelesen werden. In diesem Fall sind wir uns normalerweise auf ein End -Tag einig. Wenn die vom Client gesendeten Daten ein bestimmtes End -Tag enthalten, bedeutet dies, dass die aktuellen Daten gesendet wurden, und zu diesem Zeitpunkt können wir aussteigen. Dann sieht der verbesserte Code so aus:
Java -Code
public class Server {public static void main (String args []) löst IOException aus (// Für den Einfachheit) werden alle Ausnahmeinformationen int port = 8899 ausgeworfen; // Definieren Sie ein ServerSocket -Hören auf Port 8899 ServerSocket Server = New ServerSocket (Port); // Der Server versucht, Verbindungsanforderungen von anderen Sockets zu empfangen. Die Akzeptanzmethode des Servers ist ein blockierender Socket -Socket = server.accept (). // Nach der Erstellung einer Verbindung mit dem Client können wir den InputStream des Sockets erhalten und die vom Client gesendeten Informationen lesen. Reader reader = new InputStreamReader (Socket.getInputStream ()); char chars [] = new char [64]; Int len; StringBuilder sb = new StringBuilder (); String -Temperatur; int Index; while ((len = reader.read (chars))! = -1) {temp = new String (Zeichen, 0, len); if ((index = temp.indexof ("eof")! brechen; } sb.append (temp); } System.out.println ("From Client:" + SB); // Schreiben Sie einen Satz nach dem Lesen von Writer writer = new outputStreamwriter (socket.getOutputStream ()); writer.write ("Hallo Kunde."); writer.flush (); writer.close (); reader.close (); socket.close (); server.close (); }}Wenn der Server im obigen Code die vom Client gesendete Endmarke "EOF" liest, wird der Datenempfang beendet und die Schleife beendet, sodass der nachfolgende Code fortgesetzt wird.
Client Java -Code
Public Class Client {public static void main (String args []) löst eine Ausnahme aus. {// Für den Einfachheit halber werden alle Ausnahmen direkt ausgestattet String host = "127.0.0.1"; // die IP -Adresse des Servers angeschlossen in int port = 8899; // Der entsprechende Hörport des Servers soll angeschlossen werden // Die Verbindung wird mit dem Server Socket Client = New Socket (Host, Port) hergestellt. // Nach dem Erstellen der Verbindung können Sie Daten an den Server Writer = New OutputStreamWriter (client.getOutputStream ()) schreiben. writer.write ("Hallo Server."); writer.flush (); // Lesen Sie nach dem Schreiben von Reader Reader = New InputStreamReader (client.getInputStream ()); char chars [] = new char [64]; Int len; StringBuffer sb = new StringBuffer (); while ((len = reader.read (chars))! = -1) {sb.append (neue Zeichenfolge (Zeichen, 0, len)); } System.out.println ("From Server:" + SB); writer.close (); reader.close (); client.close (); }}Im obigen Code haben wir zuerst ein Datenstück an den Server gesendet und dann die vom Server zurückgegebenen Daten gelesen. Wie der vorherige Server kann das Programm die ganze Zeit dort hängen und niemals aus der While -Schleife springen. Dieser Code wird mit dem ersten Code des Servers kombiniert. Lassen Sie uns einfach analysieren, dass der Server dort immer Daten empfängt und niemals aus der Schleife springt. Daher gibt es keinen nachfolgenden Server, um Daten an den Client zurückzugeben, und der Client kann keine vom Server zurückgegebenen Daten empfangen. Die Lösung wird im zweiten Code des Servers angezeigt. Nachdem der Client die Daten gesendet hat, schreiben Sie eine Endmarke in den Ausgabestream, um dem Server mitzuteilen, dass die Daten gesendet wurden. Der Server sendet außerdem eine Marke, um den Client nach der Rückgabe der Daten mitzuteilen. Dann sollte der geänderte Client -Code so aussehen:
Java -Code
Public Class Client {public static void main (String args []) löst eine Ausnahme aus. {// Für den Einfachheit halber werden alle Ausnahmen direkt ausgestattet String host = "127.0.0.1"; // Die IP -Adresse des angeschlossenen Servers ist int port = 8899; // Der entsprechende Hörport des Servers soll angeschlossen werden // Die Verbindung wird mit dem Server Socket Client = New Socket (Host, Port) hergestellt. // Nach dem Erstellen der Verbindung können Sie Daten an den Server Writer = New OutputStreamWriter (client.getOutputStream ()) schreiben. writer.write ("Hallo Server."); writer.write ("eof"); writer.flush (); // Lesen Sie nach dem Schreiben von Reader Reader = New InputStreamReader (client.getInputStream ()); char chars [] = new char [64]; Int len; StringBuffer sb = new StringBuffer (); String -Temperatur; int Index; while ((len = reader.read (chars))! = -1) {temp = new String (Zeichen, 0, len); if ((index = temp.indexof ("eof")! = -1) {sb.append (temp.substring (0, index)); brechen; } SB.Append (neue String (Zeichen, 0, len)); } System.out.println ("From Server:" + SB); writer.close (); reader.close (); client.close (); }}Die häufigste Form, die wir im täglichen Leben verwenden, ist, dass der Client Daten an den Server sendet und der Server die Daten empfängt und die entsprechenden Ergebnisse an den Client zurückgibt. Es gibt jedoch keine solche Eins-zu-Eins-Beziehung zwischen dem Client und dem Server mehr, aber die Situation, in der mehrere Clients demselben Server wie unten erwähnt werden.
3.. Mehrere Clients stellen eine Verbindung zum selben Server her
Für die beiden oben genannten Beispiele endet der Server nach Erhalt der Anfrage eines Kunden und kann keine Anfragen von anderen Kunden erhalten, die unsere Anforderungen häufig nicht erfüllen können. Normalerweise machen wir das:
Java -Code
public class Server {public static void main (String args []) löst IOException aus (// Für den Einfachheit) werden alle Ausnahmeinformationen int port = 8899 ausgeworfen; // Definieren Sie ein ServerSocket -Hören auf Port 8899 ServerSocket Server = New ServerSocket (Port); while (true) {// der Server versucht, Verbindungsanforderungen von anderen Sockets zu empfangen. Die Akzeptanzmethode des Servers ist ein blockierender Socket -Socket = server.accept (). // Nach der Erstellung einer Verbindung mit dem Client können wir den InputStream des Sockets erhalten und die vom Client gesendeten Informationen lesen. Reader reader = new InputStreamReader (Socket.getInputStream ()); char chars [] = new char [64]; Int len; StringBuilder sb = new StringBuilder (); String -Temperatur; int Index; while ((len = reader.read (chars))! = -1) {temp = new String (Zeichen, 0, len); if ((index = temp.indexof ("eof")! brechen; } sb.append (temp); } System.out.println ("From Client:" + SB); // Schreiben Sie einen Satz nach dem Lesen von Writer writer = new outputStreamwriter (socket.getOutputStream ()); writer.write ("Hallo Kunde."); writer.flush (); writer.close (); reader.close (); socket.close (); }}} Im obigen Code haben wir eine tote Schleife verwendet, in der die ServerSocket seine Akzeptanzmethode aufruft, um zu versuchen, eine Verbindungsanforderung vom Client zu erhalten. Wenn die Anfrage nicht empfangen wird, blockiert das Programm hier, bis es die Verbindungsanforderung vom Kunden empfängt und dann mit dem Kunden kommuniziert, der die Verbindung hergestellt hat. Danach wird dann die Schleifenkörper ausgeführt und versucht, erneut eine neue Verbindungsanfrage zu erhalten. Auf diese Weise kann unser Serversocket Verbindungsanfragen von allen Kunden erhalten und mit ihnen kommunizieren. Dies implementiert eine einfache Kommunikationsart mit mehreren Clients auf einem Server.
Obwohl ein Server implementiert wird, um mit mehreren Clients zu kommunizieren, gibt es im obigen Beispiel immer noch ein Problem. Im obigen Beispiel verarbeitet unser Server die Verbindungsanforderung des Clients synchron. Jedes Mal, wenn wir eine Verbindungsanforderung vom Kunden erhalten, müssen wir zunächst mit dem aktuellen Kunden kommunizieren, bevor wir die nächste Verbindungsanforderung bearbeiten können. Dies wird die Leistung des Programms ernsthaft beeinflussen, wenn mehr Gleichzeitverkehr vorliegt. Aus diesem Grund können wir es in die folgende asynchrone Verarbeitung der Kommunikation mit dem Kunden ändern:
Java -Code
public class Server {public static void main (String args []) löst IOException aus (// Für den Einfachheit) werden alle Ausnahmeinformationen int port = 8899 ausgeworfen; // Definieren Sie ein ServerSocket -Hören auf Port 8899 ServerSocket Server = New ServerSocket (Port); while (true) {// der Server versucht, Verbindungsanforderungen von anderen Sockets zu empfangen. Die Akzeptanzmethode des Servers ist ein blockierender Socket -Socket = server.accept (). // Jedes Mal, wenn ein Sockel empfangen wird, wird ein neuer Thread eingerichtet, um den neuen Thread (neue Aufgabe (Socket)) zu verarbeiten. Start (); }} / ** * * / statische Klasse Task implementiert Runnable {private Socket Socket; öffentliche Aufgabe (Socket Socket) {this.socket = Socket; } public void run () {try {HandleSocket (); } catch (Ausnahme e) {e.printstacktrace (); }} / *** mit dem Client -Socket kommunizieren* @throws Exception* / private void Handlesocket () löst eine Ausnahme aus {Reader reader = new InputStreamReader (socket.getInputStream ()); char chars [] = new char [64]; Int len; StringBuilder sb = new StringBuilder (); String -Temperatur; int Index; while ((len = reader.read (chars))! = -1) {temp = new String (Zeichen, 0, len); if ((index = temp.indexof ("eof")! brechen; } sb.append (temp); } System.out.println ("From Client:" + SB); // Schreiben Sie einen Satz nach dem Lesen von Writer writer = new outputStreamwriter (socket.getOutputStream ()); writer.write ("Hallo Kunde."); writer.flush (); writer.close (); reader.close (); socket.close (); }}} Im obigen Code wird jedes Mal, wenn das Serversocket eine neue Socket -Verbindungsanforderung erhält, ein neuer Thread erstellt, um mit dem aktuellen Socket zu kommunizieren, wodurch die asynchrone Verarbeitung der Kommunikation mit dem Client -Socket erreicht wird.
Beim Empfangen von Daten aus Sockets InputStream ist das Lesen ein wenig wie das oben genannte zu kompliziert. Manchmal verwenden wir BufferedReader, um jeweils eine Zeile zu lesen, z. B.:
Java -Code
public class Server {public static void main (String args []) löst IOException aus (// Für den Einfachheit) werden alle Ausnahmeinformationen int port = 8899 ausgeworfen; // Definieren Sie ein ServerSocket -Hören auf Port 8899 ServerSocket Server = New ServerSocket (Port); while (true) {// der Server versucht, Verbindungsanforderungen von anderen Sockets zu empfangen. Die Akzeptanzmethode des Servers ist ein blockierender Socket -Socket = server.accept (). // Jedes Mal, wenn ein Sockel empfangen wird, wird ein neuer Thread eingerichtet, um den neuen Thread (neue Aufgabe (Socket)) zu verarbeiten. Start (); }} / ** * * / statische Klasse Task implementiert Runnable {private Socket Socket; öffentliche Aufgabe (Socket Socket) {this.socket = Socket; } public void run () {try {HandleSocket (); } catch (Ausnahme e) {e.printstacktrace (); }} / *** mit dem Client -Socket kommunizieren* @throws Exception* / private void Handlesocket () löst eine Ausnahme aus {BufferedReader BR = New BufferedReader (neuer InputStreamReader (socket.getInputStream ()); StringBuilder sb = new StringBuilder (); String -Temperatur; int Index; while ((temp = br.readline ())! = null) {System.out.println (temp); if ((index = temp.indexof ("eof")! brechen; } sb.append (temp); } System.out.println ("From Client:" + SB); // Schreiben Sie einen Satz nach dem Lesen von Writer writer = new outputStreamwriter (socket.getOutputStream ()); writer.write ("Hallo Kunde."); writer.write ("eof/n"); writer.flush (); writer.close (); Br.CLOSE (); socket.close (); }}}Zu diesem Zeitpunkt sollte beachtet werden, dass die Readline -Methode von BufferedReader jeweils eine Zeile liest. Diese Methode ist blockiert. Das Programm wird erst weiter ausgeführt, wenn es eine Datenzeile liest. Wann wird Readline eine Zeile lesen? Die Readline -Methode wird nicht glauben, dass sie eine Zeile gelesen wurde, bis das Programm auf eine neue Zeile oder den Endcharakter des entsprechenden Streams trifft. Es wird seine Blockade beenden und das Programm weiter ausführen. Wenn wir die Readline des BufferedReader verwenden, um Daten zu lesen, müssen wir uns daher daran erinnern, Zeilenumbrüche im entsprechenden Ausgangsstrom zu schreiben (es wird automatisch als Ende nach dem Ende des Streams gekennzeichnet und Readline kann erkannt werden). Nachdem wir die Linienbrüche geschrieben haben, müssen wir uns daran erinnern, zu spülen, wenn der Ausgangsstrom nicht sofort geschlossen ist, damit die Daten wirklich aus dem Puffer geschrieben werden. Entsprechend dem obigen Code sollte unser Client -Programm so geschrieben werden:
Java -Code
Public Class Client {public static void main (String args []) löst eine Ausnahme aus. {// Für den Einfachheit halber werden alle Ausnahmen direkt ausgestattet String host = "127.0.0.1"; // Die IP -Adresse des angeschlossenen Servers ist int port = 8899; // Der entsprechende Hörport des Servers soll angeschlossen werden // Die Verbindung wird mit dem Server Socket Client = New Socket (Host, Port) hergestellt. // Nach dem Erstellen der Verbindung können Sie Daten an den Server Writer = New OutputStreamWriter (client.getOutputStream ()) schreiben. writer.write ("Hallo Server."); writer.write ("eof/n"); writer.flush (); // Nach dem Schreiben von BufferedReader BR = New BufferedReader (neuer InputStreamReader (Client.getInputStream ())); StringBuffer sb = new StringBuffer (); String -Temperatur; int Index; while ((temp = br.readline ())! = null) {if ((index = temp.indexof ("eof")! brechen; } sb.append (temp); } System.out.println ("From Server:" + SB); writer.close (); Br.CLOSE (); client.close (); }}4. Setzen Sie die Zeitüberschreitungszeit
Angenommen, es besteht eine solche Anforderung, dass unser Client XX -Informationen über Socket vom Server erhalten und dann dem Benutzer auf der Seite angezeigt wird. Wir wissen, dass Socket beim Lesen von Daten blockiert, und wenn Sie die Daten nicht lesen, blockiert das Programm dort weiter. Bei der Synchronisierung der Anfrage dürfen wir eine solche Situation nicht zulassen. Dies erfordert, dass wir den Blockierungs -Interrupt kontrollieren, nachdem die Anfrage eine bestimmte Zeit erreicht hat, damit das Programm weiter ausgeführt werden kann. Socket bietet uns eine setSotimeout () -Methode, um die Zeitüberschreitungszeit der empfangenen Daten in Millisekunden festzulegen. Wenn die festgelegte Zeitlimitzeit größer als 0 ist und nach dieser Zeit die Socket die zurückgegebenen Daten nicht erhalten hat, wird der Socket eine SockettimeoutException werfen.
Angenommen, wir müssen unseren Kunden steuern, um zu unterbrechen und zu blockieren, bevor wir die Daten 10 Sekunden lang lesen, nachdem wir die Daten gelesen haben, können wir dies tun:
Java -Code
Public Class Client {public static void main (String args []) löst eine Ausnahme aus. {// Für den Einfachheit halber werden alle Ausnahmen direkt ausgestattet String host = "127.0.0.1"; // Die IP -Adresse des angeschlossenen Servers ist int port = 8899; // Der entsprechende Hörport des Servers soll angeschlossen werden // Die Verbindung wird mit dem Server Socket Client = New Socket (Host, Port) hergestellt. // Nach dem Erstellen der Verbindung können Sie Daten an den Server Writer = New OutputStreamWriter (client.getOutputStream ()) schreiben. writer.write ("Hallo Server."); writer.write ("eof/n"); writer.flush (); // Nach dem Schreiben von BufferedReader BR = New BufferedReader (neuer InputStreamReader (Client.getInputStream ())); // Setzen Sie das Timeout auf 10 Sekunden Client.setsotimeout (10*1000); StringBuffer sb = new StringBuffer (); String -Temperatur; int Index; try {while ((temp = br.readline ())! = null) {if ((index = temp.indexof ("eof")! brechen; } sb.append (temp); }} catch (SockettimeOutException e) {System.out.println ("Daten lesen"); } System.out.println ("From Server:" + SB); writer.close (); Br.CLOSE (); client.close (); }}5. Empfang von Daten verstümmelten Code
In solchen Fällen, in denen der Server oder der Client einen verstümmelten chinesischen Code empfängt, liegt dies normalerweise daran, dass die verwendete Kodierung, die bei der gesendeten Daten verwendet wird, nicht mit der verwendeten Kodierung, die bei Empfangsdaten verwendet wird, nicht stimmt. Zum Beispiel gibt es einen solchen Servercode:
Java -Code
public class Server {public static void main (String args []) löst IOException aus (// Für den Einfachheit) werden alle Ausnahmeinformationen int port = 8899 ausgeworfen; // Definieren Sie ein ServerSocket -Hören auf Port 8899 ServerSocket Server = New ServerSocket (Port); while (true) {// der Server versucht, Verbindungsanforderungen von anderen Sockets zu empfangen. Die Akzeptanzmethode des Servers ist ein blockierender Socket -Socket = server.accept (). // Jedes Mal, wenn ein Sockel empfangen wird, wird ein neuer Thread eingerichtet, um den neuen Thread (neue Aufgabe (Socket)) zu verarbeiten. Start (); }} / ** * * / statische Klasse Task implementiert Runnable {private Socket Socket; öffentliche Aufgabe (Socket Socket) {this.socket = Socket; } public void run () {try {HandleSocket (); } catch (Ausnahme e) {e.printstacktrace (); }} / *** mit Client -Socket kommunizieren* @throws Exception* / private void Handlesocket () löst eine Ausnahme aus {BufferedReader BR = New BufferedReader (neuer InputStreamReader (socket.getInputStream (), "gbk"); StringBuilder sb = new StringBuilder (); String -Temperatur; int Index; while ((temp = br.readline ())! = null) {System.out.println (temp); if ((index = temp.indexof ("eof")! brechen; } sb.append (temp); } System.out.println ("Client:" + SB); // Schreiben Sie einen Satz nach dem Lesen von Writer writer = new outputStreamwriter (socket.getOutputStream (), "utf-8"); writer.write ("Hallo, Kunde."); writer.write ("eof/n"); writer.flush (); writer.close (); Br.CLOSE (); socket.close (); }}}Ich bin ein wenig verwirrt, als ich es hier zum Testen verwendet habe. Im obigen Servercode definieren wir die Verwendung von GBK-Codierung zum Lesen von Daten beim Definieren des Eingabestreams klar und geben klar an, dass die Verwendung von UTF-8-Codierung zum Senden von Daten beim Definieren des Ausgabestreams. Wenn der Client beim Senden von Daten auf den Client keine Daten in GBK -Codierung sendet, dürfte die vom Server empfangenen Daten verstümmelt werden. Wenn der Client beim Senden von Daten auf dem Server keine Datencodierung sendet, dh UTF-8-Codierung, um Daten zu empfangen, ist es sehr wahrscheinlich, dass die Verwicklungen von Daten auftreten. Für den obigen Servercode, um unser Programm zu ermöglichen, um die von der anderen Partei ohne verstümmelten Code gesendeten Daten zu lesen, sollte unser Client so sein:
Java -Code
Public Class Client {public static void main (String args []) löst eine Ausnahme aus. {// Für den Einfachheit halber werden alle Ausnahmen direkt ausgestattet String host = "127.0.0.1"; // die IP -Adresse des Servers angeschlossen in int port = 8899; // Der entsprechende Hörport des Servers soll angeschlossen werden // Die Verbindung wird mit dem Server Socket Client = New Socket (Host, Port) hergestellt. // Nach dem Erstellen der Verbindung können Sie Daten an den Server Writer writer = New OutputStreamWriter (client.getOutputStream (), "GBK") schreiben. writer.write ("Hallo, Server."); writer.write ("eof/n"); writer.flush (); // Nach dem Schreiben von BufferedReader BR = New BufferedReader (neuer InputStreamReader (Client.getInputStream (), "UTF-8")); // Setzen Sie das Timeout auf 10 Sekunden Client.setsotimeout (10*1000); StringBuffer sb = new StringBuffer (); String -Temperatur; int Index; try {while ((temp = br.readline ())! = null) {if ((index = temp.indexof ("eof")! brechen; } sb.append (temp); }} catch (SockettimeOutException e) {System.out.println ("Daten lesen"); } System.out.println ("Server:" + SB); writer.close (); Br.CLOSE (); client.close (); }}Dieser Artikel wurde in "Zusammenfassung der Java -Upload -Operationstechniken" zusammengestellt, und jeder kann gerne lernen und lesen.
Das obige ist der gesamte Inhalt dieses Artikels. Ich hoffe, es wird für das Lernen aller hilfreich sein und ich hoffe, jeder wird Wulin.com mehr unterstützen.