Programación de Sockets

Índice de contenidos
Introducción............................................................................................................................................................... 3
Introducción ..................................................................................................................................................... 3
Objetivos........................................................................................................................................................... 3
Funciones de uso ...................................................................................................................................................... 3
Manejo de Sockets .................................................................................................................................................... 4
Creación de Streams de entrada y salida .............................................................................................................. 5
Utilización de TCP y UDP ........................................................................................................................................ 14
Mínimo cliente SMTP .............................................................................................................................................. 18
Servidor de Eco........................................................................................................................................................ 28
Mínimo servidor y mínimo cliente TCP/IP............................................................................................................ 31
Servidor simple de http .......................................................................................................................................... 34
Resumen .................................................................................................................................................................. 42

Página 2 de 42
Introducción

Introducción

Introducción

En esta unidad conoceremos el concepto, los tipos y la funcionalidad de los sockets en el lenguaje Java. Con
dicho lenguaje generaremos programas de manejo de sockets TCP y UDP así como de cliente/servidor.

Objetivos

Objetivos

En esta unidad serás capaz de:

• Conocer el concepto de socket, los tipos que hay y sus funcionalidades.

• Generar programas en lenguaje Java de manejo de sockets TCP y UDP.

• Generar programas cliente/servidor en lenguaje Java.

Funciones de uso
Los sockets son un mecanismo IPC (Inter-Process Communication) para la comunicación entre procesos de
dos máquinas.
Un socket es un descriptor de un punto extremo de una comunicación bidireccional entre máquinas y se
compone del par <direccionIP, puerto>.Dicha comunicación consiste en el envío de datos a través del socket
correspondiente en cada proceso de cada máquina. Para los procesos que reciben mensajes, el socket
establece la dirección IP de la máquina en la que la aplicación está corriendo y el puerto (local) a través del
cual se comunica. Así, todos los mensajes enviados a esa dirección IP y a ese puerto llegarán al receptor.

Tenemos, por tanto, un proceso que denominamos cliente (envía un mensaje) y otro en otra máquina que
denominamos servidor (recibe el mensaje), ambos con un socket asociado para la comunicación.

El proceso cliente debe conocer la dirección IP y el puerto en el que está el proceso servidor con el que se va a
comunicar.

Los procesos cliente y servidor pueden utilizar el mismo conector (socket) tanto para enviar como para recibir
información, pero debe asociarse con un protocolo de la capa de transporte, que puede ser:

• TCP (Transmission Control Protocol).

• UDP (User Datagram Protocol).

Página 3 de 42
Manejo de Sockets
En una aplicación de tipo cliente-servidor en la que se establece una comunicación entre dos procesos en dos
máquinas, el servidor tiene un socket a la escucha en un número de puerto que identifica al proceso. Ahí se
mantiene en espera de las peticiones que pueda haber para establecer una conexión con un cliente desde otra
máquina. Este debe conocer el nombre o dirección IP de la máquina servidor y el número de puerto por el
que escucha las peticiones de conexión.
El cliente también debe identificarse ante el servidor, por lo que durante la conexión se utilizará un puerto local
asignado por el sistema.Si todo va bien, el servidor acepta la conexión y obtiene un nuevo socket sobre un
puerto diferente al de escucha, a través del cual se establece el intercambio de mensajes con el cliente. Esto
se debe a que el proceso servidor debe, por un lado, seguir atendiendo a posibles peticiones por parte de otros
procesos cliente y, por otro lado, atender las necesidades del cliente que se acaba de conectar.

Cuando se acepta la conexión, en el lado cliente se creará un socket con un número de puerto distinto al
que se usó para la petición de conexión, y será a través de este por donde mandará los mensajes al servidor.
De esta forma, los procesos cliente y servidor pueden comunicarse bidireccionalmente escribiendo y leyendo
por sus respectivos sockets. Estos sockets pueden ser:

Sockets Stream, para trabajar con protocolo TCP

Ofrecen un flujo de datos (streams) bidireccional y son orientados a conexión, es decir, debe establecerse
primeramente una conexión extremo a extremo antes del envío y recepción de mensajes.
Se proporciona la seguridad de que los paquetes se reciben correctamente y en el orden en que se
enviaron.Algunas aplicaciones que trabajan con sockets TCP son:

• HTTP. HyperText Transfer Protocol, para las páginas web.

• FTP. File Transfer Potocol, para la transferencia de ficheros entre máquinas.

• SMTP. Simple Mail Transfer Protocol, para los mensajes de correo electrónico.

• Telnet. Telecommunication Network, para acceder de forma remota a una máquina.

Sockets Datagrama, para trabajar con protocolo UDP

Ofrecen un flujo de datos bidireccional a través de datagramas, pero no son orientados a conexión, por lo
que no se establece una conexión entre los procesos que se comunican y, además, no se garantiza que lleguen
en orden, sin duplicados, etc.

La aplicación DNS (Domain Name System, para traducir direcciones IP a nombres de dominio) utiliza este tipo
de sockets.

El lenguaje Java ofrece la librería java.net que dispone de numerosas clases para el manejo de conexiones
entre máquinas, creación de servidores, envío y recepción de datos, etc.

Para el manejo de sockets stream (TCP) se disponen las clases:

• ServerSocket: para sockets de escucha del proceso servidor en un

Página 4 de 42
 puerto.
• Socket: para la conexión de un proceso cliente a un puerto.

Para el manejo de datagramas (UDP) se disponen las clases:

• DatagramSocket: para construir un socket que se use para

enviar/recibir datagramas.
• DatagramPacket: para crear un paquete datagrama para el
envío/recepción de información.

Creación de Streams de entrada y salida

La entrada/salida en el lenguaje Java está basada en el uso de streams. Los streams son flujos de secuencias de
bytes desde un origen a un destino a través de una vía de comunicación.Estos streams pueden ser de lectura
y/o de escritura, conectando diferentes tipos de fuentes y destinos de datos. Existe una abstracción para
que haya una serie de métodos que permitan leer y escribir sin importar la vía de comunicación y tan solo
adaptando los streams al tipo de los extremos (origen y destino).

Toda la API relacionada con la entrada/salida en Java se encuentra en la librería java.io. De ella se extienden
varias clases entre las que destacan:

InputStream, para streams de lectura

Extendiendo a esta clase se encuentran, entre otras, las subclases BufferedInputStream, FileInputStream y
DataInputStream. Permiten la lectura (entrada de datos) desde la entrada estándar, desde un fichero binario o
desde un origen de datos primitivos, respectivamente.

Todas ellas disponen de los métodos de lectura int read() y int read(byte[]) para leer un byte o una secuencia
de bytes.

OutputStream, para streams de escritura

Extendiendo a esta clase se encuentran, entre otras, las subclases BufferedOutputStream, FileOutputStream y
DataOutputStream. Permiten la escritura (salida de datos) hacia la salida estándar, hacia un fichero binario o
hacia un destino de datos primitivos, respectivamente.

Todas ellas disponen de los métodos de escritura write(int b) y write(byte[] b) para escribir un byte o una
secuencia de bytes. Existe el método flush() que fuerza a escribir el contenido del stream en el destino.

File, para manejo de ficheros de texto ASCII

Página 5 de 42
En este caso, para las operaciones de lectura y escritura se utilizan las clases que extienden de Reader y
Writer, tales como InputStreamReader y OutputStreamWriter, FileReader y FileWriter o BufferedStreamReader y
BufferedStreamWriter.

Los streams (ya sean de entrada o salida) han de cerrarse cuando no se vayan a usar, a través de la llamada al
método close().

Si se está tratando con ficheros binarios (Unicode) tendrán que usarse las clases FileInputStream o
FileOutputStream pasando como argumento el nombre del fichero del que se pretende leer o sobre el que
se quiera escribir.

En cuanto a la lectura y escritura de datos primitivos, ha de hacerse mediante las clases DataInputStream y
DataOutputStream en las que se tienen los siguientes métodos:

De lectura
readByte(), readInt(), readDouble()

De escritura
writeInt(), writeByte(), writeDouble()

Por último destacar que todas las aplicaciones en Java disponen de 3 canales de entrada/salida:

System.in
Para la entrada estándar que usa un objeto de tipo InputStream.

Sytem.out
Para la salida estándar que usa un objeto de tipo PrintStream.

System.err
Para la salida de error que usa un objeto de tipo PrintStream.

A continuación, tenemos un ejemplo de manejo de E/S en Java con los tipos de datos más comunes:

1
Creamos una nueva clase ManejoES.java con un método Main en el que leemos, desde la entrada estándar,
unos valores para los tipos de datos String, char, int, double y boolean. Para ello usamos un objeto de tipo
Scanner asociado System.in (entrada estándar, el teclado).

Página 6 de 42
2
Una vez introducidos, los mostramos por la salida estándar (System.out, la pantalla) a través del método println.

Página 7 de 42
3
A continuación, escribimos los valores introducidos en un fichero binario llamado datos.dat, que se
encontrará en la raíz del proyecto, asociando un objeto FileOutputStream a un DataOutputStream (escritura
de datos primitivos sobre un fichero binario). Para ello usamos los métodos writeXXX() para cada tipo de dato.
También se realiza la llamada a flush() y close() para forzar la escritura y luego cerrar el stream de salida.

Página 8 de 42
4
Es importante notar que deberemos añadir los import de las librerías necesarias para que el código pueda
funcionar.

Página 9 de 42
A continuación, la clase ManejoES continúa realizando una lectura de los tipos de datos desde el propio fichero
que acaba de escribir anteriormente, a través de varias llamadas a readXXX() y, finalmente, muestra esos
valores de nuevo por la salida estándar.

Para probar este ejemplo hacemos lo siguiente:

Ejecutamos el fichero ManejoES.java

Página 10 de 42
En la consola de Netbeans, que actúa como entrada/salida estándar
dentro del entorno de desarrollo, escribimos los valores que
deseamos para cada tipo de dato.

Página 11 de 42
El programa sigue su ejecución, escribiendo en el fichero binario
datos.dat y leyendo desde el mismo.

Página 12 de 42
Podemos observar cómo en la raíz del proyecto efectivamente se ha
creado el fichero datos.dat

Página 13 de 42
Utilización de TCP y UDP
Los protocolos TCP y UDP pertenecen a la capa de transporte de la familia de protocolos TCP/IP.

Cuando se programa en Java se hace en la capa de aplicación (por encima de la de transporte), por lo que se
utilizan las clases de la librería java.net para despreocuparse de esa cuestión.

• Como ya mencionamos, el protocolo TCP es orientado a conexión, por lo que se garantiza que la
información es realmente enviada desde un extremo a otro de la conexión y en el mismo orden de envío
(notificando error en caso contrario).

• El protocolo UDP no es basado en conexión, utiliza datagramas que son paquetes independientes entre
sí que comunican una aplicación con otra, pero en este caso el orden de entrega no es importante y
tampoco queda garantizada la recepción de los paquetes enviados.

Ambos protocolos utilizan la abstracción de sockets para proporcionar los puntos extremos de la
comunicación entre procesos o aplicaciones.

A continuación, se muestra un ejemplo de aplicación cliente/servidor en la que se hace uso de sockets UDP
(datagramas). En los apartados siguientes de esta unidad se trabajará con sockets orientados a conexión (TCP).

Para ello creamos un par de nuevas clases ClienteUDP.java y ServidorUDP.java

ClienteUDP.java
El cliente prepara un datagrama a partir de las clases DatagramPacket y DatagramSocket.

• Para la primera es necesario especificar como parámetros: la secuencia de bytes a enviar, su tamaño, la
dirección de destino (del servidor, a través de la clase InetAddress) y el puerto en el destino (en este caso
fijado al valor 12345).

• Para la segunda indicamos el número de puerto en la máquina local para el socket (en este caso 34567).

Página 14 de 42
A través del socket mandamos el flujo de bytes mediante la llamada al método send() para posteriormente
cerrar dicho socket y finalizar.

ServidorUDP.java
En el servidor se crea un socket de escucha en el puerto 12345 al que llegarán sockets desde los clientes con
un paquete datagrama. El servidor recibe estos paquetes mediante el método receive().

Lo siguiente es que el propio servidor muestra las propiedades de cada datagrama que recibe y concluye la
ejecución del programa, habiendo cerrado primeramente el socket con close().

En las siguientes pantallas ejecutamos este ejemplo.

Página 15 de 42
Para ejecutar este ejemplo compilamos ambos ficheros java con el comando javac ServidorUDP.java
ClienteUDP.java en una ventana de comandos y desde la ruta en la que se encuentren los archivos. Ello nos
crea los archivos .class correspondientes.

A continuación, ejecutamos primeramente el servidor UDP mediante

el comando java ServidorUDP.

Esto provoca que el servidor se ponga a la escucha de peticiones UDP

por el puerto indicado.

Página 16 de 42
Abrimos otra ventana de comandos y lanzamos el cliente mediante
el comando java ClienteUDP.

En la ventana del cliente se muestran los datos de la secuencia de

bytes que se van a enviar (el mensaje) y sus atributos y, al ser
recibido en el servidor, se mostrará el contenido del paquete del
socket recibido.

Página 17 de 42
Mínimo cliente SMTP
A continuación, se muestra un ejemplo de cliente SMTP (Simple Mail Transfer Protocol o Protocolo de
Transferencia Simple de Correos), en el que un proceso realiza una conexión al servidor SMTP local (que por
defecto se conecta al puerto 25), manda un mail y se desconecta.

En este ejemplo se utilizará el software Argo para instalar un servidor SMTP sobre la máquina local. Para
descargarlo desde la página oficial, busca argosoft smtp server.

1
Vamos a la web oficial de ArGoSoft.

2
Descargamos el instalador para la plataforma en la que estemos (32 o 64 bits) y procedemos a la instalación
del servidor SMTP en el equipo. Aceptamos el acuerdo de usuario, indicamos dónde se instalará el software e
instalamos.

Página 18 de 42
En la primera ejecución se debe configurar el servidor. En este caso, escucharemos sobre el dominio
localhost. Además, se creará un usuario por defecto, llamado postmaster, al que asignaremos una
contraseña.

Página 19 de 42
2

Página 20 de 42
Entramos en el submenú Settings - Options, donde tenemos que el puerto de escucha SMTP se establece por
defecto en el valor 25. Detallamos las opciones del programa en las siguientes pantallas. Tenemos que arrancar
el servidor SMTP para que comience a escuchar. Para ello simplemente pulsamos en el menú Start. Si todo ha
ido bien tendremos el servidor SMTP escuchando (Running) en el puerto 25.

Continuando con el ejemplo creamos una clase Java de nombre clienteSMTP. Para ello se hará uso de la librería
Apache Commons Net, la cual dispone la clase SMTPClient (que extiende SMTP) para el envío de ficheros
a través de un servidor SMTP. Tendremos que importar la librería org.apache.commons.net.smtp en nuestro
proyecto de NetBeans. La documentación completa sobre esta librería se puede encontrar AQUÍ.Si esta librería
no está instalada ya en el equipo, vamos a la página oficial de Apache buscando por ejemplo "download
org.apache.commons.net.smtp".
Una vez en la página oficial descargamos el paquete con la librería. La librería debe copiarse en la carpeta
adecuada del entorno de desarrollo NetBeans para poder ser usada en los proyectos.
Otra opción más sencilla es obtener el .jar de dicha librería ya compilada. Para esta alternativa puede buscarse
"download JAR org.apache.commons.net.smtp".Al descargar este paquete de librerías apache-commons-net.jar
lo podemos copiar al proyecto NetBeans en una nueva carpeta llamada \lib.

A continuación, importamos en nuestro proyecto el .jar.

1
La manera más directa es pulsar con el botón derecho sobre la raíz del proyecto en Netbeans e ir al submenú
"Customize" del menú "Set Configuration".

Página 21 de 42
2
Si pulsamos en el enlace del panel lateral izquierdo llamado "Libraries" nos muestra el conjunto de librerías
ya disponibles para este proyecto concreto. Seleccionamos "Add JAR/Folder" y buscamos la ubicación en la
carpeta \lib, donde está copiado el archivo apache-commons-net.jar.

Página 22 de 42
3
Una vez seleccionado el .jar correspondiente, la librería se importa automáticamente en el proyecto y ya se
dispone de la clase SMTPClient para nuestro ejemplo.

Página 23 de 42
Ahora los errores marcados en el entorno NetBeans desaparecen.

Página 24 de 42
Página 25 de 42
En el código anterior tenemos que el proceso clienteSMTP simplemente crea una instancia de la clase
SMTPClient y conecta al servidor SMTP de la máquina localhost, que por defecto se encuentra en el puerto 25.

Si ejecutamos el programa clienteSMTP con el servidor SMTP de ArgoSoft arrancado, obtenemos la siguiente
salida:

La clase SMTPReply almacena un conjunto de valores constantes para códigos de respuesta SMTP.

Podemos identificar la llamada al método connect de la clase SMTPClient para establecer la conexión y la
llamada al método disconnect.
Si se desean más detalles puede consultarse la documentación oficial de este estándar en la RFC2821, a través
de esta dirección.

A continuación, vamos a completar el ejemplo.

1
Sustituimos la línea System.out.println(“Realizar acciones”) por el siguiente conjunto de sentencias que servirán
para conformar un mail.

2
Arrancamos de nuevo el programa clienteSMTP.

3
Volvemos al programa del servidor SMTP de ArgoSoft y tenemos en el registro (Log) que se ha establecido una

Página 26 de 42
conexión en la máquina local (127.0.0.1) en el puerto 25, es decir, con el servidor SMTP, en el que hay un mail
desde yo@localhost que debe ser enviado a postmaster@localhost.

Página 27 de 42
Servidor de Eco
A continuación, se muestra un ejemplo de aplicación cliente/servidor de tipo eco, es decir, aquella en la que
un proceso servidor responde ante una petición de un proceso cliente con un mensaje igual al que recibe.

ServidorEco.java
El proceso servidor crea un socket de escucha en el puerto 4344 y cuando llega una petición de algún proceso
cliente, la acepta para reflejar por el stream de salida lo que le llega por el de entrada. Es decir, manda al
cliente la misma cadena que este le envía. El proceso para cuando se detecta que la cadena es recibida
corresponde con el carácter ‘@’. Entonces se cierra la conexión con distintas llamadas a close.

ClienteEco.java
El proceso cliente crea un socket para establecer una conexión con el proceso servidor, que se encuentra a
la escucha en el puerto 4344 en la propia máquina (localhost).

Cuando se acepta su petición de conexión, el usuario puede comenzar a escribir por la entrada estándar una
cadena de texto seguida de retorno de carro. Automáticamente el proceso servidor responde con la misma
cadena, a modo de eco.

El proceso termina cuando en el cliente se escribe la cadena ‘@’, momento en que se cierra el socket de
comunicación con llamadas a close.

Página 28 de 42
Para ejecutar el ejemplo anterior, se abre una ventana de comandos y se llega hasta la ruta donde se
encuentran los archivos servidorEco.java y clienteEco.java.

1
Se compilan ambas clases con el comando javac servidorEco.java clienteEco.java, de forma que se generan los
ficheros servidorEco.class y clienteEco.class.

2
A continuación, se arranca el proceso servidor mediante el comando java servidorEco. Esto hará que se
escuche por peticiones de conexiones en el puerto 4344.

Página 29 de 42
3
Una vez arrancado el proceso servidor se abre una nueva ventana de comandos para ejecutar el proceso
cliente. Para ello nos ubicamos en la ruta donde se encuentre el fichero clienteEco.class y ejecutamos el
comando java clienteEco.

4
En este momento ya podemos escribir cualquier cadena de caracteres desde la ventana del proceso cliente.
Esta cadena será enviada al proceso servidor, quien responderá de vuelta al cliente con la misma cadena de
caracteres. El proceso termina cuando desde el cliente se escribe el carácter ‘@’.

Página 30 de 42
Mínimo servidor y mínimo cliente TCP/IP
A continuación, se muestra un ejemplo de aplicación cliente/servidor con sockets stream (TCP, orientados a
conexión) en el que existe un proceso cliente que manda un par de números enteros a un proceso servidor
que se encarga de realizar la suma y devolver el resultado. Para ello será necesario crear dos ficheros con dos
nuevas clases: servidorTCP.java y clienteTCP.java.

ServidorTCP.java
En el proceso servidor se crea primero un objeto de la clase ServerSocket que escuchará por peticiones
continuamente en el puerto 3322.

Cuando llega una petición desde un proceso cliente a ese puerto, la acepta, crea un Socket de conexión con
el cliente y toma la información a través de un stream de entrada (InputStream) que, en este ejemplo, es un
array con dos números enteros cuya suma almacena en la variable entera respuesta.

Seguidamente, el proceso servidor crea un stream de salida (OutputStream) y vuelca la respuesta hacia el
proceso cliente. Por último, cierra el socket de conexión con el cliente.
Por cada petición atendida, el proceso servidor realiza las tareas anteriores. Si se produce alguna excepción, se
captura para su adecuado manejo.

ClienteTCP.java
Por su parte, el proceso cliente requiere indicar el nombre de la máquina en la que se encuentra el proceso
servidor.

Página 31 de 42
A continuación, crea un Socket para establecer una comunicación con el proceso servidor en la máquina
indicada y sobre el puerto que corresponda, en este caso, el 3322.

Cuando el proceso servidor acepta la petición de conexión, el proceso cliente prepara, por un lado, un stream
de salida (OutputStream) por el que volcará un objeto array con dos números enteros y un stream de entrada
(InputStream) mediante el cual recibirá la respuesta.

Obtenida la respuesta, la muestra por la salida estándar y cierra el socket de conexión.

Cada vez que se ejecute el proceso cliente, se llevarán a cabo todas las tareas anteriores.

Para probar el ejemplo, se abre una ventana de comandos y se localiza la ubicación de los ficheros
servidorTCP.java y clienteTCP.java

En este caso se han copiado en C:\Users\lbb\Desktop.

1
Una vez en la ruta donde se encuentran los ficheros, compilamos los archivos Java con el comando:
javac servidorTCP.java clienteTCP.java

De esta forma, se crean los archivos servidorTCP.class y clienteTCP.class.

Página 32 de 42
2
A continuación, arrancamos el proceso servidor con el comando java servidorTCP para que comience a
escuchar por el puerto 3322.

3
Después se arranca el proceso cliente en una nueva ventana de comandos, ejecutando java clienteTCP localhost
en la ruta donde se encuentra el fichero clienteTCP.class.

4
Se establece una conexión con el proceso servidor en la propia máquina (localhost), en el puerto 3322. El
proceso servidor recibe el par de números enteros, los suma y devuelve el resultado al proceso cliente, que
lo muestra por pantalla y finaliza.

Página 33 de 42
Servidor simple de http

A continuación, se muestra un ejemplo de aplicación cliente/servidor en la que el proceso servidor actúa

como servidor HTTP.

Para ello será necesario crear varias clases Java: ServidorHttp.java que atenderá las solicitudes por parte de los
clientes a través de distintos manejadores (Handlers).

Cada manejador se registra en una ruta concreta que localiza y dispone un servicio en la máquina servidora.
Las solicitudes de una ruta URL (Uniform Resource Locator o Localizador de Recursos Uniforme) se asignan
al manejador adecuado para cada caso. Otras solicitudes que ningún manejador pueda gestionar serán
rechazadas con una respuesta de tipo 404 (not found o no encontrado).

ServidorHttp
Esta clase hace uso de la librería com.sun.net.httpserver.HttpServer, de manera que se crea un objeto de la
clase HttpServer que constituirá el servidor HTTP y escuchará peticiones de clientes en el puerto 5500. Para
este servidor se establecen los manejadores para las rutas a través del método createContext.

Por último, se llama a la función start para arrancar el servidor.

RootHandler
Esta clase extiende de la clase HttpHandler y debe implementar el método Handle.

En este caso, simplemente envía un mensaje de que el servidor se activó correctamente.

Página 34 de 42
EchoRootHandler
Este manejador obtiene las cabeceras enviadas junto a las solicitudes de los clientes y las devuelve agrupadas
al cliente.

Se explican más en las siguientes pantallas.

Página 35 de 42
EchoGetHandler y EchoPostHandler

Ambos manejadores responden a las peticiones de los clientes, aglutinando en una respuesta los
parámetros que se pasan en la petición, ya se trate de una solicitud de tipo GET o de tipo POST.

2
EchoGetHandler y EchoPostHandler hacen uso de la función parseQuery, cuyo código se muestra a continuación
y que constituye un parseador para reunir todos y cada uno de los parámetros que se envían en las peticiones
GET y POST por parte de los clientes al servidor HTTP.

3
Para ejecutar el ejemplo, vamos a la ventana de comandos y compilamos todos los archivos .java mediante
el comando javac *.java

Página 36 de 42
4
A continuación, lanzamos el proceso servidorHttp desde esta ventana con el comando java ServidorHttp.
Esto hará que se escuchen peticiones por el puerto 5500.

5
Por otro lado, para probar el funcionamiento de RootHandler, abrimos un navegador y escribimos la dirección
http://localhost:5500/

El resultado es que el proceso servidor identifica que la ruta es “\” y, por tanto, se ejecuta el manejador
RootHandler, que muestra un mensaje de que el servidor HTTP está activado.

Página 37 de 42
Del mismo modo, para probar el manejador EchoHeaderHandler, abrimos la dirección http://localhost:5500/
echoHeader
El resultado es que se muestran los valores de las cabeceras de la solicitud del cliente.

Página 38 de 42
Para probar el funcionamiento del manejador EchoGetHandler, escribimos en la barra de direcciones algo como
http://localhost:550/echoGet?argumento1=hola&argumento2=adios

El resultado es que muestran al usuario los valores de las variables pasadas en la solicitud a través de método
GET.

Para probar el manejador EchoPostHandler es necesario pasar valores a la dirección http://localhost:5500/

echoPost/ a través del método POST de los formularios.

Se puede emular este mecanismo a través del programa Postman, el

cual se puede descargar de su página oficial.

Página 39 de 42
Una vez instalado el programa, cerramos la ventana de inicio que se
abrirá.

Página 40 de 42
En la pantalla del programa seleccionamos el método de envío POST y nos asegurarnos de que están activadas
las opciones Body y x-www-formed-urlencoded.

Página 41 de 42
Luego introducimos los valores para los parámetros par1=1 y par2=2. Serán los que emulemos pasándolos a
través de un formulario.

Al escribir en la barra de direcciones del programa Postman la dirección http://localhost:5500/echoPost/ y

pulsar Send aparecen los valores que se han emulado.

Resumen
En esta unidad se ha explicado el concepto de socket, así como sus tipos y características principales. Se han
generado programas en Java para manejar los de tipo TCP y UDP y se han creado, también con este lenguaje,
programas de tipo cliente/servidor.

Página 42 de 42