##
CLASES UTILES EN COMUNICACIONES

Vamos a exponer otras clases que resultan útiles cuando estamos desarrollando programas de comunicaciones, aparte de las que ya se han visto. El problema es que la mayoría de estas clases se prestan a discusión, porque se encuentran bajo el directorio `sun`. Esto quiere decir que son implementaciones Solaris y, por tanto, específicas del Unix Solaris. Además su API no está garantizada, pudiendo cambiar. Pero, a pesar de todo, resultan muy interesantes y vamos a comentar un grupo de ellas solamente que se encuentran en el paquete sun.net

##### Socket

> Es el objeto básico en toda comunicación a través de Internet, bajo el protocolo TCP. Esta clase proporciona métodos para la entrada/salida a través de streams que hacen la lectura y escritura a través de sockets muy sencilla.

##### ServerSocket

> Es un objeto utilizado en las aplicaciones servidor para escuchar las peticiones que realicen los clientes conectados a ese servidor. Este objeto no realiza el servicio, sino que crea un objeto Socket en función del cliente para realizar toda la comunicación a través de él.

##### DatagramSocket

> La clase de sockets datagrama puede ser utilizada para implementar datagramas no fiables (sockets UDP), no ordenados. Aunque la comunicación por estos sockets es muy rápida porque no hay que perder tiempo estableciendo la conexión entre cliente y servidor.

##### DatagramPacket

> Clase que representa un paquete datagrama conteniendo información de paquete, longitud de paquete, direcciones Internet y números de puerto.

##### MulticastSocket

> Clase utilizada para crear una versión multicast de las clase socket datagrama. Múltiples clientes/servidores pueden transmitir a un grupo multicast (un grupo de direcciones IP compartiendo el mismo número de puerto).

##### NetworkServer

> Una clase creada para implementar métodos y variables utilizadas en la creación de un servidor TCP/IP.

##### NetworkClient

> Una clase creada para implementar métodos y variables utilizadas en la creación de un cliente TCP/IP.

##### SocketImpl

> Es un Interface que nos permite crearnos nuestro propio modelo de comunicación. Tendremos que implementar sus métodos cuando la usemos. Si vamos a desarrollar una aplicación con requerimientos especiales de comunicaciones, como pueden se la implementación de un cortafuegos (TCP es un protocolo no seguro), o acceder a equipos especiales (como un lector de código de barras o un GPS diferencial), necesitaremos nuestra propia clase Socket.

Vamos a ver un ejemplo de utilización, presentando un sencillo ejemplo, servidorUDP.java, de implementación de sockets UDP utilizando la clase DatagramSocket.

    import java.net.*;
    import java.io.*;
    import sun.net.*;

    // Implementación del servidor de datagramas UDP. Envía una cadena
    // tras petición
    //
    class servidorUDP {
        public static void main( String args[] ) {
            DatagramSocket s = (DatagramSocket)null;
            DatagramPacket enviap,recibep;
            byte ibuffer[] = new byte[100];
            String cadena = "Hola Tutorial de Java!\n";
            InetAddress IP = (InetAddress)null;
            int longitud = sendString.length();
            int puertoEnvio = 4321;
            int puertoRecep = 4322;
            int puertoRemoto;

            // Intentamos conseguir la dirección IP del host
            try {
                IP = InetAddress.getByName( "bregogan" );
            } catch( UnknownHostException e ) {
                System.out.println( "No encuentro al host breogan" );
                System.exit( -1 );
                }

            // Establecemos el servidor para escuchar en el socket 4322
            try {
                s = new DatagramSocket( puertoRecep );
            } catch( SocketException e ) {
                System.out.println( "Error - "+e.toString() );
                }

            // Creamos un paquete de solicitud en el cliente
            // y nos quedamos esperando a sus peticiones
            recibep = new DatagramPacket( ibuffer,longitud );
            try {
                s.receive( recibep );
            } catch( IOException e ) {
                System.out.println( "Error - "+e.toString() );
                }

            // Creamos un paquete para enviar al cliente y lo enviamos
            sendString.getBytes( 0,longitud,ibuffer,0 );
            enviap = new DatagramPacket( ibuffer,longitud,IP,puertoEnvio );
            try {
                s.send( enviap );
            } catch( IOException e ) {
                System.out.println( "Error - "+e.toString() );
                System.exit( -1 );
                }

            // Cerramos el socket
            s.close();
            }
        }

Y también vamos a implementar el cliente, clienteUDP.java, del socket UDP correspondiente al servidor que acabamos de presentar:

    import java.net.*;
    import java.io.*;
    import sun.net.*;

    // Implementación del cliente de datagramas UDP. Devuelve la salida
    // de los servidores
    //
    class clienteUDP {
        public static void main( String args[] ) {
            int longitud = 100;
            DatagramSocket s = (DatagramSocket)null;
            DatagramPacket enviap,recibep;
            byte ibuffer[] = new byte[100];
            InetAddress IP = (InetAddress)null;
            int puertoEnvio = 4321;
            int puertoRecep = 4322;

            // Abre una conexión y establece el cliente para recibir
            // una petición en el socket 4321
            try {
                s = new DatagramSocket( puertoRecep );
            } catch( SocketException e ) {
                System.out.println( "Error - "+e.toString() );
                }

            // Crea una petición para enviar bytes. Intenta conseguir
            // la dirección IP del host
            try {
                IP = InetAddress.getByName( "depserver" );
            } catch( UnknownHostException e ) {
                System.out.println( "No encuentro el host depserver" );
                System.exit( -1 );
                }

            // Envía una petición para que responda el servidor
            try {
                enviap = new DatagramPacket( ibuffer,ibuffer.length,
                    IP,4322 );
                s.send( enviap );
            } catch( IOException e ) {
                System.out.println( "Error - "+e.toString() );
                }

            // Consigue un controlador de fichero de entrada del socket y lee
            // dicha entrada. Creamos un paquete descriptor para recibir el
            // paquete UDP
            recibep = new DatagramPacket( ibuffer,longitud );

            // Espera a recibir un paquete
            try {
                s.receive( recibep );
            } catch( IOException e ) {
                System.out.println( "Error - "+e.toString() );
                System.exit( -1 );
                }

            // Imprimimos los resultados de lo que conseguimos
            System.out.println( "Recibido: "+recibep.getLength()+" bytes" );
            String datos = new String( recibep.getData(),0 );
            System.out.println( "Datos: "+datos );
            System.out.println( "Recibido por puerto: "+recibep.getPort() );

            // Cerramos la conexión y abandonamos
            s.close();
            }
        }

La salida que se producirá cuando ejecutemos primero el servidor y luego el cliente será la misma que reproducimos a continuación:

    %java clienteUDP
    Recibido: 17 bytes
    Datos: Hola Tutorial de Java!

    Recibido por puerto: 4322

|  | ##### [Anterior] [Indice] [Siguiente]