PDF de programación - JSockets

1.- FUNDAMENTOS ........................................................................................................................................... 2

2.- FUNCIONAMIENTO GENÉRICO ............................................................................................................... 3

3.- JAVA SOCKETS............................................................................................................................................ 4

3.1.- INTRODUCCION........................................................................................................................................... 4

3.2.- MODELO DE COMUNICACIONES CON JAVA.................................................................................................... 5

3.3.- APERTURA DE SOCKETS............................................................................................................................... 6

3.4.- CREACIÓN DE STREAMS............................................................................................................................... 7

3.4.1.- Creación de Streams de Entrada .......................................................................................................... 7

3.4.2.- Creación de Streams de Salida............................................................................................................. 8

3.5.- CIERRE DE SOCKETS.................................................................................................................................... 9

3.6.- CLASES ÚTILES EN COMUNICACIONES......................................................................................................... 10

3.7.- EJEMPLO DE USO....................................................................................................................................... 11

3.7.1.- Programa Cliente .............................................................................................................................. 11

3.7.2.- Programa Servidor ............................................................................................................................ 12

3.7.3.- Ejecución........................................................................................................................................... 14

1

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.

2

2.- Funcionamiento genérico

Normalmente, un servidor se ejecuta sobre una computadora específica y tiene un socket

que responde en un puerto específico. El servidor únicamente espera, escuchando a través del
socket a que un cliente haga una petición.

En el lado del cliente: el cliente conoce el nombre de host de la máquina en la cual el
servidor se encuentra ejecutando y el número de puerto en el cual el servidor está conectado.
Para realizar una petición de conexión , el cliente intenta encontrar al servidor en la máquina
servidora en el puerto especificado.

Si todo va bien, el servidor acepta la conexión. Además de aceptar, el servidor obtiene un

nuevo socket sobre un puerto diferente. Esto se debe a que necesita un nuevo socket (y , en
consecuencia, un numero de puerto diferente) para seguir atendiendo al socket original para
peticiones de conexión mientras atiende las necesidades del cliente que se conectó.

Por la parte del cliente, si la conexión es aceptada, un socket se crea de forma satisfactoria

y puede usarlo para comunicarse con el servidor. Es importante darse cuenta que el socket en el
cliente no está utilizando el número de puerto usado para realizar la petición al servidor. En lugar
de éste, el cliente asigna un número de puerto local a la máquina en la cual está siendo ejecutado.
Ahora el cliente y el servidor pueden comunicarse escribiendo o leyendo en o desde sus
respectivos sockets.

3

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.

4

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

5

3.3.- Apertura de Sockets

Si estamos programando un CLIENTE, el socket se abre de la forma:

Socket miCliente;
miCliente = new Socket( "maquina", numeroPuerto );

Donde maquina es el nombre de la máquina en donde estamos intentando abrir la

conexión y numeroPuerto es el puerto (un número) del servidor que está corriendo sobre el cual
nos queremos conectar. Cuando se selecciona un número de puerto, se debe tener en cuenta que
los puertos en el rango 0-1023 están reservados para usuarios con muchos privilegios
(superusuarios o root). Estos puertos son los que utilizan los servicios estándar del sistema como
email, ftp o http. Para las aplicaciones que se desarrollen, asegurarse de seleccionar un puerto por
encima del 1023.

En el ejemplo anterior no se usan excepciones; sin embargo, es una gran idea la captura

de excepciones cuando se está trabajando con sockets. El mismo ejemplo quedaría como:

Socket miCliente;
try {
miCliente = new Socket( "maquina",numeroPuerto );
} catch( IOException e ) {
System.out.println( e );
}

Si estamos programando un SERVIDOR, la forma de apertura del socket es la que

muestra el siguiente ejemplo:

Socket miServicio;
try {
miServicio = new ServerSocket( numeroPuerto );
} catch( IOException e ) {
System.out.println( e );
}

A la hora de la implementación de un servidor también necesitamos crear un objeto
socket desde el ServerSocket para que esté atento a las conexiones que le puedan realizar
clientes potenciales y poder aceptar esas conexiones:

Socket socketServicio = null;
try {
socketServicio = miServicio.accept();
} catch( IOException e ) {
System.out.println( e );
}

6

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 );
}

7

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.pr