Icefaces, JBoss, Maven2 y EJB3: Parte 2

Icefaces, JBoss, Maven2 y
EJB3: Parte 2.

Como ya os prometí
en el anterior tutorial de esta ‘saga’, en este pretendemos
configurar la parte del módulo Web y del módulo Modelo
para empezar a trabajar.

Por lo tanto, nuestro
objetivo será configurar correctamente la aplicación
Web para que se pueda desplegar correctamente en Jboss e Icefaces y
configurar el proyecto eclipse de manera correcta al igual que el
proyecto EJB.

Suponemos que ya
tenéis instalado JBoss 4.2.2 y ‘enlazado’ con eclipse y
habéis finalizado con éxito el tutorial anterior.

1. Estructura
   del proyecto WEB.

   Al
   ser un proyecto Web dinámico, y siguiendo la estructura de
   Maven2, tendremos: (si no lo tenéis así, modificadlo
   para que así sea)

• Los fuentes en la carpeta
  src/main/java

• Los recursos en src/main/resources
  (No olvidéis añadirla al proyecto como carpeta de
  fuentes)

• Las clases compiladas en:
  target/classes

• Los ficheros de la aplicación
  Web: src/main/webapp

2. Creando
   descriptor web.xml.

El descriptor web.xml (en
src/main/webapp/WEB-INF) tendrá la siguiente forma:

Web

index.jsp


Faces Servlet
javax.faces.webapp.FacesServlet
1


javax.faces.STATE_SAVING_METHOD
server


com.icesoft.faces.uploadDirectory
upload


com.icesoft.faces.uploadMaxFileSize
4048576


Persistent Faces Servlet
com.icesoft.faces.webapp.xmlhttp.PersistentFacesServlet
1


Blocking Servlet
com.icesoft.faces.webapp.xmlhttp.BlockingServlet
1


Faces Servlet
*.jsf


Faces Servlet
*.jspx



Persistent Faces Servlet
*.iface


Persistent Faces Servlet
/xmlhttp/*


Blocking Servlet
/block/*


Blocking Servlet
/block/*


uploadServlet
com.icesoft.faces.component.inputfile.FileUploadServlet
1


uploadServlet
/uploadHtml


com.icesoft.faces.util.event.servlet.ContextEventRepeater

3. Fichero de
   configuración de JSF: faces-config.xml

El fichero de
configuración faces-config.xml (en src/main/webapp/WEB-INF)
tendrá la siguiente forma:

Test Bean

testCtrl

com.autentia.tutoriales.icefaces.beans.TestCtrl

session

Por ahora, sólo
hemos configurado un bean de Sesión que nos servirá de
ejemplo.

4. Fichero
   index.jsp y test.jspx

   Crearemos dos ficheros jsp. El
   primero, que será el fichero de bienvenida, que redirigirá
   al fichero test.jspx. Nuestro único objetivo será
   demostrar que hemos configurado todo correctamente.

   El
   fichero index.jsp (en src/main/webapp) tendrá la siguiente
   forma:

El
fichero test.jspx (JSP y XML) (en src/main/webapp) tendrá la
siguiente forma:

4. Vamos a
   crear el Bean.

   Crearemos
   la clase: com.autentia.tutoriales.icefaces.beans.TestCtrl:

package com.autentia.tutoriales.icefaces.beans;

public class TestCtrl {
public String getLabel() {
return "Esta es una etiqueta";
}
}

6. Configuración
   de las trazas.

   Cread
   en la carpeta src/main/resources los ficheros:

• commons-logging.properties

  org.apache.commons.logging.Log=org.apache.commons.logging.impl.Log4JLogger
  

• log4j.properties

  # Main loggers
  log4j.rootLogger=INFO, stdout
  log4j.logger.org.apache=ERROR
  
  # Console appender
  log4j.appender.stdout=org.apache.log4j.ConsoleAppender
  log4j.appender.stdout.Target=System.out
  log4j.appender.stdout.layout=org.apache.log4j.PatternLayout
  log4j.appender.stdout.layout.ConversionPattern=%d{ABSOLUTE} %5p %c{1} - %m%n
  

7. Preparando
   para desplegar el proyecto WEB

Lo
añadimos al servidor Jboss en eclipse (no lo arranquéis
aún)

Pulsamos
sobre propiedades del proyecto y en ‘J2EE Module Dependencies’
marcamos únicamente ‘Maven Dependencies’

Arrancamos
el servidor y entramos en http://localhost:8080/Web

Debemos
ver una página muy simple:

8. Estructura
   del proyecto Modelo.

   Al
   ser un proyecto EJB 3.0, y siguiendo la estructura de Maven2,
   tendremos: (si no lo tenéis así, modificadlo para que
   así sea)

• Los fuentes en la carpeta
  src/main/java

• Los recursos en src/main/resources
  (No olvidéis añadirla al proyecto como carpeta de
  fuentes)

• Las clases compiladas en:
  target/classes

9. Configuración
   de las trazas.

   Haced
   lo mismo que hicimos para el módulo Web

10. Crearemos
    un EJB de sesión sin estado de prueba.

    Creamos
    el interfaz Local:
    com.autentia.tutoriales.modelo.services.TestServices

package com.autentia.tutoriales.modelo.services;

import javax.ejb.Local;

@Local
public interface TestService {
public String test();
}

Y ahora el Bean:
com.autentia.tutoriales.modelo.services.TestServicesImpl

package com.autentia.tutoriales.modelo.services;

import javax.ejb.Stateless;
import org.apache.commons.logging.Log;
import org.apache.commons.logging.LogFactory;

@Stateless
public class TestServiceImpl implements TestService {
private static Log log = LogFactory.getLog(TestServiceImpl.class);
public String test() {
log.info("Me llaman");
return "Y este es el valor";
}

}

Vamos a crearnos una clase
que nos permita localizar los EJBs de manera transparente:

com.autentia.tutoriales.modelo.util.EjbLocator

package com.autentia.tutoriales.modelo.util;

import javax.naming.InitialContext;
import javax.naming.NamingException;
import org.apache.commons.logging.Log;
import org.apache.commons.logging.LogFactory;

public class EjbLocator {
private static Log log = LogFactory.getLog(EjbLocator.class);
private static final InitialContext ctx;

static {
try {
ctx = new InitialContext();
} catch (NamingException e) {
log.fatal("It is not possible to create a new InitialContext.", e);
throw new RuntimeException(e);
}
}
/**
* Constructor privado.
*/
private EjbLocator() {
}
/**
* Retorna una referencia a un EJB Local
*/
@SuppressWarnings("unchecked")
public static  T lookupLocalBean(Class beanClass) throws NamingException {
final String jndiName = beanClass.getSimpleName() + "/local";
final T bean = (T)jndiLookup(jndiName);
return bean;
}

private static Object jndiLookup(String jndiName) throws NamingException {
final Object obj;
try {
obj = ctx.lookup(jndiName);
if (log.isDebugEnabled()) log.debug("Found JNDI name: " + jndiName);
} catch (NamingException e) {
log.fatal("Can not found JNDI name: " + jndiName);
throw e;
}
return obj;
}
}

11. Invocamos
    al Modelo desde el Web:

    Configuramos
    el proyecto Web en eclipse añadiendo la dependencia del
    proyecto Modelo:

Editamos la clase TestCtrl
dejándola así:

package com.autentia.tutoriales.icefaces.beans;

import javax.naming.NamingException;
import org.apache.commons.logging.Log;
import org.apache.commons.logging.LogFactory;
import com.autentia.tutoriales.modelo.services.TestService;
import com.autentia.tutoriales.modelo.services.TestServiceImpl;
import com.autentia.tutoriales.modelo.util.EjbLocator;


public class TestCtrl {
private static Log log = LogFactory.getLog(TestCtrl.class);
TestService servicio;
public TestCtrl() {
log.debug("Constructor:TestCtrl");
try {
servicio = EjbLocator.lookupLocalBean(TestServiceImpl.class);
} catch (NamingException e) {
log.error ("Error al iniciar el controlador: ", e);
}
}
public String getLabel() {
log.info("Me llaman");
return "Esta es una etiqueta";
}
public String getValor() {
return servicio.test();
}
}

Mostramos el valor en la
página test.jspx:

Invocamos a la aplicación
(no olvidéis añadir el proyecto Modelo al servidor y
arrancarlo).: http://localhost:8080/Web/

Veremos una página muy
simple:

En apariencia sólo
tenemos una página muy sencilla, pero la realidad es que ya
tenemos un arquetipo de aplicación bastante interesante
técnicamente:

• JSF e Icefaces preparaditos para
  utilizar (me encanta eso del partial submit de icefaces).

• EJB 3.0 deseando ayudarnos con su
  magia.

• Las dependencias de las librerías
  manejadas por Maven2 y ‘enganchadito’ todo con Eclipse gracias a
  m2Eclipse.

• Desplegado y funcionando en Jboss.

Aún nos queda trabajo
por hacer… os adelanto que lo próximo será
inventarnos un modelo de datos, crearnos un esquema en MySQL que lo
represente, crear las clases de entidad (Entity) y
hacernos un DAO implementado en un EJB de sesión sin estado.