Download CAPITULO 5. SOCKETS

CAPITULO 5. SOCKETS
Una de las grandes potencias del lenguaje de programación Java es la total
portabilidad de sus programas gracias a su "máquina virtual". Esto adquiere una
importancia aún mayor en Internet donde existen tipos de computadoras muy
diferentes.
Las siguientes bibliotecas de la API de Java contienen una serie de clases que
son interesantes de cara a la creación de aplicaciones que trabajen en red. Las
más importantes son:
java.applet: Da soporte a las applets.
java.net: Clases para redes. Dan acceso a TCP/IP, sockets y URLs.
Existen otras bibliotecas más complejas, orientadas también a la programación
como son las siguientes:
java.sql: Paquete que contiene el JDBC, para conexión de programas Java
con Bases de datos.
java.rmi: Paquete RMI, para localizar objetos remotos, comunicarse con
ellos e incluso enviar objetos como parámetros de un objeto a otro.
org.omg.CORBA: Facilita la posibilidad de utilizar OMG CORBA, para la
conexión entre objetos distribuidos, aunque estén codificados en distintos
lenguajes.
org.omb.CosNaming : Da servicio al IDL de Java, similar al RMI pero en
CORBA.
Una de las características de Java que lo hacen especialmente interesante
para Internet es que sus programas objeto (códigos de byte) son verificables para
poder detectar posibles virus en sus contenidos. Estos programas Códigos de byte
no necesitan ser recompilados, y una vez verificados (pues Java trabaja con
nombres no con direcciones), se transforman en direcciones físicas de la máquina
destino.
M.E Carmen Cerón G
Programación Concurrente
109
Figura 1. : Ejecución de un código de byte
Esta forma de trabajar cuida la seguridad sin un grave perjuicio de la eficiencia. Un
programa en Java es sólo unas 20 veces más lento que uno programado en C,
cifra aceptable para la mayoría de las tareas, y suponiendo que no se utilice un
compilador JIT.
•
El paquete java.net
Java ofrece un conjunto de clases que permiten utilizar los URLs (Uniform
Resource Locators). Un URL es una dirección electrónica que permite
encontrar una información en Internet especificando:
El nombre del protocolo que permitirá leer la información. Por ejemplo HTTP.
El nombre del servidor que proporciona la información. Por ejemplo
sunsite.unc.edu o bien una dirección IP directamente.
El nombre del fichero en el servidor. Por ejemplo /Javafaq/Javafaq.htm.
5.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 primitivas se puede crear un sistema de diálogo muy completo.
M.E Carmen Cerón G
Programación Concurrente
110
Imagen 10: Funcionamiento de una conexión socket
Los sockets son puntos finales de enlaces de comunicaciones entre procesos. Los
procesos los tratan como descriptores de ficheros, de forma que se pueden
intercambiar datos con otros procesos transmitiendo y recibiendo a través de
sockets.
El tipo de sockets describe la forma en la que se transfiere información a través de
ese socket.
Sockets Stream (TCP, Transport Control Protocol)
Son un servicio orientado a conexión donde los datos se transfieren sin
encuadrarlos en registros o bloques. Si se rompe la conexión entre los procesos,
éstos serán informados.
El protocolo de comunicaciones con streams es un protocolo orientado a conexión,
ya que para establecer una comunicación utilizando el protocolo TCP, hay que
establecer en primer lugar una conexión entre un par de sockets. Mientras uno de
los sockets atiende peticiones de conexión (servidor), el otro solicita una conexión
M.E Carmen Cerón G
Programación Concurrente
111
(cliente). Una vez que los dos sockets estén conectados, se pueden utilizar para
transmitir datos en ambas direcciones.
Sockets Datagrama (UDP, User Datagram Protocol)
Son un servicio de transporte sin conexión. Son más eficientes que TCP, pero no
está garantizada la fiabilidad. Los datos se envían y reciben en paquetes, cuya
entrega no está garantizada. Los paquetes pueden ser duplicados, perdidos o
llegar en un orden diferente al que se envió.
El protocolo de comunicaciones con datagramas es un protocolo sin conexión, es
decir, cada vez que se envíen datagramas es necesario enviar el descriptor del
socket local y la dirección del socket que debe recibir el datagrama. Como se
puede ver, hay que enviar datos adicionales cada vez que se realice una
comunicación.
Sockets Raw
Son sockets que dan acceso directo a la capa de software de red subyacente o a
protocolos de más bajo nivel. Se utilizan sobre todo para la depuración del código
de los protocolos.
Diferencias entre Sockets Stream y Datagrama
Ahora se nos presenta un problema, ¿qué protocolo, o tipo de sockets, debemos
usar - UDP o TCP? La decisión depende de la aplicación cliente/servidor que
estemos escribiendo. Vamos a ver algunas diferencias entre los protocolos para
ayudar en la decisión.
En UDP, cada vez que se envía un datagrama, hay que enviar también el
descriptor del socket local y la dirección del socket que va a recibir el datagrama,
luego éstos son más grandes que los TCP. Como el protocolo TCP está orientado
a conexión, tenemos que establecer esta conexión entre los dos sockets antes de
nada, lo que implica un cierto tiempo empleado en el establecimiento de la
conexión, que no existe en UDP.
En UDP hay un límite de tamaño de los datagramas, establecido en 64 kilobytes,
que se pueden enviar a una localización determinada, mientras que TCP no tiene
límite; una vez que se ha establecido la conexión, el par de sockets funciona como
los streams: todos los datos se leen inmediatamente, en el mismo orden en que se
van recibiendo.
UDP es un protocolo desordenado, no garantiza que los datagramas que se hayan
enviado sean recibidos en el mismo orden por el socket de recepción. Al contrario,
TCP es un protocolo ordenado, garantiza que todos los paquetes que se envíen
serán recibidos en el socket destino en el mismo orden en que se han enviado.
M.E Carmen Cerón G
Programación Concurrente
112
Los datagramas son bloques de información del tipo lanzar y olvidar. Para la
mayoría de los programas que utilicen la red, el usar un flujo TCP en vez de un
datagrama UDP es más sencillo y hay menos posibilidades de tener problemas.
Sin embargo, cuando se requiere un rendimiento óptimo, y está justificado el
tiempo adicional que supone realizar la verificación de los datos, los datagramas
son un mecanismo realmente útil.
En resumen, TCP parece más indicado para la implementación de servicios de red
como un control remoto (rlogin, telnet) y transmisión de ficheros (ftp); que
necesitan transmitir datos de longitud indefinida. UDP es menos complejo y tiene
una menor sobrecarga sobre la conexión; esto hace que sea el indicado en la
implementación de aplicaciones cliente/servidor en sistemas distribuidos montados
sobre redes de área local.
B. 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.
a.) 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();
M.E Carmen Cerón G
Programación Concurrente
113
} 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.
b.) Programa Servidor
El programa servidor se instala en un puerto determinado, a la espera de
conexiones, a las que tratará mediante un segundo socket.
Cada vez que se presenta un cliente, le saluda con una frase "Hola cliente N".
Este servidor sólo atenderá hasta tres clientes, y después finalizará su ejecución,
pero es habitual utilizar bucles infinitos ( while(true) ) en los servidores, para que
atiendan llamadas continuamente.
Tras atender cuatro clientes, el servidor deja de ofrecer su servicio:
import java.io.* ;
import java.net.* ;
class Servidor {
static final int PUERTO=5000;
M.E Carmen Cerón G
Programación Concurrente
114
public Servidor( ) {
try {
ServerSocket skServidor = new ServerSocket( PUERTO );
System.out.println("Escucho el puerto " + PUERTO );
for ( int numCli = 0; numCli < 3; numCli++; ) {
Socket skCliente = skServidor.accept(); // Crea objeto
System.out.println("Sirvo al cliente " + numCli);
OutputStream aux = skCliente.getOutputStream();
DataOutputStream flujo= new DataOutputStream( aux );
flujo.writeUTF( "Hola cliente " + numCli );
skCliente.close();
}
System.out.println("Demasiados clientes por hoy");
} catch( Exception e ) {
System.out.println( e.getMessage() );
}
}
public static void main( String[] arg ) {
new Servidor();
}
}
Utiliza un objeto de la clase ServerSocket (skServidor), que sirve para esperar las
conexiones en un puerto determinado (PUERTO), y un objeto de la clase Socket
(skCliente) que sirve para gestionar una conexión con cada cliente.
M.E Carmen Cerón G
Programación Concurrente
115
Mediante un bucle for y la variable numCli se restringe el número de clientes a
tres, con lo que cada vez que en el puerto de este servidor aparezca un cliente, se
atiende y se incrementa el contador.
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().
c.) 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.
Para el caso de CrearCliente necesitamos un servidor como Apache instalado en
nuestra máquina que tenga la dirección localhost (127.0.0.1) o cualquier dirección
de Internet a la que tengamos acceso y que sirva páginas html.
Para el caso de CrearServidor necesitamos un navegador en el cual
visualizaremos lo que nos devuelve el servidor.
M.E Carmen Cerón G
Programación Concurrente
116
Método CrearCliente.En el método CrearCliente creamos un socket que va a conectar con una dirección
de Internet local (127.0.0.1) y con index.html a través del puerto 80. A el socket se
le especifican estos parámetros en el constructor.
Una vez realizada la conexión obtenemos un DataOutputStream del socket con
getOutputStream y escribimos nuestra petición que en nuestro caso es igual a la
que realiza el Internet Explorer. En esa corriente de salida escribimos nuestros
datos. Después obtenemos un DataInputStream con getInputStream y leemos lo
que nos llega que puede ser el texto de una página html. Por último cerramos la
conexión con close una vez que no hay más datos que leer.
Podemos ver que la creación de un Socket es sencilla y que leer y escribir de un
socket es como leer y escribir de un archivo.
Método CrearServidor.En este método vamos a crear un servidor sencillo que va atender los datos de un
navegador tal como Internet Explorer. Este servidor va a servir por la dirección
127.0.0.1 que es la de localhost, y por el puerto 80. Estas dos condiciones se
especifican al crear el ServerSocket (Ojo con la dirección especificada ya que
tiene que existir en la máquina).
Una vez creado el ServerSocket se crea un bucle infinito en el cual el método
accept espera hasta recibir una conexión. Este método al aceptar la conexión
devuelve un Socket que es con el que vamos a realizar la conexión al cliente. Al
igual que el método anterior obtenemos un DataInputStream con getInputStream
del cual vamos a leer los datos desde el cliente.
Los datos recibidos diferirán según el navegador utilizado pero serán parecidos a
los que se envían en el ejemplo de CrearCliente. Para conectar con el navegador
una
vez
ejecutado
el ejemplo
tenemos que
introducir
en
él
“http://127.0.0.1:80/hola.html” y recibiremos de vuelta el contenido del String
respuesta. Como el navegador encuentra en la página html la referencia a una
imagen gif, realizará una segunda petición pidiendo dicha imagen.
5.2 Ejemplos de Sockets
import java.net.*;
import java.io.*;
import java.util.*;
public class Comunicacion
{
public void CrearCliente()
{
Socket conexion=null;
DataInputStream entrada=null;
DataOutputStream salida=null;
String cad="";
byte datosBytes[]=new byte[256];
M.E Carmen Cerón G
Programación Concurrente
117
int leido=0;
String peticion="";
try
{
conexion=new Socket
(InetAddress.getByName ("http://localhost/index.html"), 80);
System.out.println("Conectando");
/*Enviamos lo que envía el navegador Internet Explorer al pedir una
página*/
peticion="GET /index.html HTTP/1.1\n";
peticion+="Accept: */*\n";
peticion+="Accept-Language: es\n";
peticion+="Accept-Encoding: gzip, deflate\n";
peticion+="User-Agent: Mozilla/4.0 (compatible; MSIE 5.01; Windows
NT)\n";
peticion+="Host: 127.0.0.1\n";
peticion+="Connection: Keep-Alive\n\n";
salida=new DataOutputStream(conexion.getOutputStream());
salida.write(peticion.getBytes());
//Vemos lo que nos envía el Servidor
entrada=new DataInputStream(conexion.getInputStream());
try
{
while ((leido=entrada.read(datosBytes,0,256))!=1)
if (leido>0)
System.out.println (new String(datosBytes,0,(leido-1)));
}
catch (EOFException e) {}
conexion.close();
}
catch (IOException e)
{
System.out.println(e.toString());
System.out.println("Error al conectar");
}
}
public void CrearServidor()
{
//Socket conexion;
ServerSocket sck;
BufferedReader datos;
InputStream Entradadatos;
String texto="";
int cliente=0;
int leido=0;
M.E Carmen Cerón G
Programación Concurrente
118
try
{
//Creamos un servidor
ServerSocket conexion=new
ServerSocket(80,2,InetAddress.getByName("127.0.0.1"));
DataInputStream entrada=null;
DataOutputStream salida=null;
String cad="",body="",respuesta="";
byte bytedata[]=new byte[256];
while (true)
{
++cliente;
Socket conex=conexion.accept();
entrada=new DataInputStream(conex.getInputStream());
System.out.println("Cliente num "+Integer.toString(cliente));
InetAddress direc=conex.getInetAddress();
System.out.println ("Dirección de llamada"+direc.getHostAddress());
cad="";
leido=entrada.read(bytedata);
if (leido>0)
cad=new String(bytedata,0,(leido-1));
//Sacamos lo que hemos recibido desde el cliente
System.out.println("Recibido desde cliente");
System.out.println(cad);
salida=new DataOutputStream(conex.getOutputStream());
body+="<html>\n";
body+="<body>\n";
body+="<h1>Hola que tal!</h1>\n";
body+="<image src='barra.gif'>\n";
body+="</body>\n";
body+="</html>\n";
if (cad.indexOf("barra.gif")>=0)
{
respuesta="HTTP/1.0 200 OK\n";
respuesta+="Date: Mon, 5 Nov 2001 23:59:59GMT\n";
respuesta+="Content-Type: image/gif\n";
respuesta+="Content-Length: 112\n\n";
//Hay que añadir la imagen
//Escribimos la respuesta al cliente
salida.write(respuesta.getBytes());
salida.flush();
try
{
FileInputStream imagen=new FileInputStream("barra.gif");
while((leido=imagen.read(bytedata,0,256))!=-1)
salida.write(bytedata,0,leido);
M.E Carmen Cerón G
Programación Concurrente
119
salida.flush();
}
catch (IOException e)
{
}
}
else if (cad.indexOf("hola.html")>=0)
{
respuesta="HTTP/1.0 200 OK\n";
respuesta+="Date: Mon, 5 Nov 2001 23:59:59 GMT\n";
respuesta+="Content-Type: text/html\n";
respuesta+="ContentLength:"+Integer.toString(body.length())+"\n\n";
respuesta+=body;
//Escribimos la respuesta al cliente
salida.writeBytes(respuesta);
salida.flush();
}
else
{
respuesta="HTTP/1.0 404 Error no encontrado\n";
respuesta+="Date: Mon, 5 Nov 2001 23:59:59 GMT\n";
respuesta+="Content-Type: text/html\n";
respuesta+="ContentLength:"+Integer.toString(
body.length())+"\n\n";
respuesta+="No se ha encontrado el documento";
//Escribimos la respuesta al cliente
salida.writeBytes(respuesta);
salida.flush();
}
//Cerramos el Socket
conex.close();
}
}
catch (IOException e)
{
System.out.println(e.toString());
System.out.println("Error al conectar");
}
}
public static void main(String[] args)
{
Comunicacion Comuc =new Comunicacion();
Comuc.CrearServidor();
//Comuc.CrearCliente();
//Comuc.pruebaURL();
M.E Carmen Cerón G
Programación Concurrente
120
}
}
Los ejemplos demuestran a pesar de su sencillez la potencia del Java y la
sencillez de sus clases. El ejemplo del servidor se puede perfeccionar para que
acepte varias conexiones simultáneas a través de varios procesos o para que
responda diferentes formas diferentes según la información pedida, etc.
A partir del ejemplo expuesto debe ser el lector el que desarrolle los ejemplos y
que vea cuales son los métodos de las clases y como se comportan en realidad.
También se recomienda ver la clase URL que permite la conexión a través de
diferentes protocolos (http, ftp, etc) especificando la dirección URL de un recurso.
What Is a Socket?
Normally, a server runs on a specific computer and has a socket that is bound to a
specific port number. The server just waits, listening to the socket for a client to
make a connection request.
On the client-side: The client knows the hostname of the machine on which the
server is running and the port number to which the server is connected. To make a
connection request, the client tries to rendezvous with the server on the server's
machine and port.
If everything goes well, the server accepts the connection. Upon acceptance, the
server gets a new socket bound to a different port. It needs a new socket (and
consequently a different port number) so that it can continue to listen to the original
socket for connection requests while tending to the needs of the connected client.
M.E Carmen Cerón G
Programación Concurrente
121
On the client side, if the connection is accepted, a socket is successfully created
and the client can use the socket to communicate with the server. Note that the
socket on the client side is not bound to the port number used to rendezvous with
the server. Rather, the client is assigned a port number local to the machine on
which the client is running.
The client and server can now communicate by writing to or reading from their
sockets.
Definition: A socket is one endpoint of a two-way communication link between two
programs running on the network. A socket is bound to a port number so that the
TCP layer can identify the application that data is destined to be sent.
The java.net package in the Java platform provides a class, Socket, that implements
one side of a two-way connection between your Java program and another
program on the network. The Socket class sits on top of a platform-dependent
implementation, hiding the details of any particular system from your Java
program. By using the java.net.Socket class instead of relying on native code, your
Java programs can communicate over the network in a platform-independent
fashion.
Additionally, java.net includes the ServerSocket class, which implements a socket that
servers can use to listen for and accept connections to clients. This lesson shows
you how to use the Socket and ServerSocket classes.
If you are trying to connect to the Web, the URL class and related classes
(URLConnection, URLEncoder) are probably more appropriate than the socket classes.
In fact, URLs are a relatively high-level connection to the Web and use sockets as
part of the underlying implementation. See Working with URLs for information
about connecting to the Web via URLs.
M.E Carmen Cerón G
Programación Concurrente
122
BIBLIOGRAFIA
1. J.E. Pérez Martínez "Programación Concurrente" 2ª Edición Ed Rueda
(1990).
2. J.T. Palma Méndez, M.C. Garrido, F. Sánchez Figeroa y A. Quesada
"Programación Concurrente" Ed. Thomson (2003).
3. "Programación Concurrente en Java TM" Ed. Addison-Wesley (2000).
URL´S:
http://ima.udg.es/Docencia/02-03/3105100333/index.html
http://www.tlm.unavarra.es/~daniel/docencia/labtel/guion.pdf
http://weblidi.info.unlp.edu.ar/catedras/concurrente/teorias.html
M.E Carmen Cerón G
Programación Concurrente
123