Libros sobre smalltalk

Dejo un link de libros sobre smalltalk, si ven la lista al final hay uno que se llama Programando con Smalltalk de Diego Gomez a simple vista parece interesante lo voy a leer y les cuanto.

Dejo el link:

http://stephane.ducasse.free.fr/FreeBooks.html

Tutorial de Android

Gracias a JavaHipano encontré este tutorial de Android que esta muy bueno:

http://www.sgoliver.net/blog/?p=1313

Que lo disfruten!

Validacion por Hibernate Validator

La JSR 303 - Bean Validation propone un API de validación basada en un modelo de metadatos, además establece como principal método de definición las anotaciones, aunque estas también pueden ser especificadas y/o extendidas a través de archivos de configuración XML. Otra de las características interesantes de la JSR 303 es que su API no liga especificamente la ejecución de las validaciones a una capa en particular como podría ser la capa web o la de persistencia, sino que puede ser utilizada desde cualquier punto de la aplicación.
Hibernate Validator es la implementación de referencia de la JSR 303.

Cuando validamos datos es posible que la validación sea puesta en la capa de presentación. Poniendo la validación en la capa de presentación corremos el riesgo de replicarla cuantas pantallas se puedan cargar los datos o si por ejemplo hay que exponer una funcionalidad por un web service o mecanismo remoto. El mejor lugar para las validaciones es la capa de presentación y hibernate validator nos ayuda a escribir estas validaciones por medio de anotaciones o xml.

Hibernate validator permite:

• Definir validaciones usando XML y/o anotaciones
• Validación completa y recursiva de objetos
• Definición a medida de constraints y validadores
• Personalización de mensajes de error

Las anotaciones más útiles son:

@Length(min=, max=): Chequea si el largo del string se encuentra en el rango indicado.
@Max(value=): Chequea que el valor sea menor o igual que el valor indicado.
@Min(value=): Chequea que el valor sea mayor o igual que el valor indicado.
@NotNull: Chequea que el valor no sea nulo
@Email: Chequea que el valor sea un mail valido.
@Range(min=, max=): Chequea que el valor se encuentre entre el rango especificado.
@Future: Chequea que el valor sea una fecha futura.
@Past: Chequea que el valor sea una fecha pasada.
@Pattern(regex="regexp", flag=): Cheque a que la propiedad machea con la expresión regular, given a match flag (see java.util.regex.Pattern for more information)
@Patterns( {@Pattern(...)} ): Como @Pattern, pero con multiples expresiones regulares.

Veamos un ejemplo de una clase validada por medio de Hibernate Validator:

package org.assembly.fenrir.model.student;

import java.util.Calendar;
import java.util.Date;

import org.hibernate.validator.NotNull;
import org.hibernate.validator.Past;


/**
* class that represents a student
*
* @author emanuel
*
*/
public class Student {

private static final int COUNT_MONTH_IN_YEAR = 12;

private String name;

private String lastName;

private Date birthDate;

private String comment;

public Student(String name, String lastName, Date birthDate){
 this.name = name;
 this.lastName = lastName;
 this.birthDate = birthDate;
}

public Student() { }


@NotNull
public String getName() {
 return name;
}

public void setName(String name) {
 this.name = name;
}

@NotNull
public String getLastName() {
 return lastName;
}

public void setLastName(String lastName) {
 this.lastName = lastName;
}

@NotNull
@Past
public Date getBirthDate() {
 return birthDate;
}

public void setBirthDate(Date birthDate) {
 this.birthDate = birthDate;
}

public String getComment() {
 return comment;
}

public void setComment(String comment) {
 this.comment = comment;
}


}

Pero como es que se valida? En cualquier punto de la aplicación se puede validar si los datos son correctos en cualquier capa de la aplicación, pero por ejemplo utilizando en la capa de presentación richfaces; este ya hace las validaciones atravez de las anotaciones o xml.

Si utilizas maven y quieres agregar este framework, aca va la dependencia del pom:

 

  org.hibernate

  hibernate-validator

  3.1.0.GA

 

Como siempre dejo link:

http://docs.jboss.org/hibernate/validator/4.0.1/reference/en/html_single/

TDD vs BDD vs ASEREJE vs Equipo

A raíz de un post que ley de dos ideas, que me resulto sensacional. Me quede pensando como a travez del tiempo nos pasamos aprendiendo metodologías para que el equipo sea más productivo, en vez de concentrarnos en formar buenos equipos. Nos preocupamos más en la daily meeting que en programador trabaje, pueda trabajar y se sienta feliz con su trabajo.

Tal vez es más fácil diseñar una metodología nueva en vez de preocuparse por el equipo. Por ejemplo, un equipo bien capacitado en una metodología la cual a modificado según su forma de trabajo y de forma que el mismo cree que es más productivo va a ser más productivo que un equipo que sigue la ultima y más top de las metodologías. Además la persona se va a sentir cómoda y feliz con su trabajo.

En conclusión seguir una metodología a raja tabla, hacer cosas inútiles solo por la metodología es una perdida de tiempo. Tiempo que sería más útil para unir al equipo limar asperezas y crear un ambiente agradable para trabajar.

Y recuerden leer www.dosideas.com que esta muy buena esta web.

Apache Chemistry

Apache Chemistry Provee una implementación Open Source de Content Management Interoperability Services (CMIS) Pero que es CMIS? Bueno CMIS es una especificación de OASIS, para mejorar la interoperabilidad de los sistemas Enterprise Content Management (ECM)

CMIS es un conjunto de Web Services pensados para compartir información entre repositorios de contenidos y que buscan la interoperabilidad de los diferentes sistemas ECM.

CMIS está compuesto de los siguientes elementos:

• Un modelo de dominio, para definir los objetos y relaciones que pueden existir en el repositorio.
• Un conjunto de APIs de comunicación, Web Services y REST, que permiten a las aplicaciones conectarse, navegar, leer y crear contenidos en los diferentes repositorios.
• Un lenguaje de consultas, similar a SQL, capaz de definir criterios de búsqueda sobre propiedades, ubicación o "full-text" de los objetos.

Apache Chemistry consiste en los siguientes proyectos:

• OpenCMIS: CMIS librerias cliente y servidor para Java
• cmislib: CMIS librerias cliente y servidor para Python
• phpclient: CMIS librerias cliente y servidor para PHP
• DotCMIS: CMIS librerias cliente y servidor para .NET

Y Obviamente con Licencia Apache.

Dejo links:

http://chemistry.apache.org/

http://chemistry.apache.org/project/community.html

Maven!!!

Este post es para repasar un poco los aspectos de apache mave...

Maven es un framework de gestión de proyectos Java, basado en POM (Project Object Model), que nos proporciona funcionalidades desde la compilación hasta la distribución, despliegue y documentación de los proyectos.

Maven se basa en patrones y en estándares. Esto permite a los desarrolladores moverse entre proyectos sin la necesidad de aprender como compilar o empaquetar, mejorando de esta forma, el mantenimiento y la reusabilidad.

Que provee maven??

• Características generales de Maven

  • Convención sobre configuración

    • Si todos estamos de acuerdo en ciertas cosas ¿Para qué configurarlas? Démoslas por hechas y mantengamos la opción de configuración por si fuera necesario

  • Uso de buenas prácticas

    • Por ejemplo ejecutar los test unitarios antes de hacer un deploy o instalación

  • Un ciclo de vida extensible declarativamente basado en fases y goals

    • Facilita automatizar tareas sencillas o todo el proceso de construcción de forma rápida y simple, una única orden

  • Un modelo centralizado y transparente de gestión de dependencias

    • Se acabó el “Jar Hell”, el buscar jars por internet y las dependencias de estos jars, o casi del todo…

El principal objetivo de maven es permitir a un desarrollador comprender el estado completo del esfuerzo del desarrollo en el período más corto de tiempo. Para lograr este objetivo existen distintas áreas de las que maven se ocupa:

• Hacer el proceso de construcción sencillo.

• Proporcionar un sistema de construcción uniforme

• Proporcionar información de la calidad del proyecto.

• Proporcionar lineamientos a seguir para el desarrollo de las mejores prácticas.

• Permitir migraciones transparentes a nuevas características.

Maven utiliza el término artifact para denominar a la unidad mínima que maneja en su repositorio. Puede ser por ejemplo un jar, un ear, un zip, etc. Cuando Maven compila y empaqueta código, produce también artifacts que instala en el repositorio.

Los artifacts están agrupados bajo el id de grupo (groupId) y tienen un id propio (artifactId), una versión, un clasificador y una extensión.

Maven está basado en torno al concepto de ciclo de vida de build (build lifecycle). Esto significa que el proceso para construir y distribuir cualquier artifact (proyecto) está claramente definido.

Para la persona que construye un proyecto, esto significa que solo debe aprender un número pequeño de comandos para construir cualquier proyecto Maven.

Existen tres ciclos de vida built-in con Maven: default, clean y site.

Default	Administra hasta el proceso de deployment
Clean	Administra las tareas de reseteo del build anterior
Site	Administra la creación del sitio de publicación del proyecto

Cada uno de los ciclos de vida está definido por una lista de fases, donde cada fase representa una etapa en el ciclo de vida.

Este ciclo de vida define la secuencia de fases que va desde validar la integridad hasta el despliegue (deploy).

Cuando se solicita la ejecución de una fase Maven ejecuta primero todas las fases anteriores siguiendo la secuencia y termina en la fase solicitada.

Las principales fases del ciclo de vida default de maven son:

validate	Valida si el proyecto es correcto y si tiene toda la información necesaria
compile	Compila el código fuente del proyecto
test	Corre los test utilizando el framework de unit test disponible
package	Toma las clases compiladas y recursos y crea un paquete (jar, war, ear).
integration-test	Procesa y despliega el paquete, para que corran las pruebas de integración.
verify	Ejecuta los chequeos necesarios para verificar que el paquete cumple los criterios de calidad.
install	Instala el paquete en el repositorio local para ser usado como dependencia por otros proyectos localmente
deploy	Copia el paquete a un repositorio remoto para ser compartido con otros usuarios y proyectos.

Las fases del cilo de vida clean:

pre-clean	Ejecuta los procesos necesarios, previos al clean
clean	Remueve todos los archivos generados en un build previo
post-clean	Ejecuta los procesos necesarios para finalizar el clean

Las fases del ciclo de vida site:

pre-site	Ejecuta los procesos necesarios, previos a la generación del site
site	Genera el site con la documentación del proyecto
post-site	Ejecuta los procesos necesarios para finalizar la creación del site
site-deploy	Realiza un deploy del site de documentación, en el web Server especificado.

Tener en cuenta que para el deploy del site, debemos configurar el web Server.

website
scp://www.mycompany.com/www/docs/project/

Bueno hasta aquí un maven, repaso general.

RichFaces

RichFaces es un framework web que combina las tecnologías Ajax con JSF. Lo cual permite hacer aplicaciones web con ajax de forma fácil sin preocuparse por mantener complicados métodos javascripts.
RichFaces es un proyecto open sources que permite agregar capacidades Ajax a su aplicación JSF sin escribir javascript por lo tanto sin preocuparse por la compatibilidad entre distintos browsers.

RichFaces provee 2 conjuntos de librerías:

• Core Ajax: Contiene componentes que son útiles para “ajaxiar” las paginas jsf y los componentes estándares de JSF. También provee componentes que generan recursos binarios como imágenes, pdfs, cvs, etc.
• UI: Es un conjunto avanzado de etiquetas Jsf que utilizan Ajax usados para agregar características de una interfaz rica de usuario en su aplicación. Estos componentes soportan Ajax y están perfectamente integrados a la librería Core. Además soportan skills y pueden ser totalmente adaptados a sus necesidades.

Otra característica de RichFace es Component Development Kit (CDK) el conjunto de herramientas usado para crear la libraría UI, y puede ser utilizado para crear nuevos componentes.

Este post explica solo un poco de RichFaces, en futuros post veremos como hacer una aplicación con este framework.

PHP for Android project (PFA)

PHP for Android project (PFA) es una plataforma que nos permite programar en PHP sobre Android. Y además nos provee de la documentación y herramientas

Además esta bajo Licencia Apache!!

Dejo links:

http://www.phpforandroid.net/manual/en/index
http://www.phpforandroid.net/
http://code.google.com/p/android-scripting/wiki/ApiReference

Erjang

Erjang no es otra cosa que una mv escrita para correr erlang sobre la plataforma java.

Como trabaja esto? Lo que permite erjang es pasar un .beam a un .class lo que permite que este corra en la jvm. Además también tiene una consola interactiva.

Este proyecto esta en pañales pero le veo mucho futuro.

Dejo links:
http://groups.google.com/group/erjang
https://github.com/trifork/erjang/wiki

JBoss Seam

JBoss Seam es un framework que integra y unifica los distintos standars de la plataforma Java EE 5.0, pudiendo trabajar con todos ellos siguiendo el mismo modelo de programación.
Ha sido diseñado intentado simplificar al máximo el desarrollo de aplicaciones, basando el diseño en Plain Old Java Objects (POJOs) con anotaciones. Estos componentes se usan desde la capa de persistencia hasta la de presentación, poniendo todas las capas en comunicación directa.

El núcleo principal de Seam está formado por las especificaciones Enterprise JavaBeans 3 (EJB3) y JavaServer Faces (JSF).
A grandes rasgos podemos definir EJB3 como una arquitectura para un sistema transaccional (como bases de datos) de objetos distribuidos basado en componentes que permite construir aplicaciones portables, reusables y escalables.
JSF es un framework de la capa de presentación que define componentes para el interfaz gráfico y "managed beans" para la lógica de la aplicación que interactúan a travé de un sistema de eventos.

Sin embargo, estos frameworks tienen algunas limitaciones y no han sido concebidos para trabajar juntos (esto pretende resolverse con la futura especificación web beans ); tienen distinto tipo de configuraciones (JSF usa archivos XML mientras que EJB3 usa anotaciones), distinto ciclo de vida y no pueden comunicarse directamente a nivel de framework.
Para hacerlos cooperar necesitaríamos escribir "clases fachada" y multitud de código de relleno que se encargase de pasar las llamadas de una capa de la aplicación a otra. Ahí es donde entra en juego Seam.
Seam elimina la barrera existente entre estas tecnologías, permitiendo usar EJBs directamente como "backing beans" de JSF y lanzar o escuchar eventos web.

El maldito libro de los descarrilados

Publico un tutorial de Ruby on Rails en castellano.

http://yottabi.com/mld.pdf

Saludos

El conocimiento cuando es compartido crece, va mejorando y se diversifica

Algunas veces me preguntan ¿porque el blog? , ¿que gano escribiendo esto? Y es difícil, muy difícil explicar en especial a gente que piensa “costo-beneficio” que el blog es solo compartir. Nunca gane ni un peso ni reconocimiento, ni nada y no es necesario ganar algo de esto para seguir.

Yo como muchos de ustedes usa framework open sources, o lee blog de otras personas. Y pienso que este blog es devolver un poco todo lo que recibo gratuitamente y solo porque gente quiere compartir su conocimiento.

Al compartir el conocimiento, leer un articulo y querer compartirlo, buscar que la gente se interese por la tecnología o lo que sea, crea una pequeña responsabilidad a mejorar, escribir cada vez mejor. Y a la vez cada vez que uno escribe fija mejor el conocimiento y aprende más, por mantener el blog se “obliga” a leer alga nuevo. Comparte su entusiasmo y siente que es un poco útil a la comunidad.

El conocimiento cuando es compartido crece, va mejorando y se diversifica; un ejemplo claro es Linux. En este pequeño post quiero aconsejarlos a que sean valientes escriban un blog, inicien un proyecto open source o participen en una comunidad. Y de paso agradezco que me lean, opinen, pidan nuevos post; esto es sumamente gratificante y ayuda a seguir escribiendo.

ActiveMQ con Spring

Vamos a crear dos aplicaciones con spring y maven. Una para publicar mensajes asincronos en ActiveMQ y un cliente para leerlo. Creamos 2 proyecto para que sea notoria la separación de cliente-servidor.

Primero creemos los proyectos con maven:

mvn archetype:create -DgroupId=org.assembly -DartifactId=creadorDeMensajes

mvn archetype:create -DgroupId=org.assembly -DartifactId=lectorDeMensajes

Ahora editemos los pom's para utilizar spring:

pom.xml de creadorDeMensajes:

4.0.0



org.assembly



creadorDeMensajes



1.0-SNAPSHOT



jar



creadorDeMensajes



http://maven.apache.org





 UTF-8











   org.springframework

    spring

   2.5.6.SEC02

 





 org.apache.activemq

  activemq-all

  5.4.2

pom.xml de LectorDeMensajes:

4.0.0



org.assembly



lectorDeMensajes



1.0-SNAPSHOT



jar



lectorDeMensajes



http://maven.apache.org





 UTF-8









  

   org.springframework

    spring

   2.5.6.SEC02

 





 org.apache.activemq

  activemq-all

  5.4.2

Importante que borren los test porque no tenemos la dependencia con jUnit vayan a la carpeta:
creadorDeMensajes/src/test/java/org/assembly y lectorDeMensajes/src/test/java/org/assembly y borren AppTest.java

Corremos:
mvn clean install
mvn eclipse:eclipse

para los dos proyectos, es decir entramos en la carpeta: creadorDeMensajes y corremos los comandos y luego hacemos lo mismo para lectorDeMensajes. Lo cual nos bajara los jars necesarios.

Creador De Mensajes
Antes que nada es recomendable utilizar una ide yo estoy usando eclipse. Para importar los proyectos a eclipse vea el siguiente link:

http://united-coders.com/phillip-steffensen/maven-2-part-3-configuring-eclipse-for-apache-maven-2-projects

Vamos a centrarnos en este proyecto, que va a crear los mensajes para luego ser leídos por el lector.
En el la carpeta creadorDeMensajes/src/main/resources (si no existe la crean) vamos a generar el archivo xml para configurar los beans que vamos a utilizar para enviar mensajes. Creamos el archivo spring-context.xml con el siguiente contenido:

El primer bean que definimos es la fabrica de conecciones a ActiveMQ, como piedad definimos la URL del corredor de mensajes. EL segundo bean es el destino que como parametro se pasa un nombre de destino. El terser bean es el objeto Template que nos hace la vida más facil a la hora de programar con ActiveMQ es una clase de spring y se configura la fabrica de conección. El cuarto bean es nuestra clase que envia mensajes.

Necesitamos una interfaz que describa el servicio, la llamamos EnviadorDeMensajes.java :

package org.assembly;



/**

* @author emanuel

*

*/

public interface EnviadorDeMensajes {



void enviarUnMensaje();



}

Luego programamos la implementación EnviadorDeMensajesImpl.java:

package org.assembly;



import javax.jms.Destination;

import javax.jms.JMSException;

import javax.jms.MapMessage;

import javax.jms.Message;

import javax.jms.Session;



import org.springframework.jms.core.JmsTemplate;

import org.springframework.jms.core.MessageCreator;



/**

* @author emanuel

*

*/

public class EnviadorDeMensajesImpl implements EnviadorDeMensajes {



private static final String MENSAJE = "Hoy te escribo una carta mi pequeña Maria, " +

                               "yo que tanto te quiero y que todos los días me acuerdo de ti, " +

                               "yo me acuerdo de ti.";



private JmsTemplate jmsTemplate = null;



// usado por spring para inyectar el jms template.

public void setJmsTemplate(JmsTemplate jmsTemplate) {

this.jmsTemplate = jmsTemplate;

}





private Destination destino = null;



// usado por spring para inyectar el destino.

public void setDestino(Destination destino) {

this.destino = destino;

}





/**

* @see org.assembly.EnviadorDeMensajes#enviarUnMensaje()

*/

@Override

public void enviarUnMensaje() {

jmsTemplate.send(

  this.destino,

  new MessageCreator() {



    @Override

    public Message createMessage(Session session) throws JMSException {

     MapMessage mensaje = session.createMapMessage();

   

     mensaje.setString("mensaje", MENSAJE);

   

     return mensaje;

    }

   }

  );

}



}

La Clase envía el mensaje gracias a JmsTemplate.

Y ahora programamos la aplicación llamada AppCreador.java :

package org.assembly;



import org.springframework.beans.factory.BeanFactory;

import org.springframework.beans.factory.xml.XmlBeanFactory;

import org.springframework.core.io.FileSystemResource;





public class AppCreador

{

 public static void main( String[] args )

 {

  BeanFactory fabricaDeBeans = new XmlBeanFactory(new FileSystemResource("src/main/resources/spring-context.xml"));



  EnviadorDeMensajes enviador = (EnviadorDeMensajes) fabricaDeBeans.getBean("miEnviadorDeMensajes");



  enviador.enviarUnMensaje();

 }

}

Utilizamos a spring como fabrica de beans y le pedimos que cree el enviador; luego con el enviamos un mensaje.

Para probar esto hay que subir activeMQ, para subirlo hay que hacer:
activemq console (en sistemas Unix-Like)
activemq (en Windows)
Luego podemos ejecutar el AppCreador.

Lector De Mensajes
El lector es similar al enviador, veamos el spring-context.xml:

Ahora configuramos el destino como default en jmsTemplate para no pasarlo al lector y de esta forma es más ágil.
Necesitamos una interfaz para el lector:

package org.assembly;



import javax.jms.JMSException;



public interface LectorDeMensajes {



String leer() throws JMSException;



}

Y la implementación:

package org.assembly;



import javax.jms.Destination;

import javax.jms.JMSException;

import javax.jms.MapMessage;

import javax.jms.Message;

import javax.jms.Session;



import org.springframework.jms.core.JmsTemplate;

import org.springframework.jms.core.MessageCreator;



/**

* @author emanuel

*

*/

public class LectorDeMensajesImpl implements LectorDeMensajes {



private JmsTemplate jmsTemplate = null;



// usado por spring para inyectar el jms template.

public void setJmsTemplate(JmsTemplate jmsTemplate) {

this.jmsTemplate = jmsTemplate;

}





/**

* @throws JMSException

* @see org.assembly.EnviadorDeMensajes#enviarUnMensaje()

*/

@Override

public String leer() throws JMSException {

MapMessage mensaje = (MapMessage) jmsTemplate.receive();

return mensaje.getString("mensaje");

}





}

Ahora creamos la aplicación lectora:

package org.assembly;



import javax.jms.JMSException;



import org.sprin

gframework.beans.factory.BeanFactory;

import org.springframework.beans.factory.xml.XmlBeanFactory;

import org.springframework.core.io.FileSystemResource;



/**

* Hello world!

*

*/

public class AppLector

{

 public static void main( String[] args ) throws JMSException

 {

  BeanFactory fabricaDeBeans = new XmlBeanFactory(new FileSystemResource("src/main/resources/spring-context.xml"));



  LectorDeMensajes lectorDeMensajes = (LectorDeMensajes) fabricaDeBeans.getBean("miLectorDeMensajes");

  System.out.println(lectorDeMensajes.leer());

 }

}

Si ejecutamos esta aplicación devolvera el mensaje enviado por el creadorDeMensajes.
Este es un pequeño ejemplo del uso de Apache Active con spring espero que les sirva.

Facelets framework.

¿Que es Facelets?
Cuando JSF fue ideado, la intención fue reutilizar JSP como principal tecnología para la creación de paginas web, dado que es un estándar en la comunidad web.
La idea fue hacer natural la adopción de JSF por medio de etiquetas naturales que ya tienen una adopción el el mundo java.

Desafortunadamente JSP y JSF no se complementan entre si. JSP se usa para crear paginas web dinámicas pero no para crear arboles de componentes. En JSP los elementos son procesados desde el principio de la pagina hasta el final. JSF, sin embargo, tiene un ciclo de vida mucho más complejo, generación de componentes, y una generación separada en faces claras.

Si se mezcla JSP con JSF, el JSF se renderizara a medida que se vaya encontrando, en cambio los componentes JSF tiene cada uno su propio renderizado. Esto puede traer ciertos problemas.

Facelets llena el gap entre JSP y JSF. Esta centrado en la creación de arboles de componentes y el entrelazamiento de contenido con el complejo ciclo de vida de JSF. Facelets remplaza a JSP con una muy simple API que es el reflejo de principios simples y esto incorpora numerosas características que facilitan el desarrollo.

¿Porque utilizar Facelets?
Hay muchas razones por las que usar Facelts antes que JSP para el desarrollo de JSF:

• No depende del contenedor, Facelts puede trabajar con cualquier implementación y versión de JSF.
• La interacción entre JSP y JSF puede traer problemas.
• Facelets provee templates, que pueden ser reutilizados
• Su simpleza maximiza la reutilización, es extensible y escalable.
• Facets soporta EL (Unified Expression Language)
• Facets no requiere ninguna librería especial para el renderizado.

Descargar Facelets.
Facelets se puede descargar de la siguiente URL: http://facelets.dev.java.net/
El jar que se necesita para trabajar con Facelets es jsf- facelets.jar y las dependencias puede ser buscadas en el directorio lib.

Si usan maven la dependencia es:

 com.sun.facelets

 jsf-facelets

 1.1.6

Configuración
Para configurar un proyecto web para que use Facelets en necesario configurar el Web Descriptor (web.xml) agregando lo siguiente:

..............





 javax.faces.DEFAULT_SUFFIX

 .xhtml

De esta forma indicamos que nuestras paginas van a finalizar con el subfijo xhtml.
Además como cualquier proyecto JSF hay que agregar el servlet y el servlet-mapping

 Faces Servlet

 javax.faces.webapp.FacesServlet

 1





 Faces Servlet

 /faces/*

Además es necesario crear un archivo Configuración de Faces Descriptor (faces-config.xml) como cualquier proyecto JSF, donde es necesario remplazar el ViewHandler traido por defecto por:
com.sun.facelets.FaceletViewHandler de la siguiente manera:

 

   com.sun.facelets.FaceletViewHandler

 

En faces-config.xml también se define las reglas de navegación.

 

     home

     /index.xhtml

 





 

     parrot

     /parrot.xhtml

 





 

     eagle

     /eagle.xhtml

 

Como se puede ver se define cada uno de los links a que htmlx debe ir.


Tags
Es necesario que las paginas Facelets sean un XML valido, cuando se utiliza una librería es necesario que se declare como un namespace, donde podemos mapear la URI a un prefijo como se puede apreciar en el siguiente ejemplo:

En el ejemplo usamos 3 librerías, una XML sin prefijo, otra para Facetlet tag con el prefijo ui y otra básica de JSF con el prefijo h.
En la siguiente tabla se puede ver los namespace más comunes:

NAMESPACE	PREFIX LIBRARY	XHTML
http://www.w3.org/1999/xhtml	--	Facelets Templating
http://java.sun.com/jsf/facelets	ui	JSF Core
http://java.sun.com/jsf/core	f	JSF HTML
http://java.sun.com/jsf/html	h	MyFaces Tomahawk
http://myfaces.apache.org/tomahawk	t	MyFaces Tomahawk
http://myfaces.apache.org/sandbox	s	Sandbox
http://myfaces.apache.org/trinidad	tr	MyFaces Trinidad
http://java.sun.com/jstl/core	c	JSTL Core
http://java.sun.com/jsp/jstl/fmt	fn	JSTL Functions

Si se agrega un componente pero no se agrega el espacio de nombre correspondiente para el componente, habrá un error en el momento de compilación de la pagina.

Carga de las librerías de Tags
Facelets usa la siguiente estrategia para cargar las librerías de etiquetas. Primero, busca las librerías en la carpeta /META-INF dentro de los jars. Intenta cargar los archivos que tienen la siguiente forma *.taglib.xml. De esta forma se cargan librería de etiquetas estándares.
Luego, facelets chequea las librerías definidas en web.xml, inicializado como parámetros facelets.LIBRARIES. Esta estrategia es ideal para cuando se desea cargar una librería de etiquetas propia.

Varias librerías de etiquetas ya son incluidas en el jar de facelets:

• Templating library: Contiene las etiquetas para la creación de plantillas.
• JSF libraries: Dos librerías de etiquetas las cuales son incluidas por la especificación de JSF, son librerías incluidas por defecto por Facelets.
• JSTL: Facelets provee soporte parcial a etiquetas de JavaServer Pages Standard Tag
• Library (JSTL). Mientras la librería Function es totalmente soportada, La Core es parcialmente soportada, las etiquetas soportadas son: c:if, c:forEach, c:catch y c:set.

Otras Librerías
Para incluir otra librería de etiquetas se debe agregar la misma en la carpeta /META-INF y además se debe incluir el import del Taglib dentro de la aplicación.

Creación de plantillas
En las plantillas nosotros definimos básicamente el layout de la pagina, y los estilos. Con la etiqueta ui:insert podemos definir las áreas en la pagina que pueden ser sobreescritas, por las paginas que usan la plantilla (clientes). Para usar esta etiqueta es necesario el espacio de nombre: http://java.sun.com/jsf/facelets
El cliente usa este template con los tags ui:component, ui:composition, ui:fragment, o ui:decorate. Veamos un ejemplo de plantilla:

 

 





 

     
The Happy Birds Directory

     


         

     

     

         Welcome to the nest!

     

 

La pagina que utilice esta plantilla sera algo así:

 

     

         Hola Mundo!!

     

 

Es usada la etiquete ui:composition para referenciar la plantilla utilizada. La etiqueta ui:define es utilizada para indicar a Facelts cual area se va a redefinir.
Las plantillas no están limitadas a un nivel, es posible tener varios niveles de plantillas, de este modo un cliente para un template puede ser un template para otro cliente.

Tutorial básico de Java EE

En javahispano publicaron un tutorial de Java EE. Muy buena oportunidad para aprender, dejo el link:

http://www.javahispano.org/contenidos/es/tutorial_basico_de_java_ee__por_abraham_otero/?menuId=jH

Saludos!!