¡Descarga Sockets java y más Apuntes en PDF de Ingeniería de Telecomunicaciones solo en Docsity!
- 1.- FUNDAMENTOS
- 2.- FUNCIONAMIENTO GENÉRICO
- 3.- JAVA SOCKETS
- 3.1.- INTRODUCCION...........................................................................................................................................
- 3.2.- MODELO DE COMUNICACIONES CONJAVA....................................................................................................
- 3.3.- APERTURA DE SOCKETS...............................................................................................................................
- 3.4.- CREACIÓN DE STREAMS...............................................................................................................................
- 3.4.1.- Creación de Streams de Entrada
- 3.4.2.- Creación de Streams de Salida.............................................................................................................
- 3.5.- CIERRE DE SOCKETS....................................................................................................................................
- 3.6.- CLASES ÚTILES EN COMUNICACIONES.........................................................................................................
- 3.7.- EJEMPLO DE USO.......................................................................................................................................
- 3.7.1.- Programa Cliente
- 3.7.2.- Programa Servidor
- 3.7.3.- Ejecución...........................................................................................................................................
1.- Fundamentos
Los sockets son un sistema de comunicación entre procesos de diferentes máquinas de una red. Más exactamente, un socket es un punto de comunicación por el cual un proceso puede emitir o recibir información.
Fueron popularizados por Berckley Software Distribution , de la universidad norteamericana de Berkley. Los sockets han de ser capaces de utilizar el protocolo de streams TCP (Transfer Contro Protocol) y el de datagramas UDP (User Datagram Protocol).
Utilizan una serie de primitivas para establecer el punto de comunicación, para conectarse a una máquina remota en un determinado puerto que esté disponible , para escuchar en él, para leer o escribir y publicar información en él, y finalmente para desconectarse.
Con todas las primitivas se puede crear un sistema de diálogo muy completo.
3.- JAVA Sockets
3.1.- Introduccion
El paquete java.net de la plataforma Java proporciona una clase Socket , la cual implementa una de las partes de la comunicación bidireccional entre un programa Java y otro programa en la red.
La clase Socket se sitúa en la parte más alta de una implementación dependiente de la plataforma, ocultando los detalles de cualquier sistema particular al programa Java. Usando la clase java.net.Socket en lugar de utilizar código nativo de la plataforma, los programas Java pueden comunicarse a través de la red de una forma totalmente independiente de la plataforma.
De forma adicional, java.net incluye la clase ServerSocket , la cual implementa un socket el cual los servidores pueden utilizar para escuchar y aceptar peticiones de conexión de clientes.
Nuestro objetivo será conocer cómo utilizar las clases Socket y ServerSocket.
Por otra parte, si intentamos conectar a través de la Web, la clase URL y clases relacionadas ( URLConnection , URLEncoder ) son probablemente más apropiadas que las clases de sockets. Pero de hecho , las clases URL no son más que una conexión a un nivel más alto a la Web y utlilizan como parte de su implementación interna los sockets.
3.2.- Modelo de comunicaciones con Java
El modelo de sockets más simple es: · El servidor establece un puerto y espera durante un cierto tiempo ( timeout segundos), a que el cliente establezca la conexión. Cuando el cliente solicite una conexión, el servidor abrirá la conexión socket con el método accept(). · El cliente establece una conexión con la máquina host a través del puerto que se designe en puerto# · El cliente y el servidor se comunican con manejadores InputStream y OutputStream
3.4.- Creación de Streams
3.4.1.- Creación de Streams de Entrada
En la parte CLIENTE de la aplicación, se puede utilizar la clase DataInputStream para crear un stream de entrada que esté listo a recibir todas las respuestas que el servidor le envíe.
DataInputStream entrada; try { entrada = new DataInputStream( miCliente.getInputStream() ); } catch( IOException e ) { System.out.println( e ); }
La clase DataInputStream permite la lectura de líneas de texto y tipos de datos primitivos de Java de un modo altamente portable; dispone de métodos para leer todos esos tipos como: read() , readChar() , readInt() , readDouble() y readLine(). Deberemos utilizar la función que creamos necesaria dependiendo del tipo de dato que esperemos recibir del servidor.
En el lado del SERVIDOR , también usaremos DataInputStream , pero en este caso para recibir las entradas que se produzcan de los clientes que se hayan conectado:
DataInputStream entrada; try { entrada = new DataInputStream( socketServicio.getInputStream() ); } catch( IOException e ) { System.out.println( e ); }
3.4.2.- Creación de Streams de Salida
En el lado del CLIENTE , podemos crear un stream de salida para enviar información al socket del servidor utilizando las clases PrintStream o DataOutputStream :
PrintStream salida; try { salida = new PrintStream( miCliente.getOutputStream() ); } catch( IOException e ) { System.out.println( e ); }
La clase PrintStream tiene métodos para la representación textual de todos los datos primitivos de Java. Sus métodos write y println() tienen una especial importancia en este aspecto. No obstante, para el envío de información al servidor también podemos utilizar DataOutputStream :
DataOutputStream salida; try { salida = new DataOutputStream( miCliente.getOutputStream() ); } catch( IOException e ) { System.out.println( e ); }
La clase DataOutputStream permite escribir cualquiera de los tipos primitivos de Java, muchos de sus métodos escriben un tipo de dato primitivo en el stream de salida. De todos esos métodos, el más útil quizás sea writeBytes().
En el lado del SERVIDOR , podemos utilizar la clase PrintStream para enviar información al cliente:
PrintStream salida; try { salida = new PrintStream( socketServicio.getOutputStream() ); } catch( IOException e ) { System.out.println( e ); }
Pero también podemos utilizar la clase DataOutputStream como en el caso de envío de información desde el cliente.
3.6.- Clases útiles en comunicaciones
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.
3.7.- Ejemplo de uso
Para comprender el funcionamiento de los sockets no hay nada mejor que estudiar un ejemplo. El que a continuación se presenta establece un pequeño diálogo entre un programa servidor y sus clientes, que intercambiarán cadenas de información.
3.7.1.- Programa Cliente
El programa cliente se conecta a un servidor indicando el nombre de la máquina y el número puerto (tipo de servicio que solicita) en el que el servidor está instalado.
Una vez conectado, lee una cadena del servidor y la escribe en la pantalla:
import java.io.; import java.net.; class Cliente { static final String HOST = "localhost"; static final int PUERTO=5000; public Cliente( ) { try{ Socket skCliente = new Socket( HOST , Puerto ); InputStream aux = skCliente.getInputStream(); DataInputStream flujo = new DataInputStream( aux ); System.out.println( flujo.readUTF() ); skCliente.close(); } catch( Exception e ) { System.out.println( e.getMessage() ); } } public static void main( String[] arg ) { new Cliente(); } }
En primer lugar se crea el socket denominado skCliente , al que se le especifican el nombre de host ( HOST ) y el número de puerto ( PORT ) en este ejemplo constantes.
Luego se asocia el flujo de datos de dicho socket (obtenido mediante getInputStream) ), que es asociado a un flujo ( flujo ) DataInputStream de lectura secuencial. De dicho flujo capturamos una cadena ( readUTF() ), y la imprimimos por pantalla ( System.out ).
El socket se cierra, una vez finalizadas las operaciones, mediante el método close().
Debe observarse que se realiza una gestión de excepción para capturar los posibles fallos tanto de los flujos de datos como del socket.
Para atender a los clientes se utiliza la primitiva accept() de la clase ServerSocket , que es una rutina que crea un nuevo Socket ( skCliente ) para atender a un cliente que se ha conectado a ese servidor.
Se asocia al socket creado ( skCliente ) un flujo ( flujo) de salida DataOutputStream de escritura secuencial, en el que se escribe el mensaje a enviar al cliente.
El tratamiento de las excepciones es muy reducido en nuestro ejemplo, tan solo se captura e imprime el mensaje que incluye la excepción mediante getMessage().
3.7.3.- Ejecución
Aunque la ejecución de los sockets está diseñada para trabajar con ordenadores en red, en sistemas operativos multitarea (por ejemplo Windows y UNIX) se puede probar el correcto funcionamiento de un programa de sockets en una misma máquina.
Para ellos se ha de colocar el servidor en una ventana, obteniendo lo siguiente:
java Servidor Escucho el puerto 5000
En otra ventana se lanza varias veces el programa cliente, obteniendo:
java Cliente Hola cliente 1 java cliente Hola cliente 2 java cliente Hola cliente 3 java cliente connection refused: no further information
Mientras tanto en la ventana del servidor se ha impreso: Sirvo al cliente 1 Sirvo al cliente 2 Sirvo al cliente 3 Demasiados clientes por hoy
Cuando se lanza el cuarto de cliente, el servidor ya ha cortado la conexión, con lo que se lanza una excepción.
Obsérvese que tanto el cliente como el servidor pueden leer o escribir del socket. Los mecanismos de comunicación pueden ser refinados cambiando la implementación de los sockets , mediante la utilización de las clases abstractas que el paquete java.net provee.
