Persistencia y Datos Transaccionales

Base de datos BancoXYZ

Docente Persistencia y Datos Transaccionales

Facultad de Ingeniería y Ciencias Básicas

Bogotá
2019
Introducción

Objetivos
 DICCIONARIO DE DATOS MODELO ENTIDAD-RELACION DEL BANCO XYZ

Nombre de la Entidad: Sucursales Fecha: junio 3 de 2019

Descripción:
Campo Tamaño/Formato Tipo Descripción
ID_Sucursal (4) bytes INT Identificación de la
sucursal.
nomSucursal Longitud Variable VARCHAR (40) Nombre Sucursal.
telSucursal (4) bytes INT Teléfono Sucursal.

Relaciones Campos Clave

Sucursal (1) -> (N) Clientes PK: ID_Sucursal

Nombre de la Entidad: Clientes Fecha: junio 3 de 2019

Descripción:
Campo Tamaño/Formato Tipo Descripción
codCliente (4) bytes INT Código del Cliente.
ID_Sucursal (4) bytes INT Código de la
sucursal.
NombreCliente Longitud Fija VARCHAR Nombre del cliente.
CédulaCliente (4) bytes INT Cédula del cliente
TipoCuenta Longitud Variable VARCHAR Detalle del tipo de
cuenta. Cuenta
corriente, Cuenta de
Ahorros, etc.

Relaciones Campos Clave

Cliente (N) -> (1) Sucursales PK: codCliente
Cliente (1) -> (N) Cuentas FK: ID_Sucursal
Nombre de la Entidad: Cuentas Fecha: junio 3 de 2019
Descripción:
Campo Tamaño/Formato Tipo Descripción
codCuenta (4) bytes INT Código de la cuenta.
codCliente (4) bytes INT Código del cliente.
CuentaNumero (4) bytes INT Número de la
cuenta
FechaAfiliación (3)bytes YYYY- DATE Fecha en la que el
MM-DD cliente se afilió al
banco (sucursal).
SaldoDisponible (4) bytes INT Dinero que hay
actualmente en la
cuenta.
SaldoTotal (4) bytes INT Dinero que queda
después de hacer un
retiro.

Relaciones Campos Clave

Clientes (1) -> (N) Cuentas PK: codCuenta
Cuenta (1) -> (N) Transacciones FK: codCliente

Nombre de la Entidad: Transacciones Fecha: junio 3 de 2019

Descripción:
Campo Tamaño/Formato Tipo Descripción
PK: (4) bytes INT Código de
codTransacciones identificación de
cada una de las
transacciones.
FK: codCuenta (4) bytes INT Código de la cuenta.
FechaTransacción (3)bytes YYYY- DATE Fecha en la que se
MM-DD realizó la
transacción.
Monto (4) bytes INT Dinero por el que se
hizo la transacción.

Relaciones Campos Clave

Transacciones (N) -> (1) Cuenta PK: codTransacciones
Cuenta (1) -> (N) Transacciones FK: codCuenta
 Estado del arte Socket Cliente y Socket Servidor

INSTRUMEN
TOS DE
OBJETIV RECOLECCI
O ÓN DE LA
IDENTIFICAC GENERA CATEGORIAS/VARIA VARIABL INFORMACI RESULTA
IÓN L BLES ES ÓN DOS

Desarrollo de Presentar
proyectos el lenguaje
informáticos de
con tecnología programac
Java, Oscar ión Java y
Belmonte herramient
Fernández, as de Los autores Se logró la
Carlos Granell desarrollo recolectaron publicación
Canut, María que información de de un libro
del Carmen ayudan en 13 libros de que está
Erdozain el programación, orientado a
Navarro, desarrollo patrones de desarrollado
pagina 221 - de diseño y res que
227, publicado proyectos algoritmos quieran
el 26 de febrero utilizando Aprendizaje, proyectos, para escribir aprender
del 2016. Java. herramientas. Java, TCP este libro. Java.
Java a fondo, Java a Desarrollo, Java, TCP El autor del El autor
ingeniero Pablo fondo es aplicaciones, libro consultó publicó este
Augusto una guía networking, variables. 7 libros de libro que
Sznajdelder, de diseño y propone ser
paginas 217 - aprendizaj construcción un curso del
230, Buenos e del de algoritmos. lenguaje de
lenguaje programació
Aires 2013.
de n Java.
programac
ión Java
que
empieza
desde sus
conceptos
más
básicos
hasta los
conceptos
más
 avanzados
.
El autor
publicó un
Presentar documento
a los muy breve
sockets que
Introducción al como introduce el
uso de sockets componen concepto de
en Linux, tes de El autor sockets y
Licenciado software recolectó como
Leonardo de para información de programarlo
Matteis, comunicar libros de s en
Argentina aplicacion programación entornos
2011. es. Cliente, servidor. Linux en Linux. Linux.

El socket es un componente de software que sirve como punto de entrada y salida de información

desde un cliente y un servidor. Se conectan usando un protocolo de comunicación basado en la

arquitectura de los protocolos TCP o UDP.

UDP (User Datagram Protocol), es un protocolo de comunicación similar al envío de cartas. Se

caracteriza por su capacidad de enviar datagramas y se considera poco confiable para enviar

datos, sin embargo, es más rápido que TCP.

TCP (Transmission Control Protocol), es un protocolo orientado a conexiones que guarda gran

similitud con las comunicaciones telefónicas y es muy confiable para cuidar la integridad de los

datos. El socket TCP del servidor abre un canal mediante una dirección ip y un puerto

especificado. Espera a que un cliente se conecte y envié información o instrucciones. Similar a

un teléfono que está esperando una llamada.

Los sockets se pueden programar en distintos lenguajes de programación. Este documento

explica la construcción de sockets con Java.

Socket del Servidor

Para programar el socket del servidor es necesario importar algunos paquetes en el proyecto.

 java.io.ObjectOutputStream

 java.io.Object.InputStream

 java.net.Socket

 java.net.ServerSocket

Estos paquetes nos proporcionan los métodos necesarios para recibir información desde el cliente

y también enviar. El socket debe abrir el canal y esperar a que un cliente se conecte y haga

peticiones.

El socket del servidor también funciona como intérprete. La información viaja en paquetes de

bytes que no pueden ser interpretados por Java. Para ello, Java ofrece los métodos
ObjectOutputStream() e ObjectInputStream() para enmascarar estos bytes de información y

transformarlos en objetos que si pueden ser interpretados por Java.

Socket del cliente

Similar al socket del servidor, se deben importar algunos paquetes en el proyecto para poder

construir el socket. Se necesitan los mismos paquetes excepto java.io.ServerSocket.

El socket también funciona como interprete y enmascara la información que será enviada al

servidor.

El cliente puede hacer peticiones de forma ilimitada hasta que se interrumpa el enlace.

Enlace de una transacción

Codigo Socket Cliente
import java.io.ObjectInputStream;
import java.io.ObjectOutputStream;
import java.net.Socket;

public class Cliente

{

public static void main(String[] args) throws Exception

{
ObjectOutputStream oos = null;
ObjectInputStream ois = null;
Socket s = null;

try
{
//instancio el server con la IP y el PORT
s = new Socket("127.0.0.1", 5432);
oos = new ObjectOutputStream(s.getOutputStream());
ois = new ObjectInputStream(s.getInputStream());

// envio un nombre
oos.writeObject("Javier");
 // recibo la respuesta (el saludo personalizado)
String respuesta = (String) ois.readObject();

// muestro la respuesa que envio el servidor

System.out.println(respuesta);
}
catch (Exception ex)
{
ex.printStackTrace();
}
finally
{
if( ois != null ) ois.close();
if( oos != null ) oos.close();
if ( s != null ) s.close();
}
}
}

Código Socket Servidor

import java.net.ServerSocket;
import java.net.Socket;
import java.io.ObjectInputStream;
import java.io.ObjectOutputStream;

public class Servidor

{
 public static void main(String[] args) throws Exception
{
ObjectInputStream ois = null;
ObjectOutputStream oos = null;

Socket s = null;
ServerSocket ss = new ServerSocket(5432);

while( true )
{
try
{
// el ServerSocket me da el socket
s = ss.accept();

// informacion en la consola
System.out.println("Se conectaron desde la IP: " +
s.getInetAddress());

// enmascaro la entrada y salida de bytes

ois = new ObjectInputStream(s.getInputStream());
oos = new ObjectOutputStream(s.getOutputStream());

// leo el nombre que envia el cliente

String nombre = (String) ois.readObject();

// armo el saludo personalizado que le quiero enviar

String saludo = "Hola " + nombre;
 // envio el saludo al cliente
oos.writeObject(saludo);
System.out.println("Saludo enviado...");
}
catch (Exception ex)
{
ex.printStackTrace();
}
finally
{
if( oos != null ) oos.close();
if( ois != null ) ois.close();
if( s != null ) oos.close();
System.out.println("Conexion cerrada!");
}
}
}
}
Base de datos BancoXYZ

SET @OLD_UNIQUE_CHECKS=@@UNIQUE_CHECKS, UNIQUE_CHECKS=0;

SET @OLD_FOREIGN_KEY_CHECKS=@@FOREIGN_KEY_CHECKS,
FOREIGN_KEY_CHECKS=0;
SET @OLD_SQL_MODE=@@SQL_MODE,
SQL_MODE='ONLY_FULL_GROUP_BY,STRICT_TRANS_TABLES,NO_ZERO_IN_DATE
,NO_ZERO_DATE,ERROR_FOR_DIVISION_BY_ZERO,NO_ENGINE_SUBSTITUTION';
-- -----------------------------------------------------
-- Schema BDbancoSebas
-- -----------------------------------------------------
-- -----------------------------------------------------
-- Schema BDbancoSebas
-- -----------------------------------------------------
CREATE SCHEMA IF NOT EXISTS `BDbancoSebas` DEFAULT CHARACTER SET utf8 ;
USE `BDbancoSebas` ;

-- -----------------------------------------------------
-- Table `BDbancoSebas`.`paises`
-- -----------------------------------------------------
CREATE TABLE IF NOT EXISTS `BDbancoSebas`.`paises` (
`cod_pais` INT(255) NOT NULL AUTO_INCREMENT,
`nombre` VARCHAR(255) NOT NULL,
PRIMARY KEY (`cod_pais`),
UNIQUE INDEX `uq_cod_pais` (`cod_pais` ASC) VISIBLE,
UNIQUE INDEX `uq_nombre` (`nombre` ASC) VISIBLE)
ENGINE = InnoDb;

-- -----------------------------------------------------
-- Table `BDbancoSebas`.`ciudades`
-- -----------------------------------------------------
CREATE TABLE IF NOT EXISTS `BDbancoSebas`.`ciudades` (
`cod_ciudad` INT(255) NOT NULL AUTO_INCREMENT,
`nombre` VARCHAR(255) NOT NULL,
`cod_pais` INT(255) NOT NULL,
PRIMARY KEY (`cod_ciudad`),
UNIQUE INDEX `uq_cod_ciudad` (`cod_ciudad` ASC) VISIBLE,
UNIQUE INDEX `uq_nombre` (`nombre` ASC) VISIBLE,
 INDEX `fk_ciudades_paises` (`cod_pais` ASC) VISIBLE,
CONSTRAINT `fk_ciudades_paises`
FOREIGN KEY (`cod_pais`)
REFERENCES `BDbancoSebas`.`paises` (`cod_pais`))
ENGINE = InnoDb;

-- -----------------------------------------------------
-- Table `BDbancoSebas`.`clientes`
-- -----------------------------------------------------
CREATE TABLE IF NOT EXISTS `BDbancoSebas`.`clientes` (
`cedula` VARCHAR(255) NOT NULL,
`nombre` VARCHAR(255) NOT NULL,
`apellido` VARCHAR(255) NOT NULL,
`cod_ciudad` INT(255) NOT NULL,
PRIMARY KEY (`cedula`),
UNIQUE INDEX `uq_cedula` (`cedula` ASC) VISIBLE,
INDEX `fk_clientes_ciudades` (`cod_ciudad` ASC) VISIBLE,
CONSTRAINT `fk_clientes_ciudades`
FOREIGN KEY (`cod_ciudad`)
REFERENCES `BDbancoSebas`.`ciudades` (`cod_ciudad`))
ENGINE = InnoDb;

-- -----------------------------------------------------
-- Table `BDbancoSebas`.`telefonos`
-- -----------------------------------------------------
CREATE TABLE IF NOT EXISTS `BDbancoSebas`.`telefonos` (
`nro_tfno` INT(255) NOT NULL,
`cedula` VARCHAR(255) NOT NULL,
 PRIMARY KEY (`nro_tfno`, `cedula`),
UNIQUE INDEX `uq_nro_tfno` (`nro_tfno` ASC) VISIBLE,
INDEX `fk_telefonos_clientes` (`cedula` ASC) VISIBLE,
CONSTRAINT `fk_telefonos_clientes`
FOREIGN KEY (`cedula`)
REFERENCES `BDbancoSebas`.`clientes` (`cedula`))
ENGINE = InnoDb;

-- -----------------------------------------------------
-- Table `BDbancoSebas`.`cuentas`
-- -----------------------------------------------------
CREATE TABLE IF NOT EXISTS `BDbancoSebas`.`cuentas` (
`nro_cta` INT(255) NOT NULL,
`cedula` VARCHAR(255) NOT NULL,
`ingreso` INT(255) NOT NULL,
`egreso` INT(255) NOT NULL,
`saldo` INT(255) NOT NULL,
PRIMARY KEY (`nro_cta`),
UNIQUE INDEX `uq_nro_cta` (`nro_cta` ASC) VISIBLE,
INDEX `fk_cuentas_clientes` (`cedula` ASC) VISIBLE,
CONSTRAINT `fk_cuentas_clientes`
FOREIGN KEY (`cedula`)
REFERENCES `BDbancoSebas`.`clientes` (`cedula`))
ENGINE = InnoDb;

-- -----------------------------------------------------
-- Table `BDbancoSebas`.`tiposmovimiento`
-- -----------------------------------------------------
CREATE TABLE IF NOT EXISTS `BDbancoSebas`.`tiposmovimiento` (
`mvto_id` INT(255) NOT NULL AUTO_INCREMENT,
`descripcion` VARCHAR(255) NOT NULL,
PRIMARY KEY (`mvto_id`),
UNIQUE INDEX `uq_mvto_id` (`mvto_id` ASC) VISIBLE)
ENGINE = InnoDb;

-- -----------------------------------------------------
-- Table `BDbancoSebas`.`movimientos`
-- -----------------------------------------------------
CREATE TABLE IF NOT EXISTS `BDbancoSebas`.`movimientos` (
`nro_cta` INT(255) NOT NULL,
`fecha` DATE NOT NULL,
`secuencia` INT(255) NOT NULL AUTO_INCREMENT,
`mvto_id` INT(255) NOT NULL,
`hora` TIME NOT NULL,
`valor_mvto` INT(255) NOT NULL,
PRIMARY KEY (`secuencia`, `nro_cta`, `fecha`),
INDEX `fk_movimientos_cuentas` (`nro_cta` ASC) VISIBLE,
INDEX `fk_movimientos_tiposmovimiento` (`mvto_id` ASC) VISIBLE,
CONSTRAINT `fk_movimientos_cuentas`
FOREIGN KEY (`nro_cta`)
REFERENCES `BDbancoSebas`.`cuentas` (`nro_cta`),
CONSTRAINT `fk_movimientos_tiposmovimiento`
FOREIGN KEY (`mvto_id`)
REFERENCES `BDbancoSebas`.`tiposmovimiento` (`mvto_id`))
ENGINE = InnoDb;
SET SQL_MODE=@OLD_SQL_MODE;
SET FOREIGN_KEY_CHECKS=@OLD_FOREIGN_KEY_CHECKS;
SET UNIQUE_CHECKS=@OLD_UNIQUE_CHECKS;

La siguiente es la conexión entre bases de datos y mysql

import java.sql.DriverManager;
import java.sql.Connection;
import java.sql.PreparedStatement;
import java.sql.ResultSet;

public class PruebaMySQL

{
public static void main(String[] args)
{

Connection con = null;

try {
Connection conn =
DriverManager.getConnection("jdbc:mysql://localhost/sakila?serverTimezone=UTC", "root",
"jhmb100352JH");
System.out.println("Connection OK");
}catch (Exception e) {

System.err.println(e);

}
}
}
import java.net.*;
import java.io.*;

public class Ncliente {

// 1. initialize socket and input output streams

private Socket socket = null;
private DataInputStream input = null;
private DataInputStream inputServer = null;
private DataOutputStream out = null;
private String information = "";
// 2. Constructor to put ip address and port

public Ncliente(String address, int port) {

// establish a connection
try {
socket = new Socket(address, port);
System.out.println("Connected");

// takes input from terminal

input = new DataInputStream(System.in);

// takes imput from server

inputServer = new DataInputStream(socket.getInputStream());
 // sends output to the socket
out = new DataOutputStream(socket.getOutputStream());

// receives message from the server

information = inputServer.readUTF();
System.out.println(information);
}
catch(UnknownHostException u) {
System.out.println(u);
}
catch(IOException i) {
System.out.println(i);
}

// String to read message from input

String line = "";

// keep reading until "Over is input and shows information from server
while(!line.contentEquals("Over")) {
try {

line = input.readLine();
out.writeUTF(line);

information = inputServer.readUTF();
System.out.println(information);
}
catch(IOException i) {
 System.out.println(i);
}
}

// close the connection

try {
input.close();
out.close();
socket.close();
}
catch(IOException i) {
System.out.println(i);
}
}

public static void main(String[] args) {

// TODO Auto-generated method stub
Ncliente cliente = new Ncliente("186.86.32.212", 5000);
}
}
import java.net.*;
import java.io.*;
import java.util.Scanner;

public class Servidor {

static int PUERTO = 5000; // aquí definimos el puerto
ServerSocket sc;
 Socket so;
DataOutputStream salida; // bufer para armar las salidas o lo que debe responder
DataInputStream entrada; // bufer para recibir datos
String mensajeRecibido; // Variable donde guardo lo que llega
public void initServidor() {
Scanner teclado = new Scanner(System.in);
try {
sc = new ServerSocket(5000); //arbrir el puerto
so = new Socket();
System.out.println("Esperando conexión...");
so = sc.accept();
System.out.println("Se conecto un cliente...");

entrada = new DataInputStream(so.getInputStream()); //armar el

constructor de recibo
salida = new DataOutputStream(so.getOutputStream());
String msn = "";
while (!msn.equals("x")) {
mensajeRecibido = entrada.readUTF();// Leemos lo que
llega
System.out.println(mensajeRecibido);
System.out.println("responder al cliente --> escriba algo");
msn = teclado.nextLine();
salida.writeUTF("" + msn);// enviamos mensaje
}
// sc.close();
} catch (Exception e) {
}
}
public static void main(String[] args) {
Servidor o = new Servidor();
o.initServidor();
}

Conclusiones
Bibliografia