Día 42: EJB

EJB

Las aplicaciones EJB solo se pueden arrancar en un Servidor de aplicaciones como JBoss y los servlet, jsp y demás sólo en servidores web como el tomcat o el jetty.
Gracias al SPRING podemos usar aplicaciones EJB en servidores web. STRUTS sin SPRING no podría usar hibernate.

Servicios de los tipos de EJB

Pooling: Una lista de objetos que cada cual tiene una capacidad de usuarios, si uno se "desborda" desvia el usuario nuevo al siguiente objeto para optimizar el rendimiento.
Thread safety: cuando un usuario está conectado a un objeto lo hace mediante un "hilo" y otro usuario que se conecte tendrá que esperar hasta que el primer usuario acabe.
State Management: Cuando un usuario mete datos en un objeto y pasa cierto tiempo el objeto se serializa en un archivo y cuando vuelve a la actividad se desserializa.
Transactions: A la hora de inicializar una transaccion se utilizan X componentes y cuando se termina la transacción también.
Segurity: Que el usuario cuando acceda al componente tenga los permisos adecuados, que rol tiene.
Interceptors: Los EJB pueden interceptarse. En la comunicación de 2 componentes hay algo en medio que ninguno sabe que puede cambiar el valor de llegada y salida. No interviene en los métodos del componente de destino, simplemente intercepta.
Remote Access: Permite acceder de forma remota y obtener los objetos de esa aplicación.

Tipos de EJB:
SESSION STATEFULL
SESSION STATELESS
ENTITIES
MDB

Instalación de JBoss
Primero cojemos la carpeta "jboss-5.0.1.GA" y la introducimos a la carpeta de servidores que hicimos el primer dia para introducir el tomcat.
Entramos en el servidor, vamos a la carpeta "bin" y ejecutamos el "run.bat" para arrancar el servidor desde consola.
Para levantar el servidor desde el Eclipse nos vamos a la vista de servidores, creamos uno nuevo, seleccionamos que es un JBoss de versión 5.0 y le indicamos la ruta de la carpeta de los servidores.

Un EJB es un POJO, que no hereda de nadie.

Unas anotaciones importantes:
@Remote - Indica que es una interfaz remota.
@StateLess - Indica que la clase está sin estado y podrá ser accedido. (Es el tipo EJB de sesión remota)
@Local - Indica que la clase es local y accederá a una remota.
Si queremos añadir alguna librería al jboss la ruta es la siguiente: JBoss/Server/default/deploy/cea.jar

Ejercicio:
Tenemos que practicar el primer ejercicio de acceso remoto a un método para ello tenemos que hacer lo siguiente:

• Usar el proyecto "JavaEECea" y en el paquete "server.cap02" en el source folder "src/main/java" añadir las clases "SegundoBean" y "SegundoBeanRemote"
• Primero editamos el "SegundoBeanRemote" que será una interfaz con un método cualquiera.
• Seguidamente editamos el "SegundoBean" que implementará el método del "SegundoBeanRemote"
• Hacemos botón derecho del ratón en el proyecto y procederemos a exportar estas clases remotas. Export, tipo "JAR file", y marcaremos estas dos clases, o si están solas, el paquete entero, y le damos a "Browse..." y meteremos la nueva librería a la carpeta del jboss: "JBoss/Server/default/deploy" poniendole el nombre que queramos.
• Vamos al paquete "client.cap02" del source folder "src/test/java" y creamos una clase nueva llamada "SegundoBeanClient". En esta clase podemos copiar lo que hay en "PrimerBeanClient" y editar el nombre de la clase remota que hicimos, su objeto, el nombre del método y lo más importante decirel nombre de la clase a la que vamos a acceder: Object ref = ctx.lookup("SegundoBean/remote");
  

Un EJB es una aplicación distribuida por la web que podrá ser accedido por una aplicación de escritorio (un chat por ejemplo) o una aplicación web.

Ejercicio2:
Este ejercicio consiste en hacer un servlet que acceda a un método de una clase remota.

• Creamos un proyecto llamado "webyejbs"
• Creamos una clase servlet "Bienvenida.java" en un paquete "es.cea"
• En el servlet añadimos un método privado que sea "suma" lo que hará este método es hacer es casi lo mismo que la clase "PrimerBeanClient" del proyecto anterior, lo copiamos todo a excepción de que en vez de usar un println usamos un return.
• En el método Get del servlet comprobamos que hay escritos dos parametros en la dirección y que llame al método "suma" que hemos hecho.

Para que ésto funcione tenemos que:

• Añadir todas las librerías que están en la carpeta "JBoss/client/*.jar" en la carpeta del "tomcat/lib/"
  
• Arrancar el servidor Tomcat a la vez que aún está desplegado el servidor JBoss, para ello deben tener puertos distintos.
  

Día 41: Hibernate (2ª parte)

Hibernate
Hoy hicimos un repaso del ejercicio que teníamos que hacer ayer ya que casi la mitad de la clase faltó.
Después del repaso continuamos con el ejercicio para terminarlo.

Usando etiquetas para clases persistentes.
Sólo encima de las clases:
@Entity : Entidad
@Table(name="") : Nombre de la tabla

---

Para los métodos:
@Id : Indica que es la clave primaria
@GeneratedValue : Que se autoincremente

---

@Column : Es una columna en la tabla

---

@ManyToOne : Indica que el campo es una clave ajena para el que le referencia.
@OneToMany(mappedby="la propia clase pero con notación de objeto") : Indica que es una clave ajena.
@ManyToMany : Para indicar una relacion de muchos-muchos, para ello tendremos que usar un grupo de anotaciones en ambas clases. En una primera clase:
@ManyToMany @JoinTable(name="DiscoProductora",
joinColumns= @JoinColumn(name="productora_id", referencedColumnName="id"),
inverseJoinColumns= @JoinColumn(name="disco_id", referencedColumnName="id")
)
@IndexColumn(name="orden")

y en una segunda:

@ManyToMany @JoinTable(name="DiscoProductora",
joinColumns= @JoinColumn(name="disco_id",referencedColumnName="id"), inverseJoinColumns= @JoinColumn(name="productora_id", referencedColumnName="id") )

---

@Transient : Hibernate ignora el método que le siga, porque por defecto no hace falta usar @Column.

---

POJO
Plain Old Java Object, son objetos que no heredan, no implementan interfaces y son independientes con sus métodos getters y setters. Éste tipo de objetos son los que usamos en hibernate, las clases persistentes.
Más información AQUÍ

Día 40: Acceso a Base de Datos. Hibernate

Hibernate
Cuando recojemos algún dato de una base de datos mediante objetos lo que se hará es por ejemplo:
GrupoMusica g = m.getGrupoMusica();
List discos = g.getDiscos();
Hibernate por debajo hará la consulta SQL:
select * from discos where grupo_id = 1;

La carga perezosa, o lazy-loading, consiste en que no se realiza ningún select hasta que invoquemos un método get, de no ser así cada vez que creamos un objeto sin llenarlo el hibernate hará un select cada vez y haría que nuestra aplicación fuera más lenta.
Por suerte nuestra está siempre por defecto a "true"

Nos vamos a la página 159 del PDF "hibernate_reference"

Sobre la problemática de la herencia:
Tenemos una clase padre Usuario y otras 3 clases hijas que heredan de ésta.
Usuario tiene los campos id y nombre.
Registrado tiene además el campo dirección.
Administrador tiene un campo clave y permisos.
Para que todo esto funcione tiene que haber una tabla que tenga todos los campos de todas las clases que usamos además del campo "tipo" que indicará si es registrado o administrador.

Ejercicio
El ejercicio de hoy consiste en crear una estructura de clases usando hibernate y también crear las tablas, aunque nos centraremos simplemente en las clases y sus relaciones.

La estructura de relaciones del ejercicio es la siguiente:

• Un GrupoMusica tiene muchos Músico y un Músico solo tiene 1 GrupoMusica
• Un GrupoMusica tiene muchos Disco y un Disco solo tiene 1 GrupoMusica
• Un Disco tiene muchas Cancion y una Cancion solo tiene 1 Disco
• Un Disco tiene muchas Productora y una Productora tiene muchos Disco
• Un Disco tiene muchos Pedido y un Pedido solo tiene 1 Disco
• Un Pedido solo tiene 1 Cliente y un Cliente tiene muchos Pedido
  

Los métodos que deben tener, además del id y del nombre (método en plural=Colección de ...):

• GrupoMusica: +musicos / +discos.
• Musico: +grupoMusica
• Disco: +grupoMusica / +productoras / +pedidos / +canciones
  
• Productora: +discos
• Cancion: +disco
• Pedido: +disco / +cliente
• Cliente: +pedidos
  

Los pasos a seguir son:

• Crear los modelos de cada tabla, es decir, crear cada clase de lo que vayamos a hacer. GrupoMusica, Musico, Disco, Cancion, Productora, Pedido y Cliente.
  Cada una de ellas se tiene que crear en el proyecto modelo "libreria-model" y haremos un paquete nuevo que lo distinga.
  
• Crear cada archivo ".hbm.xml" de cada clase indicando los campos que aparecerán en la base de datos y sus relaciones.
• Actualizar el archivo "hibernate.cfg.xml" para que se apliquen las clases persistentes.
• Actualizar el archivo "import.sql" para que añada datos de ejemplo.
  
• Ejecutar un test para que se verifique que funciona todo.
  

Día 38: Struts2, Spring e Hibernate

Struts 2

Deja de haber un struts-config para ahora ser un struts.xml y su ubicación también cambia y pasa de estar en el WEB-INF a estar en el src/main/resources.
En el archivo "struts.properties" se puede cambiar por dónde escucharán las acciones en el campo "struts.action.extension".
En el archivo "applicationContext.xml" podemos ver el primer uso de spring.
En las etiquetas "bean" lo que hace es como en java crear objetos, por ejemplo "bean id="helloWorldAction" class="es.cea.HelloWorldAction" singleton="false""
Tambien tiene sus propias versiones a los "getters y setters" con los "property" y sus "value"

Ejercicio
El ejercicio consiste en la creación de un nuevo formulario sobre un libro, que introduzcamos el título del libro y su referencia y después el formulario se enviará a editLibro.action que aparezcan los valores en pantalla.

Para que el ejercicio funcione correctamente debemos hacer lo siguiente (se puede variar el orden, así es como yo lo hice):

• Primeramente crear el Action, que tenga de valores el título y la referencia.
  Colocar antes de la clase la anotación "@Validation".
  Introducir sus métodos getters y setters.
  Introducir antes de cada getter y setter de cada campo la anotación de validación. "@RequiredStringValidator(...)"
  Y por último el método "execute()"
• Lo segundo es hacer el primer jsp, poniendo la base del formulario con el s:form y los s:textfield poniendo como "name" el nombre exacto de cada campo del libro que hicimos antes.
• El segundo jsp pondremos directamente un mensaje diciendo que nuestro titulo y referencia es: y ahí ponemos "s:property" y de "value" el nombre del campo del libro
• Ahora continuemos con la configuración y funcionamiento interno. Nos vamos a "applicationContext.xml" y abajo del todo haremos un nuevo "bean" de "id" el que queramos y de "class" la clase Action que creamos al principio.
• En "struts.xml" creamos una nueva "action" de "class" con el mismo nombre que el id que pusimos antes y de "name" el nombre de la acción (que será lo que pondremos en el navegador para acceder a él, yo puse "crearLibro")
  Dentro de la etiqueta "action" ponemos un par de etiquetas llamadas "result", la primera de "name": "input" que será la página de la que enviará el formulario y el otro result, sin "name" será a la que redirigirá.

Con todos estos pasos hechos debería funcionar y a la hora de escribir "http://localhost:8080/struts2/crearLibro.action" debería salir el formulario de entrada y al enviarlo mostrar lo que escribimos.

---

Spring
El Spring Framework hace de factoría de objetos. Crea los objetos y los contiene además de que lo gestiona.
Como dijimos anteriormente en esta misma entrada:
"En las etiquetas "bean" lo que hace es como en java crear objetos, por ejemplo "bean id="helloWorldAction" class="es.cea.HelloWorldAction" singleton="false""
Tambien tiene sus propias versiones a los "getters y setters" con los "property" y sus "value""
También recibe objetos y es que en vez de usar "value" para introducir una cadena, un valor, a un parametros, usaremos "ref" para referenciar a otro objeto, otro bean.

Conozcamos algo más de spring AQUI

Ejercicio
Crear clases: Coche con marca y Motor con 2 tipos de motor, gasolina y diesel. Creando también sus test y sus respectivos applicationContext.xml

Los pasos del ejercicio serían:

• Nos creamos dos clases: Clase Motor: contendrá la propiedad Tipo. Clase Coche: contendrá las propiedades Marca y Motor de tipo Motor.
  Creamos sus getter y setters.
• Creamos un applicationContext.xml nuevo, que lo llamaremos "applicationContextCoches.xml" y crearemos los objetos de tipo Motor y de tipo Coche según Spring. "bean id=motorGasolina class=eticom.di.model.Motor" con un "property name=tipo value=Gasolina" y cerramos el "/bean"
  Haremos lo mismo otra vez pero esta vez de tipo Diesel.
  Con esto lo que hacemos es crear un objeto de tipo motor con el parametro "tipo" (que es String) con el valor que le indiquemos.
• Hacemos dentro del "applicationContextCoches.xml" los objetos del Coche. "bean id=cocheGasolina class=eticom.di.model.Coche" y sus property "property name=marca value=Ford" y el más importante: "property name=motor ref=motorGasolina" y cerramos el "/bean"
  Con el "ref" lo que hacemos es rellenar la propiedad "Motor" de tipo Motor en el objeto Coche haciendo referencia al objeto que hemos hecho de tipo motor a través de Spring.
• Creamos un test que compruebe que las marcas, los tipos y demás propiedades sean correctas.
  Para ello debemos tener un método con la anotación "@BeforeClass" que importe el xml del cual podamos acceder.
  Resource resource = new FileSystemResource("src/main/resources/applicationContextCoches.xml");
  factory = new XmlBeanFactory(resource);
  Y en cada método que vayamos a hacer la comprobación haremos:
  Object bean = factory.getBean("motorGasolina");
  En "motorGasolina" pondremos el objeto que queramos recuperar que hizo el spring.
  

---

Hibernate

Ejercicio
Guión:
Crear clase género con un ID y un NOMBRE (En el proyecto "libreria-model")
Crear un fichero de mapeo genero.hbm.xml (el resto es del proyecto "libreria-dao-hibernate-xml")
Incluimos el nuevo mapeo en el fichero de configuración de hibernate hibernate.cfg.xml
Modificamos import.sql
Hacemos una prueba

Pasos:

• Primeramente creamos un bean llamado genero, con un id y un nombre.
  
• Creamos un fichero nuevo de mapeo llamado Genero.hbm.xml que llama a la clase que hemos creado y nombramos la tabla que creará: "generos" además de escecificarle el id y la propiedad nombre.
• Añadimos una nueva ruta de mapeo en el archivo de configuración de hibernate "hibernate.cfg.xml" que será el archivo que hemos creado de mapeo de generos.
• Modificamos el import.sql para que añada dos campos nuevos.
• Creamos un test nuevo para comprobar que nos funciona pero para ello necesitaremos crear un método nuevo en "LibreriaDAOHibernate.java" que devuelva un género dada el id y otro que devuelve una lista de géneros sin decirle nada.
  

Ejercicio mejorado
Guión:
Relacionar la clase libro con la clase género.
La relación es: un libro tiene siempre un género, un género puede tener 0 o muchos libros.
En genero crear un get libros.
En libro crear el genero, para que haya una relación.

Pasos:

• Añadimos una propiedad "genero" de tipo Genero en la clase Libro y añadimos en Genero una propiedad "libros" de tipo Set y por supuesto, sus métodos getters y setters.
• Actualizamos Genero.hbm.xml y Libro.hbm.xml añadiendo las relaciones y valores necesarios.
• Actualizamos el import.sql
• No nos olvidemos de actualizar el applicationContext.xml de nuestra aplicación.
• Actualizar el import.sql de nuestra aplicación.
  
• INSTALAR los proyectos que hemos modificado (libreria-model, libreria-dao-hibernate, ....

Día 36: Struts, continuación2 e Hibernate

Hibernate, pequeta introducción
Resuelve uno de los patrones de desarrollo (ORM - Object Related Mapping)
Está entre el modelo de objetos (nuestro programa) y el modelo relacional (la base de datos) y los enlaza. Esto es una nueva capa entre un DAO y una base de datos.
En resumen: un DAO habla con el ORM (el hibernate) y éste se encarga de hablar con la base de datos. La base de datos es indiferente, simplemente le indicamos al hibernate que driver utilizar.
HSQLB, es otro motor de base de datos, tiene gran rapidez y lo tiene el open office.

Para que hibernate relacione cada clase (los modelos) de nuestra aplicación con las tablas de la base de datos necesita haber un archivo xml con la configuración, por ejemplo "Autor.hbm.xml" que le indique cada campo del modelo.

Si quisieramos tener hibernate funcionando en alguna aplicación lo mínimo es:
Un archivo sql: "import.sql"
El archivo de configuración: "hibernate.cfg.xml"
El mapeo de las clases, por ejemplo "Autor.hbm.xml"
Y la librería del hibernate: "hibernate-core.jar"

Para saber más de Hibernate miremos AQUÍ

Continuación con el proyecto struts-avanzado
Continuamos con la creación, edición y borrado de elementos.