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

INSTRUMENTOS
DE
RECOLECCIÓN
OBJETIVO DE LA
IDENTIFICACIÓN GENERAL CATEGORIAS/VARIABLES VARIABLES INFORMACIÓN RESULTADOS

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