PDF de programación - Tutorial de sockets en Java

UNIVERSIDADE DA CORUÑA

Departamento de Tecnoloxías da Información

e as Comunicacións

LABORATORIO DE RC:

TUTORIAL DE SOCKETS EN JAVA

Índice
1. Presentación.......................................................................................................................3
2. Conceptos básicos.............................................................................................................4
2.1. TCP..............................................................................................................................4
2.2. UDP............................................................................................................................4
3. Sockets...............................................................................................................................5
3.1. Sockets en Java..........................................................................................................5
4. Sockets UDP......................................................................................................................6
4.1. Ejercicio 1: Implementación del servidor de eco UDP................................................8
4.2. Preguntas UDP.........................................................................................................10
5. Sockets TCP.....................................................................................................................11
5.1. Ejercicio 2: Implementación del servidor de eco TCP...............................................13
5.2. Preguntas TCP..........................................................................................................17
6. Lectura recomendada......................................................................................................18

1. Presentación
El laboratorio de Redes de Comunicaciones constará de un conjunto de prácticas no
obligatorias. Para la elaboración de las prácticas se dispondrá del laboratorio 1.1 y todas
ellas han de ser realizadas individualmente. La evaluación de la primera práctica
consistirá en una defensa ante el profesor de prácticas y para las dos últimas se
realizarán dos pequeños exámenes en el propio laboratorio.
Este tutorial proporciona una introducción a los sockets en Java. La parte práctica de
dicho tutorial NO será evaluada, si bien es muy recomendable la realización de la misma.
Cada práctica constará de un enunciado en donde se plantearán las tareas a realizar, y
podrá incluir información complementaria para el desarrollo de la misma. Las prácticas
que requieran el empleo de un lenguaje de programación deberán ser realizadas en Java.

2. Conceptos básicos
En clase de teoría se ha mencionado en repetidas ocasiones la pila de protocolos TCP/IP,
que permite la transmisión de datos entre redes de computadores. Dicha pila consta de
una serie de capas tal y como se puede apreciar en el diagrama siguiente:

Normalmente, cuando se escriben aplicaciones Java en red trabajaremos con el nivel de
aplicación, y utilizaremos además protocolos del nivel de transporte. Por este motivo es
preciso recordar las principales diferencias entre los dos protocolos básicos del nivel de
transporte: TCP (Transmission Control Protocol) y UDP (User Datagram Protocol).

2.1. TCP

• Es un protocolo orientado a conexión
• Provee un flujo de bytes fiable entre dos ordenadores (llegada en orden, correcta,

sin pérdidas → control de flujo, control de congestión...)

• Protocolos de nivel de aplicación que usan TCP: telnet, HTTP, FTP, SMTP...

2.2. UDP

• Es un protocolo no orientado a conexión
• Envía paquetes de datos (datagramas) independientes sin garantías
• Permite broadcast y multicast
• Protocolos de nivel de aplicación que usan UDP: DNS, TFTP...

3. Sockets
Cuando estamos trabajando en una red de ordenadores y queremos establecer una
comunicación (recibir o enviar datos) entre dos procesos que se están ejecutando en dos
máquinas diferentes de dicha red, ¿qué necesitamos para que dichos procesos se
puedan comunicar entre sí?
Supongamos que una de las aplicaciones solicita un servicio (cliente), y la otra lo ofrece
(servidor).
Una misma máquina puede tener una o varias conexiones físicas a la red y múltiples
servidores pueden estar escuchando en dicha máquina. Si a través de una de dichas
conexiones físicas se recibe una petición por parte de un cliente ¿cómo se identifica qué
proceso debe atender dicha petición? Es aquí donde surge el concepto de puerto, que
permite tanto a TCP como a UDP dirigir los datos a la aplicación correcta de entre todas
las que se están ejecutando en la máquina. Todo servidor, por tanto, ha de estar
registrado en un puerto para recibir los datos que a él se dirigen (veremos en los ejemplos
cómo se hace esto).
Los datos transmitidos a través de la red tendrán, por tanto, información para identificar la
máquina mediante su dirección IP (si IPv4 32 bits, y si IPv6 128 bits) y el puerto (16 bits) a
los que van dirigidos.
Los puertos:

•

•

•

son independientes para TCP y UDP
se identifican por un número de 16 bits (de 0 a 65535)
algunos de ellos están reservados (de 0 a 1023), puesto que se emplean para
servicios conocidos como HTTP, FTP, etc. y no deberían ser utilizados por
aplicaciones de usuario.

Por tanto, un socket se puede definir como un extremo de un enlace de comunicación
bidireccional entre dos programas que se comunican por la red (se asocia a un número de
puerto).

• Se identifica por una dirección IP de la máquina y un número de puerto.
• Existe tanto en TCP como un UDP.

3.1. Sockets en Java
Java incluye la librería java.net para la utilización de sockets, tanto TCP como UDP. Este
tutorial se basa exclusivamente en clases y métodos de esta librería, por lo que será
necesario importarla en todos los ejemplos y prácticas.

4. Sockets UDP
Los sockets UDP son no orientados a conexión. Los clientes no se conectarán con el
servidor sino que cada comunicación será independiente, sin poderse garantizar la
recepción de los paquetes ni el orden de los mismos. Es en este momento en donde
podemos definir el concepto de datagrama, que no es más que un mensaje
independiente, enviado a través de una red cuya llegada, tiempo de llegada y contenido
no están garantizados.
En primer lugar, vamos a implementar un cliente de eco UDP. El formato de ejecución
será:
java ClienteUDP <máquina_servidor> <puerto_servidor> <mensaje>
En donde,

–

–

–

máquina_servidor será el nombre (o la dirección IP) de la máquina en donde se
está ejecutando un servidor de eco UDP.
puerto_servidor será el puerto en el que está escuchando el servidor de eco
UDP.
mensaje será el mensaje que queremos enviar.

A continuación se muestra el código fuente del cliente de eco UDP.

import java.net.*;

/** Ejemplo que implementa un cliente de eco usando UDP. */

public class ClienteUDP {

public static void main(String argv[]) {
if (argv.length != 3) {
System.err.println("Formato: ClienteUDP <maquina> <puerto> <mensaje>");
System.exit(-1);
}

DatagramSocket sDatagram = null;

try {

// Creamos el socket no orientado a conexión
// (en cualquier puerto libre)
sDatagram = new DatagramSocket();

// Establecemos un timeout de 30 segs
sDatagram.setSoTimeout(30000);

// Obtenemos la dirección IP del servidor
// (recibida en el primer argumento por linea de comandos)
InetAddress dirServidor = InetAddress.getByName(argv[0]);
// Obtenemos el puerto del servidor
// (recibido en el segundo argumento por linea de comandos)
int puertoServidor = Integer.parseInt(argv[1]);
// Obtenemos el mensaje
// (tercer argumento de la linea de comandos)
String mensaje = argv[2];

// Preparamos el datagrama que vamos a enviar y lo enviamos
DatagramPacket dgramEnv = new DatagramPacket(mensaje.getBytes(),
mensaje.getBytes().length, dirServidor, puertoServidor);
// Enviamos el datagrama
sDatagram.send(dgramEnv);
System.out.println("CLIENTE: Enviando "
+ new String(dgramEnv.getData()) + " a "
+ dgramEnv.getAddress().toString() + ":"
+ dgramEnv.getPort());

// Preparamos el datagrama de recepción
byte array[] = new byte[1024];
DatagramPacket dgramRec = new DatagramPacket(array, array.length);
// Recibimos el mensaje
sDatagram.receive(dgramRec);
System.out.println("CLIENTE: Recibido "
+ new String(dgramRec.getData(), 0, dgramRec.getLength())
+ " de " + dgramRec.getAddress().toString() + ":"
+ dgramRec.getPort());


} catch (SocketTimeoutException e) {
System.err.println("30 segs sin recibir nada");
} catch (Exception e) {
System.err.println("Error: " + e.getMessage());
} finally {


// Cerramos el socket para liberar la conexión
sDatagram.close();

}
}
}

De manera más detallada, estos son los pasos que se ejecutan en el cliente:

1. Se crea un socket no orientado a conexión. Es importante recalcar que no es
necesario especificar un número de puerto en el constructor, ya que el propio
constructor se encargará de seleccionar un puerto libre (puerto efímero). Para más
información ver la documentación de la clase DatagramSocket (en especial la
sección de constructores).

2. Establecemos un tiempo de espera máximo para el socket. Si pasado ese tiempo

no ha recibido nada se lanzará la excepción correspondiente.

3. Se obtiene la dirección IP de la máquina en la que se encuentra el servidor, a partir
del primer argumento recibido por línea de comandos. La clase InetAddress
representa en Java el concepto de dirección IP. Esta clase dispone de