SlideShare ist ein Scribd-Unternehmen logo
1 von 12
Pr´actica 1
Intercomunicaci´on con sockets
Java
1.1 Enunciado
El objetivo de la primera pr´actica es por una parte, familiarizar al alumno con el uso
de las herramientas de construcci´on programas en Java, y por otra conseguir que el
alumno alcance a apreciar el coste de la realizaci´on de llamadas a un servidor en
diferentes modalidades.
1.1.1 Descripci´on
La pr´actica consistir´a en la implementaci´on y puesta a punto de un cliente simple,
que realizar´a un n´umero suficiente de llamadas a un servidor utilizando los m´etodos
descritos m´as adelante. Tras lo anterior, el objetivo es medir el tiempo consumido
por cada llamada. Se utilizar´an tres tipos de servidores:
1. Un objeto local.
En este caso, se est´a midiendo el coste de una llamada a subrutina local.
2. Un proceso esperando peticiones via UDP.
3. Un proceso esperando peticiones TCP.
Adicionalmente, para los tipos 2 y 3, se considerar´an dos formas de localizarlos:
3
4 PR ´ACTICA 1. INTERCOMUNICACI ´ON CON SOCKETS JAVA
1. El servidor y el cliente est´an en el mismo nodo.
2. El servidor est´a en un nodo distinto al del cliente.
1.1.2 El servidor
Los servidores de tipo 2, y 3, son implementados dentro de un programa que se
suministra con la pr´actica. Su lectura es aconsejable. Dicho programa podr´a ser
ejecutado con tres par´ametros:
servidor (t
 
u) puerto duraci´on
Los par´ametros tienen el siguiente significado:
1. El primero indica TCP/IP si su valor es t, o UDP/IP si su valor es u.
2. El segundo indica el puerto en que esperar´a la petici´on.
3. El tercero indica cu´anto tiempo se va a tardar en ejecutar la petici´on. La dura-
ci´on est´a expresada en milisegundos.
Para la primera pr´actica, el tercer par´ametro ser´a opcional, y su ausencia indicar´a un
valor igual a 0. Eso querr´a decir que el objeto servidor no retardar´a en absoluto la
contestaci´on al cliente.
En el caso 1, el servidor es un objeto. Dicho objeto deber´a ser implementado en el
propio programa cliente, y deber´a tambi´en tener un m´etodo llamado servicio-
local, que ser´a invocado por el cliente.
1.1.3 El cliente
El c´odigo de cliente deber´a ser escrito por el alumno. El esquema del c´odigo a desa-
rrollar por la funci´on principal aparece en la figura 1.1.
La forma exacta en que sea llamado el servidor dentro del bucle debe ser implantada
de la forma que se crea m´as conveniente, aunque se aconseja la creaci´on de una clase
intermedia que incorpore tres m´etodos. Uno de ellos para la invocaci´on local, otro
para la UDP y el tercero para la TCP.
NOTA: Ser´a necesario especificar por medio de par´ametros del programa cliente: los
valores de MAXLOOP, el puerto de contacto con el servidor, el nodo donde reside el
servidor, y el m´etodo de contacto (TCP/UDP/local).
1.2. COMENTARIOS 5
public class Cliente  
public static void main( String[] args )  
Tomar tiempo
for (i = 0; i < MAXLOOP; i++)  
Enviar mensaje al servidor
Esperar respuesta del servidor¡
Tomar tiempo
tiempo por llamada = Dif. de tiempo/MAXLOOP¡
¡
Figura 1.1: Algoritmo a seguir en el cliente.
1.1.4 Documentaci´on a presentar
Como documentaci´on a entregar deber´a elaborarse un peque˜no informe donde apa-
rezca el c´odigo del programa cliente, una tabla con los valores obtenidos para tres
valores razonables de MAXLOOP y una justificaci´on sobre qu´e factores influyen en
los resultados obtenidos y por qu´e se dan esas diferencias entre los casos estudiados.
Este informe debe presentarse en la sesi´on inicial de la segunda pr´actica.
1.2 Comentarios
En las siguientes secciones se aclaran algunos puntos necesarios para resolver el
enunciado presentado.
1.2.1 Obtenci´on de tiempos
Para poder obtener el tiempo actual en Java, se puede utilizar la siguiente operaci´on
de la clase System:
static long CurrentTimeMillis();
Esta operaci´on devuelve el tiempo actual en milisegundos, tomando como origen
el 1 de enero de 1970. Por ser una operaci´on est´atica, no es necesario instanciar
ning´un objeto de la clase System para poderla utilizar. Basta con a˜nadir como
6 PR ´ACTICA 1. INTERCOMUNICACI ´ON CON SOCKETS JAVA
prefijo el nombre de la clase a la que pertenece y utilizar el punto para separar ambos
componentes.
Otra cosa a tener en cuenta para obtener el tiempo invertido en un env´ıo y recepci´on
de mensaje est´a relacionada con c´omo expresar el resultado. En Java, si se dividen
dos n´umeros enteros, el resultado tambi´en ser´a un n´umero entero. Como los tiem-
pos a tomar van a ser del orden de unos pocos milisegundos, convendr´ıa dar tambi´en
algunos “decimales”. Para ello convendr´ıa convertir, antes de efectuar la divisi´on co-
rrespondiente, tanto el tiempo transcurrido como el n´umero de repeticiones a valores
reales.
Por ejemplo, si tenemos el tiempo total transcurrido en una variable tiempo de tipo
long y el n´umero de repeticiones efectuadas en otra variable del mismo tipo llamada
nveces, bastar´ıa con escribir lo siguiente:
double tiempo2;
tiempo2 = new Long( tiempo ).doubleValue() /
˜new Long( nveces ).doubleValue();
Donde la clase Long permite mantener un valor de tipo long pero proporciona
adem´as un conjunto de operaciones para realizar las conversiones desde o hacia otros
tipos. En nuestro caso, se emplea la operaci´on doubleValue() para convertir el
long a double. El valor a convertir se pasa como argumento en el constructor de
la clase.
1.2.2 Uso de sockets
Para obtener una descripci´on detallada de las interfaces relacionadas con sockets
en Java puede consultarse la documentaci´on que acompa˜na al JDK. En caso de no
tener acceso a ella, a continuaci´on aparecen algunas de las operaciones presentes
en estas clases (en concreto, aquellas que van a resultar necesarias para desarro-
llar la pr´actica). T´engase en cuenta que estas clases se encuentran en los paque-
tes java.net (para el caso de DatagramPacket, DatagramSocket, Inet-
Address y Socket) y java.io (para las clases InputStream y Output-
Stream). Por tanto, deber´a realizarse el import correspondiente para tener acceso
a ellas.
1.2. COMENTARIOS 7
Clase DatagramPacket
Esta clase modela un paquete a transmitir mediante sockets UDP. Las operaciones a
utilizar van a ser:
 
DatagramPacket( byte[] buf, int longitud )
Constructor utilizado para poder recibir paquetes de la longitud especificada
en el segundo argumento. El contenido del paquete se dejar´a en el vector de
octetos especificado en el primer argumento una vez se haya podido recibir la
informaci´on.
Se utilizar´a para recibir la contestaci´on del servidor.
 
DatagramPacket( byte[] buf, int longitud, InetAddress
direcci´on, int puerto )
Constructor utilizado para poder enviar paquetes con la longitud especificada
en el segundo argumento hacia el ordenador cuya direcci´on y puerto se han
dado en los dos siguientes.
Se utilizar´a para construir el mensaje a enviar al servidor.
Clase DatagramSocket
Esta clase modela un socket UDP. Las operaciones a utilizar son:
 
DatagramSocket()
Construye un socket UDP y lo asocia a alg´un puerto libre en la m´aquina local.
Aunque existen variantes para especificar un puerto y/o una m´aquina, no son
de inter´es para el cliente (ver el c´odigo del servidor, en la secci´on 1.3) ya que
aqu´ı ´unicamente habr´a que especificar la direcci´on destino en los paquetes a
enviar.
 
void receive( DatagramPacket p )
El hilo de ejecuci´on permanece bloqueado hasta que se ha recibido un paquete
a trav´es de este socket. La informaci´on recibida se encuentra en el vector
asociado al paquete pasado como ´unico argumento.
 
void send( DatagramPacket p )
Env´ıa un paquete a trav´es del socket. El paquete debe tener asociada la direc-
ci´on y el puerto del socket a quien va dirigido el env´ıo.
8 PR ´ACTICA 1. INTERCOMUNICACI ´ON CON SOCKETS JAVA
Clase InetAddress
Esta clase modela la direcci´on IP de una m´aquina. Se necesita para especificar la
ubicaci´on del servidor, bien sea en la m´aquina local o en una m´aquina remota. Las
operaciones a utilizar son:
 
static InetAddress getByName( String host )
Dado un nombre de m´aquina, devuelve un objeto InetAddress con su di-
recci´on.
 
static InetAddress getLocalHost()
Devuelve un objeto InetAddress con la direcci´on de la m´aquina local.
Clase Socket
Esta clase implementa un socket cliente con comunicaci´on TCP. Los sockets servido-
res para TCP est´an modelados por la clase ServerSocket, pero ´esta ya no resulta
necesaria para el caso del programa cliente. Obs´ervese, adem´as, que la comunica-
ci´on TCP est´a orientada a conexi´on y en el programa servidor esta conexi´on se crea
y se cierra para cada petici´on efectuada por el cliente. Por tanto, el cliente deber´a
estructurarse de igual manera.
Las operaciones a utilizar son:
 
Socket( String host, int puerto )
Crea un socket y lo conecta a la m´aquina remota cuyo nombre sea host, en el
puerto especificado como segundo argumento.
 
InputStream getInputStream()
Obtiene el InputStream a utilizar para obtener la informaci´on recibida en
el socket.
 
OutputStream getOutputStream()
Obtiene el OutputStream a utilizar para enviar informaci´on por el socket.
 
void close()
Cierra el socket, cortando la conexi´on con el servidor.
1.3. PROGRAMAS FACILITADOS 9
Clase InputStream
La ´unica operaci´on a utilizar en este caso es:
int read()
que devuelve el siguiente octeto presente en ese canal de entrada.
Aunque existen otras operaciones para obtener informaci´on desde el InputStream,
como el servidor ´unicamente escribe un octeto, en el cliente s´olo habr´a que leer ese
octeto.
Clase OutputStream
Al igual que en la clase anterior, ´unicamente hay que escribir un octeto en el socket,
por lo que la operaci´on a utilizar es:
void write( int octeto )
1.3 Programas facilitados
A continuaci´on se presenta el c´odigo del programa servidor que se mencionaba en el
enunciado.
/************************************************************************/
/* */
/* FICHERO: servidor.java */
/* */
/* DESCRIPCI´ON: Contiene la implementaci´on del servidor de la 1a pr´ac- */
/* tica. Ofrece un m´etodo por cada una de las peticiones que es */
/* capaz de atender (UDP y TCP). Existe una subclase "multi" que */
/* permite la atenci´on de m´ultiples peticiones mediante m´ultiples */
/* hilos de ejecuci´on (TCP). */
/* */
/************************************************************************/
import java.net.*; // El paquete java.net se necesita para //
// las clases Socket, ServerSocket, //
// DatagramSocket y DatagramPacket. //
import java.io.*; // El paquete java.io se necesita para //
// las clases InputStream y OutputStream//
/*======================================================================*/
/* servidor */
/* Clase que implementa un m´etodo por cada modalidad de llamada. */
/* */
/*======================================================================*/
10 PR ´ACTICA 1. INTERCOMUNICACI ´ON CON SOCKETS JAVA
public class servidor
 
// La subclase multi implementa el //
// c´odigo de los hilos de ejecuci´on que //
// se utilizan en la variante multi- //
// thread del servidor TCP. //
class multi implements Runnable
 
Socket so; // El socket "so" se utiliza para con- //
// testar una petici´on, despu´es se //
// cierra. //
long dur; // "dur" mantiene la duraci´on de la //
// espera asociada a cada petici´on. //
// En el constructor se pasa el socket //
// TCP a utilizar y la duraci´on de la //
// espera de la pr´oxima petici´on. //
public multi(Socket s, long duration)
 
so = s;
dur = duration;¡
// Este es el c´odigo que ejecuta cada //
// uno de los hilos servidores. //
public synchronized void run()
 
try
 
// Se obtiene un stream de entrada //
// desde el socket. //
InputStream is = so.getInputStream();
// Se hace lo mismo para el stream de //
// salida en el que se va a dejar la //
// respuesta. //
OutputStream os = so.getOutputStream();
int ch;
// El cliente s´olo env´ıa un car´acter. //
ch = is.read();
if ( dur > 0 )
wait(dur); // Esperamos el tiempo indicado. //
os.write(65); // La contestaci´on s´olo es un car´acter. //
so.close(); // Se cierra el socket, ya no se va a //
// volver a utilizar. //¡
catch (IOException e)
 
System.out.println("Algo fue mal");¡
catch (InterruptedException e)
 
System.out.println("Adi´os");¡
¡
¡
// M´etodo a utilizar con un cliente //
// UDP. //
public synchronized void serverudp(int port, long dur)
 
DatagramSocket ds; // Socket para UDP. //
// El contenido del paquete UDP va a //
// ser un vector de bytes con una sola //
1.3. PROGRAMAS FACILITADOS 11
// componente. //
byte[] buf = new byte[1];
// El paquete UDP se crea con el vector //
// anterior. //
DatagramPacket dp = new DatagramPacket(buf,1);
try
 
// Hay que crear un socket UDP asociado //
// al puerto especificado como primer //
// argumento. //
ds = new DatagramSocket(port);¡
catch (Exception e)
 
System.out.println("No se ha podido asociar el socket " +
"UDP al puerto " + port);
return;¡
while (true)
 
try
 
// Se recibe una petici´on por parte del //
// cliente. Una vez obtenida hay que //
// esperar el tiempo indicado para si- //
// mular la ejecuci´on de la petici´on. //
ds.receive(dp);
if ( dur > 0 )
wait(dur);
// Al final se contesta, reenviando el //
// mismo paquete recibido. //
ds.send(dp);¡
catch (IOException e)
 
System.out.println("No se ha podido recibir.");
return;¡
catch (InterruptedException e)
 
System.out.println("Adi´os");
return;¡
¡
¡
// M´etodo a utilizar con clientes TCP. //
public synchronized void servertcp(int port, long dur)
 
ServerSocket ss;
Socket so;
InputStream is;
OutputStream os;
try
 
// Se crea el socket servidor ss, aso- //
// ci´andolo al n´umero de puerto especi- //
// ficado como primer argumento. //
ss = new ServerSocket(port);¡
catch (Exception e)
 
System.out.println("No se puede asociar el puerto " + port +
" al socket TCP.");
return;
12 PR ´ACTICA 1. INTERCOMUNICACI ´ON CON SOCKETS JAVA
¡
while (true)
 
try
 
// Esperar conexi´on por parte del //
// cliente y generar un nuevo socket //
// para atenderla cuando se establezca. //
so = ss.accept();
// "is" va a permitir la lectura de //
// informaci´on existente en el socket. //
is = so.getInputStream();
// "os" se utiliza para escribir infor- //
// maci´on que podr´a obtener el cliente. //
os = so.getOutputStream();
int ch;
ch = is.read(); // Esperar hasta poder leer un byte. //
if ( dur > 0 )
wait(dur); // Simular la atenci´on de la petici´on. //
os.write(65); // Enviar la respuesta. //
so.close(); // Cerrar el socket utilizado para //
// esta conexi´on. //¡
catch (IOException e)
 
System.out.println("Algo fue mal");¡
catch (InterruptedException e)
 
System.out.println("Adi´os");¡
¡
¡
// Versi´on TCP con m´utiples hilos. //
public synchronized void servertcpmt(int port, long dur)
 
ServerSocket ss;
Socket so;
try
 
// Asociar un puerto al socket servidor //
// a utilizar para esperar las conexio- //
// nes de los clientes. //
ss = new ServerSocket(port);¡
catch (Exception e)
 
System.out.println("No se puede asociar el puerto " + port +
" al socket TCP.");
return;¡
while (true)
 
try
 
// Aceptar las conexiones de los clien- //
// tes, creando un nuevo socket por //
// cada una de ellas. //
so = ss.accept();
// Crear un thread "multi" que sirva //
1.3. PROGRAMAS FACILITADOS 13
// la petici´on que acaba de llegar. //
new Thread(new multi(so,dur)).start();¡
catch (IOException e)
 
System.out.println("Algo fue mal");¡
¡
¡
public static void main(String[] args)
 
int port = 8000;
boolean udp = false;
boolean MT = false;
long duration = 0;
servidor worker = new servidor();
// Extraccion de argumentos. //
if (args.length < 2)
 
System.out.println("N´umero de argumentos err´oneo");
return;¡
// Comprobar el primer argumento. Si es //
// "u", utilizar el servidor UDP. Si es //
// "t", utilizar el servidor TCP. En //
// cualquier otro caso, utilizar el //
// servidor multithread. //
if (args[0].equalsIgnoreCase("u"))
 
System.out.println("Servidor UDP");
udp = true;¡
else if (args[0].equalsIgnoreCase("t"))
 
System.out.println("Servidor TCP");
udp = false;¡
else
 
System.out.println("Servidor TCP MT");
MT = true;¡
try
 
// Obtener el n´umero de puerto a partir //
// del segundo argumento. //
port = (new Integer(args[1])).intValue();¡
catch (Exception e)
 
System.out.println(args[1] + "no es un n´umero v´alido de puerto");
return;¡
// Si existe un tercer argumento ser´a //
// la duraci´on a asignar al servicio de //
// cada petici´on. //
if (args.length == 3)
 
try
 
duration = (new Long(args[2])).longValue();
// La duraci´on no puede ser negativa. //
if (duration < 0)
duration = -duration;
14 PR ´ACTICA 1. INTERCOMUNICACI ´ON CON SOCKETS JAVA
¡
catch (Exception e)
 
System.out.println(args[2] + "no es un valor adecuado de" +
" duraci´on.");
return;¡
¡
else
 
duration = 0;¡
// L´ogica del programa. //
if (udp)
 
worker.serverudp(port,duration);¡
else if (MT)
 
worker.servertcpmt(port,duration);¡
else
 
worker.servertcp(port,duration);¡
¡
¡

Weitere ähnliche Inhalte

Was ist angesagt? (20)

Bd nosql tecnicas III
Bd nosql tecnicas IIIBd nosql tecnicas III
Bd nosql tecnicas III
 
Curso netcsharp
Curso netcsharpCurso netcsharp
Curso netcsharp
 
Java awt javax swing
Java awt  javax swingJava awt  javax swing
Java awt javax swing
 
Lenguaje c 2_neo
Lenguaje c 2_neoLenguaje c 2_neo
Lenguaje c 2_neo
 
Lenguaje c 2
Lenguaje c 2Lenguaje c 2
Lenguaje c 2
 
Bd no sql tecnicas
Bd no sql tecnicasBd no sql tecnicas
Bd no sql tecnicas
 
Dotnetmania 9 pag_21_29
Dotnetmania 9 pag_21_29Dotnetmania 9 pag_21_29
Dotnetmania 9 pag_21_29
 
Bd no sql tecnicas2
Bd no sql tecnicas2Bd no sql tecnicas2
Bd no sql tecnicas2
 
Visual Basic
Visual  BasicVisual  Basic
Visual Basic
 
Compiladores informe final
Compiladores informe finalCompiladores informe final
Compiladores informe final
 
LibreríAs De Java
LibreríAs De JavaLibreríAs De Java
LibreríAs De Java
 
Características de c sharp
Características de c sharpCaracterísticas de c sharp
Características de c sharp
 
Caracteristicas de C Sharp
Caracteristicas de C SharpCaracteristicas de C Sharp
Caracteristicas de C Sharp
 
Traduccion capitulo 9 (completo)
Traduccion capitulo 9 (completo)Traduccion capitulo 9 (completo)
Traduccion capitulo 9 (completo)
 
Comandos
ComandosComandos
Comandos
 
Tutorial C
Tutorial CTutorial C
Tutorial C
 
investigación de Comandos, Sentencias y/o Paquetes del Lenguaje de Programaci...
investigación de Comandos, Sentencias y/o Paquetes del Lenguaje de Programaci...investigación de Comandos, Sentencias y/o Paquetes del Lenguaje de Programaci...
investigación de Comandos, Sentencias y/o Paquetes del Lenguaje de Programaci...
 
TABLA DE COMANDO /SENTENCIAS/PAQUETES
TABLA DE COMANDO /SENTENCIAS/PAQUETESTABLA DE COMANDO /SENTENCIAS/PAQUETES
TABLA DE COMANDO /SENTENCIAS/PAQUETES
 
Kimberly (3)
Kimberly (3)Kimberly (3)
Kimberly (3)
 
Tipos de Datos Abstractos.
Tipos de Datos Abstractos.Tipos de Datos Abstractos.
Tipos de Datos Abstractos.
 

Ähnlich wie Practica1

Ähnlich wie Practica1 (20)

Taller Sockets TCP UDP Multicast
Taller Sockets TCP UDP MulticastTaller Sockets TCP UDP Multicast
Taller Sockets TCP UDP Multicast
 
Unidad 2
Unidad 2Unidad 2
Unidad 2
 
Practica cliente servidor java
Practica cliente servidor javaPractica cliente servidor java
Practica cliente servidor java
 
El servidor
El servidorEl servidor
El servidor
 
presenjava.ppt
presenjava.pptpresenjava.ppt
presenjava.ppt
 
Sistemas operativos distribuidos ii
Sistemas operativos distribuidos iiSistemas operativos distribuidos ii
Sistemas operativos distribuidos ii
 
Proyecto final teleprocesamiento
Proyecto final teleprocesamientoProyecto final teleprocesamiento
Proyecto final teleprocesamiento
 
Arquitectura multicapa
Arquitectura multicapaArquitectura multicapa
Arquitectura multicapa
 
Socket
SocketSocket
Socket
 
J sockets
J socketsJ sockets
J sockets
 
Multiplicacion de matrices: Implementacion en cluster
Multiplicacion de matrices: Implementacion en clusterMultiplicacion de matrices: Implementacion en cluster
Multiplicacion de matrices: Implementacion en cluster
 
Conexion dinamica
Conexion dinamicaConexion dinamica
Conexion dinamica
 
Sockets tcp
Sockets tcpSockets tcp
Sockets tcp
 
Curso: Minicomputadoras: 06 Estructura de una minicomputadora
Curso: Minicomputadoras: 06 Estructura de una minicomputadoraCurso: Minicomputadoras: 06 Estructura de una minicomputadora
Curso: Minicomputadoras: 06 Estructura de una minicomputadora
 
Cliente servidor
Cliente servidorCliente servidor
Cliente servidor
 
Mini proyecto
Mini proyectoMini proyecto
Mini proyecto
 
Remote Procedure Call (RPC)
Remote Procedure Call (RPC)Remote Procedure Call (RPC)
Remote Procedure Call (RPC)
 
C documents and settings_pc10_configuración local_datos de programa_mozilla_...
C  documents and settings_pc10_configuración local_datos de programa_mozilla_...C  documents and settings_pc10_configuración local_datos de programa_mozilla_...
C documents and settings_pc10_configuración local_datos de programa_mozilla_...
 
RPC - LLAMADAS REMOTAS
RPC - LLAMADAS REMOTASRPC - LLAMADAS REMOTAS
RPC - LLAMADAS REMOTAS
 
Networking
NetworkingNetworking
Networking
 

Mehr von Jesus Alberto Iribe Gonzalez (20)

3 interfaces clases_abstractas_herencia_polimorfismo
3 interfaces clases_abstractas_herencia_polimorfismo3 interfaces clases_abstractas_herencia_polimorfismo
3 interfaces clases_abstractas_herencia_polimorfismo
 
1 introduccion a_java_2da_parte
1 introduccion a_java_2da_parte1 introduccion a_java_2da_parte
1 introduccion a_java_2da_parte
 
1 introduccion a_java_1er_parte
1 introduccion a_java_1er_parte1 introduccion a_java_1er_parte
1 introduccion a_java_1er_parte
 
2 programación orientada_a_objetos
2 programación orientada_a_objetos2 programación orientada_a_objetos
2 programación orientada_a_objetos
 
Metodologia de investigacion itl
Metodologia de investigacion itlMetodologia de investigacion itl
Metodologia de investigacion itl
 
U3 interfaces, clases abstractas, heencia y polimorfismo
U3 interfaces, clases abstractas, heencia y polimorfismoU3 interfaces, clases abstractas, heencia y polimorfismo
U3 interfaces, clases abstractas, heencia y polimorfismo
 
Matematicas discretas1
Matematicas discretas1Matematicas discretas1
Matematicas discretas1
 
Infore de proyecto v1
Infore de proyecto v1Infore de proyecto v1
Infore de proyecto v1
 
Conjuntos
ConjuntosConjuntos
Conjuntos
 
Trayectorias
TrayectoriasTrayectorias
Trayectorias
 
Id sw13
Id sw13Id sw13
Id sw13
 
Id sw12
Id sw12Id sw12
Id sw12
 
Id sw11
Id sw11Id sw11
Id sw11
 
Id sw10
Id sw10Id sw10
Id sw10
 
Id sw09
Id sw09Id sw09
Id sw09
 
Id sw08
Id sw08Id sw08
Id sw08
 
Id sw07
Id sw07Id sw07
Id sw07
 
Id sw06
Id sw06Id sw06
Id sw06
 
Id sw05
Id sw05Id sw05
Id sw05
 
Id sw04
Id sw04Id sw04
Id sw04
 

Practica1

  • 1. Pr´actica 1 Intercomunicaci´on con sockets Java 1.1 Enunciado El objetivo de la primera pr´actica es por una parte, familiarizar al alumno con el uso de las herramientas de construcci´on programas en Java, y por otra conseguir que el alumno alcance a apreciar el coste de la realizaci´on de llamadas a un servidor en diferentes modalidades. 1.1.1 Descripci´on La pr´actica consistir´a en la implementaci´on y puesta a punto de un cliente simple, que realizar´a un n´umero suficiente de llamadas a un servidor utilizando los m´etodos descritos m´as adelante. Tras lo anterior, el objetivo es medir el tiempo consumido por cada llamada. Se utilizar´an tres tipos de servidores: 1. Un objeto local. En este caso, se est´a midiendo el coste de una llamada a subrutina local. 2. Un proceso esperando peticiones via UDP. 3. Un proceso esperando peticiones TCP. Adicionalmente, para los tipos 2 y 3, se considerar´an dos formas de localizarlos: 3
  • 2. 4 PR ´ACTICA 1. INTERCOMUNICACI ´ON CON SOCKETS JAVA 1. El servidor y el cliente est´an en el mismo nodo. 2. El servidor est´a en un nodo distinto al del cliente. 1.1.2 El servidor Los servidores de tipo 2, y 3, son implementados dentro de un programa que se suministra con la pr´actica. Su lectura es aconsejable. Dicho programa podr´a ser ejecutado con tres par´ametros: servidor (t   u) puerto duraci´on Los par´ametros tienen el siguiente significado: 1. El primero indica TCP/IP si su valor es t, o UDP/IP si su valor es u. 2. El segundo indica el puerto en que esperar´a la petici´on. 3. El tercero indica cu´anto tiempo se va a tardar en ejecutar la petici´on. La dura- ci´on est´a expresada en milisegundos. Para la primera pr´actica, el tercer par´ametro ser´a opcional, y su ausencia indicar´a un valor igual a 0. Eso querr´a decir que el objeto servidor no retardar´a en absoluto la contestaci´on al cliente. En el caso 1, el servidor es un objeto. Dicho objeto deber´a ser implementado en el propio programa cliente, y deber´a tambi´en tener un m´etodo llamado servicio- local, que ser´a invocado por el cliente. 1.1.3 El cliente El c´odigo de cliente deber´a ser escrito por el alumno. El esquema del c´odigo a desa- rrollar por la funci´on principal aparece en la figura 1.1. La forma exacta en que sea llamado el servidor dentro del bucle debe ser implantada de la forma que se crea m´as conveniente, aunque se aconseja la creaci´on de una clase intermedia que incorpore tres m´etodos. Uno de ellos para la invocaci´on local, otro para la UDP y el tercero para la TCP. NOTA: Ser´a necesario especificar por medio de par´ametros del programa cliente: los valores de MAXLOOP, el puerto de contacto con el servidor, el nodo donde reside el servidor, y el m´etodo de contacto (TCP/UDP/local).
  • 3. 1.2. COMENTARIOS 5 public class Cliente   public static void main( String[] args )   Tomar tiempo for (i = 0; i < MAXLOOP; i++)   Enviar mensaje al servidor Esperar respuesta del servidor¡ Tomar tiempo tiempo por llamada = Dif. de tiempo/MAXLOOP¡ ¡ Figura 1.1: Algoritmo a seguir en el cliente. 1.1.4 Documentaci´on a presentar Como documentaci´on a entregar deber´a elaborarse un peque˜no informe donde apa- rezca el c´odigo del programa cliente, una tabla con los valores obtenidos para tres valores razonables de MAXLOOP y una justificaci´on sobre qu´e factores influyen en los resultados obtenidos y por qu´e se dan esas diferencias entre los casos estudiados. Este informe debe presentarse en la sesi´on inicial de la segunda pr´actica. 1.2 Comentarios En las siguientes secciones se aclaran algunos puntos necesarios para resolver el enunciado presentado. 1.2.1 Obtenci´on de tiempos Para poder obtener el tiempo actual en Java, se puede utilizar la siguiente operaci´on de la clase System: static long CurrentTimeMillis(); Esta operaci´on devuelve el tiempo actual en milisegundos, tomando como origen el 1 de enero de 1970. Por ser una operaci´on est´atica, no es necesario instanciar ning´un objeto de la clase System para poderla utilizar. Basta con a˜nadir como
  • 4. 6 PR ´ACTICA 1. INTERCOMUNICACI ´ON CON SOCKETS JAVA prefijo el nombre de la clase a la que pertenece y utilizar el punto para separar ambos componentes. Otra cosa a tener en cuenta para obtener el tiempo invertido en un env´ıo y recepci´on de mensaje est´a relacionada con c´omo expresar el resultado. En Java, si se dividen dos n´umeros enteros, el resultado tambi´en ser´a un n´umero entero. Como los tiem- pos a tomar van a ser del orden de unos pocos milisegundos, convendr´ıa dar tambi´en algunos “decimales”. Para ello convendr´ıa convertir, antes de efectuar la divisi´on co- rrespondiente, tanto el tiempo transcurrido como el n´umero de repeticiones a valores reales. Por ejemplo, si tenemos el tiempo total transcurrido en una variable tiempo de tipo long y el n´umero de repeticiones efectuadas en otra variable del mismo tipo llamada nveces, bastar´ıa con escribir lo siguiente: double tiempo2; tiempo2 = new Long( tiempo ).doubleValue() / ˜new Long( nveces ).doubleValue(); Donde la clase Long permite mantener un valor de tipo long pero proporciona adem´as un conjunto de operaciones para realizar las conversiones desde o hacia otros tipos. En nuestro caso, se emplea la operaci´on doubleValue() para convertir el long a double. El valor a convertir se pasa como argumento en el constructor de la clase. 1.2.2 Uso de sockets Para obtener una descripci´on detallada de las interfaces relacionadas con sockets en Java puede consultarse la documentaci´on que acompa˜na al JDK. En caso de no tener acceso a ella, a continuaci´on aparecen algunas de las operaciones presentes en estas clases (en concreto, aquellas que van a resultar necesarias para desarro- llar la pr´actica). T´engase en cuenta que estas clases se encuentran en los paque- tes java.net (para el caso de DatagramPacket, DatagramSocket, Inet- Address y Socket) y java.io (para las clases InputStream y Output- Stream). Por tanto, deber´a realizarse el import correspondiente para tener acceso a ellas.
  • 5. 1.2. COMENTARIOS 7 Clase DatagramPacket Esta clase modela un paquete a transmitir mediante sockets UDP. Las operaciones a utilizar van a ser:   DatagramPacket( byte[] buf, int longitud ) Constructor utilizado para poder recibir paquetes de la longitud especificada en el segundo argumento. El contenido del paquete se dejar´a en el vector de octetos especificado en el primer argumento una vez se haya podido recibir la informaci´on. Se utilizar´a para recibir la contestaci´on del servidor.   DatagramPacket( byte[] buf, int longitud, InetAddress direcci´on, int puerto ) Constructor utilizado para poder enviar paquetes con la longitud especificada en el segundo argumento hacia el ordenador cuya direcci´on y puerto se han dado en los dos siguientes. Se utilizar´a para construir el mensaje a enviar al servidor. Clase DatagramSocket Esta clase modela un socket UDP. Las operaciones a utilizar son:   DatagramSocket() Construye un socket UDP y lo asocia a alg´un puerto libre en la m´aquina local. Aunque existen variantes para especificar un puerto y/o una m´aquina, no son de inter´es para el cliente (ver el c´odigo del servidor, en la secci´on 1.3) ya que aqu´ı ´unicamente habr´a que especificar la direcci´on destino en los paquetes a enviar.   void receive( DatagramPacket p ) El hilo de ejecuci´on permanece bloqueado hasta que se ha recibido un paquete a trav´es de este socket. La informaci´on recibida se encuentra en el vector asociado al paquete pasado como ´unico argumento.   void send( DatagramPacket p ) Env´ıa un paquete a trav´es del socket. El paquete debe tener asociada la direc- ci´on y el puerto del socket a quien va dirigido el env´ıo.
  • 6. 8 PR ´ACTICA 1. INTERCOMUNICACI ´ON CON SOCKETS JAVA Clase InetAddress Esta clase modela la direcci´on IP de una m´aquina. Se necesita para especificar la ubicaci´on del servidor, bien sea en la m´aquina local o en una m´aquina remota. Las operaciones a utilizar son:   static InetAddress getByName( String host ) Dado un nombre de m´aquina, devuelve un objeto InetAddress con su di- recci´on.   static InetAddress getLocalHost() Devuelve un objeto InetAddress con la direcci´on de la m´aquina local. Clase Socket Esta clase implementa un socket cliente con comunicaci´on TCP. Los sockets servido- res para TCP est´an modelados por la clase ServerSocket, pero ´esta ya no resulta necesaria para el caso del programa cliente. Obs´ervese, adem´as, que la comunica- ci´on TCP est´a orientada a conexi´on y en el programa servidor esta conexi´on se crea y se cierra para cada petici´on efectuada por el cliente. Por tanto, el cliente deber´a estructurarse de igual manera. Las operaciones a utilizar son:   Socket( String host, int puerto ) Crea un socket y lo conecta a la m´aquina remota cuyo nombre sea host, en el puerto especificado como segundo argumento.   InputStream getInputStream() Obtiene el InputStream a utilizar para obtener la informaci´on recibida en el socket.   OutputStream getOutputStream() Obtiene el OutputStream a utilizar para enviar informaci´on por el socket.   void close() Cierra el socket, cortando la conexi´on con el servidor.
  • 7. 1.3. PROGRAMAS FACILITADOS 9 Clase InputStream La ´unica operaci´on a utilizar en este caso es: int read() que devuelve el siguiente octeto presente en ese canal de entrada. Aunque existen otras operaciones para obtener informaci´on desde el InputStream, como el servidor ´unicamente escribe un octeto, en el cliente s´olo habr´a que leer ese octeto. Clase OutputStream Al igual que en la clase anterior, ´unicamente hay que escribir un octeto en el socket, por lo que la operaci´on a utilizar es: void write( int octeto ) 1.3 Programas facilitados A continuaci´on se presenta el c´odigo del programa servidor que se mencionaba en el enunciado. /************************************************************************/ /* */ /* FICHERO: servidor.java */ /* */ /* DESCRIPCI´ON: Contiene la implementaci´on del servidor de la 1a pr´ac- */ /* tica. Ofrece un m´etodo por cada una de las peticiones que es */ /* capaz de atender (UDP y TCP). Existe una subclase "multi" que */ /* permite la atenci´on de m´ultiples peticiones mediante m´ultiples */ /* hilos de ejecuci´on (TCP). */ /* */ /************************************************************************/ import java.net.*; // El paquete java.net se necesita para // // las clases Socket, ServerSocket, // // DatagramSocket y DatagramPacket. // import java.io.*; // El paquete java.io se necesita para // // las clases InputStream y OutputStream// /*======================================================================*/ /* servidor */ /* Clase que implementa un m´etodo por cada modalidad de llamada. */ /* */ /*======================================================================*/
  • 8. 10 PR ´ACTICA 1. INTERCOMUNICACI ´ON CON SOCKETS JAVA public class servidor   // La subclase multi implementa el // // c´odigo de los hilos de ejecuci´on que // // se utilizan en la variante multi- // // thread del servidor TCP. // class multi implements Runnable   Socket so; // El socket "so" se utiliza para con- // // testar una petici´on, despu´es se // // cierra. // long dur; // "dur" mantiene la duraci´on de la // // espera asociada a cada petici´on. // // En el constructor se pasa el socket // // TCP a utilizar y la duraci´on de la // // espera de la pr´oxima petici´on. // public multi(Socket s, long duration)   so = s; dur = duration;¡ // Este es el c´odigo que ejecuta cada // // uno de los hilos servidores. // public synchronized void run()   try   // Se obtiene un stream de entrada // // desde el socket. // InputStream is = so.getInputStream(); // Se hace lo mismo para el stream de // // salida en el que se va a dejar la // // respuesta. // OutputStream os = so.getOutputStream(); int ch; // El cliente s´olo env´ıa un car´acter. // ch = is.read(); if ( dur > 0 ) wait(dur); // Esperamos el tiempo indicado. // os.write(65); // La contestaci´on s´olo es un car´acter. // so.close(); // Se cierra el socket, ya no se va a // // volver a utilizar. //¡ catch (IOException e)   System.out.println("Algo fue mal");¡ catch (InterruptedException e)   System.out.println("Adi´os");¡ ¡ ¡ // M´etodo a utilizar con un cliente // // UDP. // public synchronized void serverudp(int port, long dur)   DatagramSocket ds; // Socket para UDP. // // El contenido del paquete UDP va a // // ser un vector de bytes con una sola //
  • 9. 1.3. PROGRAMAS FACILITADOS 11 // componente. // byte[] buf = new byte[1]; // El paquete UDP se crea con el vector // // anterior. // DatagramPacket dp = new DatagramPacket(buf,1); try   // Hay que crear un socket UDP asociado // // al puerto especificado como primer // // argumento. // ds = new DatagramSocket(port);¡ catch (Exception e)   System.out.println("No se ha podido asociar el socket " + "UDP al puerto " + port); return;¡ while (true)   try   // Se recibe una petici´on por parte del // // cliente. Una vez obtenida hay que // // esperar el tiempo indicado para si- // // mular la ejecuci´on de la petici´on. // ds.receive(dp); if ( dur > 0 ) wait(dur); // Al final se contesta, reenviando el // // mismo paquete recibido. // ds.send(dp);¡ catch (IOException e)   System.out.println("No se ha podido recibir."); return;¡ catch (InterruptedException e)   System.out.println("Adi´os"); return;¡ ¡ ¡ // M´etodo a utilizar con clientes TCP. // public synchronized void servertcp(int port, long dur)   ServerSocket ss; Socket so; InputStream is; OutputStream os; try   // Se crea el socket servidor ss, aso- // // ci´andolo al n´umero de puerto especi- // // ficado como primer argumento. // ss = new ServerSocket(port);¡ catch (Exception e)   System.out.println("No se puede asociar el puerto " + port + " al socket TCP."); return;
  • 10. 12 PR ´ACTICA 1. INTERCOMUNICACI ´ON CON SOCKETS JAVA ¡ while (true)   try   // Esperar conexi´on por parte del // // cliente y generar un nuevo socket // // para atenderla cuando se establezca. // so = ss.accept(); // "is" va a permitir la lectura de // // informaci´on existente en el socket. // is = so.getInputStream(); // "os" se utiliza para escribir infor- // // maci´on que podr´a obtener el cliente. // os = so.getOutputStream(); int ch; ch = is.read(); // Esperar hasta poder leer un byte. // if ( dur > 0 ) wait(dur); // Simular la atenci´on de la petici´on. // os.write(65); // Enviar la respuesta. // so.close(); // Cerrar el socket utilizado para // // esta conexi´on. //¡ catch (IOException e)   System.out.println("Algo fue mal");¡ catch (InterruptedException e)   System.out.println("Adi´os");¡ ¡ ¡ // Versi´on TCP con m´utiples hilos. // public synchronized void servertcpmt(int port, long dur)   ServerSocket ss; Socket so; try   // Asociar un puerto al socket servidor // // a utilizar para esperar las conexio- // // nes de los clientes. // ss = new ServerSocket(port);¡ catch (Exception e)   System.out.println("No se puede asociar el puerto " + port + " al socket TCP."); return;¡ while (true)   try   // Aceptar las conexiones de los clien- // // tes, creando un nuevo socket por // // cada una de ellas. // so = ss.accept(); // Crear un thread "multi" que sirva //
  • 11. 1.3. PROGRAMAS FACILITADOS 13 // la petici´on que acaba de llegar. // new Thread(new multi(so,dur)).start();¡ catch (IOException e)   System.out.println("Algo fue mal");¡ ¡ ¡ public static void main(String[] args)   int port = 8000; boolean udp = false; boolean MT = false; long duration = 0; servidor worker = new servidor(); // Extraccion de argumentos. // if (args.length < 2)   System.out.println("N´umero de argumentos err´oneo"); return;¡ // Comprobar el primer argumento. Si es // // "u", utilizar el servidor UDP. Si es // // "t", utilizar el servidor TCP. En // // cualquier otro caso, utilizar el // // servidor multithread. // if (args[0].equalsIgnoreCase("u"))   System.out.println("Servidor UDP"); udp = true;¡ else if (args[0].equalsIgnoreCase("t"))   System.out.println("Servidor TCP"); udp = false;¡ else   System.out.println("Servidor TCP MT"); MT = true;¡ try   // Obtener el n´umero de puerto a partir // // del segundo argumento. // port = (new Integer(args[1])).intValue();¡ catch (Exception e)   System.out.println(args[1] + "no es un n´umero v´alido de puerto"); return;¡ // Si existe un tercer argumento ser´a // // la duraci´on a asignar al servicio de // // cada petici´on. // if (args.length == 3)   try   duration = (new Long(args[2])).longValue(); // La duraci´on no puede ser negativa. // if (duration < 0) duration = -duration;
  • 12. 14 PR ´ACTICA 1. INTERCOMUNICACI ´ON CON SOCKETS JAVA ¡ catch (Exception e)   System.out.println(args[2] + "no es un valor adecuado de" + " duraci´on."); return;¡ ¡ else   duration = 0;¡ // L´ogica del programa. // if (udp)   worker.serverudp(port,duration);¡ else if (MT)   worker.servertcpmt(port,duration);¡ else   worker.servertcp(port,duration);¡ ¡ ¡