Desarrollo de Aplicaciones

Distribuidas
3º Grado en I. de Tecnologías de Telecomunicación

Tema 3:
El API de Sockets en Java
3 de octubre de 2022

Presentación correspondiente al Capítulo 4 del libro:

M.L.Liu; Computación Distribuida, Fundamentos y Aplicaciones; Ed.
Pearson Addison Wesley; 2004.
 1. Introducción
• API (Application Programming Interface): es un
conjunto de clases que podemos usar para
realizar aplicaciones.

• Java proporciona el API de sockets Java como

parte de las clases básicas de Java.

• El API de sockets proporciona un bajo nivel de

abstracción.

2
2. La metáfora de sockets en IPC
• El nombre de socket (enchufe en castellano)
deriva de los tiempos en los que operadoras
telefónicas conectaban cables en un panel de
sockets.

Proceso A Proceso B

Socket en Socket en
puerto p1 puerto p2

un socket

3
 3. El API de sockets
El API de socket permite:
– Datagram Sockets (UDP), servicio no orientado a
conexión. Son los más sencillos, y son los que
emplearemos en la asignatura.

– Stream Sockets (TCP), servicio orientado a conexión.

Permiten el envío confiable de un flujo continuo de
datos entre emisor y receptor. No los emplearemos en la
asignatura.

4
Identificación: analogía en direcciones postales normales
Carta
nombre remite
dirección remite

nombre destino
dirección destino
carta -- datagrama UDP
sobre – cabecera del datagrama UDP
escrito dentro del sobre -- mensaje
Datagrama UDP
nombre remitente -- puerto origen
puerto origen, puerto destino, ….
nombre destinatario -- puerto destino
….,IP origen, IP destino, …
dirección remitente -- IP origen
datos (mensaje)
dirección destinatario -- IP destino

5
 Identificación: otra analogía
Reducimos nuestro mundo a los colegios mayores de Valladolid.
• Los colegiales representan a procesos.
• Los colegios mayores representan a ordenadores conectados a Internet con IP pública.
Hay colegiales que quieren poder enviar cartas a otros colegiales gestionándose el envío por el
colegio mayor, y colegiales que no desean ese servicio.
• Los colegiales que quieren enviar cartas son procesos que se comunican a través de
Internet.
• Los otros colegiales son procesos que no hacen uso de Internet.
Cuando un colegial que reside en el colegio decide que a partir de entonces desea comunicarse,
solicita un casillero al colegio mayor. El casillero tendrá un número.
• El colegial puede pedir un casillero que esté libre, y el servicio de comunicaciones del
colegio le asignará uno libre. Lo mismo les ocurre a los procesos, siendo el servicio de
comunicaciones del colegio el sistema operativo sobre el que se está ejecutando el proceso,
siendo el casillero el socket a través del cual se comunicará el proceso, y siendo el número
del casillero el número de puerto que ha reservado el proceso.
• También puede pedir un casillero concreto, pero si está ocupado, el servicio de
comunicaciones del colegio le indicará “ese casillero está ocupado”. Entonces el colegial
podrá pedir otro concreto, con la posibilidad de que se produzca el mismo suceso, u otro
libre. Lo mismo le ocurre a los procesos, siendo la equivalencia de cada uno de los
elementos, la indicada en el punto anterior.
Suponemos que los casilleros tienen dos zonas, la zona izquierda para recepciones, y la zona derecha
para envíos.
• El colegial pude pedir ir a ver si ha recibido algo en la zona de envíos muy frecuentemente,
o cada mucho tiempo, pero a costa de leer con retraso los mensajes. Lo mismo les ocurre
con los procesos, que no se percatan de si han recibido un mensaje hasta que no consultan
su socket.
• Un colegial que quiere enviar una carta, la deposita en su casillero en la zona de envíos,
indicando en el sobre el colegio y número de casillero del amigo con el que desea
comunicarse. El servicio de comunicaciones del colegio rellenará el remite, que será número
de casillero y colegio del colegial, y lo enviará. Lo mismo ocurre a los procesos, que sólo
deben indicar números de puerto e IP destinos, ya que el origen lo rellenará el sistema
operativo, el cual también enviará el datagrama IP.
 Identificación
Los sockets permiten comunicar un proceso de un ordenador (o
cualquier máquina) origen, con otro proceso de otra máquina
destino.
• Los ordenadores se identifican dentro de Internet mediante su dirección
IP, que será única dentro de la red Internet.
• Los procesos se identificarán dentro de todos los que se ejecutan
simultáneamente en cada ordenador mediante el protocolo de la capa de
transporte (UDP/TCP) y su número de puerto, que deberá ser único,
pues el sistema operativo no permite que dos procesos reserven para sí
el mismo puerto, siempre que utilicen el mismo protocolo.
PROCESO 1 PROCESO 2

Puerto Puerto
origen destino

ORDENADOR ORDENADOR 8
Dirección IP origen Dirección IP destino
Ejemplos de casos posibles de comunicación entre dos
aplicaciones:
157.88.130.34:1000 ----- 192.168.220.230:355
Situación que corresponde dos procesos que corren cada uno de ellos en un
ordenador. Situación típica. Ambos procesos podrán comunicarse mediante sockets.
157.88.130.34:1000 ----- 192.168.220.230:1000
Situación que corresponde a dos procesos que corren cada uno de ellos en un
ordenador. Se da la coincidencia de que ambos procesos reservaron del sistema
operativo el mismo puerto, pero cada uno en su ordenador. Situación no típica, pero
posible y válida. Ambos procesos podrán comunicarse mediante sockets.
157.88.130.34:1000 ----- 157.88.130.34:355
Situación que corresponde a procesos que se ejecutan en el mismo ordenador. Cada
uno de ellos reservó un puerto al sistema operativo, y el sistema operativo se le
concedió. Situación válida. Ambos procesos podrán comunicarse mediante sockets.
157.88.130.34:1000 ----- 157.88.130.34:1000
Situación que corresponde a un proceso que se comunica consigo mismo en el
mismo ordenador. Aunque es posible, se puede considerar que no tiene sentido
utilizar sockets para que un proceso se comunique consigo mismo.

9
 Datagramas UDP, o segmentos UDP

Los segmentos UDP o datagramas UDP a enviar tienen la

siguiente estructura:

A la hora de crear un datagrama, el programador debe aportar

el Puerto destino del ordenador al que se envía, que será el
puerto en el que el receptor esté escuchando, los Datos que se
desean enviar, y la Longitud de los datos. El resto de los
campos los rellena el API.
10
 Datagramas UDP, o segmentos UDP
En ocasiones, al segmento UDP (o datagrama UDP) se le
añade una pseudo-cabecera con más información. Esta
pseudo-cabecera se elimina al crear el datagrama IP. El
datagrama UDP tiene la estructura siguiente:

Pseudo-cabecera

En este caso, a la hora de crear el datagrama UDP, el

programador debe aportar la Dirección IP destino del
ordenador al que se envía, el Puerto destino del proceso que
escucha, la Longitud de los datos, y los Datos. El resto de los
campos los rellena el API.
11
 Clases
Dos clases que emplearemos en la comunicación
mediante sockets UDP:
DatagramSocket: Clase asociada
a la creación y manejo del socket.

DatagramPacket: Clase asociada

a la creación y manejo del
segmento UDP (datagama UDP)
que se transmitirá por el socket.

Estas clases se importan con el paquete «java.net»:

import java.net.*;
12
 Constructores representativos
de la clase DatagramSocket
Típicamente se emplearán dos constructores para
crear sockets UDP:

Normalmente se utilizará el constructor DatagramSocket(int

port) para crear un objeto socket en un puerto específico al que
nos enviarán datagramas otros procesos. En el caso de no estar
prevista la recepción de datagramas sino sólo el envío, se puede
utilizar el constructor anterior y también el constructor
DatagramSocket(), que crea el objeto socket en un puerto
cualquiera disponible que el sistema operativo le ofrezca al
proceso. 13
 Métodos representativos
de la clase DatagramSocket
Típicamente se emplearán dos métodos de esta clase:

Se utilizará el método send() para enviar un datagrama.

Se utilizará el método receive() para recibir un datagrama. Este
método tiene la particularidad de ser bloqueante

14
 Constructores representativos
de la clase DatagramPacket
Típicamente se emplearán dos constructores:

Normalmente se utilizará el constructor DatagramPacket(byte[]

buf, int length) para crear un objeto datagrama vacío en el que
sobrescribir los datos de datagramas entrantes, y se utilizará el
constructor DatagramPacket(byte[] buf, int length, InetAddress
address, int port) para crear un objeto datagrama que será enviado
a otro proceso y a otro equipo, concretamente al proceso que ha
creado un socket en el puerto port, y que está ejecutándose en un
ordenador con dirección IP address. 15
 Flujo de programa en Emisor y Receptor
Proceso emisor Proceso receptor
E1: Crea un objeto
DatagramSocket y lo enlaza a R1: Crea un objeto
cualquier puerto local (o a uno DatagramSocket y lo enlaza a un
específico). puerto local específico (al que
E2: Sitúa los datos a enviar en un enviará el proceso emisor).
array de bytes. R2: Crea un array de bytes vacío
E3: Crea un objeto para recibir los datos.
DatagramPacket especificando R3: Crea un DatagramPacket
el vector de datos, la longitud del especificando el vector de datos
mismo, el puerto y la dirección y su longitud.
IP del receptor. R4: invoca el método receive()
E4: invoca el método send() sobre el objeto DatagramSocket
sobre el objeto DatagramSocket creado.
creado.

R4 se tiene que realizar en el tiempo antes que E4, es decir, el

proceso receptor se tiene que poner a escuchar antes que el
proceso emisor empiece a emitir. 16
 Ejemplo. Envío “Clase de DAD” desde
192.168.120.220:2000 hasta 192.168.120.221:2001

RECEPTOR 1: Crea un objeto DatagramSocket, con el nombre socketReceptor, y lo

asocia al puerto local 2001, que será por el que escuche, y será al que le envíe el emisor.
DatagramSocket socketReceptor = new DatagramSocket(2001);
RECEPTOR 2: Crea un vector (array) vacío de octetos (datos del tipo byte) para
recibir los datos. En este caso se crea con un tamaño de 20 caracteres.
byte[] almacen= new byte[20];
RECEPTOR 3: Crea un objeto DatagramPacket especificando el vector de datos
creado. Este es una datagrama vacío sobre el que se escribirán los datos.
DatagramPacket paqueteEnReceptor=new DatagramPacket(almacen,almacen.length);
RECEPTOR 4: Invoca el método receive() sobre el socket creado para recibir los
datos.
socketReceptor.receive(paqueteEnReceptor);
El proceso se quedará en la línea de código anterior hasta que se reciban un datagrama
(línea de código bloqueante). Una vez que se han reciban los datos, se podrían sacar por
consola con la siguiente línea de código:
System.out.println(“El mensaje recibido es ” +new String(almacen);
El socket se cerraría mediante:
socketReceptor.close();
17
 Ejemplo. Envío “Clase de DAD” desde
192.168.120.220:2000 hasta 192.168.120.221:2001
EMISOR 1: Se crea un objeto DatagramSocket, con nombre socketEmisor, y será con
el que envíe (se ha creado en el puerto 2000 pero podría haberse solicitado al sistema
operativo uno cualquiera libre).
DatagramSocket socketEmisor = new DatagramSocket(2000);
EMISOR 2: Se sitúan los datos a enviar en un vector (array) de octetos (datos del tipo
byte).
String mensaje=“Clase de DAD”;
byte[] datos=mensaje.getBytes();
EMISOR 3: Crea un objeto DatagramPacket, con nombre paqueteAEnviar,
especificando el vector de datos, el tamaño del vector de datos, la dirección IP de la
máquina receptora, y el puerto en el que escucha el proceso receptor. En este ejemplo
sabemos que el receptor va a escuchar en el puerto 2001.
DatagramPacket paqueteAEnviar = new DatagramPacket(datos,
datos.length,InetAddress.getByName(“192.168.120.221”),2001);
EMISOR 4: Invoca el método send() sobre el socket creado para enviar los datos.
socketEmisor.send(paqueteAEnviar);
A continuación se puede cerrar el socket y liberar el puerto. El sistema operativo podrá
entonces asignar ese puerto a otro proceso.
socketEmisor.close();
18
 Nota sobre el ejemplo anterior

El empleo de la clase DatagramSocket y DatagramPacket requiere el manejo de

excepciones que puedan surgir durante la ejecución, como puede ser, por ejemplo, que se
intente crear un socket en un puerto en uso y que el Sistema Operativo no lo permita. Las
excepciones deben de capturarse con un estructura similar a la siguiente:

try{
Instrucción 1 que requiere manejo de excepciones
…
Instrucción N que requiere manejo de excepciones
}
catch{
ex.printStackTrace()
}

19
 Clase Receptor (código fuente)
import java.net.*;
public class Receptor {
public static void main(String[] args) {
try{
DatagramSocket socketReceptor = new
DatagramSocket(2001);
byte[] almacen = new byte[20];
DatagramPacket paqueteEnReceptor=new DatagramPacket
(almacen, almacen.length);
socketReceptor.receive(paqueteEnReceptor);
System.out.println("El mensaje recibido es "+
new String(almacen));
socketReceptor.close();
} // end try
catch (Exception ex){
ex.printStackTrace();
}//end catch
}//end main
}//end class
20
 Clase Emisor (código fuente)
import java.net.*;
public class Emisor {
public static void main(String[] args) {
try{
DatagramSocket socketEmisor = new
DatagramSocket(2000);
String mensaje="Clase de DAD";
byte[] datos=mensaje.getBytes();
DatagramPacket paqueteAEnviar=new DatagramPacket
(datos, datos.length,
InetAddress.getByName("192.168.120.220"), 2001);
socketEmisor.send(paqueteAEnviar);
socketEmisor.close();
} // end try
catch (Exception ex){
ex.printStackTrace();
}//end catch
}//end main
}//end class 21
 Métodos bloqueantes
El método receive() de la clase DatagramSocket es bloqueante, mientras que el método
send() de la misma clase es no bloqueante.

22