Ejecución y Funcionamiento del Programa
Cliente-Servidor
Michael A. Criollo1
1
Facultad de Ingeniería en Eletronica y Telecomunicaciones, Universidad de Cuenca,
2Av. 12 de Abril & Agustín Cueva, Cuenca, Ecuador
alexander.criollo98@ucuenca.edu.ec
Resumen. En este informe se reporta la ejecución y el funcionamiento de programa
cliente servidor desde computadores separados, con firewall habilitado. En el mismo se
detalla los pasos realizados. Consiste en un Cliente / Servidor UDP muy sencillo, el
funcionamiento es el siguiente: – En el cliente se escribirá el nombre de usuario y
además cualquier cosa que este escriba, el servidor la leerá y mostrará en pantalla la IP
del cliente, su nombre además de la información escrita por este; para finalizar la
entrada de datos del servidor, se deberá escribir “terminar” si quiere finalizar el servido
o “exit” para terminar.
Palabras Clave: Cliente, Datagrama, UDP, TCP, Servidor
1
Introducción
Gracias a los sockets, podemos conectarnos a otras máquinas y realizar el patrón de
cliente/servidor, que nos permite por ejemplo mandar mensajes entre 2 máquinas distintas.
La conexión UDP no es orientada a conexión, es decir, el servidor en principio no sabe de
dónde viene el mensaje, aunque lo puede saber mirando el datagrama que le llega. En otras
palabras y comparando con la conexión TCP, UDP no necesita saber quién se conecta a él.
2
Marco Teórico
Capa de Transporte
Es la capa encargada de transportar los mensajes de la capa de aplicación entre los puntos
terminales de la aplicación. Se aplica tanto para el modelo OSI como para el modelo TCP/IP.
Añade información para la entrega del mensaje a la aplicación apropiada y bits de detección
de error.
Protocolo: Son reglas que rigen la comunicación entre dos sistemas terminales que se
comunican a través de la red.
UDP (User Datagram Protocol): Es un protocolo que provee la entrega de datos sin utilizar
muchos recursos, es decir, tiene una sobrecarga menor al momento de utilizar la red. Es un
servicio no fiable, que no garantiza que los datos enviados por un proceso lleguen intactos al
proceso de destino.
TCP (Transmission Control Protocol): Es un protocolo que incurre en el uso adicional
derecursos para agregar funciones. Proporciona una transferencia de datos fiables utilizando
técnicas de control de flujo y de congestión
Tanto el protocolo UDP como TCP son protocolos de la capa de transporte del modelo
TCP/IP y su responsabilidad principal es ampliar el servicio de entrega de IP entre dos
sistemas terminales a un servicio de entrega entre dos procesos que estén ejecutándose en los
sistemas terminales
3
Procedimiento
Ejecutar y probar el funcionamiento del programa cliente-servidor desde computadores
separados con firewall habilitado. Informe de los pasos realizados
Código Cliente
/*
* To change this license header, choose License Headers in Project Properties.
* To change this template file, choose Tools | Templates
* and open the template in the editor.
*/
package sistemasdistribuidos2019;
import java.net.*;
import java.util.Scanner;
/**
*
* @author Hernan
*/
public class ClienteUDP
{
//método principal
public static void main(String[] args)
{
//crear un Scanner del teclado para recibir texto
Scanner entrada = new Scanner(System.in);
//Creo el socket de Cliente
DatagramSocket sktCliente=null;
try
{
//pido el nombre en una variable string
System.out.println("Ingrese su nombre");
String nombre = entrada.nextLine();
//creo el Socket con new Constructor(). El puerto es aleatorio
sktCliente = new DatagramSocket();
//creo un arreglo para el mensaje y le coloco la cadena convertida a Bytes
byte[] mensaje ;
String cadena="";
do
{
System.out.print("Ingrese el mensaje: >>exit cierra el cliente
>>terminar cierra el cliente y el servidor\n>");
cadena=nombre + ">" + entrada.nextLine();
//convierte la cadena a un arreglo de bytes para enviar por el stream
mensaje = cadena.getBytes();
//creo un objeto con la direccion IP del servidor. 127.0.0.1 es la
direccion local o localhost
InetAddress ipServidor = InetAddress.getByName("127.0.0.1");
//creo el puerto en donde escucha el servidor
int puertoServidor = 6787;
//Creo el paquere de peticion (mensaje, longitud, ipServidor,
puertoServidor)
DatagramPacket dtgPeticion = new DatagramPacket(mensaje,mensaje.length,
ipServidor,puertoServidor);
//envío el paquete a traves del socket
sktCliente.send(dtgPeticion);
//creo
un buffer y un paquete para recibir (buffer de recepcion,
longitud)
byte[] buffer = new byte[1000];
DatagramPacket dtgRespuesta = new DatagramPacket(buffer,
buffer.length);
//espero la respuesta - el programa se bloquea hasta recibir la
respuesta
sktCliente.receive(dtgRespuesta);
//extraigo e imprimo la respuesta. uso el constructor de String con el
arreglo recibido como argumento
String respuesta = new String (dtgRespuesta.getData());
System.out.println("Resp: " + respuesta);
//continuo mientras no reciba el mensaje de terminar
}while(! ( cadena.endsWith("exit") |cadena.endsWith("terminar") ));
}
catch(Exception e)
{
}
}
}
Código servidor
/*
* To change this license header, choose License Headers in Project Properties.
* To change this template file, choose Tools | Templates
* and open the template in the editor.
*/
package sistemasdistribuidos2019;
import java.io.IOException;
import java.net.*;
import java.net.SocketException;
/**
*
* @author Hernan
*/
public class ServidorUDP
{
public static void main(String[] args)
{
int cont=5;
System.out.println("Bienvenidos al Servidor UDP Sistemas Distribuidos");
//crear un objeto de clase DatagramSocket --> similar a declarar una variable
DatagramSocket socketServidor = null;
try
{
//creamos el objeto con el constructor utilizando modo: "new
constructor(numeroPuertoEscucha)"
socketServidor = new DatagramSocket(6787);
while(true)
{
//creo el buffer de recepcion de datos (arreglo de 1000 elementos)
byte[] buffer = new byte[1000];
//creo el paquete de peticion de conexion a esperar del Cliente
DatagramPacket dtgPeticion = new DatagramPacket(buffer, buffer.length);
System.out.println("*********************Espera de conexion del cliente
*******");
//espero peticion (queda bloqueado hasta recibir una peticion de un
cliente )
socketServidor.receive(dtgPeticion);
//Luego de recibida la peticion, imprime los datos de la peticion
//convierto el arrego obtenido con getData() a una cadena de String
String cadena = new String(dtgPeticion.getData());
System.out.println("Recibido >> '" + cadena+"'" );
//Imprimo datos del peticionario
System.out.println("Direccion cliente: " + dtgPeticion.getAddress() + "
Puerto: " +
dtgPeticion.getPort());
//creo una respuesta con (dato, longitud del dato, direccion cliente y
puerto cliente)
DatagramPacket dtgRespuesta = new DatagramPacket(
dtgPeticion.getData(),
dtgPeticion.getLength(), dtgPeticion.getAddress(),
dtgPeticion.getPort());
//envío la respuesta al cliente
socketServidor.send(dtgRespuesta);
if(cadena.trim().endsWith("terminar"))
{
System.out.println("Terminado...");
break;
}
else
{
System.out.println("enviar la palabra >> terminar << para
finalizar el servidor");
}
}//fin while
}
catch (SocketException ex)
{
System.out.println("Error socket: " + ex.getMessage()
} catch (IOException ex) {
System.out.println("Error IO: " + ex.getMessage() );
}
}//fin main
);
}
Pasos
Instalación de NetBeans 8.2
En la página de descarga de NetBeans IDE se puede obtener uno de los diversos instaladores, cada uno
de los cuales contiene el IDE básico y herramientas adicionales.
Adicionalmente se necesita la previa instalación de Java SE Development Kit (JDK)
Fig1: Instalación de Netbeans y Java JDK
Creación y configuración del Servidor
Creación
Se escoge una computadora como servidor en ella se realiza los siguientes pasos
En Netbeans 8.2 se crea un nuevo proyecto Java; le damos a “next” y luego “finalizar “
Fig. 2. Creación del servidor
Una vez hecho el código se verifica su correcta compilación, en este caso lo podemos
confirmar al observar el mensaje” Bienvenidos al Servidor UDP Sistemas Distribuidos” en
la ventada de salida.
Fig. 3. Programa del Servidor
Como se disponía del condigo, hay que tener presente el nombre de la carpeta que le
asignamos además de nombre del archivo .java porque nos puede producir un error.
Configuración del Servidor (Habilitar Firewall)
Para que el servidor funcione correctamente necesitamos cambiar ciertos parámetros del
firewall para permitir la comunicación.
Fig. 4. Configuración de Firewall
Un ves ingresado al firewall le damos a Propiedades de Firewall de Windows y cambiamos
el estado de Firewall para conexiones entrantes
Fig. 5. Permitir conexiones entrantes
Esto se hace para los distintos perfiles de esta manera el servidor permita las conexiones
entrantes, en el firewall solo configuramos las reglas de entrada y salida; finalmente le damos
en “aceptar”. De esta manera nuestro servidor está listo.
Creación y configuración de Cliente
De manera similar al servidor creamos un nuevo proyecto en la computadora que va ser el
cliente.
Fig. 6. Creación del Cliente
Fig. 7. Programa del Cliente
Con el código ya en nuestra disposición se puede probar su correcta ejecución, pero
necesariamente para que el programa cliente se comunique con el servidor se necesita
cambiar en el código la IP del servidor, una manera rápida de saber la ip del servidor
(computadora seleccionada como servidor) es abriendo el símbolo del sistema e ingresando
el comando ipconfig
Fig. 7. Computador-Servidor (IP:192.168.100.15)
La IP del servidor es 192.168.100.15
El siguiente paso es cambiar en el Programa cliente la ip del servidor
Fig. 8. Computador-cliente configuración del servidor
Finalmente ejecutamos el programa
En la computadora cliente sale un mensaje de “ingresar su nombre” y además de “ingresar el
mensaje “se lo realizo como se muestra la imagen
Fig. 9. Computador-cliente datos ingresados
En cambio, en la computadora del servidor nos aparecerá el siguiente mensaje
Fig. 10. Computador-servidor mensaje recibido
Como se observa está el nombre ingresado, el mensaje, la dirección ip del cliente y por último
el puerto.
Por para verificar la dirección ip del cliente se utiliza el comando ipconfig
Fig. 11. Computador-Cliente (IP:192.168.100.14)
4
Conclusiones
El protocolo UDP no brinda tanta confiabilidad como el protocolo TCP, pero a su vez TCP
requiere muchos más recursos que UDP.
Los códigos cliente y servidor tienen un gran número de líneas en común lo que hace fácil el
entendimiento de éstos.
El uso de ciclos y de instrucciones de manejo de errores nos ayuda a darle una buena
visualización a los códigos.
Referencias
[1] "Comunicacion Cliente Servidor UDP | Protocolo de Control de Transmisión | Protocolos de
comunicaciones",
Scribd,
2019.
[Online].
Available:
https://es.scribd.com/document/109447211/Comunicacion-Cliente-Servidor-UDP. [Accessed: 21Jun- 2019].
