Tutorial: Aplicacion simple TCP Cliente - Servidor en Java

Publicado por el

Hola! hoy hare un ejemplo que sirve como base para explicar lo que es TCP, y una aplicacion cliente servidor, en Java.

TCP es un protocolo de comunicacion que es bastante confiable en comparacion a UDP por ejemplo, aunque claro cada uno tiene sus usos y sus ventajas. Entre las ventajas de TCP estan las siguientes:

  • Los mensajes no tienen un tamano limite
  • La data enviada por el cliente es encolada hasta que el servidor este listo para consumirla
  • Los mensajes se envian y se reciben en orden
Sin embargo las desventajas aparecen en el rendimiento, en una aplicacion de video juegos, UDP talvez seria mas conveniente. Entre los usos de TCP estan: aplicaciones FTP, telnet etc.

Para establecer la conexion entre cliente y servidor tendremos que crear un socket, que es un "end-point" para la comunicacion entre procesos, vale recalcar que un socket solo puede tener asignado un tipo de protocolo.



TCP Cliente
Para la aplicacion en Java seguiremos los siguientes pasos:

1.- En java crearemos el proyecto "TCP Sockets", con la clase TCPClient.
2. Crearemos un socket y le asignaremos el puerto y la ip del servidor.
3. Leeremos y escribiremos data usando el stream del socket.

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
import java.io.DataInputStream;
import java.io.DataOutputStream;
import java.io.IOException;
import java.net.Socket;
import java.net.UnknownHostException;


public class TCPClient {

 public static void main(String[] args) throws UnknownHostException, IOException, InterruptedException {
  // Conectarse al servidor local con el puerto 4444
  try (Socket socket = new Socket("localhost", 4444)) {
   
   // Crear los streams de entrada y salida del socket
   DataInputStream in = new DataInputStream(socket.getInputStream());
   DataOutputStream out = new DataOutputStream(socket.getOutputStream());   

   // Un simple loop de 10 iteraciones que vamos a enviar al servidor
   for (int i = 0; i < 10; i++) {
    //Dormimos la main thread por dos segundos
    Thread.sleep(2000);
    //Por el stream de salida (out) enviamos los mensajes
    // Se bloquea automaticamente hasta que se envie el mensaje
    out.writeUTF("Test Message " + i);
    out.flush();
    
    //Se bloquea hasta que el servidor responda
    String response = in.readUTF();
    System.out.println(response);
   }
  }
 }
}
TCP Servidor

1.- En el mismo proyecto crearemos la clase TCPEchoServer
2. Crear un socket, enlazado a un puerto que estara disponible para la conexion de clientes.
3. En un ciclo infinito, esperar que los clientes soliciten una conexion.
4. El servidor acepta la conexion, y crea nuevos stream de entradas y salidas para comunicarse con el cliente a traves del socket enlazado ( en este caso el puerto que se ha puesto en el servidor es el 4444)

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
public class TCPEchoServer {

 public static void main(String[] args) throws IOException {
  // Abre un nuevo socket para el puerto 4444
  try (ServerSocket server = new ServerSocket(4444)) {
   //En un ciclo infinito continua aceptando nuevas conexiones de clientes
   while(true){
    //Se bloquea hasta que acepte una conexion entrante
    Socket socket = server.accept();
    
    // Inicializa la conexion del cliente en una nueva thread, la thread va al metodo "serveClient" (Thread con modo Lambda compatible con java 7 en adelante)
    Thread t = new Thread(() -> serveClient(socket));    
    t.start();
   }
  }
 }
 /**
  * Serves a single client - identified by the socket.
  * @param socket
  */
 private static void serveClient(Socket socket) {
  try (Socket clientSocket = socket) {
   //Streams de entrada y salida para el socket
   DataInputStream in = new DataInputStream(clientSocket.getInputStream());
   DataOutputStream out = new DataOutputStream(clientSocket.getOutputStream());   
   
   // En un loop infinito acepta los mensajes del cliente que esta sirviendo 
   while(true) {
    // Se bloquea hasta que se reciba el mensajes
    String message = in.readUTF();
    System.out.println(message);
    
    //Se bloquea hasta enviar el mensajes
    out.writeUTF(String.format("Response: %s", message));
    out.flush();
   }
  } catch (IOException e) {
   e.printStackTrace();
  }
 }
}

Luego de crear estas dos clases solo debemos correr nuestro ejemplo, primero debe ejecutarse el servidor, que estara pendiente de las nuevas conexiones. Cuando se ejecute el cliente veras el intercambio de mensajes entre cliente y servidor.

Java TCP cliente
Java TCP servidor


Y eso es basicamente todo en este tutorial, espero les sirva!

Comentarios

Publicar un comentario