El socket de programación de Java implementa varios clientes para conectarse al mismo código del servidor

Java Socket (Socket) también se conoce comúnmente como "Socket", que describe direcciones y puertos IP, y es un mango para una cadena de comunicación. Las aplicaciones generalmente realizan solicitudes o responden las solicitudes de red a través de "enchufes".

Use el socket para realizar la comunicación entre varios clientes y el mismo cliente; Primero, el cliente se conecta al servidor para enviar un mensaje, el servidor procesa el mensaje después de recibir el mensaje y luego responda al cliente a un mensaje después de completarlo. He escrito un código implementado por el servidor y el cliente a través de mi propio pensamiento, con la esperanza de aprender de todos y progresar juntos.

Código de servidor

 /** * Socket server* Function description: * */public class Server {/** * Entry* * @param args * @throws IOException */public static void main(String[] args) throws IOException {// For simplicity, all exception information is thrown out int port = 8899;// Define a ServiceSocket listener on port 8899 ServerSocket server = new ServerSocket (puerto); system.out.println ("Espere la conexión al cliente ..."); 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 de bloqueo = servidor.accept ();/*** Nuestro servidor maneja las solicitudes 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 procesar la siguiente solicitud de conexión. Esto afectará seriamente el rendimiento del programa cuando haya más concurrencia. * Para este fin, podemos cambiarlo al siguiente procesamiento asíncrono de la comunicación con el cliente* /// Cada vez que se recibe un socket, se establece un nuevo subproceso para manejar su nuevo subproceso (nueva tarea (Socket)). Start ();} // Server.Close ();}/*** Class de subprocesos que maneja las solicitudes de las solicitudes*/estatales Tareas Publicable {privado Socket Socket Socket Socket Socket Socket;/construye* Tarea (Socket Socket) {this.socket = Socket;} @anverride public void run () {try {handlersocket ();} catch (excepción e) {e.printstacktrace ();}}/** * comunicar con el socket * * @throws iOException */private videlersocket () lanza la excepción {// después de establecer una conexión con la conexión con el cliente. Entrarse y leer la información enviada por el cliente desde él/*** Al recibir datos del Socket InputStream, leer un poco como lo anterior es demasiado complicado. * A veces cambiaremos al uso de BufferedReader para leer una línea a la vez * * 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 y * finalizará el bloqueo y dejará que el programa continúe ejecutándose. * Entonces, cuando usamos la línea de lectura de BufferedReader para leer datos, debemos recordar escribir rupturas de línea en el flujo 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 rupturas de línea, debemos recordar enjuagar si la secuencia de salida no está cerrada de inmediato, * solo entonces los datos se pueden escribir realmente desde el búfer. */BufferedReader br = new BufferedReader (new InputStreamReader (Socket.getInputStream (), "UTF -8")); StringBuilder sb = new StringBuilder (); String Temp; int index; while ((temp = BR.Readline ())! = NULL) {if ((index = temp.indexof ("eof"))! sb.append (temp.substring (0, index)); break;} sb.append (temp);} system.out.println ("Form Cliente [puerto:" + Socket.getport () + "] Mensaje Content:" + Sb.ToString ()); // Responder al escritor del cliente = nuevo outtreamwriter (Socket.getPutStream (),,,,,,,,, responda "UTF-8"); Writer.Write (String.Format ("Hi,%d. El cielo es brillante y el aire está claro, el viento es suave!", Socket.getPort ())); escritor.flush (); escritor.close (); system.out.println ("al cliente [puerto:" + enchufe.getport () + " con éxito "); br.close (); socket.close ();}}}

Código de cliente

 import java.io.inputstreamreader; import java.io.outputstreamwriter; import java.io.reader; import java.io.writer; import java.net.socket;/*** Soceket Cliente* Descripción:** @author A Wise y Stupidtit Sittle Entendimiento* @Date el 30 de agosto de 2016* @Version 1.0*/Public Class Cliente {/*** ... static void main (string [] args) {// Abra tres clientes, un hilo representa un cliente para (int i = 0; i <3; i ++) {new Thread (new runnable () {@Override public void run () {try {testClient cliente = testClientFactory.createClient (); client.sEND (string.format. client.client.getLocalPort()));client.receive();}catch (Exception e) {e.printStackTrace();}}}).start();}}/** * Factory that produces the test client*/static class TestClientFactory {public static TestClient createClient() throws Exception {return new TestClient("127.0.0.1", 8899);}}}/*** Test Client*/Static Class TestClient {/*** Constructor* @param La dirección IP de host del servidor se conecta* @param Portes de escucha correspondiente del servidor para estar conectado* @throws Exception*/public testClient (string host, int port) Excepción {// Establecer una conexión con el servidor este.Client (Nuevo soce (nuevo soce (nuevo (nuevo soce (nuevo (nuevo (nuevo Soc., ( puerto); System.out.println ("Client [Port:" + Client.getLocalport () + "] Establezca una conexión con el servidor ...");} private Socket Client; private Writer Writer;/** * Enviar un mensaje * @param msg * @throws excepción */public void enviar (string msg) Excepción {// Después de establecer la conexión, puede escribir datos al servidor (escritor == NECURAD OutputStreamWriter (Client.getOutputStream (), "UTF-8");} Writer.Write (msg); Writer.Write ("EOF/N"); Writer.Flush (); // Después de escribir, recuerde flush System.out.Println ("Cliente [Port:" + Client.getLocalPort () + "Message enviado con éxito");}/******** @@treeid* @treiad* Recibe () lanza la excepción {// Leer después de escribir lector lector = new InputStreamReader (Client.getInputStream (), "UTF-8"); // Establezca el tiempo para recibir datos en 10 segundos Client.SetSoTimeOut (10*1000); char [] chars = new Char [64]; int len; string; -1) {sb.append (new String (chars, 0, len));} System.out.println ("Client [Port:" + Client.getLocalport () + "] El mensaje fue recibido, el contenido:" + SB.ToString ()); Reader.Close (); // Cerrar el escritor de conexión.close (cliente.close ();}}

A continuación, simulemos:

1. Ejecute el servidor primero

2. Luego ejecute el cliente (abra tres solicitudes del cliente)

Para la demostración, uso la herramienta Eclipse en el servidor y la herramienta Idea IntelliJ en el cliente. En este momento, puede ver el mensaje impreso por el cliente en la consola

Un número de puerto representa un cliente. Veamos hacia atrás al mensaje impreso por el servidor en la consola.

Resumir

Lo anterior es todo el contenido de este artículo sobre el socket de programación Java que implementa varios clientes para conectarse al mismo código del servidor. Espero que sea útil para todos. Si tiene alguna pregunta, deje un mensaje y el editor responderá a todos a tiempo.