JEE 5 (JSF)

DEPARTAMENTO DE FORMACION BULL-SICONET

ramiropareja@ieee.org carlos.de-la-flor@bull.es

CONTENIDO

Introduccion J2SE 5 JSF EJB

PLANIFICACION

SEMANA 1:

11 Jul: Introduccin a J2SE 1.5. Montaje del entorno 12 Jul: Introduccion a JSF. Navegacion entre pantallas 13 Jul: Componentes estandar. Validaciones 14 Jul: Eventos

PLANIFICACION

SEMANA 2:

18 Jul: Facelets 19 Jul: A4J 20 Jul: Richfaces 21 Jul: Introduccion a EJBs y cierre

J2SE 5.0
Novedades

NOVEDADES J2SE 5.0

Novedades en el lenguaje:

Varargs Bucle for-each Tipos genericos Tipos enumerados Autoboxing Anotaciones

Varargs

Declaracion en un metodo de un numero de argumentos indeterminado (variable). Similar en C / C++

Varargs - declaracion

Declaracion del metodo:

public void enviarEmail (String asunto, String... emails)

Solo puede haber un unico argumento variable en la declaracion del metodo. El argumento variable tiene que ser el ultimo.

Varargs - invocacion

Invocacion:
enviarEmail ("Saludo","pepe@dominio.com","juan@dominio.com");

Se puede invocar sin dar valor al argumento variable:

enviarEmail ("Saludo");

Varargs acceso a argumentos

Se accede como si fuera un array:

public void enviarEmail (String asunto,String... emails) { for (int i = 0; i < emails.length; i++) { ... System.out.println ( emails[i] ); ... } }

For each

Tambien llamado bucle FOR mejorado Sintaxis sencilla para recorrer arrays o cualquier implementacion del interfaz Iterable. Forma de uso:
for ( tipoElementos elementoAuxiliar : estructuraElementos ) { ... }

For each - uso

Antes:
for ( int i = 0; i < arrayStrings.length; i++ ) { System.out.println( array[i] ); }

Ahora
for ( String tmp : arrayStrings ) { System.out.println( tmp ); }

Tipos genericos

Permite escribir interfaces o metodos sin definir los tipos de los argumentos o de las variables. Similar a los templates de C++.

Tipos genericos por que los necesitamos?

Definimos una clase Box que pueda almacenar cualquier tipo de objeto:
public class Box { private Object object; public void add(Object object) { this.object = object; } public Object get() { return object; }

Tipos genericos por que los necesitamos?

Utilizamos la clase anterior para almacenar un Integer:

... Box integerBox = new Box(); integerBox.add(new Integer(10)); ... Integer someInteger = (Integer)integerBox.get(); System.out.println(someInteger); ...

Hacemos un casting para recuperarlo

Tipos genericos por que los necesitamos?

El compilador no sabe lo que metemos/recuperamos.

... Box integerBox = new Box(); integerBox.add(10)); ... Integer someInteger = (Integer)integerBox.get(); System.out.println(someInteger); ...

El casting puede ser incorrecto! Y EL COMPILADOR NI SE DARA CUENTA!

Tipos genericos por que los necesitamos?

Tipos genericos por que los necesitamos?

ERROR EN TIEMPO DE EJECUCION!!!

Exception in thread "main" java.lang.ClassCastException: java.lang.String cannot be cast to java.lang.Integer at BoxDemo1.main(BoxDemo1.java:9)

Tipos genericos por que los necesitamos?

Tipos genericos por que los necesitamos?

Tipos genericos por que los necesitamos?

Tipos genericos Declaracion / Implementacion

Misma clase, pero implementada con una variable de tipo generico:

public class Box<T> { private T t; public void add(T t) { this.t = t; } public T get() { return t; } }

Tipos genericos - Utilizacion

Utilizamos la clase con la variable generica:

... Box<Integer> integerBox; integerBox = new Box<Integer>(); integerBox.add(new Integer(10)); ... Integer someInteger = integerBox.get(); System.out.println(someInteger); ...

No hay que hacer casting!!

Tipos genericos - Utilizacion

Si usamos un tipo incorrecto...

... Box<Integer> integerBox; integerBox = new Box<Integer>(); integerBox.add(10); ... Integer someInteger = integerBox.get(); System.out.println(someInteger); ...

Se produce un error EN TIEMPO DE COMPILACION

Tipos genericos Definicion

Podemos definir varios tipos genericos en la declaracion de clase.

public class HashEntry<CLAVE, VALOR> { private CLAVE clave; private VALOR valor; public HashEntry(CLAVE clave, VALOR valor) { this.clave = clave; this.valor = valor; } ... SETTERS/GETTERS ... }

Los genericos asi definidos pueden ser usados para declarar variables en cualquier punto de la clase.

Tipos genericos Metodos genericos

Se llaman metodos genericos a aquellos que declaran un tipo generico como parametro
public class Aleatorizador { // Devuelve aleatoriamente uno de los dos objetos public <T> T elegir(T x, T y) { T elegido; if ((Math.random()-0.5)>0) elegido = x; else elegido = y; } return elegido;

El ambito del tipo generico definido como parametro es local, visible solo dentro del metodo!

Tipos genericos Metodos genericos

Al invocar el metodo generico, no hace falta indicar el tipo. Java lo deduce de la clase del parametro
public static void main(String[] args) { Aleatorizador aleatorizador = new Aleatorizador(); String cadena = aleatorizador.elegir("Cadena 1", "Cadena 2"); System.out.println(cadena); }

public class testAleatorizador {

Tipos genericos Metodos genericos

public class Box<T> { private T t; public <U> void inspect(U u){ System.out.println("T: " + t.getClass().getName()); System.out.println("U: " + u.getClass().getName()); } public void add(T t) { this.t = t; } public T get() { return t; }

Tipos genericos Interfaces

Todo anterior se aplica a los interfaces

public interface Guardable<T> { T salvar(); boolean borrar(T copia); } public class Cliente implements Guardable<File> { public File salvar() { ... } public boolean borrar(File copia) { return false; } ...

Tipos genericos Bounding

Se puede forzar que el tipo generico implemente un interfaz o extienda de una clase (bound)
public class HashEntry <CLAVE extends Number, VALOR> { private CLAVE clave; private VALOR valor; public HashEntry(CLAVE clave, VALOR valor) { this.clave = clave; this.valor = valor; } ... }

Extends sirve tanto para clases como interfaces

Tipos genericos Bounding

Un tipo que no cumpla el bounding, dara un error en tiempo de compilacion.

public class testHash { public static void main(String[] args) { HashEntry<Integer, String> hash = new HashEntry<Integer, String>(1,"uno"); HashEntry<String, String> hash = new HashEntry<String, String>("1","uno"); } }

Tipos genericos Bounding

Error en tiempo de compilacion
Exception in thread "main" java.lang.Error: Unresolved compilation problems: Bound mismatch: The type String is not a valid substitute for the bounded parameter <CLAVE extends Number> of the type HashEntry <CLAVE,VALOR>

Tipos genericos Bounding

Mediante el simbolo & hacemos bounding de varios interfaces:

public class HashEntry <CLAVE extends Number & Serializable, VALOR> { ... }

Solo se puede hacer bounding a una unica clase.

Tipos genericos Comodines

Funcionara esto?

Box<Number> caja = new Box<Number>(); caja.add(new Integer(10)); caja.add(new Double(10));

Recordemos que Integer, Float, Double, Long, Short, etc derivan de Number

Tipos genericos Comodines

Esto?

Box<Integer> caja = new Box<Number>();

Tipos genericos Comodines

Error en tiempo de compilacion

Exception in thread "main" java.lang.Error: Unresolved compilation problem: Type mismatch: cannot convert from Box<Number> to Box<Integer>

Tipos genericos Comodines

Y funcionara esto?

Box<Number> caja = new Box<Integer>();

Tipos genericos Comodines

TAMBIEN HAY ERROR EN TIEMPO DE COMPILACION!!!
Exception in thread "main" java.lang.Error: Unresolved compilation problem: Type mismatch: cannot convert from Box<Integer> to Box<Number>

Tipos genericos Comodines

Por que no funciona? Box<Integer> NO DERIVA de Box<Number> Son clases independientes.

Tiene que haber alguna manera de hacerlo...

COMODINES!

Tipos genericos Comodines

El simbolo ? es un comodin para sustituir cualquier tipo generico.

Box<?> caja; caja = new Box<Integer>(); caja = new Box<Double>(); caja = new Box<String>();

Box<?> declara una variable capaz de almacenar una instancia de Box con cualquier tipo de dato generico.

Tipos genericos Comodines

Podemos hacer un bounding con el comodin y obligar a que el comodin derive de una clase o implemente un interfaz
Box<? extends Number> caja; caja = new Box<Integer>(); caja = new Box<Double>(); caja = new Box<String>(); //Error de compilacion

En el ejemplo, caja puede contener cualquier objeto de la clase Box con tipo Number o derivado.

Tipos genericos Comodines

En este otro ejemplo, caja puede contener cualquier objeto de la clase Box con tipo Integer o un padre de Integer.
Box<? super Integer> caja; caja = new Box<Integer>(); caja = new Box<Number>(); caja = new Box<Float>(); // Error de compilacion

Tipos genericos Limitaciones

Los tipos genericos solo existen en tiempo de compilacion, no en ejecucion. Una vez compilado el codigo, se traducen a tipos normales y no queda rastro de ellos en el bytecode.

Tipos genericos Limitaciones

Una limitacion importante del uso de genericos es que no se puede instanciar un tipo generico
public class Box<T> { private T t; public Box () { t = new T(); //Error! } ... }

Tipos genericos Limitaciones

Exception in thread "main" java.lang.Error: Unresolved compilation problem: Cannot instantiate the type T

No se puede instanciar un objeto de tipo generico puesto que el compilador no tiene ni idea de los constructores.

Tipos genericos Limitaciones

Truco (nada recomendable)

t = (T) t.getClass().newInstance();

Tipos genericos Libreras estandar

A partir de la version 5 de Java, toda la librera (paquete) java.utils ha sido portada usando tipos genericos. Ejemplo:
ArrayList<Integer> lista = new ArrayList<Integer>();

Tipos enumerados

Nuevo tipo caracterizado por tener un numero limitado de valores posibles. Sustituyen (en ciertos casos) a las variables static final int.

Tipos enumerados

Declaracion:
public enum DiasSemana { LUNES,MARTES,MIERCOLES,JUEVES,VIERNES,SABADO,DOMINGO }

Uso:
DiasSemana dia = DiasSemana.DOMINGO;

Tipos enumerados

Implementan el metodo equals()

DiasSemana dia = DiasSemana.VIERNES; if (dia == DiasSemana.VIERNES) { System.out.println("Es viernes!"); }

Tambien implementan el interfaz Comparable

if (dia.compareTo(DiasSemana.VIERNES) >=0) { System.out.println("Es fin de semana!"); }

Tipos enumerados

Y ordinal()...
if (dia.ordinal() == 4) { System.out.println("Es el quinto dia de la semana!"); }

Y values()...
DiasSemana.values(); for (DiasSemana d : DiasSemana.values()) { System.out.println(d); }

Autoboxing

Ya no es necesario hacer el boxing o unboxing entre primitivos y sus wrappers. Antes:

Integer iObject= new Integer(1); // boxing int i= iObject.intValue(); // unboxing

Ahora, con autoboxing:

Integer iObject= 1; int i= iObject; // auto-boxing // auto-unboxing

Anotaciones

Sintaxis que permite asociar informacion en forma de par atributo-valor a los diferentes elementos de programacion (paquetes, clases, metodos, atributos, variables...). No modifican la ejecucion del programa de por si. Simplemente aaden informacion que en tiempo de compilacion o ejecucion es extraida e interpretada por el compilador, herramientas o librerias.

Anotaciones - Sintaxis

Forma general
@TipoAnotacion(nombre1=valor1,nombre2=valor2,...)

Sin miembros (marcador)

@TipoAnotacion

Con un unico miembro llamado value

@TipoAnotacion(valor)

Anotaciones - Sintaxis

Con un miembro de tipo array

@TipoAnotacion(nombre={subvalor1,subvalor2,...},...)

Anotaciones Ejemplos: anotaciones estandar

El compilador Java dispone de una serie de anotaciones estandar. Override:

Avisa al compilador de que el metodo anotado sobrecarga el metodo de una superclase. El compilador avisara si no existe dicho metodo en la superclase.
@Override public String toString() { ... }

Anotaciones Ejemplos: anotaciones estandar

Deprecated:

Avisa al compilador de que el elemento anotado esta obsoleto. El compilador avisara si se usa un elemento obsoleto dentro de codigo no obsoleto
@Deprecated public class Box {...}

@Deprecated public int suma(int a, int b) {...}

Anotaciones Ejemplos: anotaciones estandar

SuppressWarning:

Indica al compilador que warnings debe omitir. Se pasa un array de valores con los warnings omitidos (dependen del compilador): all, deprecation, checked, falltrough, path, serial, finally, unused...
@SuppressWarnings("unused") public class test { } private int c;

Anotaciones - Definicion

Tambien podemos definir nuestros propios tipos de anotaciones:

public @interface Registro { String programador(); int version(); String fecha(); }

Anotaciones - Definicion

Una vez definida nuestra propia anotacion, podemos utilizarla:

@Registro(programador="ramiro", version=1, fecha="1 Marzo 2010") public class Box { ... }

Anotaciones - Meta-anotaciones

Una meta-anotacion es una anotacion que se aplica a la definicion de otra anotacion Sirven para indicar el comportamiento de las anotaciones. Existen unas cuantas meta-anotaciones predefinidas: Documented, Inherited, Retention, Target

Anotaciones - Meta-anotaciones
Retention:

Especifica la politica para mantener en memoria la anotacion Unico miembro value con los siguientes posibles valores (Enum RetentionPolicy)

SOURCE: La anotacion solo esta en el codigo fuente. Se descarta por el compilador. CLASS: La anotacion se almacena en el fichero de la clase, pero no es accesible en tiempo de ejecucion. Comportamiento por defecto RUNTIME: La anotacion se almacena en el fichero de clase y es accesible en tiempo de ejecucion.

Anotaciones - Meta-anotaciones
Target:

Indica para que elementos es aplicable la anotacion: Unico miembro value con los siguientes posibles valores (Enum ElementType):

TYPE: clase, interfaz o enum METHOD PARAMETER CONSTRUCTOR LOCAL_VARIABLE ANNOTATION_TYPE PACKAGE

Anotaciones - Definicion

@Retention(RetentionPolicy.RUNTIME) @Target({ElementType.PACKAGE, ElementType.TYPE, ElementType.METHOD}) public @interface Registro { String programador(); int version(); String fecha(); }

Anotaciones - Extraccion

Podemos acceder a las anotaciones en tiempo de ejecucion mediante la API reflection

Anotaciones Extraccion
import java.lang.annotation.Annotation; import java.lang.reflect.Method; public class TestMiClase { public static void main(String[] args) { MiClase miClase = new MiClase(); Class clase = miClase.getClass(); Registro anotacion; Anotacion = (Registro)clase.getAnnotation(Registro.class); System.out.println(anotacion); System.out.println("REGISTRO - Programador: " + anotacion.programador() + " ; Version: " + anotacion.version()); for (Method metodo : clase.getMethods()) { for (Annotation anotacion2 : metodo.getAnnotations()) System.out.println("METODO: " + metodo.getName() + " - " + anotacion2); } } }

Ejercicio 1

Implementar, utilizando los tipos genericos, una pila de datos. Utilice internamente un arrayList para almacenar los elementos. El metodo toString debe imprimir ordenadamente todos los elementos almacenados. Utilizar un bucle for mejorado para ello. Implementar el interfaz Iterable para que pueda ser recorrida la pila usando un for-each. Cree un constructor con una lista indeterminada de parametros (de tipo generico). Dicha lista de parametros sera utilizada para inicializar la pila

Ejercicio 2

Implementar, utilizando los tipos genericos, una hash-table. La clave sera un tipo generico derivado de Number. El valor sera un tipo generico. Se iran ordenado los datos por el valor de la clave segn se insertan en la hash-table

Ejercicio 3

Programar un DAO que sea capaz de gestionar cualquier tipo de objeto. Cada instancia de este DAO se particularizara para una clase concreta.
DAOGenerico<usuario> usuarioDAO = new DAOGenerico<usuario>();

En vez de utilizar una DB, almacenaremos los datos en una estructura de memoria dinamica (ej: HashMap)

Ejercicio 4

Modifique el DAO del ejercicio 3 de modo que se pueda configurar su comportamiento mediante anotaciones. La anotacion @Limit indicara el numero maximo de elementos a almacenar.