Cliente - Servidor de réplica (UDP) en Java.

Vamos a experimentar con la comunicación entre procesos y los protocolos de Internet, viendo como los podemos utilizar por medio de mensajes UDP o streams TCP. Se pondrán en práctica los conceptos de sockets, que se utilizan en la interfaz de programación de aplicaciones TCP y UDP, así como las primitivas send y receive, para el envío y recepci on de mensajes.

Utilizaremos la API Java de UDP y TCP para la programaci on del cliente/servidor con UDP, respectivamente. Así como el paquete java.net, donde podemos encontrar la especificación completa de las clases involucradas. 

Cliente/Servidor con UDP

Vamos a implementar un sencillo servidor, que simplemente recibir a un mensaje del cliente, prepara y envía un mensaje de respuesta al mensaje recibido. Lo primero que hemos de hacer es preparar el fichero fuente de UDPServer:

import java.net.*;
import java.io.*;
import java.util.logging.Level;
import java.util.logging.Logger;

/**
*
* @author Iván Durango
*/

public class UDPServer {

    public static void main(String args[]){

         // Instanciamos un Socket para datagramas.
         DatagramSocket aSocket = null;

        try {

            // Crea un socket para datagramas y le asocia al puerto 6789.
            aSocket = new DatagramSocket(6789);

            // Creamo un buffer para entrada de datos.
            byte [] buffer = new byte[1000];

            // Genera un datagrama para mensages de longitud indicada.
            DatagramPacket request = new DatagramPacket(buffer, buffer.length);

            while (true){

                // Esperamos a recibir algun paquete de un cliente.
                aSocket.receive(request);
 
                // Generamos un datagrama con los datos obtenidos del cliente.
                DatagramPacket reply = new DatagramPacket(request.getData(),

                request.getLength(), request.getAddress(), request.getPort());

                // Enviamos el mismo mensaje que recivimos al cliente (replicamos)
                 aSocket.send(reply);

            }// Fin while

        } catch (SocketException ex) {

                Logger.getLogger(UDPServer.class.getName()).log(Level.SEVERE, null, ex);

        } catch (IOException ex) {

                Logger.getLogger(UDPServer.class.getName()).log(Level.SEVERE, null, ex);

        } //Excepciones
     }
}

Como vemos, el programa (servicio) se identi ca con un n umero (6789). Tras lo cu al, desarrollamos el proyecto correspondiente al cliente UDPClient:

import java.net.*;
import java.io.*;
import java.util.logging.Level;
import java.util.logging.Logger;

/**
*
* @author Iván Durango
*/

//Para probar que el código funciona, se relizan conexiones en "localhost" y
//en remoto. Para ello es necesario introducirle al cliente los argumentos
//necesarios, que son los siguientes:

//        Para conectar con localhost:"hola que ta,Soy Ivánl", localhost
//        Para Conectar en remoto:"hola que ta,Soy Ivánl", HOSTREMOTO, donde
//        HOSTREMOTOes el nombre del host a conectar.

public class UDPClient {

    public static void main(String args[]){

        // Instanciamos un Socket para datagramas.
        DatagramSocket aSocket = null;

        try{

            // Crea un socket para datagramas y le asocia un puerto local.
            aSocket = new DatagramSocket();

            // Creamos una cadena de bytes, con el mensaje recibido por argumento.
            byte [] m = args[0].getBytes();

            InetAddress aHost;

            // Obtenemos un objeto InetAddres por su nombre de host. El cual
            // es pasado como argumento.
           aHost = InetAddress.getByName(args[1]);

            // Establecemos el número de puerto.
            int serverPort = 6789;

            // Generamos un datagrama para mensages con el mensaje y su longitud,
            // usando el host y el puerto establecidos.
            DatagramPacket request = new DatagramPacket(m, args[0].length(), aHost, serverPort);

            // Envia el datagrama creado anteriormente por el socket.
            aSocket.send(request);

            // Creamos un buffer de entrada, para recoger la respuesta del servidor.
            byte[] buffer = new byte[1000];

            // Creamos el datagrama correspondiente con el buffer anterior.
            DatagramPacket reply = new DatagramPacket(buffer, buffer.length);

            // Establecemos un TimeOur de 5000 milisegundos, por si no obtenemos
            // respuesta del servidor.
            aSocket.setSoTimeout(5000);

            // Recibimos la respuesta el servidor (bloqueante)
            aSocket.receive(reply);

            // Mostramos el mensaje recibido por pantalla.
            System.out.println("Reply: " + new String(reply.getData()));

       } catch (SocketException ex) {

            Logger.getLogger(UDPClient.class.getName()).log(Level.SEVERE, null, ex);

        } catch (UnknownHostException ex) {

            Logger.getLogger(UDPClient.class.getName()).log(Level.SEVERE, null, ex);

        } catch (IOException ex) {

            Logger.getLogger(UDPClient.class.getName()).log(Level.SEVERE, null, ex);

        } //Excepciones

    }// Main

}
Como vemos, el cliente debe preparar el mensaje que enviar a al servidor, lo enviará y se quedará esperando respuesta. Como se puede observar, esta respuesta debe ser recibida en un tiempo menor o igual a 5 segundos, por lo que se debemos utilizar un timeout para dicha función.