Java escribe un servidor y un cliente que puede cargar archivos. El contenido específico es el siguiente
Lado del servidor
Class Server {public static void main (string [] args) lanza la excepción {// Crea el servidor Socket Serversocket ss = new ServerSocket (10005); // Recibe el socket del cliente fileloadersocket = ss.accept (); // Imprime la cadena de información de conexión ip = fileloadersocket.getInetAddress (). Gethostaddress (); System.out.println (ip + "... connceed"); // Recibe el archivo y guarde InputStream in = Fileloadersocket.getInputStream (); // Instanciar el objeto Filesave OutputStream filesave = new FileOutputStream ("E: //3.mp3"); // crear una matriz buf byte [] buf = new byte [1024]; int len = 0; // defiende si el final del archivo se lee mientras ((len = in.read (buf))! = -1) {filesave.write (buf, 0, len); // Actualizar filsave.flush (); } // Devuelve el archivo de información de copia BufferedWriter Out = new BufferedWriter (nuevo OutputStreamWriter (fileloadersocket.getOutputStream ())); out.write ("File Subiendo exitoso"); // refrescarse.flush (); // Resource cierre ss.close (); fileloadersocket.close (); filesave.close (); }}Cliente:
Cliente de clase {public static void main (string [] args) lanza la excepción {// crea el servicio de socket Socket fileloadersocket = new Socket ("168.168.168.94", 10005); // Lea el archivo localmente del cliente y escriba en la transmisión de salida del socket outtream stream out = fileloadersocket.getOutputStream (); // Instanciar el objeto FileReader inputStream FileRead = new FileInputStream ("g: //2.mp3"); // crear un byte de matriz [] buf = nuevo byte [1024]; int len = 0; // juzga si el final del archivo se lee mientras ((len = fileread.read (buf))! = -1) {out.write (buf, 0, len); } // dígale al servidor que el archivo ha sido transferido Fileloadersocket.shutdownOutput (); // Obtener los comentarios de la información del servidor BufferedReader en = new BufferedReader (new InputStreamReader (fileloadersocket.getInputStream ())); String serverback = in.readline (); System.out.println (ServerBack); // recursos cerrar fileloadersocket.close (); fileread.close (); }}El siguiente programa se copia directamente desde otro lugar para obtener referencia de aprendizaje:
Programación de socket Java
Para la programación de socket Java, hay dos conceptos, uno es Serversocket y el otro es Socket. El servidor y el cliente están conectados a través del socket, y luego pueden comunicarse. Primero, Serversocket escuchará un puerto en el servidor. Cuando se descubra que el cliente tiene un socket para intentar conectarse a él, aceptará la solicitud de conexión del socket y al mismo tiempo establecer un socket correspondiente en el servidor para comunicarse con él. De esta manera, hay dos enchufes, uno en el cliente y otro en el servidor.
La comunicación entre los enchufes es en realidad muy simple. Cuando el servidor escribe algo en la transmisión de salida de socket, el cliente puede leer el contenido correspondiente a través de la secuencia de entrada de socket. El socket y el socket están conectados en dos direcciones, por lo que el cliente también puede escribir cosas en la secuencia de salida de socket correspondiente, y luego la secuencia de entrada de socket correspondiente del servidor puede leer el contenido correspondiente. Aquí hay algunos ejemplos de comunicación del lado del servidor con los clientes:
1. Escribir al cliente y leer servidor
Código Java del servidor
Public Class Server {public static void main (string args []) lanza IOException {// Para simplicidad, toda la información de excepción se descarta int port = 8899; // Definir un Serversocket escucha en el puerto 8899 ServerSocket Server = new Serversocket (puerto); // El servidor intenta recibir solicitudes de conexión de otros enchufes. El método de aceptación del servidor es un socket de bloqueo = servidor.accept (); // Después de establecer una conexión con el cliente, podemos obtener el InputStream de Socket y leer la información enviada por el Cliente. Lector lector = new InputStreamReader (Socket.getInputStream ()); char chars [] = nuevo char [64]; int len; StringBuilder sb = new StringBuilder (); while ((len = lector.read (chars))! = -1) {sb.append (new String (chars, 0, len)); } System.out.println ("del cliente:" + sb); lector.close (); socket.close (); servidor.close (); }}El funcionamiento del servidor para leer datos del Socket InputStream también está bloqueando. Si los datos no se leen en el flujo de entrada, el programa permanecerá allí hasta que el cliente escriba datos en la secuencia de salida del socket o cierra la secuencia de salida del socket. Por supuesto, lo mismo es cierto para los enchufes del cliente. Una vez que se complete la operación, recuerde cerrar los recursos correspondientes antes de que termine todo el programa, es decir, cierre el flujo y socket de IO correspondiente.
Código Java del cliente
Cliente de clase pública {public static void main (string args []) lanza la excepción {// Por simplicidad, todas las excepciones se tiran directamente string host = "127.0.0.1"; // La dirección IP del servidor a conectar es int Port = 8899; // El puerto de escucha correspondiente del servidor a conectar // La conexión se establece con el servidor Socket Client = new Socket (host, puerto); // Después de establecer la conexión, puede escribir datos en el escritor del servidor = nuevo OutputStreamWriter (Client.getOutputStream ()); Writer.write ("Hello Server."); writer.flush (); // recuerda flush escritor.close (); client.close (); }}Al escribir datos en la transmisión de salida de socket, debe prestar atención a una cosa. Si el programa no corresponde al cierre de la transmisión de salida después de la operación de escritura, pero realiza otras operaciones de bloqueo (como leer datos de la secuencia de entrada), recuerde enjuagarlo. Solo de esta manera el servidor puede recibir los datos enviados por el cliente, de lo contrario puede causar una espera ilimitada mutuamente. Este problema se mencionará más adelante cuando se habla de la lectura y la escritura del cliente y el servidor al mismo tiempo.
2. El cliente y el servidor leen y escriben al mismo tiempo
Como se mencionó anteriormente, los sockets se comunican de manera bidireccional, que pueden recibir datos y enviar datos.
Código Java del servidor
Public Class Server {public static void main (string args []) lanza IOException {// Para simplicidad, toda la información de excepción se descarta int port = 8899; // Definir un Serversocket escucha en el puerto 8899 ServerSocket Server = new Serversocket (puerto); // El servidor intenta recibir solicitudes de conexión de otros enchufes. El método de aceptación del servidor es un socket de bloqueo = servidor.accept (); // Después de establecer una conexión con el cliente, podemos obtener el InputStream de Socket y leer la información enviada por el Cliente. Lector lector = new InputStreamReader (Socket.getInputStream ()); char chars [] = nuevo char [64]; int len; StringBuilder sb = new StringBuilder (); while ((len = lector.read (chars))! = -1) {sb.append (new String (chars, 0, len)); } System.out.println ("del cliente:" + sb); // Escribe una oración después de leerlo escritor escritor = nuevo outputStreamWriter (Socket.getOutputStream ()); Writer.write ("Hola Cliente"); escritor.flush (); escritor.close (); lector.close (); socket.close (); servidor.close (); }}En el código anterior, primero leemos los datos enviados por el cliente desde la secuencia de entrada y luego escribimos los datos en la transmisión de salida al cliente y luego cerramos el archivo de recursos correspondiente. De hecho, el código anterior puede no ejecutarse de la manera que asumimos de antemano, porque leer datos de la secuencia de entrada es una operación de bloqueo. Cuando los datos se leen en el anterior mientras el bucle, el cuerpo del bucle se ejecutará, de lo contrario se bloqueará, de modo que las operaciones de escritura posteriores nunca se ejecutarán. El bucle While se detendrá a menos que el enchufe correspondiente del cliente esté cerrado y bloqueado. La solución a esta situación en la que nunca se ejecuta es que el bucle mientras se debe saltar condicionalmente. Mirando el código anterior, lo único que cambia es la longitud LEN y los datos que se leen. Len ya no se puede usar, y lo único que se puede usar son los datos que se leen. En este caso, generalmente estamos de acuerdo en una etiqueta final. Cuando los datos enviados por el cliente contienen una determinada etiqueta final, significa que los datos actuales se han enviado, y en este momento podemos salir. Entonces el código mejorado se verá así:
Código Java
Public Class Server {public static void main (string args []) lanza IOException {// Para simplicidad, toda la información de excepción se descarta int port = 8899; // Definir un Serversocket escucha en el puerto 8899 ServerSocket Server = new Serversocket (puerto); // El servidor intenta recibir solicitudes de conexión de otros enchufes. El método de aceptación del servidor es un socket de bloqueo = servidor.accept (); // Después de establecer una conexión con el cliente, podemos obtener el InputStream de Socket y leer la información enviada por el Cliente. Lector lector = new InputStreamReader (Socket.getInputStream ()); char chars [] = nuevo char [64]; int len; StringBuilder sb = new StringBuilder (); Cadena temp; Índice int; while ((len = lector.read (chars))! = -1) {temp = new String (chars, 0, len); if ((index = temp.IndexOf ("eof"))! = -1) {// La recepción finaliza cuando EOF se encuentra sb.append (temp.substring (0, index)); romper; } sb.append (temp); } System.out.println ("del cliente:" + sb); // Escribir una oración después de leer escritor escritor = nuevo OutputStreamWriter (Socket.getOutputStream ()); Writer.write ("Hola Cliente"); escritor.flush (); escritor.close (); lector.close (); socket.close (); servidor.close (); }}En el código anterior, cuando el servidor lee la marca final enviada por el cliente, es decir, "EOF", la recepción de datos se terminará y el bucle finalizará, para que el código posterior pueda continuar.
Código Java del cliente
Cliente de clase pública {public static void main (string args []) lanza la excepción {// Por simplicidad, todas las excepciones se tiran directamente string host = "127.0.0.1"; // La dirección IP del servidor a conectar int Port = 8899; // El puerto de escucha correspondiente del servidor a conectar // La conexión se establece con el servidor Socket Client = new Socket (host, puerto); // Después de establecer la conexión, puede escribir datos en el escritor del servidor = nuevo OutputStreamWriter (Client.getOutputStream ()); Writer.write ("Hello Server."); escritor.flush (); // leer después de escribir lector lector = new InputStreamReader (Client.getInputStream ()); char chars [] = nuevo char [64]; int len; StringBuffer sb = new StringBuffer (); while ((len = lector.read (chars))! = -1) {sb.append (new String (chars, 0, len)); } System.out.println ("del servidor:" + sb); escritor.close (); lector.close (); client.close (); }}En el código anterior, primero enviamos un dato al servidor y luego leemos los datos devueltos por el servidor. Al igual que el servidor anterior, puede hacer que el programa cuelgue allí todo el tiempo y nunca salte del bucle While. Este código se combina con el primer código del servidor, solo permítanos analizar que el servidor siempre recibirá datos allí, y nunca saltará del bucle While, por lo que no habrá un servidor posterior para devolver datos al cliente, y el cliente no podrá recibir datos devueltos por el servidor. La solución se muestra en el segundo código del servidor. Después de que el cliente envíe los datos, escriba una marca final en la transmisión de salida para decirle al servidor que se han enviado los datos. El servidor también envía una marca para decirle al cliente después de que se devuelven los datos. Entonces el código de cliente modificado debería verse así:
Código Java
Cliente de clase pública {public static void main (string args []) lanza la excepción {// Por simplicidad, todas las excepciones se tiran directamente string host = "127.0.0.1"; // La dirección IP del servidor a conectar es int Port = 8899; // El puerto de escucha correspondiente del servidor a conectar // La conexión se establece con el servidor Socket Client = new Socket (host, puerto); // Después de establecer la conexión, puede escribir datos en el escritor del servidor = nuevo OutputStreamWriter (Client.getOutputStream ()); Writer.write ("Hello Server."); escritor.write ("EOF"); escritor.flush (); // leer después de escribir lector lector = new InputStreamReader (Client.getInputStream ()); char chars [] = nuevo char [64]; int len; StringBuffer sb = new StringBuffer (); Cadena temp; Índice int; while ((len = lector.read (chars))! = -1) {temp = new String (chars, 0, len); if ((index = temp.indexof ("eof"))! = -1) {sb.append (temp.substring (0, index)); romper; } sb.append (nueva cadena (chars, 0, len)); } System.out.println ("del servidor:" + sb); escritor.close (); lector.close (); client.close (); }}La forma más común que usamos en la vida diaria es que el cliente envía datos al servidor, y el servidor recibe los datos y devuelve los resultados correspondientes al cliente. Sin embargo, ya no existe una relación uno a uno entre el cliente y el servidor, sino la situación en la que múltiples clientes corresponden al mismo servidor que se menciona a continuación.
3. Múltiples clientes se conectan al mismo servidor
Para los dos ejemplos mencionados anteriormente, el servidor finaliza después de recibir la solicitud de un cliente y no puede recibir solicitudes de otros clientes, que a menudo no pueden cumplir con nuestros requisitos. Por lo general, hacemos esto:
Código Java
Public Class Server {public static void main (string args []) lanza IOException {// Para simplicidad, toda la información de excepción se descarta int port = 8899; // Definir un Serversocket escucha en el puerto 8899 ServerSocket Server = new Serversocket (puerto); while (true) {// El servidor intenta recibir solicitudes de conexión de otros sockets. El método de aceptación del servidor es un socket de bloqueo = servidor.accept (); // Después de establecer una conexión con el cliente, podemos obtener el InputStream de Socket y leer la información enviada por el Cliente. Lector lector = new InputStreamReader (Socket.getInputStream ()); char chars [] = nuevo char [64]; int len; StringBuilder sb = new StringBuilder (); Cadena temp; Índice int; while ((len = lector.read (chars))! = -1) {temp = new String (chars, 0, len); if ((index = temp.IndexOf ("eof"))! = -1) {// La recepción finaliza cuando EOF se encuentra sb.append (temp.substring (0, index)); romper; } sb.append (temp); } System.out.println ("del cliente:" + sb); // Escribir una oración después de leer escritor escritor = nuevo OutputStreamWriter (Socket.getOutputStream ()); Writer.write ("Hola Cliente"); escritor.flush (); escritor.close (); lector.close (); socket.close (); }}} En el código anterior, utilizamos un bucle muerto, donde el SerververSocket llama a su método de aceptación para intentar recibir una solicitud de conexión del cliente. Cuando no se recibe la solicitud, el programa bloqueará aquí hasta que reciba la solicitud de conexión del cliente y luego se comunique con el cliente que ha establecido la conexión. Después de eso, ejecutará el cuerpo del bucle e intentará recibir una nueva solicitud de conexión nuevamente. De esta manera, nuestro SerververSocket puede recibir solicitudes de conexión de todos los clientes y comunicarse con ellos. Esto implementa un modo simple de comunicación con varios clientes en un servidor.
En el ejemplo anterior, aunque se implementa un servidor para comunicarse con múltiples clientes, todavía hay un problema. En el ejemplo anterior, nuestro servidor maneja la solicitud de conexión del cliente sincrónicamente. Cada vez que recibimos una solicitud de conexión del cliente, primero debemos comunicarnos con el cliente actual antes de poder procesar la siguiente solicitud de conexión. Esto afectará seriamente el rendimiento del programa cuando haya más concurrencia. Por esta razón, podemos cambiarlo al siguiente procesamiento asincrónico de la comunicación con el cliente:
Código Java
Public Class Server {public static void main (string args []) lanza IOException {// Para simplicidad, toda la información de excepción se descarta int port = 8899; // Definir un Serversocket escucha en el puerto 8899 ServerSocket Server = new Serversocket (puerto); while (true) {// El servidor intenta recibir solicitudes de conexión de otros sockets. El método de aceptación del servidor es un socket de bloqueo = servidor.accept (); // Cada vez que se recibe un socket, se establece un nuevo hilo para manejarlo nuevo subproceso (nueva tarea (socket)). Inicio (); }} / ** * * / Tarea de clase estática implementos runnables {private socket socket; Tarea pública (socket socket) {this.socket = socket; } public void run () {try {Handlesocket (); } catch (Exception e) {E.PrintStackTrace (); }} / *** Comuníquese con el socket del cliente* @throws Exception* / private void handleSocket () lanza la excepción {Reader Reader = new InputStreamReader (Socket.getInputStream ()); char chars [] = nuevo char [64]; int len; StringBuilder sb = new StringBuilder (); Cadena temp; Índice int; while ((len = lector.read (chars))! = -1) {temp = new String (chars, 0, len); if ((index = temp.IndexOf ("eof"))! = -1) {// La recepción finaliza cuando EOF se encuentra sb.append (temp.substring (0, index)); romper; } sb.append (temp); } System.out.println ("del cliente:" + sb); // Escribir una oración después de leer escritor escritor = nuevo OutputStreamWriter (Socket.getOutputStream ()); Writer.write ("Hola Cliente"); escritor.flush (); escritor.close (); lector.close (); socket.close (); }}} En el código anterior, cada vez que el SerververSocket recibe una nueva solicitud de conexión de socket, se generará un nuevo subproceso para comunicarse con el socket actual, lo que logrará el procesamiento asincrónico de la comunicación con el socket del cliente.
Al recibir datos de InputStream de Socket, leer un poco como lo anterior es demasiado complicado. A veces usaremos BufferedReader para leer una línea a la vez, como:
Código Java
Public Class Server {public static void main (string args []) lanza IOException {// Para simplicidad, toda la información de excepción se descarta int port = 8899; // Definir un Serversocket escucha en el puerto 8899 ServerSocket Server = new Serversocket (puerto); while (true) {// El servidor intenta recibir solicitudes de conexión de otros sockets. El método de aceptación del servidor es un socket de bloqueo = servidor.accept (); // Cada vez que se recibe un socket, se establece un nuevo hilo para manejarlo nuevo subproceso (nueva tarea (socket)). Inicio (); }} / ** * * / Tarea de clase estática implementos runnables {private socket socket; Tarea pública (socket socket) {this.socket = socket; } public void run () {try {Handlesocket (); } catch (Exception e) {E.PrintStackTrace (); }} / *** Comuníquese con el socket del cliente* @throws Exception* / Private void Handlesocket () lanza la excepción {BufferedReader Br = New BufferedReader (new InputStreamReader (Socket.GetInputStream ())); StringBuilder sb = new StringBuilder (); Cadena temp; Índice int; while ((temp = br.readline ())! = null) {system.out.println (temp); if ((index = temp.IndexOf ("eof"))! = -1) {// finaliza la recepción cuando EOF se encuentra sb.append (temp.substring (0, index)); romper; } sb.append (temp); } System.out.println ("del cliente:" + sb); // Escribir una oración después de leer escritor escritor = nuevo OutputStreamWriter (Socket.getOutputStream ()); Writer.write ("Hola Cliente"); Writer.write ("EOF/N"); escritor.flush (); escritor.close (); br.close (); socket.close (); }}}En este momento, debe tenerse en cuenta que el método Readline de BufferedReader lee una línea a la vez. Este método está bloqueado. El programa no continuará ejecutándose hasta que lea una línea de datos. Entonces, ¿cuándo Readline leerá una línea? El método Readline no pensará que se haya leído una línea hasta que el programa encuentre una nueva línea o el carácter final del flujo correspondiente. Terminará su bloqueo y dejará que el programa continúe ejecutándose. Por lo tanto, cuando usamos la línea de lectura de BufferedReader para leer datos, debemos recordar escribir descansos de línea en la secuencia de salida correspondiente (se marcará automáticamente como final después de que finalice la secuencia, y la línea de lectura se puede reconocer). Después de escribir los saltos de línea, debemos recordar enjuagar si la secuencia de salida no está cerrada de inmediato, de modo que los datos se escriban realmente desde el búfer. En correspondencia con el código anterior, nuestro programa de cliente debe escribirse así:
Código Java
Cliente de clase pública {public static void main (string args []) lanza la excepción {// Por simplicidad, todas las excepciones se tiran directamente string host = "127.0.0.1"; // La dirección IP del servidor a conectar es int Port = 8899; // El puerto de escucha correspondiente del servidor a conectar // La conexión se establece con el servidor Socket Client = new Socket (host, puerto); // Después de establecer la conexión, puede escribir datos en el escritor del servidor = nuevo OutputStreamWriter (Client.getOutputStream ()); Writer.write ("Hello Server."); Writer.write ("EOF/N"); escritor.flush (); // Leer después de escribir BufferedReader BR = New BufferedReader (new InputStreamReader (Client.getInputStream ())); StringBuffer sb = new StringBuffer (); Cadena temp; Índice int; while ((temp = br.readline ())! = null) {if ((index = temp.indexof ("eof"))! = -1) {sb.append (temp.substring (0, index)); romper; } sb.append (temp); } System.out.println ("del servidor:" + sb); escritor.close (); br.close (); client.close (); }}4. Establezca el tiempo de tiempo de espera
Supongamos que existe tal requisito que nuestro cliente necesite obtener información XX del servidor a través de Socket y luego mostrarla al usuario en la página. Sabemos que Socket está bloqueando al leer datos, y si no lee los datos, el programa seguirá bloqueando allí. Al sincronizar la solicitud, no debemos permitir que suceda tal situación. Esto requiere que controlemos la interrupción de bloqueo después de que la solicitud llegue a un tiempo determinado para que el programa pueda continuar funcionando. Socket nos proporciona un método setSotimeOut () para establecer el tiempo de tiempo de espera de los datos recibidos en milisegundos. Cuando el tiempo de tiempo de espera establecido es mayor que 0 y después de este tiempo, el enchufe no ha recibido los datos devueltos, el socket lanzará un socketttimeutexception.
Supongamos que necesitamos controlar a nuestro cliente para interrumpir y bloquear antes de leer los datos durante 10 segundos después de comenzar a leer los datos, podemos hacer esto:
Código Java
Cliente de clase pública {public static void main (string args []) lanza la excepción {// Por simplicidad, todas las excepciones se tiran directamente string host = "127.0.0.1"; // La dirección IP del servidor a conectar es int Port = 8899; // El puerto de escucha correspondiente del servidor a conectar // La conexión se establece con el servidor Socket Client = new Socket (host, puerto); // Después de establecer la conexión, puede escribir datos en el escritor del servidor = nuevo OutputStreamWriter (Client.getOutputStream ()); Writer.write ("Hello Server."); Writer.write ("EOF/N"); escritor.flush (); // Leer después de escribir BufferedReader BR = New BufferedReader (new InputStreamReader (Client.getInputStream ())); // Establecer el tiempo de espera en 10 segundos de cliente. SetSotimeOut (10*1000); StringBuffer sb = new StringBuffer (); Cadena temp; Índice int; Pruebe {while ((temp = br.readline ())! = null) {if ((index = temp.indexof ("eof"))! = -1) {sb.append (temp.substring (0, index)); romper; } sb.append (temp); }} Catch (SocketTimeOutException e) {System.out.println ("Tiempo de espera de lectura de datos"); } System.out.println ("del servidor:" + sb); escritor.close (); br.close (); client.close (); }}5. Reciba datos Código de conflicto
Para tales casos, cuando el servidor o el cliente reciben código chino confuso, generalmente se debe a que la codificación utilizada cuando se envían los datos es inconsistente con la codificación utilizada cuando se reciben los datos. Por ejemplo, hay un código de servidor como este:
Código Java
Public Class Server {public static void main (string args []) lanza IOException {// Para simplicidad, toda la información de excepción se descarta int port = 8899; // Definir un Serversocket escucha en el puerto 8899 ServerSocket Server = new Serversocket (puerto); while (true) {// El servidor intenta recibir solicitudes de conexión de otros sockets. El método de aceptación del servidor es un socket de bloqueo = servidor.accept (); // Cada vez que se recibe un socket, se establece un nuevo hilo para manejarlo nuevo subproceso (nueva tarea (socket)). Inicio (); }} / ** * * / Tarea de clase estática implementos runnables {private socket socket; Tarea pública (socket socket) {this.socket = socket; } public void run () {try {Handlesocket (); } catch (Exception e) {E.PrintStackTrace (); }} / *** Comuníquese con el socket del cliente* @throws Exception* / private void handleSocket () lanza la excepción {BufferedReader BR = new BufferedReader (new InputStreamReader (Socket.GetInputStream (), "GBK")); StringBuilder sb = new StringBuilder (); Cadena temp; Índice int; while ((temp = br.readline ())! = null) {system.out.println (temp); if ((index = temp.IndexOf ("eof"))! = -1) {// finalizar la recepción cuando el EOF se encuentra sb.append (temp.substring (0, index)); romper; } sb.append (temp); } System.out.println ("Cliente:" + SB); // Escribir una oración después de leer escritor escritor = nuevo OutputStreamWriter (Socket.getOutputStream (), "UTF-8"); Writer.write ("Hola, cliente"); Writer.write ("EOF/N"); escritor.flush (); escritor.close (); br.close (); socket.close (); }}}Estoy un poco confundido cuando lo usé aquí para probar. En el código del servidor anterior, definimos claramente el uso de la codificación GBK para leer datos al definir el flujo de entrada, y especificamos claramente que el uso de la codificación UTF-8 para enviar datos al definir la secuencia de salida. Si el cliente no envía datos en la codificación GBK al enviar datos al cliente, es probable que los datos recibidos por el servidor se vean confundidos; Del mismo modo, si el cliente no envía la codificación de datos al enviar datos en el servidor, es decir, la codificación UTF-8 para recibir datos, también es muy probable que ocurran datos confusos. Por lo tanto, para el código del servidor anterior, para habilitar nuestro programa para leer los datos enviados por la otra parte sin código confuso, nuestro cliente debe ser así:
Código Java
Cliente de clase pública {public static void main (string args []) lanza la excepción {// Por simplicidad, todas las excepciones se tiran directamente string host = "127.0.0.1"; // La dirección IP del servidor a conectar int Port = 8899; // El puerto de escucha correspondiente del servidor a conectar // La conexión se establece con el servidor Socket Client = new Socket (host, puerto); // Después de establecer la conexión, puede escribir datos en el escritor del servidor = nuevo OutputStreamWriter (Client.getOutputStream (), "GBK"); Writer.write ("Hola, servidor"); Writer.write ("EOF/N"); escritor.flush (); // Leer después de escribir BufferedReader BR = New BufferedReader (new InputStreamReader (Client.getInputStream (), "UTF-8")); // Establecer el tiempo de espera en 10 segundos de cliente. SetSotimeOut (10*1000); StringBuffer sb = new StringBuffer (); Cadena temp; Índice int; Pruebe {while ((temp = br.readline ())! = null) {if ((index = temp.indexof ("eof"))! = -1) {sb.append (temp.substring (0, index)); romper; } sb.append (temp); }} Catch (SocketTimeOutException e) {System.out.println ("Tiempo de espera de lectura de datos"); } System.out.println ("servidor:" + sb); escritor.close (); br.close (); client.close (); }}Este artículo se ha compilado en "Resumen de las técnicas de operación de carga Java", y todos son bienvenidos a aprender y leer.
Lo anterior es todo el contenido de este artículo. Espero que sea útil para el aprendizaje de todos y espero que todos apoyen más a Wulin.com.