PROYECTO MODULO CLIENTE SERVIDOR

1

1. CONTENIDO 2. DESARROLLO................................................................................................................................... 7

2.1 MODULO CONCEPTOS AVANZADOS DEL LENGUAJE. ...................................................................... 7

2.1.1 Colecciones Java. ..................................................................................................................... 7

2.1.1.1 Marco Teórico. ........................................................................................................................ 7

2.1.1.1.1 Concepto. ............................................................................................................................ 7

2.1.1.1.2 Clases. ................................................................................................................................. 7

2.1.1.1.2.1 Interfaces ......................................................................................................................... 7

2.1.1.1.2.2 Métodos: ......................................................................................................................... 8

2.1.1.1.2.3 Iterando Colecciones. ....................................................................................................... 8

2.1.1.1.2.3.1 for-each ....................................................................................................................... 8

2.1.1.1.2.3.2 Iteradores .................................................................................................................... 8

2.1.1.1.2.4 Operaciones entre colecciones y arreglos........................................................................... 9

2.1.1.2 Ejemplo. .................................................................................................................................10

2.1.1.2.1 List .....................................................................................................................................10

2.1.1.2.2 Map....................................................................................................................................13

2.1.1.2.3 Set......................................................................................................................................16

2.1.1.2.4 Archivador ..........................................................................................................................18

2.1.2 AWT. ......................................................................................................................................21

2.1.2.1 Marco Teórico. .......................................................................................................................21

2.1.2.1.1 El paquete AWT...................................................................................................................21

2.1.2.1.2 Elementos...........................................................................................................................21

2.1.2.1.3 Jerarquía de Clases. .............................................................................................................21

2.1.2.1.4 Clases. ................................................................................................................................22

2.1.2.1.4.1 java.awt.Component........................................................................................................22

2.1.2.1.4.2 java.awt.Container ..........................................................................................................22

2.1.2.1.4.3 java.awt.LayoutManager..................................................................................................22

2.1.2.1.5 Coordenadas y Posicionamiento...........................................................................................23

2.1.2.1.6 Pasos a seguir: ....................................................................................................................23

2.1.2.1.7 Layout Managers.................................................................................................................23

2.1.2.1.7.1 ¿Por qué usar Layout Managers? ......................................................................................23

2.1.2.1.8 Eventos...............................................................................................................................24

2.1.2.1.8.1 Tipos de eventos: ............................................................................................................24

2.1.2.1.8.1.1 Físicos: ........................................................................................................................24

2

2.1.2.1.8.1.2 Semánticos: .................................................................................................................24

2.1.2.1.9 Adapters. ............................................................................................................................27

2.1.2.2 Ejemplos. ...............................................................................................................................28

2.1.2.2.1 Button. ...............................................................................................................................28

2.1.2.2.2 CheckBox ............................................................................................................................28

2.1.2.2.3 CheckBoxGroup...................................................................................................................29

2.1.2.2.4 Choise ................................................................................................................................31

2.1.2.2.5 Frame .................................................................................................................................32

2.1.2.2.6 Label ..................................................................................................................................32

2.1.2.2.7 List .....................................................................................................................................33

2.1.2.2.8 Panel ..................................................................................................................................34

2.1.2.2.9 Scrollbar .............................................................................................................................36

2.1.2.2.10 TextField .........................................................................................................................37

2.1.3 Swing. ....................................................................................................................................38

2.1.3.1 Marco Teórico. .......................................................................................................................38

2.1.3.1.1 El paquete Swing. ................................................................................................................38

2.1.3.1.2 Migrando de AWT a Swing ...................................................................................................38

2.1.3.1.3 Layout Managers.................................................................................................................38

2.1.3.2 Ejemplo. .................................................................................................................................40

2.1.4 Applet. ...................................................................................................................................65

2.1.4.1 Marco Teórico. .......................................................................................................................65

2.1.4.1.1 Concepto. ...........................................................................................................................65

2.1.4.1.2 Atributos ............................................................................................................................65

2.1.4.1.3 Etiqueta <object> ................................................................................................................66

2.1.4.1.4 Ciclo de vida........................................................................................................................67

2.1.4.2 Ejemplo. .................................................................................................................................69

2.1.4.2.1 Hola mundo ........................................................................................................................69

2.1.4.2.2 Convertidor de Monedas ....................................................................................................69

2.1.5 Manejo de Excepciones. ..........................................................................................................74

2.1.5.1 Marco Teórico. .......................................................................................................................74

2.1.5.1.1 Manejo de Excepciones .......................................................................................................74

2.1.5.1.2 Generación de Excepciones en Java ......................................................................................74

2.1.5.1.3 Jerarquía de Clases ..............................................................................................................75

2.1.5.1.4 Captura de Excepciones .......................................................................................................75

2.1.5.1.4.1 Try. .................................................................................................................................76

3

2.1.5.1.4.2 Catch ..............................................................................................................................76

2.1.5.1.4.3 Finally .............................................................................................................................77

2.1.5.1.5 Throw .................................................................................................................................77

2.1.5.1.6 Tipos de excepciones ...........................................................................................................78

2.1.5.1.6.1 Excepciones Predefinidas .................................................................................................78

2.1.5.2 Ejemplo. .................................................................................................................................79

2.1.6 Threads. .................................................................................................................................81

2.1.6.1 Marco Teórico. .......................................................................................................................81

2.1.6.1.1 Programación Multihilo. ......................................................................................................81

2.1.6.1.2 Clases. ................................................................................................................................81

2.1.6.1.3 java.lang.Thread..................................................................................................................81

2.1.6.1.4 java.lang.Runnable ..............................................................................................................81

2.1.6.1.5 Implementando un Thread ..................................................................................................81

2.1.6.1.6 Sincronización de threads. ...................................................................................................83

2.1.6.1.7 Uso de señales ....................................................................................................................83

2.1.6.2 Ejemplo. .................................................................................................................................84

2.1.6.2.1 Carrera ...............................................................................................................................84

2.1.6.2.2 Cronometro ........................................................................................................................85

2.1.7 Tcp/Ip. ...................................................................................................................................91

2.1.7.1 Marco Teórico. .......................................................................................................................91

2.1.7.1.1 Sockets. ..............................................................................................................................91

2.1.7.1.1.1 Sockets Stream (TCP, Transport Control Protocol) .............................................................91

2.1.7.1.1.2 Sockets Datagrama (UDP, User Datagram Protocol) ...........................................................91

2.1.7.1.1.3 Sockets Raw ....................................................................................................................91

2.1.7.1.2 La clase URL. .......................................................................................................................91

2.1.7.1.3 Apertura de sockets.............................................................................................................92

2.1.7.1.4 Cierre de sockets .................................................................................................................93

2.1.7.1.5 Creacion de streams. ...........................................................................................................94

2.1.7.1.5.1 Creación de Streams de Entrada .......................................................................................94

2.1.7.1.5.2 Creación de Streams de Salida ..........................................................................................94

2.1.7.2 Ejemplo. .................................................................................................................................96

2.1.7.2.1 URL ....................................................................................................................................96

2.1.7.2.2 Servidor ..............................................................................................................................99

2.2 MODULO BASE DE DATOS. ........................................................................................................ 114

2.2.1 Acceso a la Base de Datos...................................................................................................... 114

4

2.2.1.1 Marco Teórico. ..................................................................................................................... 114

2.2.1.1.1 Definición ......................................................................................................................... 114

2.2.1.1.2 Normalización ................................................................................................................... 116

2.2.1.1.2.1 Definición...................................................................................................................... 116

2.2.1.1.2.2 Claves ........................................................................................................................... 117

2.2.1.1.2.3 FORMAS NORMALES...................................................................................................... 118

2.2.1.1.2.3.1 PRIMERA FORMA NORMAL (1FN) ............................................................................... 118

2.2.1.1.2.3.2 SEGUNDA FORMA NORMAL (2FN) .............................................................................. 118

2.2.1.1.2.3.3 TERCERA FORMA NORMAL (3FN) ................................................................................ 119

2.2.1.1.2.3.4 FORMA NORMAL DE BOYCE-CODD (FNBC) .................................................................. 119

2.2.1.1.2.3.5 CUARTA FORMA NORMAL (4FN) ................................................................................. 120

2.2.1.1.2.3.6 QUINTA FORMA NORMAL (5FN) ................................................................................. 120

2.2.1.1.2.4 Reglas de CODD............................................................................................................. 120

2.2.1.1.2.4.1 Regla no. 1 - la regla de la información ........................................................................ 120

2.2.1.1.2.4.2 Regla no. 2 - la regla del acceso garantizado ................................................................ 120

2.2.1.1.2.4.3 REGLA NO. 3 - Tratamiento sistemático de los valores nulos......................................... 121

2.2.1.1.2.4.4 Regla no. 4 - La regla de la descripción de la base de datos........................................... 121

2.2.1.1.2.4.5 Regla no. 5 - La regla del sub-lenguaje integral ............................................................ 121

2.2.1.1.2.4.6 Regla no. 6 - la regla de la actualización de vistas ......................................................... 121

2.2.1.1.2.4.7 Regla no. 7 - la regla de insertar y actualizar ................................................................ 121

2.2.1.1.2.4.8 Regla no. 8 - la regla de independencia física ............................................................... 122

2.2.1.1.2.4.9 Regla no. 9 - la regla de independencia lógica .............................................................. 122

2.2.1.1.2.4.10 Regla no. 10 - la regla de la independencia de la integridad .......................................... 122

2.2.1.1.2.5 Las reglas de integridad.- ............................................................................................... 122

2.2.1.1.2.5.1 Regla no. 11 - la regla de la distribución ...................................................................... 122

2.2.1.1.2.5.2 Regla no. 12 - regla de la no-subversión ...................................................................... 123

2.2.1.1.2.6 Modelo Entidad – Relación............................................................................................. 123

2.2.1.1.2.6.1 Definición .................................................................................................................. 123

2.2.1.1.2.6.2 Modelado Entidad-Relación........................................................................................ 123

2.2.1.1.2.6.2.1 Base teórica y conceptual ........................................................................................... 123

2.2.1.1.2.6.2.1.1 Entidad .................................................................................................................. 124

2.2.1.1.2.6.2.1.2 Atributos ............................................................................................................... 124

2.2.1.1.2.6.2.1.3 Relación................................................................................................................. 125

2.2.1.1.2.6.2.1.4 Conjunto de relaciones ........................................................................................... 125

2.2.1.1.2.7 Restricciones.- ............................................................................................................... 126

5

2.2.1.1.2.7.1 Correspondencia de cardinalidades............................................................................. 126

2.2.1.1.2.7.2 Restricciones de participación .................................................................................... 126

2.2.1.1.2.8 Claves ........................................................................................................................... 126

2.2.1.1.2.9 Diagrama Entidad-Relación ............................................................................................ 127

2.2.1.1.2.9.1 Entidades .................................................................................................................. 128

2.2.1.1.2.9.2 Atributos ................................................................................................................... 128

2.2.1.1.2.9.3 Relaciones ................................................................................................................. 128

2.2.1.1.2.10 Diagramas Extendidos.-.................................................................................................. 128

2.2.1.1.2.10.1 Entidades Fuertes y Débiles.- ...................................................................................... 129

2.2.1.1.2.10.2 Cardinalidad de las relaciones..................................................................................... 129

2.2.1.1.2.10.3 Atributos en relaciones .............................................................................................. 130

2.2.1.1.2.10.4 Herencia.................................................................................................................... 130

2.2.1.1.2.10.5 Agregación ................................................................................................................ 130

2.2.1.2 Ejemplo. ............................................................................................................................... 131

2.3 MODULO ENTORNO WEB.......................................................................................................... 137

2.3.1 Java WEB.............................................................................................................................. 137

2.3.1.1 Marco Teórico. ..................................................................................................................... 137

2.3.1.1.1 Introducción. .................................................................................................................... 137

2.3.1.1.1.1 Modelo cliente-servidor. ................................................................................................ 138

2.3.1.1.1.2 Acceso a Datos .............................................................................................................. 139

2.3.1.1.1.3 Formas de seguir la trayectoria de los usuarios (clientes) ................................................. 140

2.3.1.1.2 EJBs .................................................................................................................................. 141

2.3.1.1.2.1 Beneficios ..................................................................................................................... 141

2.3.1.1.2.2 Componentes ................................................................................................................ 141

2.3.1.1.2.3 Desarrollar EJBs ............................................................................................................. 142

2.3.1.1.2.4 EJBs contra Servlets ....................................................................................................... 142

2.3.1.1.2.5 ¿Cúando usar EJBs? ....................................................................................................... 142

2.3.2 Framework. .......................................................................................................................... 143

2.3.2.1 Marco Teórico. ..................................................................................................................... 143

2.3.2.1.1 ¿Qué es un Framework? .................................................................................................... 143

2.3.2.1.2 Objetivos de Usar un Framework ....................................................................................... 143

2.3.2.1.3 Modelo – Vista – Controlador ............................................................................................ 145

2.3.2.1.4 Frameworks para el Modelo MVC ...................................................................................... 145

2.3.2.1.5 Struts................................................................................................................................ 146

2.3.2.1.5.1 Archivos de Configuración: ............................................................................................. 146

6

2.3.2.1.6 Spring Framework ............................................................................................................. 147

........................................................... 147

2.3.2.1.7 Hibernate ......................................................................................................................... 147

2.3.3 Java Server. .......................................................................................................................... 148

2.3.3.1 Marco Teórico. ..................................................................................................................... 148

2.3.3.1.1 Introducción a JSP. ............................................................................................................ 148

2.3.3.1.1.1 Estructura de una página JSP .......................................................................................... 148

2.3.3.1.1.1.1 Directivas .................................................................................................................. 148

2.3.3.1.1.1.2 Declaraciones ............................................................................................................ 149

2.3.3.1.1.1.3 Scriptlets ................................................................................................................... 149

2.3.3.1.1.1.4 Variables Predefinidas................................................................................................ 149

2.3.3.1.1.1.5 Expresiones ............................................................................................................... 150

2.3.3.1.1.1.6 Etiquetas específicas de JSP ........................................................................................ 150

2.3.3.1.1.1.7 Procesamiento de la página JSP .................................................................................. 151

2.3.3.1.1.1.8 Objetos implícitos ...................................................................................................... 151

3. REFERENCIAS. .............................................................................................................................. 153

7

2. DESARROLLO.

2.1 MODULO CONCEPTOS AVANZADOS DEL LENGUAJE.

2.1.1 Colecciones Java.

2.1.1.1 Marco Teórico.

2.1.1.1.1 Concepto.

Una colección es un objeto que permite agrupar otros objetos. Generalmente, los

elementos en una colección representan datos de una agrupación específico de objetos,

como una colección de personas, casas. En una colección se pueden realizar operaciones

sobre los objetos que están almacenados en su interior, así podemos almacenar,

manipular, obtener y comunicar entre estos objetos.

2.1.1.1.2 Clases.

2.1.1.1.2.1 Interfaces

Las interfaces permiten a las colecciones ser manipuladas con un cierto

comportamiento independiente o particular. A continuación se muestra su jerarquía:

Interfaces principales para el Collection Framework

Las interfaces Collection y Map son los padres de las interfaces en el Framework de

colecciones de Java. Es notorio que la jerarquía consta de dos diferentes árboles.

Hay que tomar en cuenta que las interfaces son genéricas,

public interface Collection<E>...

La sintaxis <E> indica que es una interfaz genérica. Cuando se declara una

instancia de Collection, se puede especificar el tipo de objeto que esta va a contener. Esto

8

permite que el compilador verifique el tipo de objeto que se va a poner dentro de la

colección sea el indicado (compile-time), lo cual reduce el número de errores en tiempo

de ejecución (runtime).

2.1.1.1.2.2 Métodos:

Esta interfaz tiene métodos, entre ellos:

size: que permite saber cuántos elementos existen en la colección.

isEmpty: verifica si la colección se encuentra vacía.

contains: chequea si un elemento específico se encuentra en la colección.

add: para agregar un elemento a la colección.

remove: para eliminar un elemento de la colección.

iterator: para iterar sobre la colección.

2.1.1.1.2.3 Iterando Colecciones.

Existen dos formas de recorrer una colección.

Mediante for-each

Usando iteradores

2.1.1.1.2.3.1 for-each

Permite atravesar la colección o arreglo usando un bucle for.

for(Object o: collection)

System.out.println(o);

2.1.1.1.2.3.2 Iteradores

Un iterador es un objeto que permite recorrer una colección y remover elementos de la

misma selectivamente. Se obtiene un iterador de una colección llamando al método

iterator. La interfaz Iterator se muestra a continuación:

public interface Iterator<E> {

boolean hasNext();

E next();

9

void remove(); //optional

}

Los métodos hasNext retorna true si la iteración contiene más elementos, y el método

next retorna el siguiente elemento en la iteración. El método remove, remueve el último

elemento que fue retornado por next de la colección que está siendo iterada. El método

remove solo puede ser llamado una vez por llamada de next y lanza una excepción si

esta regla es violada.

El siguiente método realiza una eliminación de elementos de la colección

static void filter(Collection<String> c) {

for (Iterator<String> it = c.iterator(); it.hasNext(); )

if (!cond(it.next()))

it.remove();

}

2.1.1.1.2.4 Operaciones entre colecciones y arreglos

El método toArray provee un puente entre las colecciones y los arreglos. Las

operaciones de arreglos permiten al contenido de una colección ser transformada en un

arreglo. La forma más simple sin argumentos crea un nuevo arreglo tipo Object. La otra

forma de este método permite especificar el tipo de salida que tendrá el arreglo.

Suponiendo que c es de tipo Collection, la siguiente expresión envía el contenido de esta

hacia un arreglo de Object cuya longitud es igual al número de elementos en c.

Object[] a = c.toArray();

Ahora suponiendo que c contiene solo elementos tipo String (Collection<String>), la

siguiente sentencia manda el contenido de c hacia un arreglo de objetos tipo String.

String[] a = c.toArray(new String[0]);

10

2.1.1.2 Ejemplo.

2.1.1.2.1 List import java.util.ArrayList;

import java.util.Iterator;

/**

*

* @author laboratorio6

*/

public class TestArrayList {

public static void main(String[] args) {

ArrayList ciudades = new ArrayList();// nos permite acceder a cada

uno de los objetos en el orden q deseemos y los presenta en forma aleatoria

ciudades.add("Machala");// al colocar el add te permite guardar los

objetos que se presentaran en la lista

ciudades.add("Guayaquil");

ciudades.add("Quito");

ciudades.add("Cuenca");

ciudades.add(1,"Loja");

ciudades.add("Machala");//si presenta los elementos repetidos

Iterator it = ciudades.iterator();//devuelve la coleccion de la

lista osea cada uno de los objetos q hemos guardado

while (it.hasNext()) {

System.out.println("Ciudad: " + it.next());// mediante el next

va acceder a los objetos q se han guardado en la lista

}

}

}

import java.util.*;

/**

*

11


*/

public class TestArrayList2 {


ArrayList ciudades = new ArrayList();// nos permite acceder a cada

uno de los objetos en el orden q deseemos y los presenta en forma aleatoria






ciudades.add(1, "Loja");


for(int i =ciudades.size()-1;i>=0;i--) {//accede a los elementos y

los presenta desde el ultimo hacia el primero posición

System.out.println("Ciudad: " +i + "es: " + ciudades.get(i));//

mediante el next va acceder a los objetos q se han guardado en la lista

}

}

}


import java.util.LinkedList;

/**

*


*/

public class TestLinkedList {


LinkedList ciudades = new LinkedList();// nos permite acceder a

cada uno de los objetos en el orden q deseemos y los presenta en forma

aleatoria

12






ciudades.add(1,"Loja");







}

}

}

import java.util.*;

/**

*


*/

public class TestVector {


Vector ciudades = new Vector();// nos permite acceder a cada uno de

los objetos en el orden q deseemos y los presenta en forma aleatoria






ciudades.add(1, "Loja");


13

for (int i = ciudades.size() - 1; i >= 0; i--) {//accede a los

elementos y los presenta desde el ultimo hacia el primero posicion

System.out.println("Ciudad: " + i + "es: " +

ciudades.get(i));// mediante el next va acceder a los objetos q se han

guardado en la lista

}

}

}

2.1.1.2.2 Map import java.util.*;

public class TestHashMap {

public static void main(String [] args){

HashMap codigos = new HashMap();

codigos.put("01","urgente");

codigos.put("02", "importante");

codigos.put("03", "normal");

codigos.put("04", "baja prioridad");

System.out.println("Aleatorio 01: "+ codigos.get("04"));


Set s = codigos.keySet();

Iterator it = s.iterator();

while(it.hasNext()){

String aux = (String)it.next();

System.out.println(aux+":"+codigos.get(aux));

}

}

}

import java.util.*;

14

/**

*


*/

public class TestHashTable {


Hashtable codigos = new Hashtable();












}

}

}

import java.util.*;

/**

*


*/

public class TestLinkedHashMap {


15

LinkedHashMap codigos = new LinkedHashMap();












}

}

}

import java.util.*;

/**

*


*/

public class TestTreeMap {


TreeMap codigos = new TreeMap();





16








}

}

}

2.1.1.2.3 Set import java.util.*;

public class TestHashSet {


HashSet ciudades = new HashSet();// es para crear una lista en la

que no tenga importancia el orden retorna los elementos en forma aleatoria






ciudades.add("Loja");

ciudades.add("Machala");




System.out.println("Ciudad: "+it.next());// mediante el next va

acceder a los objetos q se han guardado en la lista

17

}

}

}

import java.util.*;

/**

*


*/

public class TestLinkHashSet {


LinkedHashSet ciudades = new LinkedHashSet();// nos permite acceder

a cada uno de los objetos en el orden q deseemos













}

}

}


import java.util.TreeSet;

/**

18

*


*/

public class TestTreeSet {


TreeSet ciudades = new TreeSet();// nos permite acceder a cada uno

de los objetos en el orden q deseemos pero los presenta en orden alfabético













}

}

}

2.1.1.2.4 Archivador import java.util.*;

public class Archivador {

private ArrayList pacientes = new ArrayList();

public void guardar(Fichas ficha) {

pacientes.add(ficha);

}

19

public void eliminar(Fichas ficha) {

pacientes.remove(ficha);

}

public void listar() {

System.out.println("Numero de fichas de pacientes: " +

pacientes.size());

Iterator iterator = pacientes.iterator();

while (iterator.hasNext()) {

System.out.println((Fichas) iterator.next());

}

}

}

public class Fichas {

private String nombre = "";

private String apellido = "";

private int edad = 0;

public Fichas(String nombre, String apellido, int edad) {

this.nombre = nombre;

this.apellido = apellido;

this.edad = edad;

}

public String getNombre() {

return nombre;

}

public void setNombre(String nombre) {

this.nombre = nombre;

}

20

public String getApellido() {

return apellido;

}

public void setApellido(String apellido) {

this.apellido = apellido;

}

public int getEdad() {

return edad;

}

public void setEdad(int edad) {

this.edad = edad;

}

public String toString() {

return "Nombre: " + nombre + " Apellido: " + apellido + " Edad: " +

edad;

}

}

public class testArchivador {


Archivador archivar = new Archivador();

Fichas fichas = new Fichas("Marthita","Rojas",22);

archivar.guardar(fichas);

archivar.listar();

fichas.toString();

}

}

21

2.1.2 AWT.


2.1.2.1.1 El paquete AWT.

Es una librería de clases Java para el desarrollo de interfaces de usuario gráficas

(GUI). Por tratarse de código Java, las aplicaciones serán independientes de plataforma.

No así su apariencia visual. Es la librería básica. Sobre ella se construyó a posteriori otra

más flexible y potente: JFC/Swing. La AWT se encuentra en el paquete: java.awt.*

Dispone de la mayoría de controles visuales estándar: Button, Canvas, Frame,

Dialog, Label, List, Choice, ScrollBar, ScrollPane, TextField, TextArea, Menu.

2.1.2.1.2 Elementos.

Los elementos básicos que componen esta librería son:

Los componentes (java.awt.Component) como Buttons, Labels, TextFields, etc…

Los contenedores (java.awt.Container) como los Frames, los Panels, etc… que

pueden contener componentes.

Los gestores de posición (java.awt.LayoutManager) que gestionan la disposición de

los componentes dentro de los contenedores.

Los eventos (java.awt.AWTEvent) que avisan de las acciones del usuario.

2.1.2.1.3 Jerarquía de Clases.

22

2.1.2.1.4 Clases.

2.1.2.1.4.1 java.awt.Component

Se trata de una clase abstracta que implementa toda la funcionalidad básica de las

clases visuales, disponiendo de métodos para mostrar y esconder, habilitar, deshabilitar

y atributos como el color del foreground y background, tamaño y posición.

2.1.2.1.4.2 java.awt.Container

Se trata de una clase que implementa la funcionalidad de contener a otros

componentes: Window, Dialog, FileDialog, Frame, Panel.

2.1.2.1.4.3 java.awt.LayoutManager

Los contenedores sirven para agrupar componentes visuales. Pero, ¿cómo se

distribuyen dichos componentes en su interior? Para ello, se utilizan implementaciones

del interface java.awt.LayoutManager.

Cada contenedor tiene asociado un LayoutManager que distribuye los

componentes en el interior del contenedor. Por ejemplo, un Panel tiene asociado por

defecto una instancia de java.awt.FlowLayout.

23

2.1.2.1.5 Coordenadas y Posicionamiento.

La posición de los componentes visuales es relativa al contenedor en el que se

encuentra. La coordenada 0,0 es la esquina superior izquierda del contenedor. La clase

java.awt.Component implementa varios métodos para la gestión del tamaño y

posicionamiento como por ejemplo:

Rectangle getBounds( ); Dimension getSize( ); void setLocation(int x, int y);

void setSize(Dimension d); Point getLocation( ); Container getParent( );

void setBounds(int x, int y, int width, int height);

La clase java.awt.Container posee varios métodos para acceder a los componentes

que contienen como por ejemplo:

add(Component c) Inserta el componente c en el contenedor que utiliza el método.

remove(Component c) Elimina el componente c en el contenedor que utiliza el método.

Component[] getComponents( ) Devuelve un array con los componentes del contenedor

2.1.2.1.6 Pasos a seguir:

Crear el componente Button b=new Button( );

Añadir el componente al contenedor unContenedor.add(b);

Invocar métodos sobre el componente y manejar sus eventos. b.setText(“Ok”);

2.1.2.1.7 Layout Managers.

Todos los contenedores AWT tienen asociado un LayoutManager para coordinar el

tamaño y la situación de sus componentes (Panel->FlowLayout, Frame->BorderLayout).

Cada Layout se caracteriza por el estilo que emplea para situar los componentes en

su interior: Alineación de izquierda a derecha, Alineación en rejilla, Alineación del frente

a atrás.

2.1.2.1.7.1 ¿Por qué usar Layout Managers?

Determinan el tamaño y la posición de los componentes en un contenedor. Tiene

un API que permite al contenedor y al LayoutManager gestionar el cambio de tamaño de

contenedor de manera transparente. Consiguen que la aplicación sea independiente de

la resolución de las máquinas donde se ejecuta. Implementan el interface

java.awt.LayoutManager.

24

FlowLayout: sitúa los componentes de izquierda a derecha. Les modifica la

posición pero no les modifica el tamaño.

BorderLayout: se basa en los puntos cardinales. Modifica tanto la posición como

el tamaño de los componentes.

CardLayout: permite al desarrollador intercambiar distintas vistas como si se

tratase de una baraja. Modifica tanto la posición como el tamaño de los

componentes.

GridLayout: usa una matriz en la que sitúa cada uno de los componentes. El

tamaño de todas las celdas es igual.

GridBagLayout: similar al anterior, pero no fuerza a que todos los componentes

tengan el mismo tamaño.

2.1.2.1.8 Eventos.

Un evento es una encapsulación de una información que puede ser enviada a la

aplicación de manera asíncrona. Pueden corresponder a acciones físicas (ratón y

teclado) y a acciones lógicas. java.util.EventObject es la clase padre de todos los

eventos. Su subclase java.awt.AWTEvent es la clase padre de todos los eventos AWT.

Los eventos contienen un id (int que describe el tipo de evento). También contiene

información sobre el origen del evento (getSource( );).

El manejo de eventos se consigue mediante el uso de interfaces definidos en el

paquete java.awt.event: ActionListener, WindowListener, KeyListener, MouseListener,…

2.1.2.1.8.1 Tipos de eventos:

2.1.2.1.8.1.1 Físicos:

ComponentEvent: Esconder, mover, redimensionar, mostrar.

ContainerEvent: Añadir o eliminar un componente.

FocusEvent: Obtener o perder foco.

KeyEvent: Pulsar, liberar o teclear una tecla.

MouseEvent: Entrar, salir, pulsar, soltar, clicar.

2.1.2.1.8.1.2 Semánticos:

ActionEvent: Una acción se ha ejecutado.

25

AdjustmentEvent: Un valor se ha ajustado.

ItemEvent: Un estado ha cambiado.

TextEvent: Un texto ha cambiado.

27

2.1.2.1.9 Adapters.

Son clases que tienen definidos todos los métodos de un interface concreto.

La implementación de dichos métodos está vacía.

Heredando de un Adapter, y sobrescribiendo los métodos necesarios

conseguimos el mismo interface.

Problema: en Java no existe la herencia múltiple, por ello se suelen usar con las

Clases Anónimas.

28

2.1.2.2 Ejemplos.

2.1.2.2.1 Button.

package AWT;

import java.awt.*;

/**

*

* @author MARTHA

*/

public class ButtonTest {


Frame f = new Frame();//instanciando un objeto de la clase

formulario awt

f.setTitle("Button Test");//setTitle nos permite añadir un titulo

al formulario

f.setSize(200, 150);//setSIze es para colocar el tamaño del

formulario tanto largo como ancho

f.setLayout(new FlowLayout());//setLayout es para defirnir el tipo

de contenedor

Button button = new Button("OK");//instanciamiento de un objeto de

la clase boton awt

f.add(button);//add nos permite añadir compnentes al formulario en

este caso un boton

f.setVisible(true);//setVisible es para poder visualizar el

formulario

}

}

2.1.2.2.2 CheckBox import java.awt.*;

29

/**

*


*/

public class CheckBoxTest {


Frame frame = new Frame();//instanciando un objeto de la clase

formulario awt

frame.setTitle("CheckBoxTest");//setTitle nos permite añadir un

titulo al formulario

frame.setSize(200, 150);//setSIze es para colocar el tamaño del


frame.setLayout(new FlowLayout());//setLayout es para defirnir el

tipo de contenedor

Checkbox cb = new Checkbox("Mayor de 18 años");//instanciando un

objeto de la clase checkbox awt

//y en () se coloca

el titulo

frame.add(cb);//add nos permite añadir compnentes al formulario

frame.setVisible(true);//setVisible es para poder visualizar el

formulario

}

}

2.1.2.2.3 CheckBoxGroup import java.awt.*;

/**

*


*/

30

public class CheckboxGroupTest {

public static void main(String []args){


formulario awt

frame.setTitle("CheckboxGroupTest");//setTitle nos permite añadir

un titulo al formulario




tipo de contenedor

CheckboxGroup cbg = new CheckboxGroup();

Checkbox cb1 = new Checkbox("Hombre",cbg,true);//instanciando un


//y en () se coloca

el titulo

//cbg es el objeto

del checkboxgroyp,

//true para mostrar

seleccionado el cb

Checkbox cb2 = new Checkbox("Mujer",cbg,false);//instanciando un


//y en () se coloca

el titulo

//cbg es el objeto

del checkboxgroyp,

//false para no

mostrar seleccionado el cbo

frame.add(cb1);//add nos permite añadir compnentes al formulario

frame.add(cb2);//add nos permite añadir compnentes al formulario


formulario

}

}

31

2.1.2.2.4 Choise import java.awt.*;

/**

*


*/

public class ChoiseTest {



formulario awt

frame.setTitle("ChoiseTest");//setTitle nos permite añadir un


frame.setSize(200,150);//setSIze es para colocar el tamaño del



tipo de contenedor

Choice ch = new Choice();//instanciando un objeto de la clase

choise awt

ch.add("Rojo");//add nos permite añadir compnentes a la lista

choice

ch.add("Amarillo");//add nos permite añadir compnentes a la lista

choice

ch.add("Blanco");//add nos permite añadir compnentes a la lista

choice

frame.add(ch);//add nos permite añadir compnentes al formulario


formulario

}

}

32

2.1.2.2.5 Frame import java.awt.Frame;

/**

*

* @author MARTHA

*/

public class FrameTest {



formulario awt

f.setTitle("Frame Test");//setTitle nos permite añadir un titulo al

formulario




formulario

}

}

2.1.2.2.6 Label import java.awt.*;

/**

*


*/

public class LabelTest {

public static void main(String []args){

33


formulario awt

frame.setTitle("LabelTest");//setTitle nos permite añadir un titulo

al formulario




tipo de contenedor

Label lbl1 = new Label("Una etiqueta");//instanciando un objeto de

la clase formulario awt

//en () se coloca el título

del label

Label lbl2 = new Label();//instanciando un objeto de la clase

formulario awt

lbl2.setText("Otra Etiqueta");//setText nos permite colocar el

título del label

frame.add(lbl1);//add nos permite añadir compnentes al formulario

frame.add(lbl2);//add nos permite añadir compnentes al formulario


formulario

}

}

2.1.2.2.7 List import java.awt.*;

/**

*


*/

34

public class ListTest {

public static void main (String [] args){


formulario awt

frame.setTitle("ListTest");//setTitle nos permite añadir un titulo al

formulario



frame.setLayout(new FlowLayout());//setLayout es para defirnir el tipo

de contenedor

List l = new List();//instanciando un objeto de la clase list awt

l.add("Primero");//add nos permite añadir compnentes a la lista

l.add("Segundo");//add nos permite añadir compnentes a la lista

l.add("Tercero");//add nos permite añadir compnentes a la lista

l.add("Cuarto");//add nos permite añadir compnentes a la lista

frame.add(l);//add nos permite añadir compnentes al formulario


formulario

}

}

2.1.2.2.8 Panel import java.awt.*;

/**

*


*/

35

public class EjemploAWT {



formulario awt

frame.setLayout(null);//setLayout es para defirnir el tipo de

contenedor

frame.setBounds(0, 0, 400, 300);//setBounds es para colocar el

tamaño de un componente

frame.setTitle("Ejemplo AWT");//setTitle nos permite añadir un


Panel panel = new Panel();//instanciando un objeto de la clase

panel awt

panel.setLayout(null);//setLayout es para defirnir el tipo de

contenedor

panel.setBounds(50, 40, 250, 220);//setBounds es para colocar el


panel.setBackground(Color.PINK);

Button boton = new Button();//instanciando un objeto de la clase

button awt

boton.setBounds(100, 80, 100, 20);//setBounds es para colocar el


panel.add(boton);//add nos permite añadir compnentes al panel

frame.add(panel);//add nos permite añadir compnentes al formulario


formulario

}

}

36

2.1.2.2.9 Scrollbar import java.awt.*;

import javax.swing.plaf.ScrollBarUI;

/**

*


*/

public class ScrollbarTest {



formulario awt

frame.setTitle("Scrollbar Test");//setTitle nos permite añadir un





tipo de contenedor

Scrollbar sb = new Scrollbar(Scrollbar.HORIZONTAL,0,5,-100,300);

frame.add(sb);//add nos permite añadir compnentes al formulario


formulario

}

}

37

2.1.2.2.10 TextField import java.awt.*;

public class TextFieldText {



formulario awt

f.setTitle("TextField Test");//setTitle nos permite añadir un




f.setLayout(new FlowLayout());//setLayout es para defirnir el tipo

de contenedor

TextField txt = new TextField("Escribe aqui...");//instanciando un

objeto de la clase textfield awt

//en () se coloca

el título del textfield

f.add(txt);//add nos permite añadir compnentes al formulario


formulario

}

}

38

2.1.3 Swing.


2.1.3.1.1 El paquete Swing.

Hereda de la clase java.awt.Container. Se trata de una clase abstracta que

implementa toda la funcionalidad básica de las clases visuales: Ayudas emergentes,

bordes, gestión del Look & Feel, gestión de la accesibilidad, gestión de teclas asociadas,

soporte de Drag & Drop.

2.1.3.1.2 Migrando de AWT a Swing

Se eliminan todos los import de paquetes java.awt.*. Se importa el paquete

javax.swing.*. Se cambia cada componente AWT por el Swing más parecido.

Frame->JFrame, Button->JButton

NOTA: No se pueden añadir componentes o establecer LayoutManagers

directamente sobre JWindow, JFrame, JDialog o JApplet. Esto hay que hacerlo sobre el

Container que devuelve el método: public Container getContentPane( ).

2.1.3.1.3 Layout Managers

Todos los contenedores Swing tienen asociado un LayoutManager para coordinar el

tamaño y la situación de sus componentes. JPanel->FlowLayout, JFrame->BorderLayout.

Cada Layout se caracteriza por el estilo que emplea para situar los componentes en su

interior:

Alineación de izquierda a derecha.

Alineación en rejilla.

Alineación del frente a atrás.

BoxLayout: sitúa los componentes en línea vertical u horizontal, respetando sus

tamaños. La clase javax.swing.Box tiene métodos para crear zonas con espacio

como createVerticalStrut(int) y zonas que absorban los espacios como

createVerticalGlue(int).

SpringLayout: permite definir la relación (distancia) entre los límites de los

distintos controles.

39

ScrollPaneLayout, ViewportLayout: utilizados internamente por Swing para

algunos de los componentes como el ScrollPane.

40

2.1.3.2 Ejemplo. import java.awt.Button;

import java.awt.event.ActionEvent;

import java.awt.event.ActionListener;

/**

*

* @author MARTHA

*/

public class ActionListenerTest implements ActionListener {

public void actionPerformed(ActionEvent ev) {

if (((Button) ev.getSource()).getLabel().equals("Aceptar")) {

System.out.println("Has pulsado Aceptar");

} else {

System.out.println("Has pulsado Cancelar");

}

}

}

import java.awt.BorderLayout;

import java.awt.Button;

import java.awt.FlowLayout;

import java.awt.Frame;

/**

*

* @author MARTHA

*/

public class BorderLayoutTest {


41

Frame f = new Frame();

f.setTitle("FlowLayout Test");

f.setSize(200, 150);

f.setLayout(new BorderLayout());

Button b1 = new Button("Button 1 (Norte)");

f.add(b1, BorderLayout.NORTH);

Button b2 = new Button("Button 2 (Este)");

f.add(b2, BorderLayout.WEST);

Button b3 = new Button("Button 3 (centro)");

f.add(b3, BorderLayout.CENTER);

Button b4 = new Button("Button 4 (este)");

f.add(b4, BorderLayout.EAST);

Button b5 = new Button("Button 5 (sur)");

f.add(b5, BorderLayout.SOUTH);

f.setVisible(true);

}

}






/**

*

* @author MARTHA

*/

public class ButtonEventTest {



42

f.setTitle("Button Event Test");


f.setLayout(new FlowLayout());

Button b1 = new Button("Aceptar");

b1.addActionListener(new ActionListenerTest());

f.add(b1);

Button b2 = new Button("Cancelar");

b2.addActionListener(new ActionListenerTest());

f.add(b2);

f.setVisible(true);

}

}


import java.awt.CardLayout;



/**

*

* @author MARTHA

*/

public class CardLayoutTest {



f.setTitle("CardLayout Test");


CardLayout cl = new CardLayout();

f.setLayout(cl);

Button b1 = new Button("Button 1");

43

f.add(b1, "uno");


f.add(b2, "dos");


f.add(b3, "tres");

f.setVisible(true);

cl.show(f, "dos");

}

}


import java.awt.Cursor;



import java.awt.event.MouseAdapter;

import java.awt.event.MouseEvent;

/**

*

* @author MARTHA

*/

public class CursorTest {

Frame f = null;


new CursorTest();

}

public CursorTest() {

f = new Frame();

f.setTitle("CursorTest");

44



Button b1 = new Button("Aceptar");

b1.addMouseListener(new MouseAdapter() {

public void mouseEntered(MouseEvent ev) {

f.setCursor(Cursor.HAND_CURSOR);

}

public void mouseExited(MouseEvent ev) {

f.setCursor(Cursor.DEFAULT_CURSOR);

}

});

f.add(b1);

f.setVisible(true);

}

}

import java.awt.*;

/**

*

* @author MARTHA

*/

public class DialogTest {



f.setTitle("Dialog Test");


f.setVisible(true);

Dialog d = new Dialog(f);

45

d.setTitle("Dialog Test");

d.setBounds(50, 50, 70, 50);

d.setVisible(true);

}

}

import java.awt.*;

public class FileDialogTest {



f.setTitle("Dialog Test");


f.setVisible(true);

FileDialog d = new FileDialog(f);

d.setTitle("FileDialog Test");

d.setBounds(50, 50, 70, 50);

d.setVisible(true);

System.out.println(d.getFile());

}

}

import java.awt.*;

/**

*

* @author MARTHA

*/

public class FlowLAyoutTest {

46



f.setTitle("FlowLayout Test");




f.add(b1);


f.add(b2);


f.add(b3);

f.setVisible(true);

}

}



import java.awt.Font;


import java.awt.Label;

import javax.swing.JLabel;

/**

*

* @author MARTHA

*/

public class FontTest {



f.setTitle("Font Test");


47


Label l1 = new Label("Marthita");

l1.setFont(new Font("Marthita",Font.BOLD,20));

Label l2 = new Label("Carolina");

l2.setFont(new Font("Carolina",Font.BOLD,20));

Label l3 = new Label("David");

l3.setFont(new Font("David",Font.PLAIN,20));

Label l4 = new Label("Marianela");

l4.setFont(new Font("Marianela",Font.BOLD,20));

Label l5 = new Label("Danilo");

l5.setFont(new Font("Danilo",Font.PLAIN,20));

f.add(l1); f.add(l2);f.add(l3);f.add(l4);f.add(l5);

f.setVisible(true);

}

}

import java.awt.Color;

import java.awt.Font;


import java.awt.Graphics;

/**

*

* @author MARTHA

*/

public class GraphicsTest extends Frame {


new GraphicsTest().setVisible(true);

}

public GraphicsTest() {

48

this.setTitle("Graphics Test");

this.setBackground(Color.LIGHT_GRAY);

this.setSize(300, 150);

}

public void paint(Graphics g) {

g.setColor(Color.LIGHT_GRAY);

g.draw3DRect(10, 30, this.getWidth() - 20, this.getWidth() - 40,

true);

g.setColor(Color.BLACK);

g.drawLine(15, 35, 65, 65);

g.drawRect(70, 35, 50, 30);

g.drawRoundRect(125, 35, 50, 30, 10, 10);

g.drawOval(180, 35, 50, 30);

g.drawArc(235, 35, 50, 30, 25, 200);

int[] x = {15, 65, 15, 65};

int[] y = {90, 90, 120, 120};

g.drawPolygon(x, y, x.length);

g.setColor(Color.red);

g.fillRect(70, 90, 50, 30);

g.fillRoundRect(125, 90, 50, 30, 10, 10);

g.fillOval(180, 90, 50, 30);

g.fillArc(235, 90, 50, 30, 25, 200);

g.setColor(Color.BLACK);

g.setFont(new Font("Marthita", Font.ITALIC, 9));

g.drawString("Linea", 30, 80);

g.drawString("Rectangulo", 90, 80);

g.drawString("Ovalo", 192, 80);

g.drawString("Arco", 250, 80);

g.drawString("Poligono", 22, 135);

g.drawString("Rectangulos", 95, 135);

g.drawString("Ovalo", 192, 135);

49

g.drawString("Arco", 250, 135);

}

}



import java.awt.GridLayout;

/**

*

* @author MARTHA

*/

public class GridLayoutTest {



f.setTitle("GridLayout Test");


f.setLayout(new GridLayout(2, 3, 2, 2));

f.add(new Button("Boton 1"));





f.setVisible(true);

}

}


import javax.swing.JColorChooser;

import javax.swing.JFileChooser;

import javax.swing.JFrame;

50

/**

*

* @author MARTHA

*/

public class JColorChooserTest {


JFrame f = new JFrame();

f.setTitle("JColorChooser Test");


f.setVisible(true);

JFileChooser fc = new JFileChooser();

int op = fc.showOpenDialog(fc);

if (op == JFileChooser.APPROVE_OPTION) {

System.out.println(fc.getSelectedFile());

}

}

}


import javax.swing.JComboBox;


/**

*

* @author MARTHA

*/

public class JComboBoxTest {


51


f.setTitle("JComboBox Test");


f.getContentPane().setLayout(new FlowLayout());

String[] lista= {"Martha","Carolina","Marianela"};

JComboBox jcb = new JComboBox(lista);

f.getContentPane().add(jcb);

f.setVisible(true);

}

}


import javax.swing.JColorChooser;


/**

*

* @author MARTHA

*/

public class JFileChooserTest {



f.setTitle("JFileChooser Test");


f.setVisible(true);

Color c = JColorChooser.showDialog(f, "Seleccione un color",

Color.RED);

System.out.println("El color seleccionado es: " + c);

}

}

52


/**

*

* @author MARTHA

*/

public class JFrameTest {



f.setTitle("JFrame Test");


f.setVisible(true);

}

}


import javax.swing.JInternalFrame;

/**

*

* @author MARTHA

*/

public class JInternalFrameTest {



f.setTitle("JInternalFrame Test");


f.getContentPane().setLayout(null);

JInternalFrame f1 = new JInternalFrame("Internal Frame 1");

f1.setBounds(10, 10, 150, 100);

53

f1.setVisible(true);

JInternalFrame f2 = new JInternalFrame("Internal Frame 2");

f2.setBounds(50, 50, 150, 100);

f2.setVisible(true);

f.getContentPane().add(f1);

f.getContentPane().add(f2);

f.setVisible(true);

}

}



import javax.swing.JList;

/**

*

* @author MARTHA

*/

public class JListTest {



f.setTitle("JList Test");



String[] lista = {"Martha", "Carolina", "Marianela", "Steve"};

JList jl = new JList(lista);

f.getContentPane().add(jl);

f.setVisible(true);

}

}

import javax.swing.JCheckBoxMenuItem;

54


import javax.swing.JMenu;

import javax.swing.JMenuBar;

import javax.swing.JMenuItem;

/**

*

* @author MARTHA

*/

public class JMenuBarTest {



f.setTitle("JMenuBar Test");


JMenuBar jmb = new JMenuBar();

JMenu m1 = new JMenu("Menu 1");

m1.add(new JMenuItem("Opcion 1"));

m1.add(new JMenuItem("Opcion 2"));

JMenu m2 = new JMenu("Menu 2");

m2.add(new JCheckBoxMenuItem("Opcion 1"));

m2.add(new JCheckBoxMenuItem("Opcion 2", true));

m2.addSeparator();

m2.add(new JCheckBoxMenuItem("Opcion 3", true));

jmb.add(m1);

jmb.add(m2);

f.setJMenuBar(jmb);

f.setVisible(true);

}

}


55


import javax.swing.JPasswordField;

/**

*

* @author MARTHA

*/

public class JPasswordFieldTest {



f.setTitle("JPasswordField Test");



JPasswordField pf = new JPasswordField("Marthita");

f.getContentPane().add(pf);

f.setVisible(true);

}

}


import javax.swing.ButtonGroup;


import javax.swing.JRadioButton;

/**

*

* @author MARTHA

*/

public class JRadioButtonTest {


56


f.setTitle("Test");



ButtonGroup bg = new ButtonGroup();

JRadioButton b1 = new JRadioButton("Hombre", true);

bg.add(b1);

JRadioButton b2 = new JRadioButton("Mujer", false);

bg.add(b2);

f.getContentPane().add(b1);


f.setVisible(true);

}

}



import javax.swing.JSpinner;

import javax.swing.SpinnerListModel;

/**

*

* @author MARTHA

*/

public class JSpinnerTest {



f.setTitle("JSpinner Test");



String[] alumnos = {"Martha", "Carolina", "Marianela", "Steve"};

57

SpinnerListModel modelo = new SpinnerListModel(alumnos);

JSpinner js = new JSpinner(modelo);

f.getContentPane().add(js);

f.setVisible(true);

}



import javax.swing.JTextArea;

/**

*

* @author MARTHA

*/

public class JTextAreaTest {



f.setTitle("JText Area");



JTextArea txta = new JTextArea("Escribe aqui...", 5, 15);

f.getContentPane().add(txta);

f.setVisible(true);

}

}


import javax.swing.ButtonGroup;


import javax.swing.JToggleButton;

/**

*

58

* @author MARTHA

*/

public class JToggleButtonTest {



f.setTitle("JToggleButton");



ButtonGroup bg = new ButtonGroup();

JToggleButton b1 = new JToggleButton("Hombre", true);

bg.add(b1);

JToggleButton b2 = new JToggleButton("Hombre", true);

bg.add(b2);



f.setVisible(true);

}

}

import java.awt.*;

public class MenuTest {



f.setTitle("Menu Test");

MenuBar mb = new MenuBar();

Menu m = new Menu("Menu 1");

m.add(new MenuItem("opcion 1"));

m.add(new MenuItem("opcion 2"));

Menu m2 = new Menu("Menu 2");

m2.add(new CheckboxMenuItem("opcion 1", true));

59

m2.add(new CheckboxMenuItem("opcion 2"));

mb.add(m);

mb.add(m2);

f.setMenuBar(mb);


f.setVisible(true);

}

}




/**

*

* @author MARTHA

*/

public class NullLayoutTest {



f.setTitle("NullLayout Test");


f.setLayout(null);


b1.setBounds(50, 25, 100, 25);

f.add(b1);


b2.setBounds(125, 85, 100, 50);

f.add(b2);

f.setVisible(true);

}

60

}


import javax.swing.JButton;


/**

*

* @author MARTHA

*/

public class Test {



f.setTitle("Test");



JButton b1 = new JButton("Ok");


f.setVisible(true);

}

}

import java.awt.*;

/**

*

* @author MARTHA

*/

public class TextAreaTest {



61

f.setTitle("Text Area");



TextArea txta = new TextArea("Escribe aqui...", 5, 15);

f.add(txta);

f.setVisible(true);

}

}

import java.awt.*;

/**

*

* @author MARTHA

*/

public class WindowEventTest1 {



f.setTitle("Frame Test");


f.addWindowListener(new WindowListenerTest());

f.setVisible(true);

}

}


import java.awt.event.WindowAdapter;

import java.awt.event.WindowEvent;

import java.awt.event.WindowListener;

/**

62

*

* @author MARTHA

*/

public class WindowEventTest2 extends WindowAdapter {


WindowEventTest2 we = new WindowEventTest2();

}

public WindowEventTest2() {




f.addWindowListener(this);

f.setVisible(true);

}

public void windowActived(WindowEvent ev) {

}

public void windowClosed(WindowEvent ev) {

}

public void windowClosing(WindowEvent ev) {

System.exit(0);

}

public void windowDeactived(WindowEvent ev) {

}

public void windowDeiconified(WindowEvent ev) {

63

}

public void windowIconified(WindowEvent ev) {

}

}




/**

*

* @author MARTHA

*/

public class WindowEventTest3 {


WindowEventTest3 we = new WindowEventTest3();

}

public WindowEventTest3() {




f.addWindowListener(new WindowAdapter() {


System.exit(0);

}

});

f.setVisible(true);

}

}

64


import java.awt.event.*;

/** @author MARTHA

*/

public class WindowListenerTest extends WindowAdapter{


System.exit(0);

}

}

65

2.1.4 Applet.


2.1.4.1.1 Concepto.

Un applet Java es un applet escrito en el lenguaje de programación Java. Los

applets de Java pueden ejecutarse en un navegador web utilizando la Java Virtual

Machine (JVM), o en el AppletViewer de Sun.

Entre sus características podemos mencionar un esquema de seguridad que

permite que los applets que se ejecutan en el equipo no tengan acceso a partes sensibles

(por ej. no pueden escribir archivos), a menos que uno mismo le dé los permisos

necesarios en el sistema; la desventaja de este enfoque es que la entrega de permisos es

engorrosa para el usuario común, lo cual juega en contra de uno de los objetivos de los

Java applets: proporcionar una forma fácil de ejecutar aplicaciones desde el navegador

web.

En Java, un applet es un programa que puede incrustarse en un documento HTML,

es decir en una página web. Cuando un navegador carga una página web que contiene un

applet, este se descarga en el navegador web y comienza a ejecutarse. Esto permite crear

programas que cualquier usuario puede ejecutar con tan solo cargar la página web en su

navegador.

2.1.4.1.2 Atributos

Atributo Descripción Ejemplo

codebase

Dirección desde donde se

puede descargar la clase de

Java que va a cargar el applet, el

URL de la clase. Si no se

especifica, será la ubicación

actual de la página HTML.

codebase="http://www.pagina.com/applet/"

code

Nombre de la clase que se

quiere cargar en el applet. La

dirección donde se encuentra

es relativa al codebase. Si no se

ha especificado codebase, es la

code="NombreClase.class"

http://es.wikipedia.org/wiki/Applet

http://es.wikipedia.org/wiki/Lenguaje_de_programaci%C3%B3n

http://es.wikipedia.org/wiki/Java_%28lenguaje_de_programaci%C3%B3n%29

http://es.wikipedia.org/wiki/Navegador_web

http://es.wikipedia.org/wiki/Java_Virtual_Machine

http://es.wikipedia.org/wiki/Java_Virtual_Machine

http://es.wikipedia.org/w/index.php?title=AppletViewer&action=edit&redlink=1

http://es.wikipedia.org/wiki/Sun_Microsystems

http://es.wikipedia.org/wiki/Applet

http://es.wikipedia.org/wiki/Hypertext_Markup_Language

http://es.wikipedia.org/wiki/P%C3%A1gina_web

66

misma carpeta donde está la

página HTML que carga el

applet.

width Tamaño en píxels de la

anchura. width=100

height Tamaño en píxels de la altura. height=100

alt

Texto que se muestra donde

debería cargarse el applet si el

navegador no permite su carga.

alt="Su navegador no permite cargar este

Applet"

name Establece un nombré único

para el applet. name="MiApplet"

archive

Es un listado de clases

separados por comas que

deben ser cargados en la caché

del usuario local antes de poder

ejecutarse.

archive="Clase1.class, Clase2.class,

Clase3.class"

hspace Establece los márgenes

laterales en píxels. hspace=25

vspace Establece el margen superior e

inferior en píxels. vspace=25

align

Alineación respecto a otros

elementos.

Valores: left, center, rigth, top,

middle y botton

align="center"

mayscript

Permite especificar si el applet

puede tener acceso al código

JavaScript

No tiene valor asociado. Si aparece se aplica.

Dentro de la etiqueta <applet> puede aparecer la etiqueta <param> que contiene

pares clave/valor, que son leídos por el programa Java, tantas veces como se quiera.

2.1.4.1.3 Etiqueta <object>

A partir de la versión 4.0 de HTML se consideró obsoleto el uso de la etiqueta

<applet>, siendo sustituida por <object>.

http://es.wikipedia.org/wiki/HTML

67

Esta etiqueta es compatible con los navegadores Microsoft Internet Explorer,

Netscape 6 (y versiones superiores) y Mozilla Firefox.

Comparte muchos de los atributos con <applet>, siendo los únicos para esta

etiqueta:

Atributo Descripción Ejemplo

classid Identificador del tipo de objeto. Para Java es: classid="clsid:CAFEEFAC-0014-0001-

0000-ABCDEFFEDCBA"

codebase

URL que apunta a un fichero .cab

en la red del plugin necesario

para poder ejecutar el contenido.

codebase="Dirección_del_instalador_de_la_Máquin

a_Virtual_Java"

type Tipo de archivo que va a

reproducirse mediante el objeto.

<param name="type" value="application/x-java-

applet;jpi-version=1.5.0">

2.1.4.1.4 Ciclo de vida

Cuando un applet se inicia, se llaman en este orden a los siguientes métodos:

init: suele contener instrucciones para inicializar el applet.

start: como init, se suele usar para inicializar, pero con la diferencia de que este

método también se llama cuando se reinicia un applet.

http://es.wikipedia.org/wiki/Microsoft_Internet_Explorer

http://es.wikipedia.org/wiki/Netscape_Navigator

http://es.wikipedia.org/wiki/Mozilla_Firefox

68

paint: se encarga de mostrar el contenido del applet. Se ejecuta cada vez que se

tenga que redibujar.

Para terminar o pausar la ejecución se llama a los siguientes métodos:

stop: suspende la ejecución del programa. Se llama cuando el applet se vuelve

temporalmente invisible.

destroy: cuando no se va a necesitar más el applet. Se usa para liberar recursos.

69

2.1.4.2 Ejemplo.

2.1.4.2.1 Hola mundo

import javax.swing.*;

/**

*

* @author MARTHA

*/

public class HelloWorld2 extends JApplet{

public void init(){

JLabel l = new JLabel("Hola Mundo!");

this.getContentPane().add(l);

}

}

2.1.4.2.2 Convertidor de Monedas public class Constantes {

public static final String AUDIO ="";

public static final String AYUDA ="";

}

70

import com.sun.xml.internal.messaging.saaj.soap.JpegDataContentHandler;

import java.applet.AudioClip;

import java.awt.BorderLayout;


import java.awt.MenuItem;



import javax.swing.JApplet;


import javax.swing.JComponent;


import javax.swing.JMenu;

import javax.swing.JMenuBar;

import javax.swing.JMenuItem;

import javax.swing.JOptionPane;

import javax.swing.JPanel;

import javax.swing.JTextField;

import javax.swing.SwingConstants;

71

/**

*

* @author MARTHA

*/

public class ConvertidorMoneda extends JApplet implements ActionListener {

private JTextField moneda1 = null;

private JTextField moneda2 = null;

private AudioClip clip = null;

@Override

public void init() {

JMenuBar barra = new JMenuBar();

JMenu menu1 = new JMenu("Menu");

JMenuItem menuitem1 = new JMenuItem("Ayuda");

menuitem1.setMnemonic('A');

menuitem1.setName("Menu Item 1");

menuitem1.addActionListener(this);

menu1.add(menuitem1);

barra.add(menu1);

this.setJMenuBar(barra);

this.getContentPane().setLayout(new BorderLayout());

moneda1 = new JTextField();

moneda1.setHorizontalAlignment(SwingConstants.RIGHT);

moneda2 = new JTextField();

moneda2.setHorizontalAlignment(SwingConstants.RIGHT);

JPanel aux = new JPanel();

aux.setLayout(new GridLayout(4, 2));

72

aux.add(new JLabel(this.getParameter("Texto1")));

aux.add(moneda1);

aux.add(new JLabel(this.getParameter("Texto2")));

aux.add(moneda2);

this.getContentPane().add(aux, BorderLayout.NORTH);

aux = new JPanel();

JButton convertir = new JButton(this.getParameter("Texto3"));

convertir.setName("convertir");

convertir.addActionListener(this);

aux.add(convertir);

JButton limpiar = new JButton(this.getParameter("Texto4"));

limpiar.setName("limpiar");

limpiar.addActionListener(this);

aux.add(limpiar);

this.getContentPane().add(aux, BorderLayout.SOUTH);

clip = this.getAudioClip(this.getDocumentBase(), "audio1");

}

@Override

public void start() {

//clip.loop();

}

@Override

public void stop() {

//clip.stop();

}

73

@Override

public void actionPerformed(ActionEvent ev){

String temp = ((JComponent)ev.getSource()).getName();

if(temp.equals("convertir")){

try{

float tmp = Float.parseFloat(moneda1.getText());

tmp*=38.5F;

moneda2.setText(Float.toString(tmp));

}

catch(NumberFormatException ex){

JOptionPane.showMessageDialog(this,"Solo puede introducir

numeros",

"Mensaje de Eror", JOptionPane.ERROR_MESSAGE);

moneda1.setText("");

}

}

else if(temp.equals("limpiar")){



}

}

}

74

2.1.5 Manejo de Excepciones.


2.1.5.1.1 Manejo de Excepciones

Cuando un programa Java viola las restricciones semánticas del lenguaje (se

produce un error), la máquina virtual Java comunica este hecho al programa mediante

una excepción. La aplicación Java no debe morir y generar un core (o un crash en caso

del DOS), al contrario, se lanza (throw) una excepción y se captura (catch) para resolver

esa situación de error.

2.1.5.1.2 Generación de Excepciones en Java

Para que se pueda lanzar una excepción es necesario crear un objeto de tipo

Exception o alguna de sus subclases como ArithmeticException y lanzarlo mediante la

instrucción throw como se muestra en el siguiente ejemplo:

class LanzaExcepcion {

public static void main(String argumentos[]) throws ArithmeticException {

int i=1, j=2;

if (i/j< 1)

throw new ArithmeticException();

else

System.out.println(i/j);

}

}

75

2.1.5.1.3 Jerarquía de Clases

2.1.5.1.4 Captura de Excepciones

Un manejador de excepciones es una porción de código que se va a encargar de

tratar las posibles excepciones que se puedan generar. En Java, de forma similar a C++ se

pueden tratar las excepciones previstas por el programador utilizando unos

mecanismos, los manejadores de excepciones, que se estructuran en tres bloques:

El bloque try

76

El bloque catch

El bloque finally (no existente en C++)

2.1.5.1.4.1 Try.

Define un bloque de código donde se puede generar una excepción. El bloque try

va seguido inmediatamente de uno o más bloques catch y opcionalmente de una cláusula

finally. Cuando se lanza una excepción el control sale del bloque try actual y pasa a un

manejador catch apropiado.

La sintaxis general del bloque try consiste en la palabra clave try y una o más

sentencias entre llaves.

try {

// Sentencias Java

}

Se pueden presentar dos situaciones diferentes a la hora de definir el bloque try:

Podemos tener más de una sentencia que generen excepciones, en cuyo caso

podemos definir bloques individuales para tratarlos.

Podemos tener agrupadas en un mismo bloque try varias sentencias que puedan

lanzar excepciones, con lo que habría que asociar múltiples controladores a ese

bloque.

2.1.5.1.4.2 Catch

Define el bloque de sentencias que se ejecutarán cuando se haya producido una

excepción en un bloque try.

La sintaxis general de la sentencia catch en Java es la siguiente:

catch( TipoExcepcion nombreVariable ) {

// sentencias Java

77

}

Se pueden colocar sentencias catch sucesivas, cada una controlando una excepción

diferente.

No debería intentarse capturar todas las excepciones con una sola cláusula ya que

representa un uso demasiado general y podrían llegar muchas excepciones.

catch( Exception e ) { … } //captura genérica

2.1.5.1.4.3 Finally

El bloque finally se utiliza para ejecutar un bloque de instrucciones sea cual sea la

excepción que se produzca. Este bloque se ejecutará en cualquier caso, incluso si no se

produce ninguna excepción. Sirve para no tener que repetir código en el bloque try y en

los bloques catch

...

try {

Bloque de Instrucciones del try

} catch (TipoExcepción nombreVariable) {

Bloque de Instrucciones del primer catch

} catch (TipoExcepción nombreVariable) {

Bloque de Instrucciones del segundo catch

} .....

}finally {

Bloque de Instrucciones de finally

2.1.5.1.5 Throw

La sentencia throw se ejecuta para indicar que ha ocurrido una excepción, o

lanzamiento de una excepción. La sentencia throw específica el objeto que se lanzará. La

forma general de la sentencia throw es:

throw ObjetoThrowable;

El flujo de la ejecución se detiene inmediatamente después de la sentencia throw, y

nunca se llega a la sentencia siguiente, ya que el control sale del bloque tr y y pasa a un

manejador catch cuyo tipo coincide con el del objeto. Si se encuentra, el control se transfiere a

esa sentencia. Si no, se inspeccionan los siguientes bloques hasta que el gestor de excepciones

más externo detiene el programa.

78

2.1.5.1.6 Tipos de excepciones

2.1.5.1.6.1 Excepciones Predefinidas

Excepciones predefinidas más comunes:

ArithmeticException: Las excepciones aritméticas son típicamente el resultado de

una división por 0:

int i = 12 / 0;

NullPointerException: Se produce cuando se intenta acceder a una variable o método

antes de ser definido.

ClassCastException: El intento de convertir un objeto a otra clase que no es válida.

y = (Prueba)x; // donde x no es de tipo Prueba

NegativeArraySizeException: Puede ocurrir si se intenta definir el tamaño de un

array con un número negativo.

ArrayIndexOutOfBoundsException: Se intenta acceder a un elemento de un array

que está fuera de sus límites.

NoClassDefFoundException: Se referenció una clase que el sistema es incapaz de

encontrar.

79

2.1.5.2 Ejemplo. import java.io.File;

import java.io.FileInputStream;

import java.io.FileNotFoundException;

import java.io.IOException;

/**

*

* @author MARTHA

*/

public class ExceptionTest {


File f = new File("d:\\test.txt");

FileInputStream fis = null;

try {

fis = new FileInputStream(f);

} catch (FileNotFoundException ex) {

System.out.println("Fichero no encontrado");

} finally {

try {

fis.close();

} catch (IOException ex) {

System.out.println("Error al cerrar el fichero");

}

}

}

}

public class MiClase {

80

public int miMetodo() throws MiException{

int num=(int)Math.rint(Math.random());

if(num==0){

throw new MiException("Salio un cero :(");

}

return num;

}

}

public class MiException extends Exception{

public MiException(String parametro){

super(parametro);

}

}

public class testException {

public static void main (String [] args){

MiClase clasetest = new MiClase();

for(int i=0; i<20; i++){

try{

System.out.println(clasetest.miMetodo());

}

catch(MiException ex){

System.out.println(ex.getMessage());

}

}

}

}

81

2.1.6 Threads.


2.1.6.1.1 Programación Multihilo.

Los threads son flujos de ejecución secuencial dentro de un proceso. Un mismo

proceso Java puede tener un único thread (monotarea) o varios threads (por ejemplo el

thread principal y otros secundarios, multitarea).

2.1.6.1.2 Clases.

Casi todas las clases referentes al manejo de threads se encuentran en el paquete

java.lang.*.

2.1.6.1.3 java.lang.Thread

Nos ofrece el API genérico de los threads así como la implementación de su

comportamiento incluyendo: arrancar, dormirse, parar, ejecutarse, esperar, gestión de

prioridades.

La lógica que va a ejecutar un thread se introduce en el método: public void run( ).

Cuando termina la ejecución del método run ( ) se termina el thread. La clase

java.lang.Thread contiene un método run( ) vacío.

2.1.6.1.4 java.lang.Runnable

Se trata de una interfaz. Simplemente fuerza la implementación de un método:

public void run( ).

2.1.6.1.5 Implementando un Thread

Existen dos técnicas:

Heredar de la clase java.lang.Thread y sobrescribir el método run( ).

Implementar el interfaz java.lang.Runnable (por tanto tenemos que implementar

el método run( )) y crear una instancia de la clase

java.lang.Thread pasándole el objeto que implementa

java.lang.Runnable como parámetro.

82

Normalmente se usará la opción de Runnable cuando la clase que va a contener la

lógica del thread ya herede de otra clase (Swing, Applets, …).

Un thread puede pasar por varios estados durante su vida: ejecutándose, pausado

o parado, muerto. Existen distintos métodos que provocan las transiciones entre estos

estados.

Para crear un thread hay que instanciarlo llamando al constructor como con el

resto de clases Java.

Dependiendo de cómo hayamos implementado el thread se actuará de una forma u

otra:

Si hereda de la clase java.lang.Thread, simplemente se instancia nuestra clase.

Si implementa el interfaz java.lang.Runnable, se instancia la clase java.lang.Thread

pasándole como parámetro del constructor una instancia de nuestra clase.

Para arrancar un thread hay que llamar al método start( ). Este método registra al

thread en el planificador de tareas del sistema y llama al método run( ) del thread.

Pueden existir distintos motivos por los que un thread puede detener

temporalmente su ejecución, o pasar a un estado de pausa. Se llama a su método sleep.

Recibe un long con el número de milisegundos de la pausa. Se llama al método

wait, y espera hasta recibir una señal (notify) o cumplirse un timeout definido por un

long con el número de milisegundos. Se realiza alguna acción de entrada/salida. Se llama

al método yield( ), que saca del procesador al thread hasta que el Sistema Operativo le

vuelva a meter.

Existen distintos motivos por los que un thread puede reanudar su ejecución:

Se consumen los milisegundos establecidos en una llamada al método sleep.

Se recibe una señal (notify) o se consumen los milisegundos en una llamada al

método wait.

Se termina alguna acción de entrada/salida.

83

2.1.6.1.6 Sincronización de threads.

Para poder bloquear un objeto e impedir que otro thread lo utilice mientras está

este, se emplea la palabra synchronized en la definición de lo s métodos susceptibles de

tener problemas de sincronización: public synchronized int getNumero( ).

Cuando un thread está ejecutando un método synchronized en un objeto, se

establece un bloqueo en dicho objeto. Cualquier otro thread que quiera ejecutar un

método marcado como synchronized en un objeto bloqueado, tendrá que esperar a que

se desbloquee. El objeto se desbloquea cuando el thread actual termina la ejecución del

método synchronized. Se creará una lista de espera y se irán ejecutando por orden de

llegada. El sistema de bloqueo/desbloqueo es algo gestionado de forma automática por

la JVM.

2.1.6.1.7 Uso de señales

Este es un sistema mediante el cual un thread puede detener su ejecución a la

espera de una señal lanzada por otro thread. Para detener la ejecución y esperar a que

otro thread nos envié una señal se utiliza el método: public void wait( ) o public void

wait(long timeout).

Para enviar una señal a los threads que están esperando en el objeto desde donde

enviamos la señal se utiliza el método: public void notify o public void notifyAll( ).

84

2.1.6.2 Ejemplo.

2.1.6.2.1 Carrera public class Carrera {


TortugaThreads tortuga = new TortugaThreads();

Thread liebre = new Thread(new LiebreThreads());

tortuga.start();

liebre.start();

}

}

public class LiebreThreads implements Runnable{

public void run(){

int i=0;

System.out.println("Comienza la libre");

while(i<5){

try{

Thread.sleep(2000);

System.out.println("liebre");

}

catch(InterruptedException ex){

}

i++;

}

System.out.println("Termina la liebre");

}

}

import sun.awt.windows.ThemeReader;

/**

85

*

* @author MARTHA

*/

public class TortugaThreads extends Thread{

public void run(){

int i=0;

System.out.println("Comienza la tortuga");

while(i<5){

try{

Thread.sleep(5000);

System.out.println("tortuga");

}


}

i++;

}

System.out.println("Termina la tortuga");

}

}

2.1.6.2.2 Cronometro import java.awt.Color;

import java.awt.Dimension;




import javax.swing.Box;

import javax.swing.BoxLayout;

import javax.swing.ImageIcon;




86

import javax.swing.border.BevelBorder;

import javax.swing.border.LineBorder;

/**

*

* @author MARTHA

*/

public class Cronometro extends JPanel implements Runnable {

private JLabel label[] = new JLabel[8];

private ImageIcon digitos[] = new ImageIcon[11];

private int horas = 0;

private int minutos = 0;

private int segundos = 0;

private boolean sw = false;

private Cronometro c = null;

public Cronometro() {

c = this;

for (int i = 0; i < 10; i++) {

digitos[i] = new ImageIcon("imagenes/" + i + ".gif");

digitos[10] = new ImageIcon("imagenes/marthita.gif");

}

this.setLayout(new BoxLayout(this, BoxLayout.Y_AXIS));

this.setBorder(new LineBorder(Color.BLACK, 2));

this.add(Box.createVerticalStrut(5));

JPanel aux = new JPanel();

aux.setMaximumSize(new Dimension(108, 23));

aux.setBorder(new BevelBorder(1));

87

aux.setLayout(new GridLayout(1, 8));

for (int i = 0; i < 8; i++) {

label[i] = new JLabel();

aux.add(label[i]);

}

this.add(aux);

aux = new JPanel();

JButton arrancar = new JButton("Arrancar/Parar");

arrancar.setMnemonic('A');

arrancar.addActionListener(new ActionListener() {

@Override

public void actionPerformed(ActionEvent e) {

if (sw) {

sw = false;

} else {

sw = true;

new Thread(c).start();

}

}

});

JButton reiniciar = new JButton("Reiniciar");

reiniciar.setMnemonic('R');

reiniciar.addActionListener(new ActionListener() {

@Override

public void actionPerformed(ActionEvent e) {

sw = false;

horas = 0;

88

minutos = 0;

segundos = 0;

mostrarHora();

}

});

aux.add(reiniciar);

this.add(aux);

this.mostrarHora();

}

public void run(){

int i=0;

// System.out.println("Comienza la libre");

while(i<5){

try{

Thread.sleep(2000);

// System.out.println("liebre");

}


}

i++;

}

// System.out.println("Termina la liebre");

}

private void mostrarHora() {

label[0].setIcon(digitos[horas/10]);

label[1].setIcon(digitos[horas%10]);

label[2].setIcon(digitos[10]);

label[3].setIcon(digitos[minutos/10]);

89

label[4].setIcon(digitos[minutos%10]);

label[5].setIcon(digitos[10]);

label[6].setIcon(digitos[segundos/10]);

label[7].setIcon(digitos[segundos%10]);

}

}

public class MiThread extends Thread{

public void run(){

int i=0;

while(i<5){

System.out.println(this.getName());

i++;

}

}

}

public class test {


MiThread t1= new MiThread();

t1.setName("Thread1");

t1.setPriority(Thread.MIN_PRIORITY);

MiThread t2= new MiThread();

t2.setName("Thread2");

t2.setPriority(Thread.MAX_PRIORITY);

t1.start();

t2.start();

}

}

import java.awt.Component;


90




/**

*

* @author MARTHA

*/

public class testCronometro {


JFrame frame = new JFrame("Prueba del componente cronometro");

frame.setBounds(10, 10, 290, 120);

frame.getContentPane().setLayout(new FlowLayout());

frame.getContentPane().add(new Cronometro());

frame.setVisible(true);

frame.addWindowListener(new WindowAdapter() {

public void windowClosing(WindowEvent ev){

System.exit(0);

}

});

}

}

91

2.1.7 Tcp/Ip.


2.1.7.1.1 Sockets.

Los sockets son puntos finales de enlaces de comunicaciones entre procesos. Los

procesos los tratan como descriptores de ficheros, de forma que se pueden intercambiar

datos con otros procesos transmitiendo y recibiendo a través de sockets.

2.1.7.1.1.1 Sockets Stream (TCP, Transport Control Protocol)

El protocolo de comunicaciones con streams es un protocolo orientado a conexión,

ya que para establecer una comunicación utilizando el protocolo TCP, hay que establecer

en primer lugar una conexión entre un par de sockets. Mientras uno de los sockets

atiende peticiones de conexión (servidor), el otro solicita una conexión (cliente). Una vez

que los dos sockets estén conectados, se pueden utilizar para transmitir datos en ambas

direcciones.

2.1.7.1.1.2 Sockets Datagrama (UDP, User Datagram Protocol)

El protocolo de comunicaciones con datagramas es un protocolo sin conexión, es

decir, cada vez que se envíen datagramas es necesario enviar el descriptor del socket

local y la dirección del socket que debe recibir el datagrama. Como se puede ver, hay que

enviar datos adicionales cada vez que se realice una comunicación.

2.1.7.1.1.3 Sockets Raw

Son sockets que dan acceso directo a la capa de software de red subyacente o a

protocolos de más bajo nivel. Se utilizan sobre todo para la depuración del código de los

protocolos.

2.1.7.1.2 La clase URL.

La clase URL contiene constructores y métodos para la manipulación de URL

(Universal Resource Locator): un objeto o servicio en Internet. El protocolo TCP necesita

dos tipos de información: la dirección IP y el número de puerto. Vamos a ver cómo

podemos recibir pues la página Web principal de nuestro buscador favorito al teclear:

http://www.yahoo.com

92

En primer lugar, Yahoo tiene registrado su nombre, permitiendo que se use

yahoo.com como su dirección IP, o lo que es lo mismo, cuando indicamos yahoo.com es

como si hubiésemos indicado 205.216.146.71, su dirección IP real.

Hay un servicio, el DNS (Domain Name Service), que traslada www.yahoo.com a

205.216.146.71, lo que nos permite teclear www.yahoo.com, en lugar de tener que

recordar su dirección IP.

Si queremos obtener la dirección IP real de la red en que estamos corriendo,

podemos realizar llamadas a los métodos getLocalHost() y getAddress(). Primero,

getLocalHost() nos devuelve un objeto iNetAddress, que si usamos con getAddress()

generará un array con los cuatro bytes de la dirección IP, por ejemplo:

InetAddress direccion = InetAddress.getLocalHost();

byte direccionIp[] = direccion.getAddress();

Si la dirección de la máquina en que estamos corriendo es 150.150.112.145,

entonces:

direccionIp[0] = 150




2.1.7.1.3 Apertura de sockets.

Si estamos programando un cliente, el socket se abre de la forma:

Socket miCliente;

miCliente = new Socket( "maquina",numeroPuerto );

Donde maquina es el nombre de la máquina en donde estamos intentando abrir la

conexión y numeroPuerto es el puerto (un número) del servidor que está corriendo

sobre el cual nos queremos conectar. Cuando se selecciona un número de puerto, se

debe tener en cuenta que los puertos en el rango 0-1023 están reservados para usuarios

con muchos privilegios (superusuarios o root). Estos puertos son los que utilizan los

servicios estándar del sistema como email, ftp o http. Para las aplicaciones que se

desarrollen, asegurarse de seleccionar un puerto por encima del 1023.

En el ejemplo anterior no se usan excepciones; sin embargo, es una gran idea la

captura de excepciones cuando se está trabajando con sockets. El mismo ejemplo

quedaría como:

93

Socket miCliente;

try {

miCliente = new Socket( "maquina",numeroPuerto );

} catch( IOException e ) {

System.out.println( e );

}

Si estamos programando un servidor, la forma de apertura del socket es la que

muestra el siguiente ejemplo:

Socket miServicio;

try {

miServicio = new ServerSocket( numeroPuerto );



}

A la hora de la implementación de un servidor también necesitamos crear un

objeto socket desde el ServerSocket para que esté atento a las conexiones que le puedan

realizar clientes potenciales y poder aceptar esas conexiones:

Socket socketServicio = null;

try {

socketServicio = miServicio.accept();



}

2.1.7.1.4 Cierre de sockets

Siempre deberemos cerrar los canales de entrada y salida que se hayan abierto

durante la ejecución de la aplicación. En la parte del cliente:

try {

salida.close();

entrada.close();

miCliente.close();



}

Y en la parte del servidor:

try {

salida.close();

entrada.close();

socketServicio.close();

miServicio.close();



}

94

2.1.7.1.5 Creacion de streams.

2.1.7.1.5.1 Creación de Streams de Entrada

En la parte cliente de la aplicación, se puede utilizar la clase DataInputStream para

crear un stream de entrada que esté listo a recibir todas las respuestas que el servidor le

envíe.

DataInputStream entrada;

try {

entrada = new DataInputStream( miCliente.getInputStream() );



}

La clase DataInputStream permite la lectura de líneas de texto y tipos de datos

primitivos de Java de un modo altamente portable; dispone de métodos para leer todos

esos tipos como: read(), readChar(), readInt(), readDouble() y readLine(). Deberemos

utilizar la función que creamos necesaria dependiendo del tipo de dato que esperemos

recibir del servidor.

En el lado del servidor, también usaremos DataInputStream, pero en este caso para

recibir las entradas que se produzcan de los clientes que se hayan conectado:

DataInputStream entrada;

try {

entrada =

new DataInputStream( socketServicio.getInputStream() );



}

2.1.7.1.5.2 Creación de Streams de Salida

En el lado del cliente, podemos crear un stream de salida para enviar información

al socket del servidor utilizando las clases PrintStream o DataOutputStream:

PrintStream salida;

try {

salida = new PrintStream( miCliente.getOutputStream() );



}

La clase PrintStream tiene métodos para la representación textual de todos los

datos primitivos de Java. Sus métodos write y println() tienen una especial importancia

en este aspecto. No obstante, para el envío de información al servidor también podemos

utilizar DataOutputStream:

DataOutputStream salida;

95

try {

salida = new DataOutputStream( miCliente.getOutputStream() );



}

La clase DataOutputStream permite escribir cualquiera de los tipos primitivos de

Java, muchos de sus métodos escriben un tipo de dato primitivo en el stream de salida.

De todos esos métodos, el más útil quizás sea writeBytes().

En el lado del servidor, podemos utilizar la clase PrintStream para enviar información al

cliente:

PrintStream salida;

try {

salida = new PrintStream( socketServicio.getOutputStream() );



}

Pero también podemos utilizar la clase DataOutputStream como en el caso de envío de

información desde el cliente.

96

2.1.7.2 Ejemplo.

2.1.7.2.1 URL import java.io.BufferedReader;


import java.io.InputStreamReader;

import java.io.PrintWriter;

import java.net.Socket;

/**

*

* @author MARTHA

*/

public class EchoClient {


try{

Socket clientSocket = new Socket("192.68.1.2",1234);

PrintWriter out = new

PrintWriter(clientSocket.getOutputStream(),true);

BufferedReader bf = new BufferedReader(new

InputStreamReader(clientSocket.getInputStream()));

System.out.println("Enviando: Eco!!!");

System.out.println("Recibiendo: "+bf.readLine());

out.close();

bf.close();

clientSocket.close();

}

catch(UnknownError e){

}

97

catch(IOException ex){}

}

}

import java.io.BufferedReader;



import java.io.PrintWriter;

import java.net.ServerSocket;


/**

*

* @author MARTHA

*/

public class EchoServer {


try{

ServerSocket serverSocket = new ServerSocket(1234);

Socket clientSocket = new Socket("192.68.1.2",1234);

PrintWriter out = new

PrintWriter(clientSocket.getOutputStream(),true);


InputStreamReader(clientSocket.getInputStream()));

String inputline=bf.readLine();

System.out.println("Recibiendo: "+bf.readLine());

String outputline=bf.readLine();

System.out.println("Enviando: Eco!!!"+outputline);

out.println(outputline);

out.close();

bf.close();

clientSocket.close();

serverSocket.close();

98

}

catch(IOException ex){}

}

}




import java.net.MalformedURLException;

import java.net.URL;

/**

*

* @author MARTHA

*/

public class LeerURLTest {

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

try{

URL yahoo = new URL("http://www.yahoo.com");


InputStreamReader(yahoo.openStream()));

String aux;

while((aux=bf.readLine())!=null){

System.out.println(aux);

bf.close();

}

}

catch(MalformedURLException ex){

}

catch(IOException ex){

}

99

}

}

import java.net.MalformedURLException;

import java.net.URL;

/**

*

* @author MARTHA

*/

public class URLTest {


try{

URL aURL = new

URL("http://www.netbeans.org:80/netbeans/faq/netbeans-faq.html#about_8");

System.out.println("Protocol= "+aURL.getProtocol());

System.out.println("Host= "+aURL.getHost());

System.out.println("FileName= "+aURL.getFile());

System.out.println("Port= "+aURL.getPort());

System.out.println("Ref= "+aURL.getRef());

}

catch(MalformedURLException ex){

ex.printStackTrace();

}

}

}

2.1.7.2.2 Servidor import java.awt.BorderLayout;





100


import java.io.BufferedWriter;


import java.io.InputStream;


import java.io.OutputStreamWriter;


import java.net.UnknownHostException;

import javax.swing.BorderFactory;




import javax.swing.JScrollPane;

import javax.swing.JTextArea;

import javax.swing.JTextField;

public class Cliente extends JFrame

{

//ATRIBUTOS .

private Socket cliente = null;

private BufferedReader br = null;

private BufferedWriter bw = null;

private JTextArea salida = null;

private JTextField entrada = null;

private static String ip = null;

private static int puerto = 0;

private static String nick = null;

private Tareadecliente tarea = null;


// CHEQUEAR ARGUMENTOS DE ENTRADA.

101

if (args.length < 6) {

mostrarAyuda();

}

for (int i = 0; i < 6; i++) {

switch (args[i]) {

case "-h":

ip = args[++i];

break;

case "-p":

puerto = Integer.parseInt(args[++i]);

break;

case "-n":

nick = args[++i];

break;

default:

mostrarAyuda();

break;

}

}

// Crear el cliente.

Cliente cliente = new Cliente();

cliente.setSize(300,200);

cliente.setVisible(true);

// Conectar el cliente.

cliente.conectar();

}

public static void mostrarAyuda()

{

System.out.println("Uso: java.exe Cliente -h %DirecciÃ³n_IP% -p

%Puerto% -n %Nick%");

System.out.println(" -h: DirecciÃ³n IP del Servidor");

102

System.out.println(" -p: Puerto del Servidor");

System.out.println(" -n: Nick a utilizar en esta sesiÃ³n");

System.out.println("Ejemplo: java.exe Cliente -h 127.0.0.1 -p 1234 -

n wezpo");

System.exit(-1);

}

// Constructor.

public Cliente()

{

this.setTitle("Chat - " + nick);

this.getContentPane().setLayout(new BorderLayout());

salida = new JTextArea();

salida.setEditable(false);

salida.setAutoscrolls(true);

salida.setBorder(BorderFactory.createEtchedBorder());

JScrollPane pane = new JScrollPane(salida);

this.getContentPane().add(pane,BorderLayout.CENTER);

entrada = new JTextField(18);

entrada.addActionListener(new ActionListener()

{

public void actionPerformed(ActionEvent ev)

{

enviar();

}

});

JButton enviar = new JButton("Enviar");

enviar.setMnemonic('E');

enviar.setToolTipText("Pulsar para enviar el texto.");

enviar.addActionListener(new ActionListener()

{

103

@Override

public void actionPerformed(ActionEvent ev)

{

enviar();

}

});

JPanel tmp = new JPanel();

tmp.add(entrada);

tmp.add(enviar);

this.getContentPane().add(tmp,BorderLayout.SOUTH);

this.addWindowListener(new WindowAdapter()

{

@Override

public void windowClosing(WindowEvent ev)

{

tarea.stop(true);

System.exit(0);

}

});

}

// MÃ©todos.

private void conectar()

{

try

{

this.mostrar("#Conectando con el servidor",false);

cliente = new Socket(ip,puerto);

104

this.mostrar("#Abriendo streams",false);

br = new BufferedReader(new InputStreamReader(cliente.getInputStream()));

bw = new BufferedWriter(new

OutputStreamWriter(cliente.getOutputStream()));

this.mostrar("#Conectado",false);

bw.write("#Se ha conectado: " + nick + "\n");

bw.flush();

tarea = new Tareadecliente(this);

tarea.start();

}

catch (UnknownHostException ex)

{

this.mostrar("Ha habido un problema -

UnknownHostException",false);

}

catch (IOException ex)

{

this.mostrar("Ha habido un problema - IOException",false);

}

}

private void enviar()

{

salida.append(nick + "> " + entrada.getText() + "\n");

try

{

bw.write(nick + "> " + entrada.getText() + "\n");

bw.flush();

}

catch (IOException ex)

105

{


}

entrada.setText("");

entrada.requestFocus();

}

private void mostrar(String texto, boolean sw)

{

if(sw)

salida.append(nick + "> " + texto + "\n");

else

salida.append(texto + "\n");

}

// Getters

public BufferedReader getBufferedReader()

{

return br;

}

public JTextArea getSalida()

{

return salida;

}

public JTextField getEntrada()

{

return entrada;

106

}

}


import java.net.BindException;

import java.net.ServerSocket;


import java.util.ArrayList;

import java.util.Calendar;

public class SERVIDOR {

// Atributos.

private ArrayList clientes = null;

private boolean sw = true;

private static int puerto = 0;


// Chequear argumentos de entrada.

if (args.length < 2) {

mostrarAyuda();

}

for (int i = 0; i < 2; i++) {

if (args[i].equals("-p")) {

puerto = Integer.parseInt(args[++i]);

} else {

mostrarAyuda();

}

}

// Crear y arrancar el servidor.

new SERVIDOR().arrancar();

}

107

public static void mostrarAyuda() {

System.out.println("Uso: java.exe Servidor -p %Puerto%");

System.out.println(" -p: Puerto del Servidor");

System.out.println("Ejemplo: java.exe Servidor -p 1234");

System.exit(-1);

}

// Constructor.

public SERVIDOR() {

clientes = new ArrayList();

}

// MÃ©todos.

private void arrancar() {

ServerSocket servidor = null;

while (sw) {

try {

if (servidor == null) {

servidor = new ServerSocket(puerto);

}

Socket cliente = servidor.accept();

Tareaservidor tarea = new Tareaservidor(cliente, clientes);

clientes.add(tarea);

tarea.start();

} catch (BindException ex) {

sw = false;

System.out.println(Calendar.getInstance().getTime() + " -

El puerto estÃ¡ en uso.");



sw = false;

108


}

}

}

private static class Tareaservidor {

public Tareaservidor() {

}

private Tareaservidor(Socket cliente, ArrayList clientes) {

throw new UnsupportedOperationException("Not supported yet.");

//To change body of generated methods, choose Tools | Templates.

}

private void start() {

throw new UnsupportedOperationException("Not supported yet.");

//To change body of generated methods, choose Tools | Templates.

}

}

}


import java.net.SocketException;

public class Tareadecliente extends Thread

{

// Atributos.

private Cliente cliente = null;


109

// Constructor.

public Tareadecliente(Cliente param) {

cliente = param;

}

// Métodos.

public void run() {

while (sw) {

try {

cliente.getSalida().append(cliente.getBufferedReader().readLine() + "\n");

cliente.getEntrada().requestFocus();

} catch (SocketException ex) {

cliente.getSalida().append("#Se ha perdido la conexión

con el Servidor\n");

sw = false;




}

}

}

public void stop(boolean param) {

sw = param;

}

}


import java.io.BufferedWriter;

110



import java.io.OutputStreamWriter;


import java.net.SocketException;

import java.util.ArrayList;

public class Tareaservidor extends Thread

{

// Atributos.

private Socket cliente = null;

private ArrayList clientes = null;

private BufferedReader br = null;

private BufferedWriter bw = null;

private String usuario = null;


// Constructor.

public Tareaservidor(Socket param1, ArrayList param2) {

cliente = param1;

clientes = param2;

try {

br = new BufferedReader(new

InputStreamReader(cliente.getInputStream()));

bw = new BufferedWriter(new

OutputStreamWriter(cliente.getOutputStream()));


sw = false;


}

111

}

// Métodos.

public void run() {

try {

// Recibir el nick del cliente recien conectado.

String tmp = this.recibir();

usuario = tmp.substring(tmp.indexOf(": ") + 2,

tmp.length());

// Reenviar al resto de clientes el nick del cliente recien

conectado.

this.broadcast("#Se ha conectado: " + usuario);

while (sw) {

// Reenviar al resto de clientes el mensaje recibido.

this.broadcast(this.recibir());

}

} catch (SocketException ex) {

try {

// Reenviar al resto de clientes el nick del cliente

recien desconectado.

this.broadcast("#Se ha desconectado: " + usuario);

} catch (IOException ex2) {

ex2.printStackTrace();

}



} finally {

try {

if (br != null) {

br.close();

}

112



}

try {

if (bw != null) {

bw.close();

}



}

try {

if (cliente != null) {

cliente.close();

}



}

}

clientes.remove(this);

}

private void broadcast(String param) throws IOException {

for (int i = 0; i < clientes.size(); i++) {

if (clientes.get(i) != this) {

((Tareaservidor) clientes.get(i)).enviar(param + "\n");

}

}

}

113

private void enviar(String param) throws IOException {

bw.write(param);

bw.flush();

}

private String recibir() throws IOException {

return br.readLine();

}

}

114

2.2 MODULO BASE DE DATOS.

2.2.1 Acceso a la Base de Datos.


2.2.1.1.1 Definición

Una base de datos o banco de datos es un conjunto de datos pertenecientes a un

mismo contexto y almacenados sistemáticamente para su posterior uso. En este sentido;

una biblioteca puede considerarse una base de datos compuesta en su mayoría por

documentos y textos impresos en papel e indexados para su consulta. Actualmente, y

debido al desarrollo tecnológico de campos como la informática y la electrónica, la

mayoría de las bases de datos están en formato digital (electrónico), y por ende se ha

desarrollado y se ofrece un amplio rango de soluciones al problema del almacenamiento

de datos.

Existen programas denominados sistemas gestores de bases de datos, abreviado

DBMS, que permiten almacenar y posteriormente acceder a los datos de forma rápida y

estructurada. Las propiedades de estos DBMS, así como su utilización y administración,

se estudian dentro del ámbito de la informática.

Los principales objetivos de un DBMS son los siguientes:

1. Independencia lógica y física de los datos: se refiere a la capacidad de modificar

una definición de esquema en un nivel de la arquitectura sin que esta modificación

afecte al nivel inmediatamente superior. Para ello un registro externo en un esquema

externo no tiene por qué ser igual a su registro correspondiente en el esquema

conceptual.6

2. Redundancia mínima: se trata de usar la base de datos como repositorio común de

datos para distintas aplicaciones.

3. Acceso concurrente por parte de múltiples usuarios: control de concurrencia

mediante técnicas de bloqueo o cerrado de datos accedidos.

4. Distribución espacial de los datos: la independencia lógica y física facilita la

posibilidad de sistemas de bases de datos distribuidas. Los datos pueden encontrarse

http://es.wikipedia.org/wiki/Inform%C3%A1tica

http://es.wikipedia.org/wiki/Electr%C3%B3nica

http://es.wikipedia.org/wiki/Programa_inform%C3%A1tico

http://es.wikipedia.org/wiki/Sistemas_gestores_de_bases_de_datos

http://elies.rediris.es/elies9/4-1-2.htm#Nota6

115

en otra habitación, otro edificio e incluso otro país. El usuario no tiene por qué

preocuparse de la localización espacial de los datos a los que accede.

5. Integridad de los datos: se refiere a las medidas de seguridad que impiden que se

introduzcan datos erróneos. Esto puede suceder tanto por motivos físicos (defectos

de hardware, actualización incompleta debido a causas externas), como de operación

(introducción de datos incoherentes).

6. Consultas complejas optimizadas: la optimización de consultas permite la rápida

ejecución de las mismas.

7. Seguridad de acceso y auditoría: se refiere al derecho de acceso a los datos

contenidos en la base de datos por parte de personas y organismos. El sistema de

auditoría mantiene el control de acceso a la base de datos, con el objeto de saber qué

o quién realizó una determinada modificación y en qué momento.

8. Respaldo y recuperación: se refiere a la capacidad de un sistema de base de datos

de recuperar su estado en un momento previo a la pérdida de datos.

9. Acceso a través de lenguajes de programación estándar: se refiere a la

posibilidad ya mencionada de acceder a los datos de una base de datos mediante

lenguajes de programación ajenos al sistema de base de datos propiamente dicho.

Una base de datos típica conlleva la existencia de tres tipos de usuario con relación

a su diseño, desarrollo y uso:

1. El administrador de bases de datos (DBA: Database Administrator): diseña y

mantiene la DB.

2. El desarrollador de aplicaciones (programador): implementa las transacciones e

interfaces.

3. Los usuarios finales: consultan y editan los datos de la DB mediante un lenguaje de

consulta de alto nivel.

No cabe duda de que la parte más importante es la llevada a cabo por el DBA. A él

le corresponde la elección de un determinado modelo de datos y el diseño de la DB. La

etapa de diseño es la más importante, ya que es ahí donde se refleja la semántica7 de la

información contenida en la DB a través del denominado esquema conceptual. Nos

detendremos sobre este tema cuando estudiemos el modelado de datos.

En general, podemos decir que el propósito de una base de datos es doble:


116

a) responder a consultas sobre los datos que contiene, y

b) ejecutar transacciones

Una consulta (query) se expresa como una expresión lógica sobre los objetos y

relaciones definidos en el esquema conceptual; el resultado es la identificación de un

subconjunto lógico de la base de datos. Una transacción consiste en un número de

consultas y operaciones de modificación o actualización sobre un subesquema. Las

transacciones son atómicas8 por definición: todos los pasos de una transacción han de

ser debidamente ejecutados y confirmados como requisito previo para que la

transacción pueda ser llevada a cabo en su conjunto, en caso contrario ha de ser

invalidada.

Para llevar a cabo estas tareas, el DBA tiene a su disposición la principal

herramienta de una base de datos, el sistema gestor de bases de datos (DBMS). A través

de éste se realizan todas las operaciones con los datos (consultas y transacciones), de

forma que al DBA no le atañe la manera en que los datos se encuentran almacenados

físicamente, pudiéndose concentrar en los aspectos conceptuales en cuanto a diseño,

desarrollo y mantenimiento. Un DBMS típico integra los siguientes componentes:

Un lenguaje de definición de datos (DDL: Data Definition Language).

Un lenguaje de manipulación de datos (DML: Data Manipulation Language)

Un lenguaje de consulta (QL: Query Language).

De forma accesoria, pero ya casi obligada, los DBMS modernos añaden un interfaz de

usuario gráfico (GUI: Graphical User Interface).

consultas mediante ejemplo (posiblemente gráficas) ((G)QBE: (Graphical) Query By

Example)

2.2.1.1.2 Normalización

2.2.1.1.2.1 Definición

El proceso de normalización de bases de datos consiste en aplicar una serie de

reglas a las relaciones obtenidas tras el paso del modelo entidad-relación al modelo

relacional.

Las bases de datos relacionales se normalizan para:


117

Evitar la redundancia de los datos.

Evitar problemas de actualización de los datos en las tablas.

Proteger la integridad de los datos.

En el modelo relacional es frecuente llamar tabla a una relación, aunque para que una

tabla sea considerada como una relación tiene que cumplir con algunas restricciones:

Cada tabla debe tener su nombre único.

No puede haber dos filas iguales. No se permiten los duplicados.

Todos los datos en una columna deben ser del mismo tipo.

2.2.1.1.2.2 Claves

Una clave primaria es aquella columna (o conjunto de columnas) que identifica únicamente

a una fila. La clave primaria es un identificador que va a ser siempre único para cada fila. Se

acostumbra a poner la clave primaria como la primera columna de la tabla pero es más una

conveniencia que una obligación. Muchas veces la clave primaria es numérica auto-

incrementada, es decir, generada mediante una secuencia numérica incrementada

automáticamente cada vez que se inserta una fila.

En una tabla puede que tengamos más de una columna que puede ser clave primaria por sí

misma. En ese caso se puede escoger una para ser la clave primaria y las demás claves serán

claves candidatas.

Una clave ajena (foreign key o clave foránea) es aquella columna que existiendo como

dependiente en una tabla, es a su vez clave primaria en otra tabla.

Una clave alternativa es aquella clave candidata que no ha sido seleccionada como clave

primaria, pero que también puede identificar de forma única a una fila dentro de una tabla.

Ejemplo: Si en una tabla clientes definimos el número de documento (id_cliente) como clave

primaria, el número de seguro social de ese cliente podría ser una clave alternativa. En este

caso no se usó como clave primaria porque es posible que no se conozca ese dato en todos

los clientes.

Una clave compuesta es una clave que está compuesta por más de una columna.

La visualización de todas las posibles claves candidatas en una tabla ayuda a su

optimización. Por ejemplo, en una tabla PERSONA podemos identificar como claves su DNI, o

el conjunto de su nombre, apellidos, fecha de nacimiento y dirección. Podemos usar

cualquiera de las dos opciones o incluso todas a la vez como clave primaria, pero es mejor en

la mayoría de sistemas la elección del menor número de columnas como clave primaria.

http://es.wikipedia.org/wiki/Redundancia

http://es.wikipedia.org/wiki/Integridad_de_datos

http://es.wikipedia.org/wiki/Tabla_%28base_de_datos%29

http://es.wikipedia.org/wiki/Fila_%28base_de_datos%29

http://es.wikipedia.org/wiki/Columna_%28base_de_datos%29

118

2.2.1.1.2.3 FORMAS NORMALES

Las formas normales son aplicadas a las tablas de una base de datos. Decir que una base de

datos está en la forma normal N es decir que todas sus tablas están en la forma normal N.

Diagrama de inclusión de todas las formas normales.

En general, las primeras tres formas normales son suficientes para cubrir las necesidades de

la mayoría de las bases de datos. El creador de estas 3 primeras formas normales (o reglas)

fue Edgar Alanis.

2.2.1.1.2.3.1 PRIMERA FORMA NORMAL (1FN)

Una tabla está en Primera Forma Normal si:

Todos los atributos son atómicos. Un atributo es atómico si los elementos del dominio son

indivisibles, mínimos.

La tabla contiene una clave primaria única.

La clave primaria no contiene atributos nulos.

No debe existir variación en el número de columnas.

Los Campos no clave deben identificarse por la clave (Dependencia Funcional)

Debe Existir una independencia del orden tanto de las filas como de las columnas, es decir, si

los datos cambian de orden no deben cambiar sus significados

Una tabla no puede tener múltiples valores en cada columna.

Los datos son atómicos (a cada valor de X le pertenece un valor de Y y viceversa).

Esta forma normal elimina los valores repetidos dentro de una BD

2.2.1.1.2.3.2 SEGUNDA FORMA NORMAL (2FN)

Dependencia Funcional. Una relación está en 2FN si está en 1FN y si los atributos que no

forman parte de ninguna clave dependen de forma completa de la clave principal. Es decir

que no existen dependencias parciales. (Todos los atributos que no son clave principal deben

depender únicamente de la clave principal).

En otras palabras podríamos decir que la segunda forma normal está basada en el concepto

de dependencia completamente funcional. Una dependencia funcional es

completamente funcional si al eliminar los atributos A de X significa que la dependencia no

es mantenida, esto es que . Una dependencia funcional

es una dependencia parcial si hay algunos atributos que pueden ser

eliminados de X y la dependencia todavía se mantiene, esto es .

Por ejemplo {DNI, ID_PROYECTO} HORAS_TRABAJO (con el DNI de un empleado y el ID de

un proyecto sabemos cuántas horas de trabajo por semana trabaja un empleado en dicho

http://es.wikipedia.org/w/index.php?title=Edgar_Alanis&action=edit&redlink=1

119

proyecto) es completamente funcional dado que ni DNI HORAS_TRABAJO ni

ID_PROYECTO HORAS_TRABAJO mantienen la dependencia. Sin embargo {DNI,

ID_PROYECTO} NOMBRE_EMPLEADO es parcialmente dependiente dado que DNI

NOMBRE_EMPLEADO mantiene la dependencia.

2.2.1.1.2.3.3 TERCERA FORMA NORMAL (3FN)

La tabla se encuentra en 3FN si es 2FN y si no existe ninguna dependencia funcional

transitiva entre los atributos que no son clave.

Un ejemplo de este concepto sería que, una dependencia funcional X->Y en un esquema de

relación R es una dependencia transitiva si hay un conjunto de atributos Z que no es un

subconjunto de alguna clave de R, donde se mantiene X->Z y Z->Y.

Por ejemplo, la dependencia SSN->DMGRSSN es una dependencia transitiva en EMP_DEPT

de la siguiente figura. Decimos que la dependencia de DMGRSSN el atributo clave SSN es

transitiva vía DNUMBER porque las dependencias SSN→DNUMBER y DNUMBER→DMGRSSN

son mantenidas, y DNUMBER no es un subconjunto de la clave de EMP_DEPT.

Intuitivamente, podemos ver que la dependencia de DMGRSSN sobre DNUMBER es

indeseable en EMP_DEPT dado que DNUMBER no es una clave de EMP_DEPT.

Formalmente, un esquema de relación está en 3 Forma Normal Elmasri-Navathe, si para

toda dependencia funcional , se cumple al menos una de las siguientes

condiciones:

1. es superllave o clave.

2. es atributo primo de ; esto es, si es miembro de alguna clave en .

Además el esquema debe cumplir necesariamente, con las condiciones de segunda

forma normal.

2.2.1.1.2.3.4 FORMA NORMAL DE BOYCE-CODD (FNBC)

La tabla se encuentra en FNBC si cada determinante, atributo que determina

completamente a otro, es clave candidata. Deberá registrarse de forma anillada ante la

presencia de un intervalo seguido de una formalización perpetua, es decir las variantes

creadas, en una tabla no se llegaran a mostrar, si las ya planificadas, dejan de existir.

Formalmente, un esquema de relación está en FNBC, si y sólo si, para toda

dependencia funcional válida en , se cumple que

1. es superllave o clave.

http://es.wikipedia.org/w/index.php?title=Elmasri-Navathe&action=edit&redlink=1

120

De esta forma, todo esquema que cumple FNBC, está además en 3FN; sin

embargo, no todo esquema que cumple con 3FN, está en FNBC.

2.2.1.1.2.3.5 CUARTA FORMA NORMAL (4FN)

Una tabla se encuentra en 4FN si, y sólo si, para cada una de sus dependencias

múltiples no funcionales X->->Y, siendo X una super-clave que, X es o una clave

candidata o un conjunto de claves primarias.

2.2.1.1.2.3.6 QUINTA FORMA NORMAL (5FN)

Una tabla se encuentra en 5FN si:

La tabla está en 4FN

No existen relaciones de dependencias no triviales que no siguen los criterios de las claves.

Una tabla que se encuentra en la 4FN se dice que está en la 5FN si, y sólo si, cada relación de

dependencia se encuentra definida por las claves candidatas.

2.2.1.1.2.4 Reglas de CODD

2.2.1.1.2.4.1 Regla no. 1 - la regla de la información

Toda la información en un RDBMS está explícitamente representada de una sola manera por

valores en una tabla.

Cualquier cosa que no exista en una tabla no existe del todo. Toda la información, incluyendo

nombres de tablas, nombres de vistas, nombres de columnas, y los datos de las columnas

deben estar almacenados en tablas dentro de las bases de datos. Las tablas que contienen tal

información constituyen el Diccionario de Datos. Esto significa que todo tiene que estar

almacenado en las tablas.

Toda la información en una base de datos relacional se representa explícitamente en el nivel

lógico exactamente de una manera: con valores en tablas. Por tanto los metadatos

(diccionario, catálogo) se representan exactamente igual que los datos de usuario. Y puede

usarse el mismo lenguaje (ej. SQL) para acceder a los datos y a los metadatos (regla 4)

2.2.1.1.2.4.2 Regla no. 2 - la regla del acceso garantizado

Cada ítem de datos debe ser lógicamente accesible al ejecutar una búsqueda que combine el

nombre de la tabla, su clave primaria, y el nombre de la columna.

121

Esto significa que dado un nombre de tabla, dado el valor de la clave primaria, y dado el

nombre de la columna requerida, deberá encontrarse uno y solamente un valor. Por esta

razón la definición de claves primarias para todas las tablas es prácticamente obligatoria.

2.2.1.1.2.4.3 REGLA NO. 3 - Tratamiento sistemático de los valores nulos

La información inaplicable o faltante puede ser representada a través de valores nulos

Un RDBMS (Sistema Gestor de Bases de Datos Relacionales) debe ser capaz de soportar el

uso de valores nulos en el lugar de columnas cuyos valores sean desconocidos.

2.2.1.1.2.4.4 Regla no. 4 - La regla de la descripción de la base de datos

La descripción de la base de datos es almacenada de la misma manera que los datos

ordinarios, esto es, en tablas y columnas, y debe ser accesible a los usuarios autorizados.

La información de tablas, vistas, permisos de acceso de usuarios autorizados, etc, debe ser

almacenada exactamente de la misma manera: En tablas. Estas tablas deben ser accesibles

igual que todas las tablas, a través de sentencias de SQL (o similar).

2.2.1.1.2.4.5 Regla no. 5 - La regla del sub-lenguaje integral

Debe haber al menos un lenguaje que sea integral para soportar la definición de datos,

manipulación de datos, definición de vistas, restricciones de integridad, y control de

autorizaciones y transacciones.

Esto significa que debe haber por lo menos un lenguaje con una sintaxis bien definida que

pueda ser usado para administrar completamente la base de datos.

2.2.1.1.2.4.6 Regla no. 6 - la regla de la actualización de vistas

Todas las vistas que son teóricamente actualizables, deben ser actualizables por el sistema

mismo.

La mayoría de las RDBMS permiten actualizar vistas simples, pero deshabilitan los intentos

de actualizar vistas complejas.

2.2.1.1.2.4.7 Regla no. 7 - la regla de insertar y actualizar

La capacidad de manejar una base de datos con operandos simples aplica no sólo para la

recuperación o consulta de datos, sino también para la inserción, actualización y borrado de

datos'.

Esto significa que las cláusulas para leer, escribir, eliminar y agregar registros (SELECT,

UPDATE, DELETE e INSERT en SQL) deben estar disponibles y operables,

independientemente del tipo de relaciones y restricciones que haya entre las tablas o no.

122

2.2.1.1.2.4.8 Regla no. 8 - la regla de independencia física

El acceso de usuarios a la base de datos a través de terminales o programas de aplicación,

debe permanecer consistente lógicamente cuando quiera que haya cambios en los datos

almacenados, o sean cambiados los métodos de acceso a los datos.

El comportamiento de los programas de aplicación y de la actividad de usuarios vía

terminales debería ser predecible basados en la definición lógica de la base de datos, y éste

comportamiento debería permanecer inalterado, independientemente de los cambios en la

definición física de ésta.

2.2.1.1.2.4.9 Regla no. 9 - la regla de independencia lógica

Los programas de aplicación y las actividades de acceso por terminal deben permanecer

lógicamente inalteradas cuando quiera que se hagan cambios (según los permisos

asignados) en las tablas de la base de datos.

La independencia lógica de los datos especifica que los programas de aplicación y las

actividades de terminal deben ser independientes de la estructura lógica, por lo tanto los

cambios en la estructura lógica no deben alterar o modificar estos programas de aplicación.

2.2.1.1.2.4.10 Regla no. 10 - la regla de la independencia de la integridad

Todas las restricciones de integridad deben ser definibles en los datos, y almacenables en

el catálogo, no en el programa de aplicación.

2.2.1.1.2.5 Las reglas de integridad.-

1. Ningún componente de una clave primaria puede tener valores en blanco o nulos (ésta es la

norma básica de integridad).

2. Para cada valor de clave foránea deberá existir un valor de clave primaria concordante. La

combinación de estas reglas aseguran que haya integridad referencial.

2.2.1.1.2.5.1 Regla no. 11 - la regla de la distribución

El sistema debe poseer un lenguaje de datos que pueda soportar que la base de datos esté

distribuida físicamente en distintos lugares sin que esto afecte o altere a los programas de

aplicación.

El soporte para bases de datos distribuidas significa que una colección arbitraria de

relaciones, bases de datos corriendo en una mezcla de distintas máquinas y distintos

sistemas operativos y que esté conectada por una variedad de redes, pueda funcionar como

si estuviera disponible como en una única base de datos en una sola máquina.

123

2.2.1.1.2.5.2 Regla no. 12 - regla de la no-subversión

Si el sistema tiene lenguajes de bajo nivel, estos lenguajes de ninguna manera pueden ser

usados para violar la integridad de las reglas y restricciones expresadas en un lenguaje de

alto nivel (como SQL).

Algunos productos solamente construyen una interfaz relacional para sus bases de datos No

relacionales, lo que hace posible la subversión (violación) de las restricciones de integridad.

Esto no debe ser permitido.

2.2.1.1.2.6 Modelo Entidad – Relación

2.2.1.1.2.6.1 Definición

Un diagrama o modelo entidad-relación (a veces denominado por sus siglas en inglés, E-R

"Entity relationship", o del español DER "Diagrama de Entidad Relación") es una herramienta

para el modelado de datos que permite representar las entidades relevantes de un sistema de

información así como sus interrelaciones y propiedades.

2.2.1.1.2.6.2 Modelado Entidad-Relación

1. Se elabora el diagrama (o diagramas) entidad-relación.

2. Se completa el modelo con listas de atributos y una descripción de otras restricciones que no

se pueden reflejar en el diagrama.

El modelado de datos no acaba con el uso de esta técnica. Son necesarias otras técnicas

para lograr un modelo directamente implementable en una base de datos. Brevemente:

Transformación de relaciones múltiples en binarias.

Normalización de una base de datos de relaciones (algunas relaciones pueden transformarse

en atributos y viceversa).

Conversión en tablas (en caso de utilizar una base de datos relacional).

2.2.1.1.2.6.2.1 Base teórica y conceptual

El modelo de datos entidad-relación está basado en una percepción del mundo real que

consta de una colección de objetos básicos, llamados entidades, y de relaciones entre esos

objetos.

http://es.wikipedia.org/wiki/Modelo_de_datos

http://es.wikipedia.org/wiki/Sistema_de_informaci%C3%B3n

http://es.wikipedia.org/wiki/Sistema_de_informaci%C3%B3n

http://es.wikipedia.org/wiki/Base_de_datos

http://es.wikipedia.org/wiki/Normalizaci%C3%B3n_de_bases_de_datos

http://es.wikipedia.org/wiki/Base_de_datos_relacional

124

2.2.1.1.2.6.2.1.1 Entidad

Representa una “cosa” u "objeto" del mundo real con existencia independiente, es decir, se

diferencia unívocamente de otro objeto o cosa, incluso siendo del mismo tipo, o una misma

entidad.

Algunos Ejemplos:

Una persona. (Se diferencia de cualquier otra persona, incluso siendo gemelos).

Un automóvil. (Aunque sean de la misma marca, el mismo modelo,..., tendrán atributos

diferentes, por ejemplo, el número de chasis).

Una casa (Aunque sea exactamente igual a otra, aún se diferenciará en su dirección).

Una entidad puede ser un objeto con existencia física como: una persona, un animal, una

casa, etc. (entidad concreta); o un objeto con existencia conceptual como: un puesto de trabajo,

una asignatura de clases, un nombre, etc. (entidad abstracta).

Una entidad está descrita y se representa por sus características o atributos. Por ejemplo,

la entidad Persona las características: Nombre, Apellido, Género, Estatura, Peso, Fecha de

nacimiento.

2.2.1.1.2.6.2.1.2 Atributos

Los atributos son las características que definen o identifican a una entidad. Estas pueden

ser muchas, y el diseñador solo utiliza o implementa las que considere más relevantes. Los

atributos son las propiedades que describen a cada entidad en un conjunto de entidades.

En un conjunto de entidades del mismo tipo, cada entidad tiene valores específicos

asignados para cada uno de sus atributos, de esta forma, es posible su identificación unívoca.

Ejemplos:

A la colección de entidades «alumnos», con el siguiente conjunto de atributos en común,

(id, nombre, edad, semestre), pertenecen las entidades:

(1, Sofía, 38 años, 2)

(2, Josefa, 19 años, 5)

(3, Carlos, 20 años, 2)

...

Cada una de las entidades pertenecientes a este conjunto se diferencia de las demás por el

valor de sus atributos. Nótese que dos o más entidades diferentes pueden tener los mismos

valores para algunos de sus atributos, pero nunca para todos.

125

En particular, los atributos identificativos son aquellos que permiten diferenciar a una

instancia de la entidad de otra distinta. Por ejemplo, el atributo identificativo que distingue a un

alumno de otro es su número de id.

Para cada atributo, existe un dominio del mismo, este hace referencia al tipo de datos que

será almacenado o a restricciones en los valores que el atributo puede tomar (cadenas de

caracteres, números, solo dos letras, solo números mayores que cero, solo números enteros...).

Cuando algún atributo correspondiente a una entidad no tiene un valor determinado,

recibe el valor nulo, bien sea porque no se conoce, porque no existe o porque no se sabe nada al

respecto del mismo.

2.2.1.1.2.6.2.1.3 Relación

Describe cierta dependencia entre entidades o permite la asociación de las mismas.

Ejemplo:

Si tenemos dos entidades, "CLIENTE" y "HABITACION", podemos entender la relación

entre ambas al tomar un caso concreto (ocurrencia) de cada una de ellas. Entonces, podríamos

tener la ocurrencia "Habitación 502", de la entidad "HABITACION" y la ocurrencia "Henry

Jonshon Mcfly Bogard", de la entidad "CLIENTE", entre las que es posible relacionar que la

habitación 502 se encuentra ocupada por el huésped de nombre Henry Jonshon.

Una relación tiene sentido al expresar las entidades que relaciona. En el ejemplo anterior,

podemos decir que un huésped (entidad), se aloja (relación) en una habitación (entidad).

2.2.1.1.2.6.2.1.4 Conjunto de relaciones

Consiste en una colección, o conjunto, de relaciones de la misma naturaleza.

Ejemplo:

Dados los conjuntos de entidades "Habitación" y "Huésped", todas las relaciones de la

forma habitación-huésped, permiten obtener la información de los huéspedes y sus respectivas

habitaciones.

La dependencia o asociación entre los conjuntos de entidades es llamada participación. En

el ejemplo anterior los conjuntos de entidades "Habitación" y "Huésped" participan en el

conjunto de relaciones habitación-huésped.

Se llama grado del conjunto de relaciones a la cantidad de conjuntos de entidades

participantes en la relación.

126

2.2.1.1.2.7 Restricciones.-

Son reglas que deben mantener los datos almacenados en la base de datos.

2.2.1.1.2.7.1 Correspondencia de cardinalidades Dado un conjunto de relaciones en el que participan dos o más conjuntos de entidades, la

correspondencia de cardinalidad indica el número de entidades con las que puede estar

relacionada una entidad dada.

Dado un conjunto de relaciones binarias y los conjuntos de entidades A y B, la

correspondencia de cardinalidades puede ser:

Uno a Uno: (1:1) Una entidad de A se relaciona únicamente con una entidad en B y

viceversa (ejemplo relación vehículo - matrícula: cada vehículo tiene una única matrícula, y

cada matrícula está asociada a un único vehículo).

Uno a varios: (1:N)Una entidad en A se relaciona con cero o muchas entidades en B. Pero

una entidad en B se relaciona con una única entidad en A (ejemplo vendedor - ventas).

Varios a Uno: (N:1)Una entidad en A se relaciona exclusivamente con una entidad en B.

Pero una entidad en B se puede relacionar con 0 o muchas entidades en A (ejemplo

empleado-centro de trabajo).

Varios a Varios: (N:M)Una entidad en A se puede relacionar con 0 o muchas entidades en B

y viceversa (ejemplo asociaciones- ciudadanos, donde muchos ciudadanos pueden

pertenecer a una misma asociación, y cada ciudadano puede pertenecer a muchas

asociaciones distintas).

2.2.1.1.2.7.2 Restricciones de participación

Dado un conjunto de relaciones R en el cual participa un conjunto de entidades A, dicha

participación puede ser de dos tipos:

Total: Cuando cada entidad en A participa en al menos una relación de R.

Parcial: Cuando al menos una entidad en A NO participa en alguna relación de R.

2.2.1.1.2.8 Claves

Es un subconjunto del conjunto de atributos comunes en una colección de entidades, que

permite identificar inequívocamente cada una de las entidades pertenecientes a dicha colección.

Asimismo, permiten distinguir entre sí las relaciones de un conjunto de relaciones.

Dentro de los conjuntos de entidades existen los siguientes tipos de claves:

127

Superclave: Es un subconjunto de atributos que permite distinguir unívocamente cada una

de las entidades de un conjunto de entidades. Si se añade un atributo al anterior

subconjunto, el resultado seguirá siendo una superclave.

Clave candidata: Dada una superclave, si ésta deja de serlo quitando únicamente uno de los

atributos que la componen, entonces ésta es una clave candidata.

Clave primaria: Es una clave candidata, elegida por el diseñador de la base de datos, para

identificar unívocamente las entidades en un conjunto de entidades.

Los valores de los atributos de una clave, no pueden ser todos iguales para dos o más instancias.

Para poder distinguir unívocamente las relaciones en un conjunto de relaciones R, se

deben considerar dos casos:

R NO tiene atributos asociados: En este caso, se usa como clave primaria de R la unión de

las claves primarias de todos los conjuntos de entidades participantes.

R tiene atributos asociados: En este caso, se usa como clave primaria de R la unión de los

atributos asociados y las claves primarias de todos los conjuntos de entidades participantes.

Si el conjunto de relaciones, R, sobre las que se pretende determinar la clave primaria está

compuesto de relaciones binarias, con los conjuntos de entidades participantes A y B, se

consideran los siguientes casos, según sus cardinalidades:

R es de muchos a uno de A a B entonces sólo se toma la clave primaria de A, como clave

primaria de R.

R es de uno a muchos de A a B entonces se toma sólo la clave primaria de B, como clave

primaria de R.

R es de uno a uno de A a B entonces se toma cualquiera de las dos claves primarias, como

clave primaria de R.

R es de muchos a muchos de A a B entonces se toma la unión de los atributos que

conforman las claves primarias de A y de B, como clave primaria de R.

2.2.1.1.2.9 Diagrama Entidad-Relación

Anteriormente detallamos los conceptos relacionados al modelo ER, en esta sección

profundizaremos en como representarlos gráficamente. Cabe destacar que para todo proceso de

modelado, siempre hay que tener en claro los conceptos, estos nos brindan conocimiento

necesario y además fundamentan nuestro modelo al momento de presentarlo a terceros.

128

Formalmente, los diagramas ER son un lenguaje gráfico para describir conceptos.

Informalmente, son simples dibujos o gráficos que describen información que trata un sistema

de información y el software que lo automatiza.

2.2.1.1.2.9.1 Entidades

Las entidades son el fundamento del modelo entidad relación. Podemos adoptar como

definición de entidad cualquier cosa o parte del mundo que es distinguible del resto. Por

ejemplo, en un sistema bancario, las personas y las cuentas bancarias se podrían interpretar

como entidades. Las entidades pueden representar entes concretos, como una persona o un

avión, o abstractas, como por ejemplo un préstamo o una reserva. Se representan por medio de

un rectángulo que pueden ser de tipo: maestras, transaccionales, históricas y temporales

2.2.1.1.2.9.2 Atributos Se representan mediante un círculo o elipse etiquetado mediante un nombre en su

interior. Cuando un atributo es identificativo de la entidad se suele subrayar dicha etiqueta.

Por motivos de legibilidad, los atributos suelen no aparecer representados en el diagrama

entidad-relación, sino descritos textualmente en otros documentos adjuntos.

2.2.1.1.2.9.3 Relaciones

Se representan mediante un rombo etiquetado en su interior con un verbo. Este rombo se

debe unir mediante líneas con las entidades (rectángulos) que relaciona, para así saber cuál es la

relación que lleva cada uno.

2.2.1.1.2.10 Diagramas Extendidos.-

Los diagramas Entidad-Relación no cumplen su propósito con eficacia debido a que tienen

limitaciones semánticas. Por ese motivo se suelen utilizar los diagramas Entidad-Relación

extendidos que incorporan algunos elementos más al lenguaje:

http://commons.wikimedia.org/wiki/File:Diagrama_Entidad_Relacion.svg

129

2.2.1.1.2.10.1 Entidades Fuertes y Débiles.-

Cuando una entidad participa en una relación puede adquirir un papel fuerte o débil. Una

entidad débil es aquella que no puede existir sin participar en la relación; es decir, aquella que

no puede ser unívocamente identificada solamente por sus atributos.

Una entidad fuerte (también conocida como entidad regular) es aquella que sí puede ser

identificada unívocamente. En los casos en que se requiera, se puede dar que una entidad fuerte

"preste" algunos de sus atributos a una entidad débil para que esta última se pueda identificar.

Las entidades débiles se representan- mediante un doble rectángulo; es decir, un

rectángulo con doble línea.

Se puede hablar de la existencia de 2 tipos de dependencias en las entidades débiles:

Dependencia por existencia.

Las ocurrencias de la entidad débil pueden identificarse mediante un atributo

identificador clave sin necesidad de identificar la entidad fuerte relacionada.

Dependencia por identidad.

La entidad débil no puede ser identificada sin la entidad fuerte relacionada. (Ejemplo:

si tenemos una entidad LIBRO y otra relacionada EDICIÓN, para identificar una edición

necesitamos conocer el identificador del libro).

2.2.1.1.2.10.2 Cardinalidad de las relaciones

El tipo de cardinalidad se representa mediante una etiqueta en el exterior de la relación,

respectivamente: "1:1", "1:N" y "N:M", aunque la notación depende del lenguaje utilizado, la que

más se usa actualmente es el unificado. Otra forma de expresar la cardinalidad es situando un

símbolo cerca de la línea que conecta una entidad con una relación:

"0" si cada instancia de la entidad no está obligada a participar en la relación.

"1" si toda instancia de la entidad está obligada a participar en la relación y, además,

solamente participa una vez.

"N" , "M", o "*" si cada instancia de la entidad no está obligada a participar en la relación

y puede hacerlo cualquier número de veces.

Ejemplos de relaciones que expresan cardinalidad:

Cada esposo (entidad) está casado (relación) con una única esposa (entidad) y viceversa.

Es una relación 1:1.

130

Una factura (entidad) se emite (relación) a una persona (entidad) y sólo una, pero una

persona puede tener varias facturas emitidas a su nombre. Todas las facturas se emiten a

nombre de alguien. Es una relación 1:N.

Un cliente (entidad) puede comprar (relación) varios servicios (entidad) y un servicio

puede ser comprado por varios clientes distintos. Es una relación N:M.

2.2.1.1.2.10.3 Atributos en relaciones Las relaciones también pueden tener atributos asociados. Se representan igual que los

atributos de las entidades. Un ejemplo típico son las relaciones de tipo "histórico" donde debe

constar una fecha o una hora. Por ejemplo, supongamos que es necesario hacer constar la fecha

de emisión de una factura a un cliente, y que es posible emitir duplicados de la factura (con

distinta fecha). En tal caso, el atributo "Fecha de emisión" de la factura debería colocarse en la

relación "se emite".

2.2.1.1.2.10.4 Herencia

La herencia es un intento de adaptación de estos diagramas al paradigma orientado a

objetos. La herencia es un tipo de relación entre una entidad "padre" y una entidad "hijo". La

entidad "hijo" hereda todos los atributos y relaciones de la entidad "padre". Por tanto, no

necesitan ser representadas dos veces en el diagrama. La relación de herencia se representa

mediante un triángulo interconectado por líneas a las entidades. La entidad conectada por el

vértice superior del triángulo es la entidad "padre". Solamente puede existir una entidad "padre"

(herencia simple). Las entidades "hijo" se conectan por la base del triángulo.

2.2.1.1.2.10.5 Agregación

Es una abstracción a través de la cual las relaciones se tratan como entidades de un nivel

más alto. Se utiliza para expresar relaciones entre relaciones o entre entidades y relaciones. Se

representa englobando la relación abstraída y las entidades que participan en ella en un

rectángulo. En la figura se muestra un ejemplo de agregación en el que se representa la situación

http://commons.wikimedia.org/wiki/File:Ejemplo_de_Agregaci%C3%B3n.svg

131

en la que un profesor, cuando está impartiendo una clase, puede poner una incidencia ocurrida a

lo largo de ésta (se fue la luz, falta la configuración de un determinado software, etc.).

2.2.1.2 Ejemplo.

PostGre SQL

Pasos para agregar una librería en NetBeans.-

1. Nos dirigimos al Menú Herramientas y damos clic en Bibliotecas.

132

2. Luego en Administrador de Bibliotecas damos clic en Nueva Biblioteca.

3. En Nombre de biblioteca ponemos PostgreSQL y damos clic en Aceptar.

133

4. En esta ventana damos clic en .

5. Elegimos el archivo y damos clic en .

134

6. Por último damos clic en Aceptar.

NetBeans

Codificación para conectar y guardar en la base de datos desde un formulario de NetBeans

String driver = "org.postgresql.Driver";

String connectionString =

"jdbc:postgresql://localhost:5432/veterinaria/";//muestra DB

String user = "postgres";//usuario DB

String password = "12345";//contraseña

try {

Class.forName(driver);//hacemos la conexion

Connection conn = DriverManager.getConnection(connectionString, user, password);

PreparedStatement stm = conn.prepareStatement("INSERT INTO

veterinaria.cliente(cli_codigo, cli_nombre, cli_telefono, cli_direccion) VALUES

(?,?,?,?)");

stm.setString(1, txtCodigo.getText());

stm.setString(2, txtNombre.getText());

stm.setString(3, txtTelefono.getText());

135

stm.setString(4, txtDireccion.getText());

stm.executeUpdate();

JOptionPane.showMessageDialog(this, "insertado...!");

} catch (Exception e) {

JOptionPane.showMessageDialog(this, e.toString());

}.

Codificación para conectar y guardar en la base de datos desde un formulario de NetBeans

btnNuevoActionPerformed(java.awt.event.ActionEvent evt) {

String driver = "org.postgresql.Driver";

String connectionString =

"jdbc:postgresql://localhost:5432/veterinaria/";//muestra DB

String user = "postgres";//usuario DB

String password = "12345";//contraseña

try {

Class.forName(driver);//hacemos la conexion

Connection conn = DriverManager.getConnection(connectionString,

user, password);

PreparedStatement stm = conn.prepareStatement("INSERT INTO

veterinaria.medico(med_codigo, med_nombre, med_telefono, med_direccion) VALUES

(?,?,?,?)");

stm.setString(1, txtCodigo.getText());

stm.setString(2, txtNombre.getText());

stm.setString(3, txtTelefono.getText());

136

stm.setString(4, txtDireccion.getText());

stm.executeUpdate();

JOptionPane.showMessageDialog(this, "insertado...!");

} catch (Exception e) {

JOptionPane.showMessageDialog(this, e.toString());

}

}

137

2.3 MODULO ENTORNO WEB.

2.3.1 Java WEB.


2.3.1.1.1 Introducción.

La Web dinámica se ha desarrollado desde un sistema de información distribuido

hipermedia (HTML) basado en red que ofrecía información estática hasta un conjunto de

portales y aplicaciones en Internet que ofrecen un conjunto variado de servicios.

Las soluciones de primera generación incluyeron CGI, que es un mecanismo para

ejecutar programas externos en un servidor web. El problema con los scripts CGI es la

escalabilidad; se crea un nuevo proceso para cada petición.

Las soluciones de segunda generación incluyeron vendedores de servidores Web

que proporcionaban plug-ins y APIs para sus servidores. El problema es que sus

soluciones eran específicas a sus productos servidores. Microsoft proporcionó las

páginas activas del servidor (ASP) que hicieron más fácil crear el contenido dinámico.

Sin embargo, su solución sólo trabajaba con Microsoft IIS o Personal Web Server. Otra

tecnología de segunda generación son los Servlets. Los Servlets hacen más fácil escribir

aplicaciones del lado del servidor usando la tecnología Java. El problema con los CGI o

los Servlets, sin embargo, es que tenemos que seguir el ciclo de vida de escribir, compilar

y desplegar.

Las páginas JSP son una solución de tercera generación que se pueden combinar

fácilmente con algunas soluciones de la segunda generación, creando el contenido

dinámico, y haciendo más fácil y más rápido construir las aplicaciones basadas en Web

que trabajan con una variedad de otras tecnologías: servidores Web, navegadores Web,

servidores de aplicación y otras herramientas de desarrollo.

La tecnología Java Server Pages™ (JSP) nos permite poner segmentos de código

servlet directamente dentro de una página HTML estática. Cuando el navegador carga

una página JSP, se ejecuta el código del servlet y el servidor de aplicaciones crea,

compila, carga y ejecuta un servlet en segundo plano para ejecutar los segmentos de

código servlet y devolver una página HTML o imprimir un informe XML.

138

2.3.1.1.1.1 Modelo cliente-servidor.

Cuando se utiliza un servicio en Internet, como consultar una base de datos,

transferir un fichero o participar en un foro de discusión, se establece un proceso en el

que entran en juego dos partes. Por un lado, el usuario, quien ejecuta una aplicación en

el ordenador local: el denominado programa cliente. Este programa cliente se encarga

de ponerse en contacto con el ordenador remoto para solicitar el servicio deseado. El

ordenador remoto por su parte responderá a lo solicitado mediante un programa que

está ejecutando. Este último se denomina programa servidor. Los términos cliente y

servidor se utilizan tanto para referirse a los programas que cumplen estas funciones,

como a los ordenadores donde son ejecutados esos programas.

El programa o los programas cliente que el usuario utiliza para acceder a los

servicios de Internet realizan dos funciones distintas. Por una parte, se encargan de

gestionar la comunicación con el ordenador servidor, de solicitar un servicio concreto y

de recibir los datos enviados por éste; y por otra, es la herramienta que presenta al

usuario los datos en pantalla y que le ofrece los comandos necesarios para utilizar las

prestaciones que ofrece el servidor.

El navegador es una especie de aplicación capaz de interpretar las órdenes

recibidas en forma de código HTML fundamentalmente y convertirlas en las páginas que

son el resultado de dicha orden.

Fig. Lenguajes del lado cliente y del lado servidor

139

Fig. Ejecución en el modelo web cliente-servidor

En resumen, los programadores de aplicaciones JAVA mediante la especificación

J2EE escriben componentes de aplicación J2EE. Un componente J2EE es una unidad de

software funcional auto-contenida que se ensambla dentro de una aplicación J2EE y que

se comunica con otros componentes de aplicación. La especificación J2EE define los

siguientes componentes de aplicación:

Componentes de Aplicación Cliente: Navegador y páginas jsp renderizadas

Componentes JavaBeans Enterprise: clases de negocio (EJBs)

Componentes Servlets y JavaServer Pages (también llamados componentes

Web): clases controladoras.

Applets: pequeñas aplicaciones que se ejecutan en el cliente

2.3.1.1.1.2 Acceso a Datos

Una de las tareas más importantes y más frecuentemente realizadas por los

servlets es la conexión a bases de datos mediante JDBC. Esto es debido a que los servlets

son un componente ideal para hacer las funciones de capa media en un sistema con una

arquitectura de tres capas como la mostrada en la Figura:

140

2.3.1.1.1.3 Formas de seguir la trayectoria de los usuarios (clientes)

Los servlets permiten seguir la trayectoria de un cliente, es decir, obtener y

mantener una determinada información acerca del cliente. De esta forma se puede tener

identificado a un cliente (usuario que está utilizando un browser) durante un

determinado tiempo. Esto es muy importante si se quiere disponer de aplicaciones que

impliquen la ejecución de varios servlets o la ejecución repetida de un mismo servlet. Un

claro ejemplo de aplicación de esta técnica es el de los comercios vía Internet que

permiten llevar un carrito de la compra en el que se van guardando aquellos productos

solicitados por el cliente. El cliente puede ir navegando por las distintas secciones del

comercio virtual, es decir realizando distintas conexiones HTTP y ejecutando diversos

servlets, y a pesar de ello no se pierde la información contenida en el carrito de la

compra y se sabe en todo momento que es un mismo cliente quien está haciendo esas

conexiones diferentes.

El mantener información sobre un cliente a lo largo de un proceso que implica

múltiples conexiones se puede realizar de tres formas distintas:

Mediante cookies

Mediante seguimiento de sesiones (Session Tracking)

141

Mediante la reescritura de URLs y paso de parámetros en formulario (Request)

2.3.1.1.2 EJBs

Un EJB es un componente del lado del servidor que encapsula la lógica del negocio

de una aplicación. En cualquier aplicación, los beans enterprise implementan los

métodos de la lógica del negocio, que pueden ser invocados por clientes remotos para

acceder a los servicios importantes proporcionados por la aplicación.

2.3.1.1.2.1 Beneficios

Los EJBs simplifican el desarrollo de grandes aplicaciones empresariales seguras y

distribuidas por las siguientes razones:

Los desarrolladores pueden concentrarse en solventar la lógica del

negocio: el contenedor EJB proporciona servicios a nivel del sistema como el

control de transaciones y las autorizaciones de seguridad. Por lo tanto, los

desarrolladores o tienen que preocuparse de estos problemas.

Clientes pequeños: Los desarrolladores no tienen que desarrollar código para

las reglas de negocio o accesos a bases de datos; pueden concentrarse en la

presentación del cliente. El resultado final es que los clientes son pequeños, y

esto es especialmente importante para clientes que se ejecutan en pequeños

dispositivos con recursos limitados.

Desarrollo rápido: Los EJBs son componentes portables, y por lo tanto los

ensambladores de aplicaciones pueden construir nuevas aplicaciones desde

beans existentes. Las aplicaciones resultantes se pueden ejecutar en cualquier

servidor compatible J2EE.

2.3.1.1.2.2 Componentes

Hay dos tipos principales de componentes EJB : session y entity. Un EJB de sesión

se usa para realizar una tarea para un cliente, y un EJB de entidad es específico del

dominio y se usa para representar un objeto de entidad del negocio que existe en un

almacenamiento persistente. Sin embargo, los beans de entidad y de sesión tienen

algunas diferencias que podemos ver en la siguiente tabla:

142

EJB de Sesión

EJB de Entidad

Transitorio

Puede ser usado por un sólo

cliente.

No tiene identidad

Persistente

Puede ser usado por muchos

clientes.

Tiene una identidad (como una

clave primaria)

2.3.1.1.2.3 Desarrollar EJBs

Para desarrollar EJBs, todo bean enterprise necesita:

Un interface remoto que exponga los métodos que soporta bean enterprise.

Un interface home que proporciona los métodos del ciclo de vida del bean

enterprise.

Una clase de implementación, incluyendo la lógica de negocio que necesite.

2.3.1.1.2.4 EJBs contra Servlets

A primera vista, los EJBs y los Servlets son tecnologías similares porque ambos son

componentes distribuidos del lado del servidor. Sin embargo, hay una diferencia

importante entre los dos en el tipo de solución que ofrecen; los EJBs no pueden aceptar

peticiones HTTP.

En otras palabras, los EJBs no peuden servir peticiones que vienen directamente

desde un navegador Web, y los servlets si pueden. Servlets y JSPs se pueden usar para

implementar presentación y control web, pero al contrario que los EJBs, no pueden

manejar transacciones distribuidas. Los EJBs pueden ser llamados desde cualquier

cliente basado en Java.

2.3.1.1.2.5 ¿Cúando usar EJBs?

Los EJBs son buenos para las aplicaciones que tienen alguno de estos requerimientos:

Escalabilidad: si tenemos un número creciente de usuarios, los EJBs nos

permitirán distribuir los componentes de nuestra aplicación entre varias

máquinas con su localización transparente para los usuarios.

143

Integridad de Datos: los EJBs nos facilitan el uso de transacciones distribuidas.

Variedad de clientes: si nuestra aplicación va a ser accedida por una variedad

de clientes (como navegadores tradicionales o navegadores WAP), se pueden

usar los EJBs para almacenar el modelo del negocio, y se puede usar una

variedad de clientes para acceder a la misma información.

2.3.2 Framework.


2.3.2.1.1 ¿Qué es un Framework?

Un Framework es una abstracción de un componente de software para resolver un

problema en un contexto.

No hay que limitarlo a aplicaciones Web.

Existen también para desarrollar juegos, aplicaciones médicas, aplicaciones

empresariales, aplicaciones de escritorio, dispositivos móviles, etc.

Aplicación genérica que interactúa con nuestro desarrollo y que a la vez es

configurable.

2.3.2.1.2 Objetivos de Usar un Framework

Los objetivos principales que persigue un Framework son:

Acelerar el proceso de desarrollo.

Reutilizar código ya existente.

144

Promover buenas prácticas de desarrollo como el uso de patrones.

145

2.3.2.1.3 Modelo – Vista – Controlador

Guía para el diseño de arquitecturas de aplicaciones que interactúen con muchos

usuarios.

2.3.2.1.4 Frameworks para el Modelo MVC

Para la vista o Presentación:

o Struts Versiones 1 (1.1 – 1.2 – 1.3) y 2.

o JSF (Java Server Faces)

Para el controlador o lógica de negocio:

o Spring

Para el acceso a datos o persistencia de datos:

o Hibernate

o Ibatis

o Symbian

o EJB

146

2.3.2.1.5 Struts

2.3.2.1.5.1 Archivos de Configuración:

struts-config.xml

ApplicationResources.properties

struts-html.tld

struts-bean.tld

struts-logic.tld

147

2.3.2.1.6 Spring Framework

Object/relational mapping integration module: spring no implementa su propio orm

(objet relational mapping), incluye implementaciones para ibatis, hibernate, JDO, etc.

Spring’s web module: Orientado a tareas Web, integración y soporte con struts.

The Spring MVC framework: 100 % modelo vista controlador para separar el

controlador de los objetos de negocio.

2.3.2.1.7 Hibernate

Framework para la persistencia de objetos hacia bases de datos (orm = OBJECT

RELATIONAL MAPPING)

Se basa en SessionFactory y Transacciones hacia bases de datos.

Soporta el uso de Annotations

Las consultas se pueden realizar a nivel de objetos (HSQL) y a nivel de SQL.

148

2.3.3 Java Server.


2.3.3.1.1 Introducción a JSP.

La tecnología JSP (Java Server Pages) es una especificación abierta desarrollada

por Sun Microsystems como un alternativa a Active Server Pages (ASP) de Microsoft, y

son un componente dominante de la especificación de Java 2 Enterprise Edition (J2EE).

Muchos delos servidores de aplicaciones comercialmente disponibles (como BEA

WebLogic, IBM WebSphere, Live JRun, Orion, etcétera) ya utilizan tecnología JSP.

Esta tecnología permite desarrollar páginas web con contenido dinámico y supone

una evolución frente a la tecnología CGI, y los Servlets. Un fichero JSP puede contener

etiquetas HTML normales, y elementos especiales para generar el contenido dinámico.

Al mismo tiempo permite una separación en n capas de la arquitectura de la

aplicación web y se integra perfectamente con todas las API's empresariales de Java:

JDBC, RMI (y CORBA), JNDI, EJB, JMS, JTA, ...

2.3.3.1.1.1 Estructura de una página JSP

Una página JSP es básicamente una página Web con HTML tradicional y código

Java. La extensión de fichero de una página JSP es ".jsp" en vez de ".html" o".htm", y eso

le dice al servidor que esta página requiere un manejo especial que se conseguirá con

una extensión del servidor o un plug-in.

Un ejemplo sencillo:

<%@ page language="java" contentType="text/html" %>

<html>

<head>

<title>Hola, mundo!!</title>

</head>

<body>

<h1>Hola, mundo!</h1>

Hoy es <%= new java.util.Date() %>.

</body>

</html>

2.3.3.1.1.1.1 Directivas

Las directivas JSP son instrucciones procesadas por el motor JSP cuando la página

JSP se traduce a un servlet. Las directivas usadas en este ejemplo le dicen al motor JSP

149

que incluya ciertos paquetes y clases. Las directivas están encerradas entre etiquetas de

directiva <%@ y %>.

<%@ page import="javax.naming.*" %>

<%@ page import="javax.rmi.PortableRemoteObject" %>

<%@ page import="Beans.*" %>

2.3.3.1.1.1.2 Declaraciones

Las declaraciones JSP nos permiten configurar variables para su uso posterior en

expresiones o scriptlets. También podemos declarar variables dentro de expresiones o

scriptlets en el momento de usarlas. El ámbito es toda la página JSP, no hay concepto de

variables de ejemplar. Es decir, no tenemos que declarar variables de ejemplar para usar

en más de una expresión o scriptlet. Las declaraciones van encerradas entre etiquetas de

declaración <%! y %>. Podemos tener varias declaraciones. Por ejemplo,

<%! double bonus; String text; %> .

<%! String strMult, socsec; %>

<%! Integer integerMult; %>

<%! int multiplier; %>

<%! double bonus; %>

2.3.3.1.1.1.3 Scriptlets

Los scriptlets JSP nos permiten embeber segmentos de código java dentro de una página

JSP. El código embebido se inserta directamente en el servlet generado que se ejecuta

cuando se pide la página. Este scriptlet usa las variables declaradas en las directivas

descritas arriba. Los Scriptlets van encerradas entre etiquetas <% y %>.

<%

strMult = request.getParameter("MULTIPLIER");

socsec = request.getParameter("SOCSEC");

integerMult = new Integer(strMult);

multiplier = integerMult.intValue();

bonus = 100.00;

%>

2.3.3.1.1.1.4 Variables Predefinidas

Un scriptlet puede usar las siguientes variables predefinidas: session, request,

response, out, e in. Este ejemplo usa la variable predefinida request, que es un objeto

HttpServletRequest. De igual forma, response es un objeto HttpServletResponse, out es

un objeto PrintWriter, e in es un objeto BufferedReader. Las variables predefinidas se

usan en los scriptlets de la misma forma que se usan en los servelts, excepto que no las

declaramos.

150

<%

strMult = request.getParameter("MULTIPLIER");

socsec = request.getParameter("SOCSEC");

integerMult = new Integer(strMult);

multiplier = integerMult.intValue();

bonus = 100.00;

%>

2.3.3.1.1.1.5 Expresiones

Las expresiones JSP nos permiten recuperar dinámicamente o calcular valores a

insertar directamente en la página JSP. En este ejemplo, una expresión recupera el

número de la seguridad social desde el bean de entidad Bonus y lo pone en la página JSP.

<H1>Bonus Calculation</H1>

Social security number retrieved:

<%= record.getSocSec() %>

<P>

Bonus Amount retrieved: <%= record.getBonus() %>

<P>

2.3.3.1.1.1.6 Etiquetas específicas de JSP

La especificación JavaServer Pages 1.1 define etiquetas específicas de JSP que nos

permiten extender la implementación JSP con nuevas características y ocultar mucha

complejidad a los diseñadores visuales que necesitan buscar la página JSP y modificarla.

Fig. Estructura de una página JSP

151

2.3.3.1.1.1.7 Procesamiento de la página JSP

Cuando se llame a ésta página (date.jsp), será compilada (por el motor JSP) en un

Servlet Java. En este momento el Servlet es manejado por el motor Servlet como

cualquier otro Servlet. El motor Servlet carga la clase Servlet (usando un cargador de

clases) y lo ejecuta para crear HTML dinámico para enviarlo al navegador, como se ve en

la Figura 2. Para este ejemplo, el Servelt crea un objeto Date y lo escribe como un String

en el objeto out, que es el stream de salida hacia el navegador.

2.3.3.1.1.1.8 Objetos implícitos

El motor JSP nos ofrece instancias de un conjunto de clases. Son objetos ya

establecidos, que no tenemos más que usar (no hay que instanciarlos). Deben utilizarse

dentro del código Java.

Algunos objetos implícitos:

page (javax.servlet.jsp.HttpJspPage.): Instancia del servlet de la página. Esto es

sólo un sinónimo de this, y no es muy útil en Java. Fue creado como situación

para el día que el los lenguajes de script puedan incluir otros lenguajes distintos

de Java.

config (javax.servlet.ServletConfig): Datos de configuración del servlet.

request (javax.servlet.http.HttpServletRequest): Datos de la petición, incluyendo

los parámetros. Este es el HttpServletRequest asociado con la petición, y nos

permite mirar los parámetros de la petición (mediante getParameter), el tipo de

petición (GET, POST, HEAD, etc.), y las cabeceras HTTP entrantes (cookies,

Referer, etc.). Estrictamente hablando, se permite que la petición sea una

subclase de ServletRequest distinta de HttpServletRequest, si el protocolo de la

152

petición es distinto del HTTP. Esto casi nunca se lleva a la práctica. response

(javax.servlet.http.HttpServletResponse): Datos de la respuesta. Este es el

HttpServletResponse asociado con la respuesta al cliente. Como el stream de

salida tiene un buffer, es legal seleccionar los códigos de estado y cabeceras de

respuesta, aunque no está permitido en los servlets normales una vez que la

salida ha sido enviada al cliente.

out (javax.servlet.jsp.JspWriter): Flujo de salida para el contenido de la

página. Este es el PrintWriter usado para enviar la salida al cliente. Sin embargo,

para poder hacer útil el objeto response esta es una versión con buffer de

PrintWriter llamada JspWriter. Podemos ajustar el tamaño del buffer, o incluso

desactivar el buffer, usando el atributo buffer de la directiva page. Se usa casi

exclusivamente en scriptlets ya que las expresiones JSP obtienen un lugar en el

stream de salida, y por eso raramente se refieren explícitamente a out.

session (javax.servlet.http.HttpSession): Datos específicos de la sesión de un

usuario. Este es el objeto HttpSession asociado con la petición. Las sesiones se

crean automáticamente, por esto esta variable se une incluso si no hubiera una

sesión de referencia entrante. La única excepción es usar el atributo session de la

directiva page para desactivar las sesiones, en cuyo caso los intentos de

referenciar la variable sesión causarán un error en el momento de traducir la

página JSP a un servlet.

application (javax.servlet.ServletContext): Datos compartidos por todas las

páginas de una aplicación. El ServletContext obtenido mediante

getServletConfig().getContext().

pageContext (javax.servlet.jsp.PageContext): Datos de contexto para la

ejecución de la página. JSP presenta una nueva clase llamada PageContext para

encapsular características de uso específicas del servidor como JspWriters de

alto rendimiento. La idea es que, si tenemos acceso a ellas a través de esta clase

en vez directamente, nuestro código seguirá funcionando en motores servlet/JSP

"normales".

exception (java.lang.Throwable): Errores o excepciones no capturadas.

Ejemplo:

<%

String strParam = request.getParameter("nombre_del_parametro");

out.println( strParam );

%>

153

3. REFERENCIAS.

“Java – Paso a Paso”; Lopez Atienza; Lunes 06/01/11, 11:00; Blog Educativo.

http://www.lopezatienza.es/java/java-paso-a-paso-tema-11/

“Sintaxis del lenguaje Java”; SeviaSoft; Lunes 06/01/11, 11:00; Blog Educativo.

http://tutorial.saviasoft.com/java-basico/html/collections-intro.html

“Applet Java”; Deitel, Harvey, Paul & Asociados (2004); Lunes 06/01/11, 11:00;Wikipedia.

http://es.wikipedia.org/wiki/Applet_Java

“LA CLASE APPLET”; Zarza; Lunes 06/01/11, 11:00; Blog Educativo.

http://zarza.usal.es/~fgarcia/doc/tuto2/VI_2.htm

“Tutorial de Java”; Proton; Lunes 06/01/11, 11:00; Blog Educativo.

http://proton.ucting.udg.mx/tutorial/java/Cap9/cierre.html

“Programación orientada a objetos con java -Capítulo 4: Excepciones en java”; Lunes

06/01/11, 11:00; Documento PDF.

“Curso de Java”; Jesús Cáceres Tello; Lunes 06/01/11, 11:00; Documento PDF.

“Introducción a las aplicaciones Web con JAVA”; Macario Polo,Daniel Villafranca;

Ingeniería del Software II. Curso 07-08. ESI-UCLM; Lunes 06/01/11, 11:00; Documento

PDF.

“Frameworks en JAVA”; Juan Bugarin; slideshare; Lunes 06/01/11, 11:00.

http://www.slideshare.net/jlbugarin/frameworks-java-1456835

http://es.wikipedia.org/wiki/Modelo_entidad-relaci%C3%B3n

http://elies.rediris.es/elies9/4-1-2.htm

http://es.wikipedia.org/wiki/Base_de_datos

PROYECTO MODULO CLIENTE SERVIDOR

Technology

Transcript of PROYECTO MODULO CLIENTE SERVIDOR