Día 48: EJB (7ª Parte) y JSF (6ª parte)

Si queremos inyectar un valor de un parametro hacemos lo de siempre pero con el value de tal forma: "#{param.id}" (id, por ejemplo)

Hoy continuamos con los ejercicios de siempre y esta vez que haya un buscador de canciones dado un disco además de que en la tabla que aparezca de los resultados nos muestre un enlace especial de tipo "h:commandLink" que haga una acción y que se muestren los detalles de la canción.

Día 47: EJB (6ª Parte) y JSF (5ª parte)

Siempre que hagamos algún cambio en nuestros proyectos de JSF, EJB o JPA debemos hacer en la consola "mvn clean install"

Formulario de busqueda de disco por nombre. Llama a una página que muestra los datos del disco encontrado.
Formulario por nombre del disco y nombre del autor.

Antes de acabar la clase: hacer pruebas en aislamiento en el EJB, en el JPA y en el JSF y usando el mockito.

---

Hoy terminamos el ejercicio que dejamos ayer pendiente sobre la búsqueda del disco y del cantante.
Este ejercicio lo hice a mi manera y me funciona, pero se puede hacer de otra manera.
Los pasos para que funcione son los siguientes:

JPA (Java Persistence API) >Usado en el proyecto "discografía-hibernate" // Saber Más

• Tener la clase "Disco" creada implementando "Serializable" con sus parámetros: id, nombre, cantante (de tipo Cantante) y canciones (Conjunto de Canciones) con sus anotaciones "@Entity" y "@Table" al comienzo de la clase y las anotaciones "@Id" y "@GeneratedValue" en el método getter del Id y "@Column" en los getter del resto de parámetros.
• Tener la clase "Cantante" creada, implementando también "Serializable" y sus parámetros son: id, nombre y discos (Conjunto de Discos) y con las mismas anotaciones de "Disco"
• Vamos a la consola y limpiamos del repositorio el proyecto y lo volvemos a instalar introduciendo el comando mvn clean install (C:\workspace\discografica-hibernate>mvn clean install)
  

EJB (Enterprise JavaBeans) >Usado en el proyecto "ejbProject" // Saber Más

• Primeramente debemos tener creada la interfaz "DiscograficaDAORemote" encabezando los métodos para buscar un cantante introduciendole un nombre y devolviendo un "Cantante" y otro método para buscar un disco que le introducimos el nombre del disco y el nombre del cantante y devolviendo un "Disco"
• Creamos la clase "DiscograficaDAO" que implemente la interfaz "DiscograficaDAORemote" y rellenando los métodos de búsqueda.
  El método para buscar el cantante quedaría así:
  
  • Query query = entityManager.createQuery("" +
    "from Cantante ca where " +
    "ca.nombre=:nombre");
    query.setParameter("nombre", nombre);
    try{
    Cantante resultadoConsulta = (Cantante) query.getSingleResult();
    return resultadoConsulta;
    }catch (NoResultException e) {
    e.printStackTrace();
    return null;
    }
    
  
  El método para buscar el Disco quedaría así:
  
  • Query query = entityManager.createQuery(""
    "from Disco d " +
    "where d.nombre=:nombreDisco and " +
    "d.cantante.nombre=:nombreCantante");
    query.setParameter("nombreDisco", nombreDisco);
    query.setParameter("nombreCantante", nombreCantante);
    try{
    Disco resultadoConsulta = (Disco) query.getSingleResult();
    return resultadoConsulta;
    }catch (NoResultException e) {
    e.printStackTrace();
    return null;
    }
• Vamos a la consola, en este proyecto y realizamos un "mvn clean install"
  

JSF (JavaServer Faces) >usado en el proyecto "jsf1" // Saber Más

• Primero creamos un archivo ".xhtml" en "src/main/webapp" que será el que muestre un formulario de la búsqueda. Hacemos 2 formularios con distintos id.
  Formulario 1:
  
  • Usando la etiqueta de jsf "h:inputText" le introducimos un valor "#{busquedaBean.cantante.nombre}" que lo que hace es rellenar una propiedad de una clase llamada "BusquedaBean" y que el campo sea requerido y al final un "h:commandButton" de action: "#{busquedaAction.busca1}" que lo que hará será llamar un método de una clase llamada "BusquedaAction"
  Formulario 2:
  
  • Lo mismo que el primer formulario pero que introduzca el nombre del disco.
• Creamos una clase llamada "BusquedaBean" que tenga como atributos cantante (de tipo Cantante) y disco (de tipo Disco) con sus métodos getter y setter.
• Creamos una clase llamada "BusquedaAction" que será la que enlazará con el EJB DiscograficaDAO y sus métodos.
  Añadimos un método que será el que recoja de forma remota la clase DiscograficaDAO, lo hacemos método porque el código es algo engorroso y feo:
  
  • private DiscograficaDAORemote getDiscograficaDAO() throws NamingException {
    Properties p = new Properties();
    p.put(Context.INITIAL_CONTEXT_FACTORY,
    "org.jnp.interfaces.NamingContextFactory");
    p.put(Context.URL_PKG_PREFIXES, "org.jboss.naming:org.jnp.interfaces");
    p.put(Context.PROVIDER_URL, "jnp://localhost:1099");
    Context ctx = new InitialContext(p);
    Object ref = ctx.lookup("DiscograficaDAO/remote");
    DiscograficaDAORemote discograficaDAORemote = (DiscograficaDAORemote) PortableRemoteObject
    .narrow(ref, DiscograficaDAORemote.class);
    return discograficaDAORemote;
    }
  
  Creamos los métodos que llaman los formularios que a su vez llaman a los métodos que creamos de búsqueda en el EJB DiscograficaDAO
  También tendrá como atributo la clase "BusquedaBean" que creamos antes y que usaremos aquí. Por ejemplo el método para buscar un cantante:
  
  • public String busca1(){ //Buscar el cantante
    DiscograficaDAORemote discograficaDAORemote;
    try {
    discograficaDAORemote = getDiscograficaDAO();
    } catch (NamingException e) {
    throw new RuntimeException(e);
    }
    Cantante cantante = discograficaDAORemote
    .buscaCant(busquedaBean.getCantante().getNombre());
    if(cantante!=null)
    return ("cantanteEncontrado");
    else
    return("cantanteNEncontrado");
    }
    
• Lo siguiente sería enlazar y asignar un nombre al Bean y a las acciones y que el formulario de la página lo use. Para ello tenemos que editar el archivo de configuración "my-config.xml" situado en "src/main/webapp/WEB-INF"
  
  • Añadimos una etiqueta "managed-bean" y le asignamos un nombre "busquedaBean", seleccionamos la clase (en cuál paquete está ubicado y el nombre de la clase) y que tenga un tiempo de vida de tipo petición.
  • Hacemos de nuevo lo mismo pero de nombre "busquedaAction" y le añadimos una propiedad (managed-property) que de nombre es el bean (busquedaBean) y de valor (value) sera "#{busquedaBean}". Con esto lo que estamos haciendo es que se inyecte la clase bean en la clase de la accion ya que necesitamos de ella.
• En este proyecto no hace falta hacer la instalación

---

Ejercicio
Ampliamos nuestro ejercicio y esta vez en vez de solamente hacer una búsqueda que borre y guarde en la base de datos.

Día 46: EJB (5ª Parte) y JSF (4ª parte)

Lo más puntero hoy día es la combinación de las tecnologías JSF, EJB y JPA

El JPA son las clases persistentes, las clases java que tienen la anotación @Entity , que siempre tendran un id (@Id) que será un valor generado (@GeneratedValue) y que la clase implementará "serializable"

Los EJB son interfaces que usan la anotación "@Remote" e implementaciones que usan @Stateless o @Statefull en el que se inyectan los "entityManager" a través de la anotación "@PersistenceContext"

Los JSF son las páginas ".xhtml" que rellenan con sus formularios los datos de las acciones y un archivo de configuración "my-config.xml" los crea y los enlaza.

En resumen: Un usuario accede a un formulario lo rellena y lo envía. -> Un JSF envía los datos a unas acciones que se encargan de redirigirlas a un EJB que éste rellena los datos en una entidad (JPA) y se guardan en una base de datos.

Proyectos clave:
JPA: discografia-hibernate
EJB: ejbProject
JSF: jsf1

Lo que hoy hicimos fue lo mismo que estos dias atras, el caso de hoy es que un usuario introduce su nombre y su clave y para los que terminaran que introdujeran mejoras en el proyecto como un buscador de cantante y otro de disco metiendo nuevos métodos en el "DiscograficaDAO"

Día 45: EJB (4ª Parte) y JSF (3ª parte)

Hoy comenzamos cambiando el puerto en la que abre las aplicaciones. Para ello modificamos las propiedades de configuración del pluggin jetty de maven del proyecto que queremos arrancar (modificar el archivo "pom.xml").
Después añadimos todas las librerías que están en: "jboss-5.0.1.GA\client" a las librerías del proyecto "jsf1"

Creamos un nuevo servicio, ServicioCadenas que lo que hace es recibir una cadena de caracteres y devolver el número de su longitud.
El método para hacerlo es como lo hemos hecho anteriormente.




Consejos
Atajo del eclipse: (Alt+T) Botón secundario, Refactor y "Pull up" y marcamos los métodos que queramos "subir" de una implementación a una interfaz.
Problemas con proyectos remotos EJB: Las soluciones son varias al igual que los problemas, pero lo más común es:

• Reponer la librería del proyecto: Run As, Maven Clean (Eliminará la librería del proyecto en el servidor JBoss) y después Run As, Maven Package (volverá a poner la librería)
• Si se nos ha olvidado instalar el proyecto: Run As, Maven Install (Añadirá una librería del proyecto en el repositorio del maven) y después: Run As, Maven package (lo de antes, ...)
• Lo que casi todo en la informática, reiniciar:
  > Cerrar y volver a encender el servidor jetty (Control+c y después S)
  > Cerrar y volver a encender el JBoss
  > Combinar orden de encendidos y apagados, ...
• Se admiten más consejos
  

Día 44: EJB (3ª Parte) y JSF (2ª parte)

JSF

Funcionalidades del proyecto en grupo / ideas
El JSF controla la Vista y el Modelo
Usará EJBs usando tambien Entidades

Tareas con JSF-> (MVC) Reglas de navegación, formularios, botones de acciones e inyeccion de dependencias.
Tareas con Reglas de negocio (EJB) -> Acceso a persistencia, transacciones, realizará las consultas.
Tareas con Entidades -> Clases persistentes, clase Libro, clase Género, etc.
Disco disco = new Disco();
session.save(disco);, etc

Ejercicio 1
Dentro del proyecto de ayer (jsf1) creamos una nueva funcionalidad, la de registro.

• Primero creamos "registro.xhtml" y usamos las etiquetas predefinidas de "h" y colocamos un "inputText" y un "inputSecret", que serán el mail y la clave.
• Seguidamente creamos "registroCorrecto.xhtml" que simplemente mostrará que lo hemos conseguido y mostrando el mail que introdujimos.
  
• Creamos, en el paquete "es.cea", la clase "Registro" cuyas propiedades son un mail y una clave y sus métodos getter y setters.
• Hacemos un "RegistroAction" que será la acción del registro cuando pulsamos el botón. Tendrá una propiedad de tipo "Registro" y que tenga un método llamado "registra". En el método si el mail que se recibe no es "(un email que queramos)" que devuelva nulo y si es el mail que queremos pues que devuelva "válido"
  
• En el archivo de configuración "my-config.xml" añadimos el bean de registro (managed-bean) y su acción y en éste último no nos olvidemos de la inyección de la dependencia (managed-property).
• Tampoco nos olvidemos de la regla de navegación en el "my-config.xml" (navigation-rule) sobre si el mail es válido o no.
• Probar que funciona arrancando el jetty desde la línea de comandos en el proyecto. (recuerdo que era: "mvn jetty:run")
  

Ejercicio 2 (variante del 1)
Este ejercicio consiste en lo mismo que el ejercicio anterior.
Recojemos el proyecto "discografia-hibernate" y hacemos "Run As...", "Maven install" y en el proyecto que estamos trabajando, "jsf1", le añadimos la dependencia desde maven del proyecto de la discografía y hacemos lo mismo que el ejercicio anterior, que haya una página de cantante, que se introduzca su nombre, que haya una acción, que redijira, etc etc. (no vuelvo a repetir los pasos porque son los mismos)

Esqueleto de proyecto JSF-EJB-Hibernate
Unos puntos clave (ha sido muy intensa la clase así que más o menos de lo que me acuerde xD)

• Necesitamos 3 proyectos: "discografía-hibernate" , "ejbProject" y "ejbProjectClient"
• Debemos "empaquetar" los dos primeros proyectos. (Run As.., Maven package)
• Arrancar el servidor JBoss y si nos falla revisar en la carpeta deploy (jboss-5.0.1.GA\server\default\deploy)
• Abriremos la clase java "DiscograficaDAOClient" del proyecto "ejbProjectClient" que será en donde veremos que funciona toda la estructura del proyecto.
• En los Beans "Cancion", "Cantante", "Disco" tenemos que implementar la interfaz serializable (del paquete java.io) y haciendo Control+1 (marcar la 2ª opción) añadir el serialVersionUID para que a la hora de pasar la clase persistente a travez de la red se serialice y despues se deserialice en su destino.
• Abrimos el "pom.xml" del proyecto "ejbProject" y copiamos:
  Copiar la etiqueta "Properties" (Al principio) que es la ruta en donde se empaquetará el proyecto en el servidor JBoss
  Copiar el plugin cuyo artifactId se llama "maven-jar-plugin"
  Copiar el plugin cuyo artifactId se llama "maven-clean-plugin"
  Pegarlos todos en su respectivo lugar en el "pom.xml" del proyecto "discografia-hibernate"
• Abrir el archivo "persistence.xml" del proyecto "discografia-hibernate" y comprobar que el nombre de la unidad persistente concuerde con el que se nombra en el archivo "discografica-ds.xml" que está en el "deploy" del server
  

Consejos
Sobre Ejercicio 1 y 2:
Si queremos que aparezca un mensaje de error en el jsf lo que tenemos que hacer es un control en la acción, que si no devuelve success o válido (o lo que hayamos puesto que sea afirmativo) que envíe un mensaje de error y lo hacemos de la siguiente manera:
FacesMessage message =
new FacesMessage(FacesMessage.SEVERITY_INFO,"El mail no se corresponde",null);
FacesContext.getCurrentInstance().addMessage("mail", message);
Para que funcione en la página del formulario ".xhtml" debemos indicar la etiqueta "h:messages" encima del primer input del formulario y cuando introduzcamos un valor incorrecto nos aparecerá.
Aviso!!: para que funcione no tiene que haber una regla de navegación en el "my-config.xml" (a ver si encuentro el porqué)

Día 43: EJB (2ª Parte) y JSF

EJB

EJB + JBoss AS
Proyecto Eclipse Configuración

Primero tener en el build path la librería de tiempo de ejecución del JBoss.

Localizaciones a recordar:
JBoss : Para que arranquen las aplicaciones debemos tener presente: JBoss/server/default/deploy/* (con extensiones como .ear, .war o .jar)
TomCat : Tomcat/webapps/*.jar

Practicar la creación de un proyecto EJB:

• Nuevo proyecto maven
• Crear un simple proyect
• Group Id: nombre del paquete
  Artifac id: nombre del jar
• Build Path, añadir libreria, server runtime, JBoss
• Crear un paquete es.cea y dentro una interfaz: ServicioCalculadoraRemote
• Añadir una anotación "@Remote" encima del nombre de la intefaz y crear un método "suma"
• Crear una clase ServicioCalculadora que implemente ServicioCalculadoraRemote e implemente el método "suma" y añadir en la cabecera de la clase la etiqueta de sin estado "@Stateless"
• Botón secundario encima del proyecto, Export y marcamos el paquete es.cea que están nuestras dos clases.
  La librería se colocará en "..\servers\jboss-5.0.1.GA\server\default\deploy\" y le ponemos de nombre "calculadora.jar"
• También tenemos otro modo de hacer lo mismo y es botón secundario encima del proyecto, Run As.. y marcamos "Maven Package" y la librería que nos crea lo copiamos en la misma ruta antes dicha.
  
• Si queremos acceder desde una clase java
• Copiamos del proyecto de ayer la clase "PrimerBeanClient" y lo modificamos. Recordemos que llamamos a las interfaces, no a las clases.
• El main debe quedar tal que así:
  try {
  Properties p = new Properties();
  p.put(Context.INITIAL_CONTEXT_FACTORY,
  "org.jnp.interfaces.NamingContextFactory");
  p.put(Context.URL_PKG_PREFIXES,
  "org.jboss.naming:org.jnp.interfaces");
  p.put(Context.PROVIDER_URL, "jnp://localhost:1099");
  Context ctx = new InitialContext(p);
  Object ref = ctx.lookup("ServicioCalculadora/remote");
  ServicioCalculadoraRemote servCalc = (ServicioCalculadoraRemote) PortableRemoteObject
  .narrow(ref, ServicioCalculadoraRemote.class);
  System.out.println("1 + 2 = " + servCalc.suma(1, 2));
  } catch (NamingException e) {
  e.printStackTrace();
  }

Ejercicio:
Pequeño manual de enviar un mensaje de correo usando gmail: Manual
Teniendo este código: Java Mail
Tenemos que hacer un EJB de servicio de mail usando nuestra cuenta de GMail.

• Primero creamos un proyecto, lo llamaremos servicioMail
  
• Configuramos el "build Path" y añadimos una librería nueva de tipo "Server runtime" y seleccionamos el JBoss
  
• Creamos una interfaz "ServicioMailRemote" y su clase implementación "ServicioMail" en el paquete "es.cea"
• En la interfaz añadimos la anotación @Remote y creamos la cabecera del método de enviar el Email.
  
• En la clase implementación ("ServicioMail") añadimos la anotación @Stateless e implementamos el método según el enlace que puse antes pero cambiando algunas cosas:
  
• Cambiar: props.setProperty("mail.smtp.port","465");
  Añadir: props.setProperty("mail.smtp.socketFactory.class",
  "javax.net.ssl.SSLSocketFactory");
• El código completo sería:
  // Propiedades de la conexión
  Properties props = new Properties();
  props.setProperty("mail.smtp.host", "smtp.gmail.com");
  props.setProperty("mail.smtp.starttls.enable", "true");
  props.setProperty("mail.smtp.port", "465");
  props.setProperty("mail.smtp.socketFactory.class",
  "javax.net.ssl.SSLSocketFactory");
  props.setProperty("mail.smtp.user", origen);
  props.setProperty("mail.smtp.auth", "true");
  // Preparamos la sesion
  Session session = Session.getDefaultInstance(props);
  // Construimos el mensaje
  MimeMessage message = new MimeMessage(session);
  message.setFrom(new InternetAddress(origen));
  message.addRecipient(
  Message.RecipientType.TO,
  new InternetAddress(destinatario));
  message.setSubject(asunto);
  message.setText(mensaje);
  // Lo enviamos.
  Transport t = session.getTransport("smtp");
  t.connect(origen, password);
  t.sendMessage(message, message.getAllRecipients());
  // Cierre.
  t.close();
  
• Despues de esto exportamos el paquete al JBoss como explicamos antes.
• Run As.. Java Application y listo

Ejercicio expandido (opcional):
Usando el mismo ejercicio usar el ANT para automatizar copiar el jar a la carpeta de destino del servidor y otra tarea de borrar para "desinstalar" la aplicación.

---

JSF
Java Server Faces

Es una herramienta de modelo vista controlador (MVC)

Más información AQUÍ

Abrimos el proyecto "jsf1" que sólo arrancará desde el jetty y desde la línea de comandos (mvn jetty:run)
Vamos al localhost/jsf1/ y ahí lo veremos.

El proyecto consiste en que hay unas clases bean (Modelo), un xhtml y unos archivos de configuración.
Un xhtml (Vista) tiene un formulario, cuyo botón de submit se envía a una clase de acción que controlará (controlador) el formulario. Un archivo xml enlazará todo y si recibe de los controladores el "success" mostrará los xhtml de respuesta.

Consejo:
Toda página que hagamos tiene que ser xhtml y no html

Día 34: Struts

STRUTS

Recordamos en esencia qué es el struts:
Es un framework de componenetes para desarrollo MVC.

> Para utilizar struts debemos tener su librería en el pom.xml
> Debemos definir un controlador en el web.xml que llamará al servlet "ActionServlet" que contiene los métodos que usará el struts. Añadir que es un controlador frontal que escuchará todo terminado en ".do"
> En el xml de la configuración debe contener un documento descriptor de documentos o DTD y el cual tiene varias versiones.
> Todas las peticiones que sean ".do" deben ser escuchadas por alguna clase que extienda de Action.
> Una acción necesita un formulario para poder manejar sus datos
Un ActionForm puede vivir en el "request" o en el "session"
> Las acciones de Struts nos dejan acceder al "request" y al "response"
> Aquel que necesite algo, la dependencia que necesita de otro, éste se la inyecta.

> Una dependencia es algo de lo que dependemos para realizar cualquier cosa, por ejemplo:
class Servicio{
Calculadora calculadora;
public int suma(int x,int y){
return calculadora.suma(x,y);
}
}
Inyección de dependencias. La idea es crear un objeto para muchos servicios para economizar recursos y no hacer un objeto para cada servicio.
Un ejemplo de inyección:
servicio = new Servicio();
servicio.calculadora = new Calculadora();
servicio.suma(5,6);

Componentes:
Servlet, hace de controlador.
Los TAG son para la vista.
Y los ActionForm hacen la función de modelo.

Proyecto struts-avanzado
JPQL: Java Persistence Query Languaje.

Modificación 1 (Ejercicio 1):
En la página del libro lo que debemos hacer es mostrar un enlace para ver todos sus detalles.
En los detalles del libro debemos añadir un enlace para ver con detalles los datos de su autor y también mostrar sus editoriales y otro enlace para verlos con detalles.
La página de detalles del autor mostrar simplemente sus datos.
La página de detalles de la editorial mostrar sus datos.

Modificación 2 (Ejercicio 2):
Ahora hacer que se puedan ver los capítulos e internacionalizar los textos.
Antes usábamos la etiqueta "fmt:message key=""" pero ahora usaremos "struts-bean:message key=""" ya que el struts se encarga ahora de eso.

Día 33: Internacionalización y STRUTS

Proyecto i18n
Recojemos del servidor el proyecto i18n y lo colocamos en el workspace, creamos un nuevo proyecto con el mismo nombre y lo abrirá.
Una vez abierto botón derecho, run as, maven build ... y en Goals: "tomcat:run-war"
Ahora podremos acceder al proyecto a la siguiente dirección: "http://localhost:8080/i18n/" y veremos un mensaje de salida que variará según el idioma que tengamos configurado en el navegador.

Ejercicio:
Ampliaremos los idiomas haciendo más archivos ".properties" al italiano.

---

--- STRUTS ---

Es un framework para desarrollar aplicaciones web a través de servlets.
Los jsp tendrá etiquetas de struts.
Todos los servlets deberían escuchar por un ".do" ya que todo lo que se hace son acciones.
En el archivo struts-config.xml es donde se configuran todas las acciones.
Para más información sobre el struts: Struts

Añadido 1 (Ejercicio1):
Añadiremos un nuevo "forward" que si recibe la petición "conocido" que redirija a un jsp que crearemos ahora: "/usuarioConocido.jsp"
En "SaludoAction" creamos una condicional:
if(saludoForm.getNombre().equals("pepe"))
actionForward= mapping.findForward("conocido");
else
actionForward= mapping.findForward("ok");

Añadido 2 (Ejercicio2):
Un formulario que hereda de LibroForm y que a su vez a ActionForm, el LibroForm es como un bean de libro, con su título y lo que queramos con sus métodos getters y setters.
Una vez que se rellena el formulario y se envía llamamos a la accion libro.do
Tendremos una clase LibroAction que reconocerá el título del libro y llamará a una acción que estará configurada en el archivo "struts-config.xml".
En la acción pondremos que si es un libro Y da error llamando al archivo "errorLibro.jsp" y si el libro esperado X redirija a "libroOk.jsp"

Añadido 3 (Ejercicio3):
La siguiente añadidura consiste en realizar practicamente lo mismo pero con un club.
La idea es que un usuario de nombre X y edad Y no supere los 100 años y ni sea inferior a 18, en ambos casos redirigirán a sus páginas de error y si es entre 18 y 100 que entre en el club.
La página de inicio es "club.jsp" con un formulario de "ClubForm"
El "ClubAction" se encargará de "filtrar" la edad y en la configuración del struts una acción dedicada para el formulario del club y dependiendo de la edad redirigir a una página jsp u otra.

Explicación validación:
En "traducciones.properties" tenemos 2 mensajes de error que son para el ejercicio original cuando un usuario no introduce el nombre y el apellido.
El cómo acceder a ellos, pues es fácil.
Utilizamos la etiqueta "struts-html:errors" con la propiedad "nombre", por ejemplo, aunque esto es simplemente para acceder a una propiedad dentro de un método, el cual está contenido en el "bean" o el xForm.java, que consiste en sobrescribir el método "ActionErrors validate" y realizamos lo siguiente:
if(request.getParameter("nombre")==null || request.getParameter("nombre").equals("")){
actionErrors.add("nombre", new ActionMessage("error.nombreVacio"));
}
Lo que hace es recojer el parámetro "nombre" del formulario de usuario y comprobar que no está vacío y si lo está que acceda al archivo ".properties" al campo "error.nombreVacio" y entonces se mostraría el mensaje, la propiedad de ese mensaje se le llamó "nombre" tal y como dije al principio con la etiqueta del struts de error.

Día 27: Proyecto MVC, Finalización

Término.
Hoy, por fin, damos por concluido el proyecto de la bibliotecaMvc. (aunque no se recoje hasta el lunes, así que tenemos "prórroga" este fin de semana)

Día 26: Proyecto MVC, continuación 5

Continuación, ...
Continuamos con el proyecto con algo de prisa porque mañana ya termina el plazo.
Consejo sobre la validación
Servlet
...doGet()..{
try{
compruebaNoNulos(req,"mail","clave");
}catch(){
req.setAtribute("error",...);
}
...
}

Método
public void compruebaNoNulos(HttpRequest req,String ... parametros){
foreach(String para:parametros)
if(request.getParameter(par)==null) throw new (par);
}

Día 25: Proyecto MVC, continuación 4

Continuando, ...
Hoy continuamos con el proyecto de la biblioteca usando el modelo vista controlador.

MAVEN
Se hizo una pequeña introducción de lo que es capaz de hacer el MAVEN.

Es una herramienta de consola.
Puede crear proyectos java, creando también la estructura básica.
También puede compilar: "mvn compile"
Puede crear paquetes: "mvn package" (un jar)

Día 24: Proyecto MVC, continuación 3

Continuando, ...
Hoy continuamos con el proyecto.

MAVEN
Tenemos que mirar el maven, este enlace: MAVEN

Día 23: Proyecto MVC, continuación 2

Continuando, ...
Hoy continuamos haciendo el proyecto de la biblioteca usando el modelo vista controlador.

Día 22: Proyecto MVC, continuación

Continuando, ...
Hoy continuamos con la nueva versión del proyecto de la biblioteca.

Día 21: DAO / Iniciar Proyecto MVC

Clase DAO
Un ejemplo de una clase DAO: VER.
Ese es un ejemplo de una clase DAO sin usar una base de datos, pero si la usáramos solo tendríamos que sustituir las listas por consultas SQL.

Los datos del ejemplo se usarían por las variables de aplicación usando el servletContext como tantas veces hemos hecho.

El DAO es una capa de acceso a datos y cada capa pueden lanzar excepciones.

Proyecto MVC: Biblioteca
Una vez terminado esta pequeña explicación comenzamos a organizar la continuación del proyecto de la biblioteca adaptándolo al Modelo-Vista-Controlador.

Día 20: JSTL - Parte 3, Proyecto2 e Introducción al MVC

JSTL

Etiquetas implícitas

Un primer grupo de etiquetas proporciona funcionalidad a nivel de la página de una manera muy simple:
<jsp:forward>, redirige la request a otra URL
<jsp:include>, incluye el texto de un fichero dentro de la página
<jsp:plugin>, descarga un plugin de Java (una applet o un Bean).

Un segundo grupo permite manipular componentes JavaBean sin conocimientos de Java.
<jsp:useBean>, permite manipular un Bean (si no existe, se creará el Bean), especificando su ámbito (scope), la clase y el tipo.
<jsp:getProperty>, obtiene la propiedad especificada de un bean previamente declarado y la escribe en el objeto response.
<jsp:setProperty>, establece el valor de una propiedad de un bean previamente declarado.

Un Bean tiene un id, un scope y una class.

---

Consejo:
Para poder usar variables de una clase y mostrarlas primeramente invocamos la clase con un "id", después las variables que manejaremos se tienen que colocar en una variable que manejará el jsp y despues mostrarlos ya que el jsp no sabe manejar las variables de las clases, no sabe de qué tipo son. (aunque si ponemos un valor que no corresponde, un int a un String por ej. dará error.)

<jsp:useBean id="miCosa" scope="request" class="es.cea.Cosa"/>
<jsp:setProperty name="miCosa" property="propiedad1" value="hola"/>
<jsp:setProperty name="miCosa" property="propiedad2" value="40"/>
Propiedad1 de miCosa: <jsp:getProperty name="miCosa" property="propiedad1"/>

---

Para crear etiquetas con un cuerpo la clase java tiene que extender de la clase padre "BodyTagSupport" aunque se puede tranquilamente con el "TagSupport"

Ejercicios
Primer ejercicio:
Probar en "functions.jsp" todas los métodos posibles de "jsp:", mirando las apis de java.

Segundo ejercicio:
La página del formulario: que hayan inputs de tipo text, password, inputbutton, etc.
Hacer que haya herencia en los tags.

---

Proyecto 2

Retomamos el proyecto de la biblioteca para expandirlo con lo último que hemos dado.
- Crear menus
- Dividir el proyecto en distintos paquetes segun sus funcionalidades.
- Que haya solo una clase para la manipulación de datos, cuya interfaz se llamará DAO y que en un futuro se usará para manejar bases de datos.

Un ejemplo del último punto:
List lista = new ArrayList();
convertirlo a:
Dao dao = new DaoSimple();
o si accedieramos a una base de datos:
Dao dao = new DaoMySQL();

- Implementar logueo por consola
- Incluir pruebas

Eso es remarcando lo más importante, pero el guión del proyecto es:

El proyecto se desarrollará con las siguientes tecnologías

• Patrón de desarrollo MVC (Modelo Vista Controlador)
• Servlets: Listener, Filters, Servlets
• JSP
• JSTL (tags implicitos en JSP, tags de JSTL y tags personalizados)
• Pruebas

Especial atención a:

• Modularización de la vista con uso de la etiqueta jsp:include
• Paquetes separando aspectos/finalidades/roles de las clases java
• Aislamiento de acceso a datos en una sola clase con una interfaz
• Nomenclatura
• Características standars de proyecto web java.

---

MVC
Cojemos el proyecto mvc y lo abrimos en el Eclipse para ver un ejemplo simple el funcionamiento básico de un Modelo Vista Controlador.