1.

PROYECTO GRUPAL PERSISTENCIA Y DATOS TRANSACCIONALES

SIMULADOR DE EJECUCION DE TRES TRANSACCIONES
PRIMERA ENTREGA 
 
 

   
PROFESOR:  
MARGARITA AVELLANEDA
  

 
 
  
INTEGRANTES DEL GRUPO:  

Juan David Henao - 1811021630

Juan Carlos Catano - 1811021231
Luis Oswaldo Quintero - 1811014524
Jhon Jairo Peña - 1821020399
Juan Carlos Nieto - 1621025469
 

  
 
   
INSTITUCIÓN UNIVERSITARIA POLITÉCNICO GRANCOLOMBIANO  
FACULTAD DE INGENIERÍA  
INGENIERÍA DE SOFTWARE  

 
  
 JUNIO 2, 2020 

TABLA DE CONTENIDOS

I. OBJETIVO DEL PROYECTO........................................................................................2

II. PLANTEAMIENTO DE LA SITUACION.....................................................................3
III. ENTREGA 1.......................................................................................................................3
1. MODELO ENTIDAD- RELACION DE PERSISTENCIA.................................3
a. Entidades y atributos...............................................................................................3
b. Relaciones identificadas y Cardinalidad...............................................................6
c. Modelo Entidad – Relación para simulador de transacciones bancarias...........7
2. IMPLEMENTACION DE BASE DE DATOS......................................................8
3. ESTADO DE ARTE CONSTRUCCION DE UN SOCKET.............................12
IV. ENTREGA 2.....................................................................................................................13
1. CODIGO SOCKET SERVER..............................................................................13
2. CODIGO SOCKET CLIENTE............................................................................13
3. DOCUMENTACION PROGRAMA...................................................................13
V. ENTREGA 3.....................................................................................................................13
1. CONSTRUCCION SOCKET CLIENTE – SERVER PARA RETIRO...........13
2. CONTRUCCION SOCKET CLIENTE – SERVER PARA CONSULTA......13
3. DOCUMENTACION PROGRAMA...................................................................13
4. PLAN DE PRUEBAS............................................................................................13
VI. CONCLUSIONES...........................................................................................................13
VII. REFERENCIAS...............................................................................................................13
 I. OBJETIVO DEL PROYECTO

Diseñar un modelo transaccional para una entidad bancaria, haciendo aplicación de los

protocolos de comunicación sockets y de una base de datos para llevar a cabo las

operaciones de consignación, retiro y consulta de saldos.

II. PLANTEAMIENTO DE LA SITUACION

El banco XYZ requiere que se desarrolle un prototipo transaccional, para simular la

ejecución de tres transacciones a saber, una consulta, una consignación y un retiro. Para

el desarrollo del proyecto, se requiere:

 Hacer un modelo entidad relación sencillo del banco XYZ, con las entidades de saldo,

cliente, ciudad, país y movimientos (el propósito es académico).

 Implementar el modelo en una base de datos libre como Oracle 11g R2 Express, por

ejemplo.

 Desarrollar los sockets server y cliente respectivos para hacer una consignación

(insert), un retiro (update) y una consulta (select).

 Probar las operaciones desde el socket cliente con el socket server iniciado.

III. ENTREGA 1

1. MODELO ENTIDAD- RELACION DE PERSISTENCIA

a. Entidades y atributos
A continuación, detallamos las entidades y atributos identificados para la

construcción de nuestro modelo Entidad- Relación:

NOMBRE ENTIDAD CLIENTES

DESCRIPCIÓN Describe la identificación individual del

cliente
ATRIBUTO DESCRIPCIÓN DEL ATRIBUTO
ID Número de identificación del cliente del
banco (cédula de ciudadanía).

Número de cuenta Número de consecutivo único asignado por

el sistema de operaciones bancarias (campo
clave) para identificar una cuenta.

Nombre, dirección, teléfono, e Información de contacto del cliente

mail
Sucursal Nombre de sucursal donde apertura la cuenta
el cliente.

ID Ciudad Número de referencia de la ciudad del cliente

NOMBRE ENTIDAD MOVIMIENTOS

DESCRIPCIÓN Contiene los registros de las transacciones

individuales generadas por los clientes

ATRIBUTO DESCRIPCIÓN DEL ATRIBUTO

Consecutivo movimiento Es el número único asignado por el sistema
de operaciones bancarias que identifica la
transacción (campo clave)

Fecha Fecha cronológica en la que la transacción

fue exitosa.

Tipo de movimiento Identifica si la transacción fue una

consignación o un retiro de dinero.

Número de cuenta Número de consecutivo único asignado por

 el sistema de operaciones bancarias para
identificar una cuenta.

Monto Valor en pesos colombianos de la

transacción.

NOMBRE ENTIDAD SALDOS

DESCRIPCIÓN Contiene los saldos de las cuentas bancarias

para cada uno de los clientes

ATRIBUTO DESCRIPCIÓN DEL ATRIBUTO

Número de cuenta Número de consecutivo único asignado por
el sistema de operaciones bancarias para
identificar una cuenta.

Fecha Se refiere a la fecha diaria de registro de los

saldos.
Saldo inicial Es el saldo final de la fecha anterior (o cero
si la cuenta está recién abierta).

Débitos Se refiere a las consignaciones de dinero

hechas a la cuenta del cliente.

Créditos Se refiere a los retiros de dinero hechoes a la

cuenta del cliente.

Saldo final Es el valor neto calculado así: Saldo inicial +

débitos – créditos

NOMBRE ENTIDAD CIUDAD

DESCRIPCIÓN Se refiere a las ciudades de cada país en

donde el banco tiene sucursales, y por tanto
clientes.

ATRIBUTO DESCRIPCIÓN DEL ATRIBUTO

ID Ciudad Se refiere al código numérico asignado a
 cada ciudad.

Nombre Se refiere al nombre de la ciudad.

NOMBRE ENTIDAD PAIS

DESCRIPCIÓN Se refiere a los países en donde el banco

tiene sucursales, y por tanto clientes.

ATRIBUTO DESCRIPCIÓN DEL ATRIBUTO

ID Ciudad Se refiere al código numérico asignado a
cada país.

Nombre Se refiere al nombre del país.

b. Relaciones identificadas y Cardinalidad

A continuación, detallamos las premisas lógicas entre entidades y relaciones, para

determinar la cardinalidad:

1. Cada cliente puede generar muchos movimientos; cada movimiento pertenece

a un cliente específico.

1:N

(1,1) (N,1)
Clientes Generan Movimientos

2. Un movimiento puede actualizar un saldo, varios saldos pueden actualizarse

con un movimiento (traslados entre cuentas).

 1:N
(1,1) (1,N)
Movimientos actualizan Saldos

3. Cada cliente puede consultar varios saldos (si tiene varias cuentas), pero el

saldo sólo puede ser consultado por el cliente respectivo.

1:N
(1,1) (N,1)
Clientes consulta Saldos

4. Cada cliente tiene una ciudad relacionada, una ciudad tiene varios clientes.

N:1
(1,N) (1,1)
Clientes tiene Ciudad

5. Cada ciudad pertenece a un único país, varias ciudades pertenecen a un país.

N:1

(1,N) (1,1)
pertenecee
Ciudad país
e

c. Modelo Entidad – Relación para simulador de transacciones bancarias

2. IMPLEMENTACION DE BASE DE DATOS

Luego de consultar con todos los integrantes del grupo, se decide trabajar la

implementación de la base de datos con MySQL, dado que es una de las herramientas

principales respecto a la gestión de bases de datos a nivel mundial, por lo tanto,

encontrar información acerca del uso de esta herramienta se convierte en una tarea

interesante, ya que se puede profundizar en todas sus funciones, debido a la gran

cantidad de información que se encuentra.

 En primer lugar, se procedió a descargar la aplicación desde la página oficial

de Oracle. Para nuestro caso particular se configura MySQL Workbench para poder

trabajarlo localmente.

Luego de la instalación se empieza entonces con la implementación del

modelo. Se crea un nuevo modelo y se le da el nombre respectivo. Estando en el área

de trabajo, se usa la herramienta de crear nuevas tablas para ingresar las entidades y

atributos.

A cada tabla se le da el nombre correspondiente, así como a cada atributo.

Además de los nombres, a los atributos se les debe de indicar ciertas características

dependiendo del rol que cumplan dentro de la entidad y del tipo de datos que van a

recibir. Los más usados son INT para enteros, VARCHAR () para caracteres variables

y DATE para fechas.

 Cada entidad contará con una llave primaria, esta está representada con una

llave y se asigna señalando PK en el área de atributos. Para aquellos atributos que

necesitan de un número consecutivo cada vez que se ingresa un nuevo dato, entonces

se señala AI para que se autoincremente. Finalmente, señalamos NN, que es la

función que indica de manera obligatoria el ingreso de datos, pues dicho espacio no

debe quedar en blanco.

Luego de definir todas las características de las tablas de la base de datos, se

empiezan a establecer las respectivas relaciones. Se dirige entonces hacia la opción

Foreign Keys y allí se establece la relación dependiendo de cómo se haya definido en

el Modelo Entidad-Relación (1:n, n:1, n:m, 1:1)

 En el lado izquierdo se define el nombre de la relación y se señala la otra tabla

que contendrá al atributo directamente relacionado. Al lado derecho se señala el

atributo de la tabla principal que se relacionará con el indicado anteriormente. De esta

manera se obtendría algo como lo mostrado a continuación:

 Luego de relacionar todas las tablas, se procede a guardar el modelo de base de

datos para posteriormente guardarlo nuestro servidor local para su posterior

ejecución. A continuación, el resultado final:

 3. ESTADO DE ARTE CONSTRUCCION DE UN SOCKET

¿Qué es un Socket?

Según (Martin Santana & A. David, 2019) afirma que:

Los sockets son mecanismos de comunicación entre procesos que permiten que un proceso hable (emita o
reciba información) con otro proceso incluso estando en distintas máquinas.
Una forma de conseguir que dos programas se transmitan datos.
Un socket no es más que un "canal de comunicación" entre dos programas que corren sobre ordenadores
distintos o incluso en el mismo ordenador.
Desde el punto de vista de programación, un socket no es más que un "fichero" que se abre de una manera
especial.
Es conclusión el socket es el punto de comunicación entre dos programas que pueden o no estar en la
misma máquina.

Tipos de sockets

Existen dos tipos de socket: socket stream y socket datagram, según (Pereria, 2019), existe una tercera
categoría sockets raw, para los interesados en desarrollar nuevos protocolos de comunicación, en (Murillo
Morera & Juan de Dios, 2010) define que socket stream está orientado a la conexión y el datagrama es no
orientado a la conexión, básicamente el socket stream está orientado al protocolo TCP que garantiza el
envío de toda la data y en el mismos orden de envío, y para el socket datagram está orientado al protocolo
UDP que no garantiza que los paquetes de data lleguen pero es más rápido comparado con TCP.
Es decir, para analizar la creación de los sockets debemos tener en cuenta el protocolo y de qué lado se
encuentra es decir si es servidor o es cliente.
Creación de Sockets en Java

En (https://www.infor.uva.es/~fdiaz/sd/doc/java.net.pdf, 2019), indica que:

Java nos proporciona el paquete java.net, que permite utilizar las clases para proporcionar comunicación
de red independiente del sistema. Las clases URL, URLConnection, Socket, y SocketServer utilizan TCP
para comunicarse a través de la Red. Las clases DatagramPacket y DatagramServer utilizan UDP.
El paquete Java.net nos proporciona entre otras las siguientes clases según
(https://www.infor.uva.es/~fdiaz/sd/doc/java.net.pdf, 2019):
Socket: Implementa un extremo de la conexión TCP.
ServerSocket: Se encarga de implementar el extremo Servidor de la conexión en la que se esperarán las
conexiones de los clientes.
DatagramSocket: Implementa tanto el servidor como el cliente cuando se utiliza UDP.
DatagramPacket: Implementa un datagram packet, que se utiliza para la creación de servicios de reparto
de paquetes sin conexión.
InetAddress: Se encarga de implementar la dirección IP.
Socket TCP Servidor

Según (Belmonte Fernandez & Óscar):

Para crear un Socket que acepte conexiones en un determinado puerto, Java nos proporciona la clase
java.net.ServerSocket, en el momento de crear una instancia de esta clase indicamos el puerto de escucha.
Para aceptar conexiones utilizamos el método public Socket accept() throws IOException, que es
bloqueante, es decir, la ejecución se detiene en este método hasta que un cliente se conecta. Cada vez que
un cliente se conecta al Socket servidor, el método accept() nos devolverá una referencia al Socket cliente
(instancia de la clase Socket esta vez), a partir de la cual podremos obtener Flujos de lectura o escritura.
En (https://www.infor.uva.es/~fdiaz/sd/doc/java.net.pdf, 2019) se detalla tanto los métodos como los
constructores que se pueden utilizar según la clase java.net por la tanto se tiene que:
public final class java.net.ServerSocket extends java.lang.Object

A. Constructores:
public ServerSocket (int port) throws IOException: Se crea un socket local al que se enlaza el puerto
especificado en el parámetro port, si se especifica un 0 en dicho parámetro creará el socket en cualquier
puerto disponible. Puede aceptar hasta 50 peticiones en cola pendientes de conexión por parte de los
clientes.
public ServerSocket (int port , int count) throws IOException: Aquí, el parámetro count sirve para que
puede especificarse, el número máximo de peticiones de conexión que se pueden mantener en cola.
Hay que recordar, que es fundamental que el puerto escogido sea conocido por el cliente, en caso
contrario, no se podría establecer la conexión.

B. Métodos:
public Socket accept () throws IOException: Sobre un ServerSocket se puede realizar una espera de
conexión por parte del cliente mediante el método accept(). Hay que decir, que este método es de
bloqueo, el proceso espera a que se realice una conexión por parte del cliente para seguir su ejecución.
Una vez que se ha establecido una conexión por el cliente, este método devolverá un objeto tipo Socket, a
través del cual se establecerá la comunicación con el cliente.
public void close () throws IOException: Se encarga de cerrar el socket.
public InetAddress getInetAddress (): Retorna la dirección IP remota a la cual está conectado el socket. Si
no lo está retornará null .
public int getLocalPort (): Retorna el puerto en el que está escuchando el socket.
public static void setSocketImplFactory (SocketImplFactory fac) throws IOException: Este método
establece la compañía de implementación del socket para la aplicación. Debido a que cuando una
aplicación crea un nuevo socket, se realiza una llamada al método createSocketImpl() de la compañía que
implementa al socket. Es por tanto en el parámetro fac, donde se especificará la citada compañía.
public String toString( ) Retorna un string representando el socket.

Socket TCP Cliente

Según (Belmonte Fernandez & Óscar) tenemos que:

Para conectarnos a un Socket servidor desde Java disponemos de la clase java.net.Socket. Al crear una
instancia de esta clase le pasamos la dirección a la que nos queremos conectar y en que puerto, y una vez
establecida la conexión podremos abrir Flujos de lectura y escritura.
En (https://www.infor.uva.es/~fdiaz/sd/doc/java.net.pdf, 2019) se detalla tanto los métodos como los
constructores e indica que en este protocolo enfocado en el lado del cliente se tiene que:
public final class java.net.Socket extends java.lang.Object

A. Constructores:
public Socket (InetAddress address, int port) throws IOException: Crea un StreamSocket y lo conecta al
puerto remoto y dirección IP remota especificados.
public Socket (InetAddress address, int port, boolean stream) throws IOException Ídem a la anterior
incluyendo el parámetro booleano stream que si es true creará un StreamSocket y si es false un
DatagramSocket (En desuso).
public Socket (String host, int port) throws UnKnownHostException, IOException: Crea un
StreamSocket y lo conecta al número de puerto y al nombre de host especificados.
public Socket (String host, int port , boolean stream) throws IOException: Ídem al anterior incluyendo el
parámetro booleano stream que si es true creará un StreamSocket y si es
false un DatagramSocket (En desuso).

B. Métodos:
public void close() throws IOException: Se encarga de cerrar el socket.
public InetAddress getInetAddress (): Retorna la dirección IP remota a la que se conecta el socket.
public InputStream getInputStream () throws IOException: Retorna un input stream para la lectura de
bytes desde el socket.
public int getLocalPort(): Retorna el puerto local al que está conectado el socket.
public OutputStream getOutputStream () throws IOException: Retorna un output stream para la escritura
de bytes hacia el socket.
public int getPort (): Retorna el puerto remoto al que está conectado el socket.
public static void setSocketImplFactory (SocketImplFactory fac) throws IOException: Este método
establece la compañía de implementación del socket para la aplicación. Debido a que cuando una
aplicación crea un nuevo socket, se realiza una llamada al método createSocketImpl( ) de la compañía que
implementa al socket. Es por tanto en el parámetro fac , donde especificaremos la citada compañía.

Socket UDP Servidor

Según (Belmonte Fernandez & Óscar) para el protocolo UDP en el lado del servidor tenemos que:
Utilizar el constructor de la clase DatagramSocket que recibe como parámetro el puerto de conexión
public DatagramSocket(int puerto). Una vez creado el Socket UDP, la clase DatagramSocket nos
permitirá tanto enviar como recibir paquetes en el puerto indicado.
Para enviar un paquete como contestación al cliente del que se acaba de recibir un paquete creamos una
nueva instancia de la clase DatagramPacket pero esta vez utilizando el constructor que incluye un tercer
parametro con la dirección de destino del paquete public DatagramPacket(byte[] buffer, int tamBuffer,
SocketAddress direccion).
Es posible utilizar la misma instancia de la clase DatagramSocket para enviar datos. La dirección a la cual
se debe enviar el paquete la obtiene la clase DatagramSocket a partir de la clase DatagramPacket.

Socket UDP Cliente

Según (Belmonte Fernandez & Óscar) para el protocolo UDP en el lado del cliente tenemos que:
Para escribir un cliente utilizando el protocolo UDP utilizamos de nuevo las clases DatagramPacket y
DatagramSocket, pero esta vez, al crear una instancia de DatagramPacket, indicamos la dirección y el
puerto del servidor al que queremos hacer llegar el paquete, por ejemplo new DatagramPacket(new
byte[1], 1, inetAddress, 12345). Para crear la instancia de DatagramSocket utilizaremos el constructor por
defecto new DatagramSocket(). Finalmente, para enviar el paquete utilizaremos de nuevo el método
send(paquete) de la clase DatagramSocket.
Así mismo indica que: al igual que en el lado del servidor el cliente puede quedar a la escucha de los
paquetes que reciba del servidor.
Socket UDP

Para (https://www.infor.uva.es/~fdiaz/sd/doc/java.net.pdf, 2019) indica que para los lados, servidor y

cliente, se utilizan los mismos paquetes datagram socket y datagram packet, solo que la configuración
cambia según el lado, afirmando lo mencionado por (Belmonte Fernandez & Óscar) y explica los
constructores y los métodos de cada uno así:
Datagram Socket

public class java.net.DatagramSocket extends java.lang.Object

A. Constructores:
public DatagramSocket () throws SocketException: Se encarga de construir un socket para datagramas y
de conectarlo al primer puerto disponible.
public DatagramSocket (int port) throws SocketExceptionÍdem: Con la salvedad de que permite
especificar el número de puerto asociado.
public DatagramSocket (int port, InetAddress ip) throws SocketException: Permite especificar, además
del puerto, la dirección local a la que se va a asociar el socket.

B. Métodos:
public void close(): Cierra el socket.
protected void finalize(): Asegura el cierre del socket si no existen más referencias al mismo.
public int getLocalPort(): Retorna el número de puerto en el host local al que está conectado el socket.
public void receive (DatagramPacket p) throws IOException: Recibe un DatagramPacket del socket, y
llena el búfer con los datos que recibe.
public void send (DatagramPacket p) throws IOException: Envía un DatagramPacket a través del socket.

Datagram Packet

En (https://www.infor.uva.es/~fdiaz/sd/doc/java.net.pdf, 2019) indica que:

Un DatagramSocket envía y recibe los paquetes y un DatagramPacket contiene la información relevante.
Cuando se desea recibir un datagrama, éste deberá almacenarse bien en un búfer o un array de bytes. Y
cuando preparamos un datagrama para ser enviado, el DatagramPacket no sólo debe tener la información,
sino que además debe tener la dirección IP y el puerto de destino, que puede coincidir con un puerto TCP.
pulic final class java.net.DatagramPacket extends java.lang.Object
 A. Constructores:
public DatagramPacket(byte ibuf[], int ilength) Implementa un DatagramPacket para la recepción de
paquetes de longitud ilength, siendo el valor de este parámetro menor o igual que ibuf.length.
public DatagramPacket(byte ibuf[], int ilength, InetAddress iaddr, int iport): Implementa un
DatagramPacket para el envío de paquetes de longitud ilength al número de puerto especificado en el
parámetro iport, del host especificado en la dirección de destino que se le pasa por medio del parámetro
iaddr.

B. Métodos:
public InetAddress getAddress (): Retorna la dirección IP del host al cual se le envía el datagrama o del
que el datagrama se recibió.
public byte[] getData(): Retorna los datos a recibir o a enviar.
public int getLength(): Retorna la longitud de los datos a enviar o a recibir.
public int getPort(): Retorna el número de puerto de la máquina remota a la que se le va a enviar el
datagrama o del que se recibió.

EJEMPLO CONSTRUCCIÓN SOCKET TCP SERVIDOR

Ejemplo tomado de (Belmonte Fernandez & Óscar) package red ;

import java.io.IOException; import java.io. PrintWriter; import java.net.ServerSocket; import

java.net.Socket;

public final class ServidorSencillo { private ServidorSencillo ( ) {

super ( ) ;
}
private void ejecuta (int puerto) { try {

System.out.println ("Servidor a la escucha");

// Creamos un Socket servidor a la escucha en el puerto indicado ServerSocket servidor =
new ServerSocket (puerto);

Socket cliente; try {

// Cada vez que se conecta un cliente le enviamos un saludo while (( cliente = servidor.accept ()) != null)

new Thread (new Saludo (cliente)).start();

} finally { servidor.close( );

}
} catch ( IOException e ) { e.printStackTrace ( );

}
}
private class Saludo implements Runnable {

private Socket cliente;

public Saludo ( Socket cliente) { this.cliente = cliente;

}
@Override
public void run ( ) {
System.out.println ("Cliente conectado"); try {

// Obtenemos un stream de escritura a partir del Socket del cliente PrintWriter pw = new PrintWriter
(cliente.getOutputStream( ), true); pw.println ("Hola desde el servidor");

pw.close( );
} catch (IOException e ) { e.printStackTrace ( );

}
}
}
public static void main (String args [ ]) {
new ServidorSencillo( ).ejecuta(Integer.parse Int (args [0]));
}
}

EJEMPLO CONSTRUCCIÓN SOCKET TCP CLIENTE

Ejemplo tomado de (Belmonte Fernandez & Óscar) package red ;

import java.io.BufferedReader; import java.io.IOException; import java.io.InputStreamReader; import

java.net.Socket;

import java.net.UnknownHostException;
public final class ClienteSencillo { private ClienteSencillo ( ) {

super ( );
}
private void ejecuta (int puerto) { try {

// Me conecto al servidor local que escucha es este puerto Socket cliente = new Socket ("local host",
puerto);

try {
// Recupero un stream de lectura
BufferedReader br = new BufferedReader (new InputStreamReader ( cliente.getInputStream ( ) ) ); String
saludo ;

while (( saludo = br.readLine ( )) != null) System.out.println (saludo);

} finally {
if (cliente != null) cliente.close( ) ;
}
} catch (UnknownHostException e) { e.printStackTrace ( ) ;

} catch (IOException e ){ e.printStackTrace ( );

}
}

public static void main ( String [ ] args ) {

new ClienteSencillo( ).ejecuta ( Integer.parseInt ( args [0]));
}
}

EJEMPLO CONSTRUCCIÓN SOCKET UDP SERVIDOR

Ejemplo tomado de (Belmonte Fernandez & Óscar) byte [ ] buffer = new byte [8 * 1024];

DatagramPacket paquete = new DatagramPacket (buffer, buffer.length); DatagramSocket servidor = new

DatagramSocket (12345);

// Puerto de escucha 12345

servidor.receive (paquete); // El método receive es bloqueante InetSocketAddress direccionCliente =
paquete.getSocketAddress ( ); System.out.println ("Host cliente:" + direccionCliente.getHostName ( ));
bytes [ ] mensaje = "Hola".getBytes ( );

DatagramPacket paqueteRespuesta = new DatagramPacket (mensaje, mensaje.length,

direccionCliente);
servidor.send (paqueteRespuesta) ;
EJEMPLO CONSTRUCCIÓN SOCKET UDP CLIENTE

Ejemplo tomado de (Belmonte Fernandez & Óscar)

DatagramPacket paquete = new DatagramPacket (new byte [1],1,inetAddress,12345); DatagramSocket

servidor = new DatagramSocket ( );

servidor.send (paquete);
byte [ ] buffer = new byte [ 8 * 1024];
paquete = new DatagramPacket (buffer, buffer.length); servidor.receive (paquete);

6. Bibliografía

Belmonte Fernández, G. C., & Óscar, C. M. (s.f.). Desarrollo de Proyectos Informáticos con Tecnología
Java. Universitat Jaume.
https://www.infor.uva.es/~fdiaz/sd/doc/java.net.pdf. (25 de 05 de 2019). Obtenido de
https://www.infor.uva.es/~fdiaz/sd/doc/java.net.pdf
Martin Santana, M. S., & A. David, L. I. (25 de 05 de 2019). sopa.dis.ulpgc.es/ii-
dso/leclinux/ipc/sockets/sockets.pdf. Obtenido de http://sopa.dis.ulpgc.es/ii-
dso/leclinux/ipc/sockets/sockets.pdf
Murillo Morera, C. P., & Juan de Dios, S. (2010). Implementación de un servidor ftp utilizando el modelo
cliente/servidor mediante el uso de sockets en lenguaje C UNIX con el fin de mejorar los tiempos de
respuesta en la red. Uniciencia, 85.
Pereria, A. (25 de 05 de 2019). https://eslinux.com/articulos/8591/programacion-sockets-lenguaje- c/.
1. Sistemas operativos: Comunicación mediante sockets[ CITATION Sua07 \l 9226 ]

Objetivo: Este documento resume la definición de sockets, tipos de sockets,

dominio y su construcción. Menciona que la comunicación a través de sockets se

base en la filosofía cliente servidor, en donde existe una comunicación inicial de

cada uno a la red mediante una IP específica y posteriormente una petición y

envío de respuesta entre ambos para completar la tarea predefinida.

2. Socket programming [ CITATION Nik07 \l 9226 ]- programación de sockets

Objetivo: Este documento presenta que es un API (Application programming

Interface), una interfase para utilizar la red y transportar datos. Igualmente, qué es

un socket, definido como una aplicación para enviar y recibir datos de un proceso

a otro, en la misma máquina o entre máquinas. Presenta gráficamente la relación

entre dos máquinas de la siguiente manera:

 Fuente: https://inst.eecs.berkeley.edu/~ee122/sp07/Socket%20Programming.pdf Slide

# 13, Adaptado de http://www.troubleshooters.com/codecorn/sockets/

Adicionalmente, el documento explica el uso de los puertos, las conexiones TCP,

cómo crear un socket y cómo enviar y recibir datos.

IV. ENTREGA 2

1. CODIGO SOCKET SERVER

2. CODIGO SOCKET CLIENTE

3. DOCUMENTACION PROGRAMA

V. ENTREGA 3

1. CONSTRUCCION SOCKET CLIENTE – SERVER PARA RETIRO

2. CONTRUCCION SOCKET CLIENTE – SERVER PARA CONSULTA

3. DOCUMENTACION PROGRAMA

4. PLAN DE PRUEBAS
VI. CONCLUSIONES

VII. REFERENCIAS
Shetty, N. (2007). https://inst.eecs.berkeley.edu/. Obtenido de EECS instructional and electronics
support: https://inst.eecs.berkeley.edu/~ee122/sp07/Socket%20Programming.pdf

Suarez, O. D., Quesada, A., & Santana, F. J. (1 de 09 de 2007). http://sopa.dis.ulpgc.es/. Obtenido de

Universidad de las Palmas de Gran Canaria: http://sopa.dis.ulpgc.es/progsis/material-didactico-
teorico/tema7_1transporpagina.pdf