Este documento describe el desarrollo de una aplicación de chat basada en sockets en Java. Explica conceptos teóricos como el paradigma cliente-servidor, sockets, protocolos TCP/IP y hilos en Java. Detalla la arquitectura del proyecto, que utiliza sockets para establecer la comunicación entre un servidor y múltiples clientes a través de streams de entrada y salida. Finalmente, presenta fragmentos de código del servidor y cliente para implementar el chat.

1. UNIVERSIDAD NACIONAL DE
TRUJILLO
FACULTAD DE CIENCIAS FISICAS Y
MATEMATICAS
ESCUELA DE INFORMATICA
“Aplicación JAVA basada en Socket - Chat común”
CURSO : TELEPROCESAMIENTO
PROFESOR : JOSE A. DIAZ PULIDO
CICLO : V
SECCION : A
ALUMNOS :
 LAYZA MARTINEZ ROGGER
 MONTAÑEZ JULCAMORO EDWIN
 MONTENEGRO CHAVEZ WILLIAM
 RUELAS VASQUEZ DAYANARA
 UGAZ SALAZAR BRANDON
2018

2. INDICE
RESUMEN.........................................................................................................................3
INTRODUCCIÓN..............................................................................................................4
REALIDAD PROBLEMÁTICA.........................................................................................5
MARCO TEORICO...........................................................................................................6
1. PARADIGMA CLIENTE/SERVIDOR ...................................................................6
2. SOCKETS...............................................................................................................7
3. PROTOCOLOS DE TRANSPORTE ......................................................................8
4. JAVA.......................................................................................................................9
5. HILOS Y SOCKETS EN JAVA............................................................................10
INGENIERIA DEL PROYECTO.....................................................................................12
1. ARQUITECTURA................................................................................................12
2. MODELO..............................................................................................................14
CODIFICACIÓN.............................................................................................................15
.........................................................................................................................................16
CONCLUSIONES............................................................................................................22
BIBLIOGRÁFIA..............................................................................................................23
INDICE DE FIGURAS
Ilustración 1 Paradigma Cliente/Servidor _______________________________________6
Ilustración 2 Socket Servidor ________________________________________________8
Ilustración 3 socket Cliente _________________________________________________8
Ilustración 4 Sockets _____________________________________________________12
Ilustración 5 TCP/IP y MODELO OSI________________________________________13
Ilustración 6 Servidor/Cliente_______________________________________________14

3. RESUMEN
El presente proyecto trata de llevar a cabo el desarrollo de un Chat común
mediante la Aplicación JAVA basada en Socket. A lo largo del documento
se explicará el caso de estudio especificado como también algunos temas
teóricos que es necesario su descripción para poder conocer más a fondo el
tema y así lograr un mayor entendimiento para el público en general.

4. INTRODUCCIÓN
La programación en red siempre ha sido dificultosa, el programador debía
de conocer la mayoría de los detalles de la red, incluyendo el hardware
utilizado, los distintos niveles en que se divide la capa de red, las librerías
necesarias para programar en cada capa, etc. Pero, la idea simplemente
consiste en obtener información desde otra máquina, aportada por otra
aplicación software.
Los Sockets sirven para comunicar procesosde diferentes máquinas de una
red.
En las aplicaciones en red es muy común el paradigma cliente-servidor. El
servidor es el que espera las conexiones del cliente (en un lugar claramente
definido) y el cliente es el que lanza las peticiones a la maquina donde se
está ejecutando el servidor, y al lugar donde está esperando el servidor (el
puerto(s) específico que atiende). Una vez establecida la conexión, ésta es
tratada como un stream (flujo) típico de entrada/salida. Cuando se escriben
programas Java que se comunican a través de la red, se está programando
en la capa de aplicación. Típicamente, no se necesita trabajar con las capas
TCP y UDP, en su lugar se puede utilizar las clases del paquete java.net.
Estas clases proporcionan comunicación de red independiente del sistema.

5. REALIDAD PROBLEMÁTICA
La comunicación es una herramienta para establecer un intercambio de
información entre dos o más participantes con el fin de transmitir un
mensaje.
Actualmente, la comunicación también se da a través de un sistema digital
mediante dispositivos electrónicos; esta se puede dar de forma distribuida,
la cual facilita él envió de mensajes entre una gran cantidad de usuarios que
compartan la misma red.
En los laboratorios de computo usados para dar clases en la escuela de
Ingeniería Informática de la Universidad Nacional de Trujillo, observamos
una gran deficiencia en la comunicación entre los usuarios. Una solución
para este problema consiste en desarrollar un software basado en sockets a
través de un lenguaje de programación (en nuestro caso usaremos Java). un
chat capaz de atender varios clientes a la vez
Con este software daremos solución a los diversos conflictos que se
generan en él envió de un mensaje entre los usuarios que asistan al
laboratorio.

6. MARCO TEORICO
1. PARADIGMA CLIENTE/SERVIDOR
El paradigma Cliente/Servidor es quizás el más conocido de los paradigmas
para aplicaciones de red. Se usa para describir un modelo de interacción
entre dos procesos, que se ejecutan de forma simultánea. Este modelo es
una comunicación basada en una serie de preguntas y respuestas, que
asegura que, si dos aplicaciones intentan comunicarse, una comienza la
ejecución y espera indefinidamente que la otra le responda y luego continua
con el proceso.
Ilustración 1 Paradigma Cliente/Servidor
Los dos componentes del paradigma son:
Cliente: aplicación que inicia la comunicación, es dirigida por el usuario.
Servidor: es quien responde a los requerimientos de los clientes, son
procesos que se están ejecutando indefinidamente.
Los procesos clientes son más sencillos que los procesos de los servidores,
los primeros no requieren de privilegios de sistemas para funcionar, en
cambio los procesos servidores sí.
Los usuarios cuando quieren acceder a un servicio de red, ejecutan un
software cliente. El diseño de los servidores debe ser muy cuidadoso, debe
incluir código para la manipulación de:
 autenticación: verificar la identidad del cliente.

7.  seguridad de datos: para que estos no puedan ser accedidos
inapropiadamente.
 privacidad: garantizar que la información privada de un usuario, no
sea accedida por alguien no autorizado.
 protección: asegurar que las aplicaciones no monopolicen los
recursos del sistema.
 autorización: verificar si el cliente tiene acceso al servicio
proporcionado por el servidor.
La mayoría de las comunicaciones punto-a-punto en las redes (incluida
Internet), están basadas en el modelo Cliente/Servidor. Desde el punto de
vista Internet/Intranet, se tendría:
 Un servidor es un ordenador remoto - en algún lugar de la red - que
proporciona información según petición.
 Un cliente funciona en su ordenador local, se comunica con el
servidor remoto, y pide a éste información.
 El servidor envía la información solicitada.
Un único servidor típicamente sirve a una multitud de clientes, ahorrando a
cada uno de ellos el problema de tener la información instalada y
almacenada localmente.
2. SOCKETS
Normalmente, un servidor se ejecuta en una máquina específica y tiene un
socket asociado a un número de puerto específico. El servidor simplemente
espera a la escucha en el socket a que un cliente se conecte con una
petición. El cliente conoce el nombre de la máquina sobre la que está
ejecutándose el servidor y el número de puerto al que está conectado.
Solicitar una conexión consiste en intentar establecer una cita con el
servidor en el puerto de la máquina servidora.

8. Ilustración 2 Socket Servidor
Si todo va bien, el servidor acepta la conexión. Pero antes, el servidor crea
un nuevo socket en un puerto diferente. Es necesario crear un nuevo socket
(y consecuentemente un número de puerto diferente) de forma que en el
socket original se continúe a la escucha de las peticiones de nuevos clientes
mientras se atiende a las necesidades del cliente conectado. En el cliente, si
se acepta la conexión, el socket se crea satisfactoriamente y se puede
utilizar para comunicarse con el servidor.
Ilustración 3 socket Cliente
Un socket es el extremo final de un enlace punto-a-punto que comunica a
dos programas ejecutándose en una red.
Los sockets siempre están asociados a un número de puerto que es utilizado
por TCP para identificar la aplicación a la que está destinada la solicitud y
poder redirigirsela.
3. PROTOCOLOS DE TRANSPORTE
UDP (User Datagram Protocol)
Es un protocolo no orientado a conexión. Es decir cuando una maquina A
envía paquetes a una maquina B, el flujo es unidireccional. La transferencia

9. de datos es realizada sin haber realizado previamente una conexión con la
máquina de destino (maquina B), y el destinatario recibirá los datos sin
enviar una confirmación al emisor (la maquina A). Esto es debido a que la
encapsulación de datos enviada por el protocolo UDP no permite transmitir
la información relacionada al emisor. Por ello el destinatario no conocerá al
emisor de los datos excepto su IP.
TCP (Transmission Control Protocol)
Contrariamente a UDP, el protocolo TCP está orientado a conexión.
Cuando una máquina A envía datos a una máquina B, la máquina B es
informada de la llegada de datos, y confirma su buena recepción. Aquí
interviene el control CRC de datos que se basa en una ecuación matemática
que permite verificar la integridad de los datos transmitidos. De este modo,
si los datos recibidos son corruptos, el protocolo TCP permite que los
destinatarios soliciten al emisor que vuelvan a enviar los datos corruptos.
4. JAVA
Lenguaje de programación del servidor La que es hoy en día, uno de los
lenguajes de programación con mayor difusión, fue creado en la década de
los 90 por la compañía Sun Microsystems para su uso en dispositivos
electrónicos de consumo.
Dado que sus características se adaptaban perfectamente al uso en Internet,
poco a poco se convirtió en el lenguaje de programación con mayor
aceptación en ese ámbito.
Siendo el lenguaje orientado a objetos por excelencia, sin duda su mayor
baza es la comunidad de usuarios y desarrolladores que lo siguen, ya que

10. son innumerables los colectivos que se dedican a mantener y ampliar las
funciones de Java, adaptándolo así a las nuevas tendencias que surgen y
motivando su uso. Podríamos decir entonces, que existe una solución Java
para cada necesidad que pudiéramos tener, y de no ser así pronto se creará.
Algunas de sus características más destacadas son:
 Es orientado a objetos.
 Con soporte en el núcleo a la programación concurrente.
 Sintaxis muy familiar a otros lenguajes de gran importancia, como
C++.
 Es multiplataforma (el código funciona en cualquier plataforma que
disponga de soporte Java. En la actualidad, prácticamente todas).
 Es interpretado: El código Java se compila a un código
independiente de la plataforma y es ejecutado por la máquina virtual
de java (JVM), evitando generar instrucciones nativas.
5. HILOS Y SOCKETS EN JAVA
Un hilo (Thread) es un proceso en ejecución dentro de un programa. Los
hilos implementan prioridad y mecanismos de sincronización.
Los hilos se comunican generalmente a través de campos y los objetos que
tienen esos campos.
La sincronización es la herramienta para evitar este tipo de problemas,
definiendo órdenes estrictos de ejecución.
Todos los hilos de un programa comparten el espacio de memoria,
haciendo posible que dos hilos accedan la misma variable o corran el
mismo método de un objeto al "mismo tiempo". Se crea así la necesidad de

11. disponer de un mecanismo para bloquear el acceso de un hilo a un dato
crítico si el dato está siendo usado por otro hilo.
Ciclo de Vida de una Thread
Cada hilo, después de su creación y antes de su destrucción, estará en uno
de cuatro estados: recién creada, "corrible", bloqueada, o muerta.
Recién creada (New thread): entra aquí inmediatamente después de su
creación. Datos locales son ubicados e iniciados. Luego de la invocación a
start(), el hilo pasa al estado "corrible".
Corrible (Runnable): Aquí el contexto de ejecución existe y el hilo puede
ocupar la CPU en cualquier momento.
Bloqueada (not Runnable): Se ingresa cuando: se invoca suspend(), el hilo
invoca el método wait() de algún objeto, el hilo invoca sleep(), el hilo
espera por alguna operación de I/O, o el hilo invoca join() de otro hilo para
espera por su término. El hilo vuelve al estado Corrible cuando el evento
por que espera ocurre.

12. INGENIERIA DEL PROYECTO
1. ARQUITECTURA
La arquitectura de red más utilizada es la arquitectura llamada TCP/IP, que
se basa en el modelo de red teórico OSI. Esta arquitectura toma su nombre
del protocolo de transporte TCP y del protocolo de red IP. Al ser la
arquitectura de red en la que se basa Internet, otras redes que se conectan a
ella también emplean la misma arquitectura.
Ilustración 4 Sockets
El modelo TCP/IP se divide en cuatro niveles, de los que nos interesan
los tres niveles superiores (de menor a mayor):
 Nivel de Interred; Su función es la encaminar los paquetes de
datos hasta su destino final. Utiliza un sistema de
direccionamiento que identifica de forma única a cada dispositivo
de comunicaciones llamado dirección IP.
 Nivel de transporte; Es el encargado de establecer el canal de
comunicaciones extremo a extremo. Dispone de dos protocolos:
TCP y UDP.
 TCP es un protocolo orientado a conexión, es decir, espera
confirmación de cada unidad de datos que envía. Debido a ello
emisor y receptor deben establecer una conexión antes de
empezar a enviarse datos deben cerrarla después de terminar la

13. comunicación. Funciona análogamente como un servicio de
telefonía.
 UDP es un protocolo no orientado a conexión, sin garantía de
entrega del mensaje pero más rápido que TCP. Por lo tanto, no es
necesario establecer una conexión entre emisor y receptor.
Funciona análogamente como un servicio de correos
convencional.
Tanto TCP como UDP ofrecen sus servicios al nivel de aplicación a
través de los Puntos de Acceso al Servicio (SAP), denominados también
puertos y que se identifican con número comprendido entre 0 y 65535.
De esta manera permiten multiplexar sobre un mismo host (dirección
IP) múltiples servicios (aplicaciones).
 Nivel de aplicación; Es el nivel más alto del modelo TCP/IP y lo
forman las aplicaciones que ofrecen sus servicios al usuario o al
sistema dóndeestán instaladas. Ejemplos de protocolosdeeste
nivel son HTTP, FTP o SSH.
Ilustración 5 TCP/IP y MODELO OSI

14. 2. MODELO
En Java, las clases que nos permiten la comunicación en red se encuentran
en el paquete java.net.
Ilustración 6 Servidor/Cliente
 El servidor asigna un número de puerto. Cuando el cliente solicita
una conexión, el servidor abre un socket a través del método
accept().
 El cliente establece una conexión con el host en el puerto
especificado.
 Tanto el cliente como el servidor se comunican a través de
InputStream y de OutputStream

15. CODIFICACIÓN
Clase Servidor
Código principal del Servidor, dondese implementó las interfaces y se
declara variables ServerSocket y Socket, quenos servirán para la
conexión con el usuario.

16. Método que iniciará la comunicación conel cliente, serverSocket se
inicializa con puerto 5000 para la conexión, luego cuando acepta la
conexión, lo guarda en la variable clienteSocket para usarlo cuando se crea
el Hilo denominado usuario, que proviene de la clase HiloServidor

17. Clase HiloServidor
Lo principal son las declaraciones de las variables de tipo Socket y
Servidor, que nos permitirá usar el socket del usuario para comunicarnos y
la ventana del servidor para envío de mensajes.
Esta clase tiene se extiende de la clase Thread, ya que se necesita hacer
uso del concepto de hilos para que se puedan ejecutar varios a la vez.
Run es un método para ejecutar este hilo, lo principal son las variables
entrada y salida, de tipo DataImputStream y DataOutputStream, que
nos servirán para poder comunicarnos con los usuarios.

18. Un punto importante es que el envío de mensaje se realiza a través de un
número y luego el mensaje, este número le indica al servidor que hacer con
el mensaje.

19. Clase Cliente
La función más importante del Cliente, lo que hace es inicializar la variable
socket con la IP del Servidor previamente ingresada y el número de puerto,
que debe ser el mismo que el del cliente.
Posterior a que se acepte la conexión, se crea un nuevo HiloCliente que
nos sirve para la comunicación con el servidor.

20. Clase HiloCliente
De manera análoga con la clase HiloServidor, esta es diseñada para
ejecutarse como hilo, la entrada y salida de mensajes se realiza de la misma
forma, y cuando recibe un mensaje, lo hace con un número que indica que
hacer con el mensaje.
NOTA:
Vale recalcar que la comunicación es entre Cliente y Servidor, por ende, si
un cliente quiere comunicarse con otro, necesita mandar el mensaje al
servidor para que este se lo envíe al otro cliente a comunicar.
La clase Privado es una implementación de una interfaz que muestra
mensajes enviados de manera privada.
USO DE HILOS EN EL CODIGO:
Para permitir que usuarios se conecten simultáneamente, se hace uso de
hilos (threads). Los hilos se usan para las instancias que interactúan con

21. nuestro servidor permitiendo así evitar problemas con lo que se conoce
como código bloqueante.
El código bloqueante, es un segmento de código que tarda una cantidad
considerable de tiempo en ejecutarse y que de no ser por tener diferentes
hilos asignados para cada usuario ejecutándose independientemente uno del
otro, bloquearía la aplicación para los demás mientras alguno realiza el
proceso bloqueante.

22. CONCLUSIONES
 Se logró resolver la problemática que se especificó en las primeras
páginas del informe, logrando así el desarrollo de una aplicación en
Java basada en socket, para la realización de un chat común.
 Para poder intercambiar mensajes y/o información, es decir para que
se dé la comunicación entre los distintos clientes que están
sincronizados; se logra mediante procesos, es decir: el cliente
enviará la solicitud al servidor, quien es el encargado de recibir y
aceptar la solicitud para poder enviar el mensaje a los demás clientes.
 La comunicación se puede dar de manera distribuida y también de
uno a uno es decir unidireccional mediante el chat privado.
 En caso que un cliente cualquiera cierre la conexión, otro nuevo
cliente puede acceder. Pero si el servidor cierra la conexión entonces
finaliza todo tipo de conexión y se cierra por completo.
 Se usó a Java como aplicación debido a que es un lenguaje de
programación orientados a objetos, en la cual se puede trabajar de
una manera mucho más eficiente debido a las interfaces que posee
como también a algunos recursos que nos facilitan la programación.

23. BIBLIOGRÁFIA
Fernández N, Alcaraz M (2005)” Desarrollo de una plataforma
multiusuario en tiempo real”.
Chiques Chávez L.(2011)”Comunicación Remota y Local. Software de
Comunicación”. Trujillo.
http://nereida.deioc.ull.es/~cleon/doctorado/doc06/doc06/html/node9.html
https://upcommons.upc.edu/bitstream/handle/2099.1/3703/35773-
1.pdf?sequence=2&isAllowed=y
https://www.ctr.unican.es/asignaturas/procodis_3_II/Doc/Procodis_6_01.p
df