TCP Y UDP EN JAVA

TCP en Java

Ejemplos Servidor

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.PrintStream;
import java.net.ServerSocket;
import java.net.Socket;

public class Servidor {

    public static void main(String[] args) {

        ServerSocket    s;  //Socket servidor
        Socket      sc;      //Socket cliente

        PrintStream     p;    //Canal de escritura
        BufferedReader  b;      //Canal de Lectura
       
        String    mensaje;
       
        try {
            //Creo el socket server
            s = new ServerSocket(9999);
           
            //Invoco el metodo accept del socket servidor, me devuelve una referencia al socket cliente
            sc = s.accept();
           
            //Obtengo una referencia a los canales de escritura y lectura del socket cliente
            b = new BufferedReader( new InputStreamReader ( sc.getInputStream() ) );
            p = new PrintStream   ( sc.getOutputStream() );

            while ( true ) {
                //Leo lo que escribio el socket cliente en el canal de lectura
                mensaje = b.readLine();
                System.out.println(mensaje);
               
                //Escribo en canal de escritura el mismo mensaje recibido
                p.println(mensaje);

                if ( mensaje.equals("by")) {
                    break;
                }
            }
           
            p.close();
            b.close();
           
            sc.close();
            s.close();
        } catch (IOException e) {
            System.out.println("No puedo crear el socket");
        }
    }

}

Ejemplo Cliente

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.PrintStream;
import java.net.Socket;
import java.net.UnknownHostException;

public class Cliente {

    public static void main(String[] args) {

        Socket      s;
        PrintStream             p;
        BufferedReader    b;

        String          host = "localhost";
        int      port = 9999;
        String          respuesta;

        //Referencia a la entrada por consola (System.in)
        BufferedReader    in = new BufferedReader(new InputStreamReader(System.in));

        try {

            //Creo una conexion al socket servidor
            s = new Socket(host,port);  

            //Creo las referencias al canal de escritura y lectura del socket
            p = new PrintStream(s.getOutputStream());
            b = new BufferedReader ( new InputStreamReader ( s.getInputStream() ) );

            while ( true ) {
                //Ingreso un String por consola 
                System.out.print("Mensaje a enviar: ");

                //Escribo en el canal de escritura del socket
                p.println( in.readLine() );
               
                //Espero la respuesta por el canal de lectura
                respuesta = b.readLine();
                System.out.println(respuesta);
                if ( respuesta.equals("by")) {
                    break;
                }         
            }
            p.close();
            b.close(); 
            s.close();

        } catch (UnknownHostException e) {
            System.out.println("No puedo conectarme a " + host + ":" + port);
        } catch (IOException e) {
            System.out.println("Error de E/S en " + host + ":" + port);
        }
    }
}

UDP en JAVA

UNA PEQUEÑA INTRODUCCIÓN

En los sockets TCP es necesario establecer una conexión. El servidor TCP espera que un cliente TCP se le conecte. Una vez hecha la conexión, se pueden enviar mensajes. El protocolo TCP garantiza que todos los mensajes enviados van a llegar bien y en el orden enviado. Sólo el cliente necesita saber dónde está el servidor y en qué puerto está escuchando.

Por el contrario, en los sockets UDP no se establece conexión. El servidor se pone a la escucha de un puerto de su ordenador. El cliente también se pone a la escucha de un puerto de su ordenador. En cualquier momento, cualquiera de ellos puede enviar un mensaje al otro.  Ambos necesitan saber en qué ordendador y en qué puerto está escuchando el otro. Aquí el concepto de cliente y servidor está un poco más difuso que en el caso de TCP. Podemos considerar servidor al que espera un mensaje y responde. Cliente sería el que inicia el trasiego de mensajes. El servidor debería, además, estar siempre arrancado y a la escucha.

Además, en contra de TCP, el protocolo UDP sólo garantiza que si el mensaje llega, llega bien. No garantiza que llegue ni que lleguen en el mismo orden que se han enviado. Este tipo de sockets es útil para el envío más o menos masivo de información no crucial. Por ejemplo, enviar los datos para el refresco de gráficos en una pantalla.

Otra ventaja de UDP respecto a TCP, es que con UDP se puede enviar un mensaje a varios receptores a la vez, mientras que en TCP, al haber una conexión previa, sólo se puede enviar el mensaje al que está conectado al otro lado. Con UDP se puede, por ejemplo, enviar una sola vez los datos para que varias pantallas refresquen sus gráficos a la vez.

LA CLASE DatagramSocket

Tanto cliente como servidor, para ponerse a la escucha de un puerto UDP, únicamente tienen que instanciar la clase DatagramSocket, pasándole los parámetros adecuados:

• El número de puerto que están escuchando.
• El InetAddress del ordenador en que se está corriendo cada uno, habitualmente InetAddress.getLocalHost();

Por ello, el código del servidor es tan sencillo como esto

ServidorUdp.java

DatagramSocket socket = new DatagramSocket(
   Constantes.PUERTO_DEL_SERVIDOR,
   InetAddress.getByName("localhost"));

y el del cliente se parece bastante

ClienteUdp.java

DatagramSocket socket = new DatagramSocket(
   Constantes.PUERTO_DEL_CLIENTE,
   InetAddress.getByName("localhost"));

LA CLASE DatagramParcket

Esta es la clase que se va a enviar y recibir como mensaje. Lleva dentro un array de bytes que es el que debemos rellenar con lo queremos enviar o en el que estará lo que hemos recibido.

Dependiendo de si es para enviar o recibir, esta clase se instancia de forma distinta. En ambos casos hay que pasarle el array de bytes. En el caso de enviar, hay que pasarle además la InetAdress del destinatario y el puerto en el que está escuchando el destinatario.

Para enviar

DatagramPacket dato = new DatagramPacket(
   elDatoEnBytes, // El array de bytes
   elDatoEnBytes.length, // Su longitud
   InetAddress.getByName(Constantes.HOST_SERVIDOR),  // Destinatario
   Constantes.PUERTO_DEL_SERVIDOR);   // Puerto del destinatario

Para recibir

DatagramPacket dato = new DatagramPacket(new byte[100], 100);

ENVIAR Y RECIBIR LOS DatagramPacket

Para enviar el DatagramPacket, debemos llamar al método send() de DatagramSocket pasando como parámetro el DatagramPacket que acabamos de crear.

Enviar DatagramPacket

socket.send(dato);

Para recibir, igual pero con socket.receive().

Recibir DatagramPacket

socket.receive(dato);

CONVERTIR UNA CLASE Serializable A ARRAY DE BYTES Y VICEVERSA

Lo de meter un array de bytes en el DatagramPacket está muy bien si leemos bytes de un fichero o de algún otro sitio. Sin embargo, si queremos enviar o recibir clases (Serializable, por supuesto), tenemos que hacer una conversión. Los siguientes código nos ayudan a hacer este tipo de conversiones. Suponemos que la clase se llamaDatoUdp y que implenta la interface Serializable.

De Serializable a byte[]

ByteArrayOutputStream bytes = new ByteArrayOutputStream();
ObjectOutputStream os = new ObjectOutputStream (bytes);
os.writeObject(this);  // this es de tipo DatoUdp
os.close();
return bytes.toByteArray(); // devuelve byte[]

De byte[] a Serializable

ByteArrayInputStream byteArray = new ByteArrayInputStream(bytes); // bytes es el byte[]
ObjectInputStream is = new ObjectInputStream(byteArray);
DatoUdp aux = (DatoUdp)is.readObject();
is.close();
return aux;

EL EJEMPLO

Con todo esto ya sabemos lo necesario para hacer un pequeño ejemplo de Servidor udp y cliente udp. Los fuentes del ejemplo los tienes en socketudp.zip. Si lo descomprimes, simplemente compila y ejecuta de la siguiente manera:

Para arrancar el servidor

$ unzip socketudp.zip
$ javac chuidiang\ejemplos\*.java
$ java chuidiang.ejemplos.ServidorUdp

Para arrancar el cliente

$ unzip socketudp.zip
$ javac chuidiang\ejemplos\*.java
$ java chuidiang.ejemplos.ClienteUdp

Deberías ver cómo el cliente envía 10 mensajes y el servidor los escribe en pantalla. Si no ejecutas ambos programas en el mismo ordenador, tendrás que cambiar los fuentes para que el cliente tenga el nombre del servidor.