Persistencia de Datos y Transaccionalidad 01

Simulador de ejecución de tres transacciones.
Sergio Alberto Gamboa Díaz.

Código: 1721025420
José Miguel Barreto Sandoval.
Código: 1310011674
Junio de 2019.
Politécnico Gran Colombiano.

Ingeniería de software.
Persistencia de datos y transaccionalidad.
2
Copyright © 2019. Todos los derechos reservados.

3
Tabla de contenidos
Introduccion ..................................................................................................................................... 4
Descripcion del problema................................................................................................................. 5
Modelo entidad relacion ................................................................................................................... 6
Base de datos en ORACLE .............................................................................................................. 7
Estado del arte .................................................................................................................................. 8
Bibliografia ...................................................................................................................................... 9
4
4. Introducción
En el presente documento se plantea el desarrollo del ejercicio propuesto en el módulo de persistencia

de datos y transaccionalidad, el cual consta de tres entregas donde cada una de las entregas debe
mostrar que ha sido desarrollada y en las reuniones o sesiones en línea del grupo con el tutor, los
alumnos deben estar en capacidad de demostrar que la respectiva entrega fue desarrollada de manera
honesta y de autoría propia teniendo el dominio del tema.
5
5. Descripción del problema
Durante las semanas transcurridas hemos adquirido el conocimiento para realizar la primera de tres
entregas del desarrollo del módulo en cuestión la cual consta de lo siguiente:
1. Elaboración del Modelo Entidad Relación de Persistencia en la base de datos para un

cliente de un Banco XYZ.
2. Implantarlo en una base de datos Hsql, MySQL, PostgreSQL u Oracle-express-11g y
documentar el proceso.
3. Agregar el estado del arte de la construcción de un socket.
6
6. Modelo entidad relación.
A continuación, se muestra la elaboración del modelo entidad relación de persistencia en la base de

datos para un cliente de un Banco XYZ.
Figura 1. Modelo entidad relación de persistencia de la base de datos para un cliente de un banco.
7
7. Base de datos en ORACLE

El primer paso después de tener nuestro modelo entidad relación es empezar a plasmarlo desde
nuestro manejador de bases de datos en este caso ORACLE en su versión 11g para ello procedemos
instalando ORACLE 11g y ORACLE SQL Developer.
1. Creación del listener y la base de datos.
Posteriormente a la instalación de nuestro entorno de desarrollo ejecutamos desde una ventana de
comando ‘netca’ y seguimos el asistente para configurar el listener.
Una vez terminado el asistente, proseguimos a crear la base de datos.
2. Posteriormente ejecutamos desde la misma consola el comando ‘dbca’ donde se ejecutará el

asistente de creación de base de datos seguimos el paso a paso y esperamos a que se cree, al
finalizar nos desplegará un resumen de las opciones de configuración utilizadas en el
momento de la creación. Vamos a crear una base llamada BANCOXYZ.
8
3. Es muy importante tener en cuenta la personalización de nuestra base de datos ya que de ello
depende el buen funcionamiento, algo para tener en cuenta es la selección del listener
previamente creado.
9
4. Para empezar a realizar el esquema planteado en el modelo entidad relación nos conectamos
a la base de datos creada desde nuestra herramienta ORACLE SQL Developer.
5. Vamos a crear el esquema planteado en el modelo entidad relación.
Creamos las tablas y posteriormente asignamos las llaves primarias que contendrá cada tabla y
posteriormente las llaves foráneas para relacionar las tablas.
10
SQL
Creación de la tabla Bancos
CREATE TABLE "SYSTEM"."BANCOS"
( "ID_BANCO" NUMBER NOT NULL ENABLE,
"NOMBRE" VARCHAR2(20 BYTE) NOT NULL ENABLE,
"TELEFONO" NUMBER NOT NULL ENABLE,
CONSTRAINT "BANCOS_PK" PRIMARY KEY ("ID_BANCO")
USING INDEX PCTFREE 10 INITRANS 2 MAXTRANS 255 COMPUTE STATISTICS
STORAGE(INITIAL 65536 NEXT 1048576 MINEXTENTS 1 MAXEXTENTS 2147483645
PCTINCREASE 0 FREELISTS 1 FREELIST GROUPS 1 BUFFER_POOL DEFAULT
FLASH_CACHE DEFAULT CELL_FLASH_CACHE DEFAULT)
TABLESPACE "SYSTEM" ENABLE
) PCTFREE 10 PCTUSED 40 INITRANS 1 MAXTRANS 255 NOCOMPRESS LOGGING
TABLESPACE "SYSTEM" ;
Creación de la tabla Clientes
CREATE TABLE "SYSTEM"."CLIENTES"

( "ID_CLIENTE" NUMBER NOT NULL ENABLE,
"TELEFONO" NUMBER NOT NULL ENABLE,
"DIRECCION" VARCHAR2(20 BYTE) NOT NULL ENABLE,
CONSTRAINT "CLIENTES_PK" PRIMARY KEY ("ID_CLIENTE")
TABLESPACE "SYSTEM" ENABLE
11

Creación de la tabla Créditos
CREATE TABLE "SYSTEM"."CREDITOS"

( "ID_CREDITO" NUMBER NOT NULL ENABLE,
"FK_ID_CLIENTE" NUMBER NOT NULL ENABLE,
"VALOR" NUMBER NOT NULL ENABLE,
"SALDO_PENDIENTE" NUMBER NOT NULL ENABLE,
"FK_ID_SUCURSAL" NUMBER NOT NULL ENABLE,
CONSTRAINT "CREDITOS_PK" PRIMARY KEY ("ID_CREDITO")
TABLESPACE "SYSTEM" ENABLE,
CONSTRAINT "FK_ID_CLIENTE_2" FOREIGN KEY ("FK_ID_CLIENTE")
REFERENCES "SYSTEM"."CLIENTES" ("ID_CLIENTE") ENABLE,
CONSTRAINT "FK_ID_SUCURSAL_2" FOREIGN KEY ("FK_ID_SUCURSAL")
REFERENCES "SYSTEM"."SUCURSALES" ("ID_SUCURSAL") ENABLE
12
Creación de la tabla Cuentas

CREATE TABLE "SYSTEM"."CUENTAS"
( "ID_CUENTA" NUMBER NOT NULL ENABLE,
"FK_ID_CLIENTE" NUMBER NOT NULL ENABLE,
"SALDO" NUMBER NOT NULL ENABLE,
"FK_ID_SUCURSAL" NUMBER NOT NULL ENABLE,
CONSTRAINT "CUENTAS_PK" PRIMARY KEY ("ID_CUENTA")
CONSTRAINT "FK_ID_CLIENTE" FOREIGN KEY ("FK_ID_CLIENTE")
REFERENCES "SYSTEM"."CLIENTES" ("ID_CLIENTE") ENABLE,
CONSTRAINT "FK_ID_SUCURSAL" FOREIGN KEY ("FK_ID_SUCURSAL")
REFERENCES "SYSTEM"."SUCURSALES" ("ID_SUCURSAL") ENABLE
Creación de la tabla Pagos
CREATE TABLE "SYSTEM"."PAGOS"

( "ID_PAGOS" NUMBER NOT NULL ENABLE,
"FK_ID_CUENTA" NUMBER NOT NULL ENABLE,
"FECHA" DATE NOT NULL ENABLE,
CONSTRAINT "PAGOS_PK" PRIMARY KEY ("ID_PAGOS")
13

CONSTRAINT "FK_ID_CUENTA_2" FOREIGN KEY ("FK_ID_CUENTA")
REFERENCES "SYSTEM"."CUENTAS" ("ID_CUENTA") ENABLE
Creación de la tabla Sucursales
CREATE TABLE "SYSTEM"."SUCURSALES"

( "ID_SUCURSAL" NUMBER NOT NULL ENABLE,
"COLUMN1" VARCHAR2(20 BYTE) NOT NULL ENABLE,
"FK_ID_BANCO" NUMBER NOT NULL ENABLE,
"DIRECCION" VARCHAR2(20 BYTE) NOT NULL ENABLE,
CONSTRAINT "SUCURSALES_PK" PRIMARY KEY ("ID_SUCURSAL")
CONSTRAINT "FK_ID_BANCO" FOREIGN KEY ("FK_ID_BANCO")
REFERENCES "SYSTEM"."BANCOS" ("ID_BANCO") ENABLE
14

Creación de la tabla Transferencias
CREATE TABLE "SYSTEM"."TRANSFERENCIAS"

( "ID_TRANSFERENCIA" NUMBER NOT NULL ENABLE,
"FK_ID_CUENTA" NUMBER NOT NULL ENABLE,
"FECHA" DATE NOT NULL ENABLE,
CONSTRAINT "TRANSFERENCIAS_PK" PRIMARY KEY ("ID_TRANSFERENCIA")
CONSTRAINT "FK_ID_CUENTA" FOREIGN KEY ("FK_ID_CUENTA")
REFERENCES "SYSTEM"."CUENTAS" ("ID_CUENTA") ENABLE
15
Modelo entidad relación ya implementado en ORACLE.

16
17
18
19
20
21
22
8. Estado del arte

¿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.
23
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.
24
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.
25
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.
26
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ó.
27
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 {
28
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 ) {
}
}
}
public static void main (String args [ ]) {
new ServidorSencillo( ).ejecuta(Integer.parse Int (args [0]));
}
}
EJEMPLO CONSTRUCCIÓN SOCKET TCP CLIENTE
package red ;
import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.net.Socket;
import java.net.UnknownHostException;
29
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 ){
}
}
public static void main ( String [ ] args ) {
new ClienteSencillo( ).ejecuta ( Integer.parseInt ( args [0]));
}
}
EJEMPLO CONSTRUCCIÓN SOCKET UDP SERVIDOR
byte [ ] buffer = new byte [8 * 1024];
30
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

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);
31
9. 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/.

Persistencia de Datos y Transaccionalidad 01

Caricato da

Informazioni sul documento

Copyright

Formati disponibili

Condividi questo documento

Condividi o incorpora il documento

Opzioni di condivisione

Hai trovato utile questo documento?

Questo contenuto è inappropriato?

Copyright:

Formati disponibili

Persistencia de Datos y Transaccionalidad 01

Caricato da

Copyright:

Formati disponibili

Simulador de ejecución de tres transacciones.

Sergio Alberto Gamboa Díaz.

Politécnico Gran Colombiano.

Copyright © 2019. Todos los derechos reservados.

En el presente documento se plantea el desarrollo del ejercicio propuesto en el módulo de persistencia

5. Descripción del problema

1. Elaboración del Modelo Entidad Relación de Persistencia en la base de datos para un

6. Modelo entidad relación.

A continuación, se muestra la elaboración del modelo entidad relación de persistencia en la base de

7. Base de datos en ORACLE

Una vez terminado el asistente, proseguimos a crear la base de datos.

2. Posteriormente ejecutamos desde la misma consola el comando ‘dbca’ donde se ejecutará el

5. Vamos a crear el esquema planteado en el modelo entidad relación.

Creación de la tabla Clientes

CREATE TABLE "SYSTEM"."CLIENTES"

) PCTFREE 10 PCTUSED 40 INITRANS 1 MAXTRANS 255 NOCOMPRESS LOGGING

Creación de la tabla Créditos

CREATE TABLE "SYSTEM"."CREDITOS"

Creación de la tabla Cuentas

Creación de la tabla Pagos

CREATE TABLE "SYSTEM"."PAGOS"

STORAGE(INITIAL 65536 NEXT 1048576 MINEXTENTS 1 MAXEXTENTS 2147483645

Creación de la tabla Sucursales

CREATE TABLE "SYSTEM"."SUCURSALES"

PCTINCREASE 0 FREELISTS 1 FREELIST GROUPS 1 BUFFER_POOL DEFAULT

Creación de la tabla Transferencias

CREATE TABLE "SYSTEM"."TRANSFERENCIAS"

Modelo entidad relación ya implementado en ORACLE.

8. Estado del arte

InetAddress: Se encarga de implementar la dirección IP.

Socket TCP Cliente

Socket UDP Servidor

EJEMPLO CONSTRUCCIÓN SOCKET TCP SERVIDOR

public final class ServidorSencillo {

private Socket cliente;

public final class ClienteSencillo {

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

EJEMPLO CONSTRUCCIÓN SOCKET UDP CLIENTE

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

Potrebbero piacerti anche