validadores en jsf

bueno este validador es en visual web JSF, es sumanente facil
y los pasos son los siguientes.

primero vamos a tener algo asi de sencillo, el button manda
el numero al label


ahora arrastramos el long range validator a nuestro texto


ahora le damos los rangos a nuestro validador de tipo long, existen
otros para float, etc


agregamos un message y desde nuestro texto mantenemos
apretados Ctrl + Shift y desde el mismo texto llevamos la linea
a nuestro mensaje.(El mensaje es automatico solo dice todo)

despues tenemos que agregar la accion de boton

String palabra=(String)textField1.getText();
label1.setText(palabra);

y por ultimo asi nos queda , el rango que yo tenia es de 50 a 100

uso de visual web jsf page fragment

bueno primero creamos nuestro page fragment

para configurar el tamaño de nuestro fragmento lo realizamos aqui


vamos a añadir un arbol y le vamos asignar un link, esto se logra con
el url que se ve en la imagen.

obs: se puede lograr tambien en el faces-config.xml ,
con las etiquetas


ahora vamos añadir nuestro fragmento en nuestra pagina , lo hacemos
page fragment box.

bueno ahora solamente nos queda ejecutar nuestro proyecto

obs: si queremos tener otra pagina de inicio lo tenemos
que anteponer faces/ a nuestra pagina cuando lo configuremos.

ejemplo de visual web jsf en netbeans

bueno este ejemplo es sumamente sencillo, pero para
empezar esta muy bueno.

1 primero creamos nuestro proyecto web

2.- luego creamos otra pagina que tiene que ser de tipo
visual web JSF page

3.- en el navegador vamos a encontrar el sessionBean1, requestBean1,
etc , pero solamenten vamos a ocupar el sessionBean1(buscar para
el que no sabe la naturaleza de estas variables)

4.- en sessionBean1 , creamos las variables de tipo privadas nombres
y apellido, con sus respectivos get y set.

creamos

String nombre;
String apellido;

y luego encapsulamos los datos, de forma automatica se crean
los get y set.
luego hacemos lo mismo con el apellido

5.- supuestamente este paso no sale en otros manuales, pero
si no realizo esto no me funciona, si a ustedes le funciona sin
este paso lo cuentan

sobre el navegador de page a los atributos de nuestra pagina
tenemos que hacer este paso uno por uno(los que vamos a usar
en el boton)
esto nos crea los new de los atrubutos como son los textfield

6.- ahora vamos asociamos las paginas (esto es entrete jeje)


7 .- ahora sobre el evento del boton , asociamos las variables a la session

getSessionBean1().setNombre((String)textField1.getText());
getSessionBean1().setApellido((String)textField2.getText());

8.- luego asociamos los text de la pagina dos con las variables que
creamos, con el boton derecho y buind to data



y estamos listos, una observacion el return del boton es un string
"case1" , esto lo podemos configurar en faces-config.xml, es bueno saber
como funcionan las cosas por detras, en un articulo anterior explico como
hacerlo a lo macho jajaja solo codigo

empezando con ajax

En realidad, el término AJAX es un acrónimo de Asynchronous
JavaScript + XML, que se puede traducir como "JavaScript
asíncrono + XML.

Ajax no es una tecnología en sí mismo. En realidad, se trata
de varias tecnologías independientes que se unen de formas
nuevas y sorprendentes.

Las tecnologías que forman AJAX son:

• XHTML y CSS, para crear una presentación basada en estándares.
• DOM, para la interacción y manipulación dinámica de la presentación.
• XML, XSLT y JSON, para el intercambio y la manipulación de información.
• XMLHttpRequest, para el intercambio asíncrono de información.
• JavaScript, para unir todas las demás tecnologías.

En las aplicaciones web tradicionales, las acciones del usuario en la
página (pinchar en un botón, seleccionar un valor de una lista, etc.)
desencadenan llamadas al servidor. Una vez procesada la petición
del usuario, el servidor devuelve una nueva página HTML al
navegador del usuario.

En el siguiente esquema, la imagen de la izquierda muestra el
modelo tradicional de las aplicaciones web. La imagen de la derecha
muestra el nuevo modelo propuesto por AJAX:

Comparación gráfica del modelo tradicional de aplicación web y
del nuevo modelo propuesto por AJAX. (Imagen original creada
por Adaptive Path y utilizada con su permiso)

Esta técnica tradicional para crear aplicaciones web funciona correctamente, pero no crea una buena sensación al usuario. Al realizar peticiones continuas al servidor, el usuario debe esperar a que se recargue la página con los cambios solicitados. Si la aplicación debe realizar peticiones continuas, su uso se convierte en algo molesto

AJAX permite mejorar completamente la interacción del usuario con la aplicación, evitando las recargas constantes de la página, ya que el intercambio de información con el servidor se produce en un segundo plano.

Las aplicaciones construidas con AJAX eliminan la recarga constante de páginas mediante la creación de un elemento intermedio entre el usuario y el servidor. La nueva capa intermedia de AJAX mejora la respuesta de la aplicación, ya que el usuario nunca se encuentra con una ventana del navegador vacía esperando la respuesta del servidor.

El siguiente esquema muestra la diferencia más importante
entre una aplicación web tradicional y una aplicación web
creada con AJAX. La imagen superior muestra la interación
síncrona propia de las aplicaciones web tradicionales. La imagen
inferior muestra la comunicación asíncrona de las aplicaciones
creadas con AJAX


Las peticiones HTTP al servidor se sustituyen por peticiones JavaScript
que se realizan al elemento encargado de AJAX. Las peticiones más
simples no requieren intervención del servidor, por lo que la respuesta
es inmediata. Si la interacción requiere una respuesta del servidor, la
petición se realiza de forma asíncrona mediante AJAX. En este caso,
la interacción del usuario tampoco se ve interrumpida por recargas de
página o largas esperas por la respuesta del servidor


como siempre unos videos, para hacer mas dinamico nuestro aprender
jejejeje



http://java.sun.com/blueprints/ajax.html
http://java.sun.com/javaee/javaserverfaces/ajax/tutorial.jsp
http://www.librosweb.es/ajax/
http://java.sun.com/developer/technicalArticles/J2EE/AJAX/
http://developers.sun.com/scripting/ajax/index.jsp
http://ajaxpatterns.org/Java_Ajax_Frameworks
https://ajax.dev.java.net/jmaki-plugin.html
http://www.adictosaltrabajo.com/tutoriales/tutoriales.php?pagina=AjaxConJavaFacil
http://www.slideshare.net/Mordok/java-script-bsico-ajax-presentation
http://directwebremoting.org/dwr/
http://java.sun.com/developer/technicalArticles/J2EE/ajax_jsf/
http://www.ajaxya.com.ar/

unos videos de ejemplo de JSF

encontre estos videos muy entretenidos en youtube sobre
como realizar aplicaciones con jsf, yo no los creeasi
que no me llamo como dice en el video.

creo que hasta el mas flojo le gusta ver un video
explicando como hacer las cosas, asi que para empezar
a tener nociones sobre jsf estan rebuenos

JSF con Clases Entidad en Netbeans CRUD

Ejemplo JSF

JMS (Java Message Service)

El JMS (Java Message Service) fue desarrollado por
Sun Microsystems para que en los programas en Java
tuviera acceso a sistemas de mensajería para empresas.

JMS se situa como middleware en medio de la comunicación
de dos aplicaciones. En entornos cliente servidor, cuando la
aplicación A quiere comunicarse con la Aplicación B, necesita
saber donde esta B (su IP por ejemplo) y que B esté
escuchando en ese momento. Cuando se usa JMS
(o cualquier otro sistema de mensajes), la aplicación A
envía un mensaje, el sistema de mensajes lo recibe y se lo
envía a B cuando se conecte al servicio. De esta manera se
consigue una comunicación asíncrona entre A y B, es decir no
hace falta que B este presente en el momento del envío del
mensaje, y no por ello va a dejar de recibirlo.


esto es solamente una introduccion y acontinuacion unos link para
entrar en detalle

http://java.sun.com/products/jms/
http://www.javapassion.com/j2ee/JMS.pdf
http://www.programacion.net/java/articulo/jms/
http://www.adictosaltrabajo.com/tutoriales/tutoriales.php?pagina=JMSJBOSS
http://www.softwarementors.com/arti/j2ee/IntroduccionJ2EE.pdf
http://www.fing.edu.uy/inco/cursos/tsi/TSI3/TSI3-2007-JMS.pdf
http://xxito.wordpress.com/2007/06/07/11-jms/

instalar jboss en netbeans

la version de jboss que instale es jboss-5.0.1.GA sobre
netbeans 6.5 y es sumamente facil, solamente que
tiene un detalle que luego lo dare.




bueno aqui esta el detalle, porque nos da un error al tratar de
instalar jboss, para solucionarlo tenemos que copiar algunos archivos
("jboss-javaee.jar", "jboss.jar", "jbosssx.jar", "jmx-adaptor-plugin.jar",
"jnpserver.jar", "log4j.jar") que se ubican en
jboss-5.0.0.GA\common\lib\
a
jboss-5.0.0.GA\server\default\lib\


y ahora estamos listos y ahora aprobar el servidor jejejejje

Descarga del servidor :
http://www.jboss.org/jbossas/downloads/

http://www.jboss.org/
http://www.redhat.com/docs/manuals/jboss/jboss-eap-4.2/readme-es-ES.html#issue3
http://www.netbeans.org/kb/55/ejb30-jboss.html

Certificacion java

El programa de certificación Sun en tecnología Java, que goza de reconocimiento
mundial, se centra en funciones críticas en el desarrollo de aplicaciones y
arquitectura de la empresa.. Dado que las certificaciones tratan sobre la tecnología,
los conocimientos y habilidades adquiridos durante la preparación para las
mismas pueden trasladarse de una compañía a otra..

El criterio de Sun es que la certificación es esencial para el proceso de aprendizaje, ya que convalida la preparación para realizar tareas específicas. La certificación de Sun también ofrece una evolución natural para la consolidación de los objetivos profesionales.

Lo imortante es que existe una promocion muy buena que si compras un examen de certificación de Sun antes del 19 de junio, podrá repetir el examen totalmente gratis en caso de que lo necesite.

Certificación Básica en Plataforma Java (SCJA)

68% (35 de 51 preguntas)
Time limit: 115
En español

Objetivos del examen

Sección 1: Conceptos fundamentales de la programación
orientada a objetos

• Describir, comparar y contrastar las primitivas (entero, coma flotante, booleano y carácter), los tipos de enumeración y los objetos.
• Describir, comparar y contrastar las clases concretas, las clases abstractas y las interfaces, así como la forma de aplicarles la función de herencia.
• Describir, comparar y contrastar las composiciones de clases, las asociaciones (incluida la multiplicidad: (uno a uno, uno a muchos y muchos a muchos) y la exploración de asociaciones.
• Describir la ocultación de información (mediante atributos y métodos privados), la encapsulación y la presentación de la funcionalidad de objeto utilizando métodos públicos. Describir las convenciones de programación de JavaBeans para los métodos setter y getter.
• Describir la función de polimorfismo que se aplica a clases e interfaces, y describir y aplicar el principio de "programación en interfaz".

Sección 2: Representación UML de conceptos de programación orientados a objetos

• Reconocer la representación UML de clases (incluidos atributos y operaciones, clases abstractas e interfaces), de herencia (implementación e interfaz) y de modificadores de visibilidad de miembros de clases (-/privado y +/público).
• Reconocer la representación UML de asociaciones de clases, composiciones, indicadores de multiplicidad de asociaciones e indicadores de exploración de asociaciones.

Sección 3: Implementación de conceptos de programación Java orientados a objetos

• Notas: Los ejemplos de códigos pueden utilizar el operador 'new'.
• Desarrollar código que utilice primitivas, tipos de enumeración y referencias de objeto, así como reconocer literales de estos tipos.
• Desarrollar código que declare clases concretas, clases abstractas e interfaces, que admita herencia de implementación e interfaz, que declare atributos y métodos de instancia y que utilice modificadores de acceso Java privados y públicos.
• Desarrollar código que implemente asociaciones de clases simples y código que implemente multiplicidad mediante matrices. Reconocer el código que implementa composiciones frente a asociaciones simples y el código que implementa correctamente la exploración de asociaciones.
• Desarrollar código que utilice la función de polimorfismo para clases e interfaces, y reconocer el código que utiliza el principio de "programación en interfaz".

Sección 4: Diseño e implementación de un algoritmo

• Describir, comparar y contrastar estos tres tipos fundamentales de instrucciones: asignación, condicional e iteración. Dada la descripción de un algoritmo, seleccionar el tipo adecuado de instrucción para diseñar el algoritmo.
• Con un algoritmo como seudocódigo, determinar el ámbito correcto de una variable empleada en el algoritmo y desarrollar código para declarar variables en cualquier de los ámbitos siguientes: variable de instancia, parámetro de método y variable local.
• Con un algoritmo como seudocódigo, desarrollar código de método que implemente el algoritmo utilizando instrucciones condicionales (if y switch), instrucciones de iteración (for, for-each, while y do-while), instrucciones de asignación, e instrucciones break y continue para controlar el flujo en las instrucciones switch e iteration.
• Dado un algoritmo con múltiples entradas y una salida, desarrollar código de método que implemente el algoritmo utilizando parámetros de método, un tipo de retorno y la instrucción return. Reconocer los efectos que produce cuando las referencias y primitivas de objeto se pasan a los métodos que las modifican.
• Con un algoritmo como seudocódigo, desarrollar código que aplique correctamente los operadores adecuados para obtener el resultado deseado, incluidos los operadores de asignación (limitados a: =, +=, -=), los operadores aritméticos (limitado a: +, -, *, /, %, ++, --), los operadores relacionales (limitado a: <, <=, >, >=, ==, !=) y los operadores lógicos (limitado a: !, &&, ||). Asimismo, escribir código que determine la igualdad de dos objetos o dos primitivas.
• Desarrollar código que utilice el operador de concatenación (+) y los siguientes métodos de la clase String: charAt, indexOf, trim, substring, replace, length, startsWith y endsWith.

Sección 5: Aspectos básicos del desarrollo Java

• Describir la finalidad de los paquetes en el lenguaje Java y examinar el uso adecuado de las instrucciones import y package.
• Conocer el uso adecuado del comando "javac" (incluidas las opciones de la línea de comandos -d y –classpath) y del comando "java" (incluidas las opciones de la línea de comandos -classpath, -D y –version).
• Describir la finalidad y los tipos de clases de los paquetes de Java siguientes: java.awt, javax.swing, java.io, java.net y java.util.

Sección 6: Plataformas Java y tecnologías de integración

• Distinguir las características básicas de las tres plataformas Java (J2SE, J2ME y J2EE) y seleccionar la plataforma o plataformas adecuadas cuando se requiera una arquitectura de alto nivel.
• Describir con detalle las ventajas y características básicas de RMI.
• Describir con detalle las ventajas y características básicas de las tecnologías JDBC, SQL y RDBMS.
• Describir con detalle las ventajas y características básicas de las tecnologías JNDI, de mensajería y JMS.

Sección 7: Tecnologías de cliente

• Describir con detalle las características básicas, las ventajas y las desventajas de la creación de arquitecturas thin-client con HTML y JavaScript, así como los problemas de implementación y las soluciones correspondientes.
• Describir con detalle las características básicas, las ventajas, las desventajas y los problemas de implementación relacionados con la creación de clientes utilizando midlets J2ME.
• Describir con detalle las características básicas, las ventajas, las desventajas y los problemas de implementación relacionados con la creación de arquitecturas fat-client mediante el uso de miniaplicaciones.
• Describir con detalle las características básicas, las ventajas, las desventajas y los problemas de implementación relacionados con la creación de arquitecturas fat-client mediante el uso de Swing.

Sección 8: Tecnologías de servidor

• Describir con detalle las características básicas de EJB, servlets, JSP, JMS, JNDI, SMTP, JAX-RPC, servicios Web (incluidos SOAP, UDDI, WSDL y XML) y JavaMail.
• Describir con detalles las características básicas de compatibilidad de servlet y JSP con thin-clients HTML.
• Describir con detalle el uso y las características básicas de los beans de sesión, entidad y controlados por mensajes de EJB.
• Describir con detalles las ventajas y los inconvenientes más importantes de utilizar tecnologías del lado de servidor J2EE, y describir y comparar las características básicas de la capa Web, la capa de negocio y la capa EIS.

https://www.suntrainingcatalogue.com/eduserv/client/learningPath.do?p=/training/certification/java/index.html&d=t&l=es_CL
https://www.suntrainingcatalogue.com/eduserv/client/viewPromo.do?pr_id=4399&l=es_CL&intcmp=2382

JNDI, Java Naming and Directory Interface

El Java Naming and Directory Interface (JNDI) es un interface de
programación (API) que proporciona funcionalidades de nombrado
y directorio a las aplicaciones escritas usando Java. Está definido
para ser independiente de cualquier implementación de servicio
de directorio. Así se puede acceder a una gran variedad de
directorios, -- nuevos, emergentes, y ya desarrollados --
de una forma común.

en este ejemplo vamos a quedar mas claros:

los discos duros trabajana con pistas y sectores, aunque el
usuario se preocupa solamente del fichero y el directorio, el
sistema asocia el fichero(nombre) dado con una localizacion
especifica en el disco duro. bueno algo asi es la idea de JNDI.


La arquiectura JNDI consiste en un API y un "service provider
interface (SPI)". Las aplicaciones Java usan el API JNDI para
acceder a una gran variedad de servicios de nombres y directorios.
El SPI permite conectar de forma transparente una gran
variedad de servicios de nombres y directorios, por lo tanto
permite a las aplicaciones Java usar el API JNDI para acceder
a sus servicios


como esto es solamente una introduccion y el tema es más complejo
e importante, dare los siguientes link

http://java.sun.com/products/jndi/
http://java.sun.com/products/jndi/tutorial/
http://programacion.com/tutorial/jndi/
http://xxito.wordpress.com/2007/06/06/10-jndi/
http://publib.boulder.ibm.com/infocenter/iseries/v5r4/index.jsp?topic=/rzatz/51/program/jndicorba.htm
http://sophia.javeriana.edu.co/~cbustaca/Arquitectura%20Software/J2EE/Presentaciones/JNDI.pdf

ejemplo ejb, persistencia y servlet

bueno en mi aprendizaje diario en la plataforma j2ee, encontre
este manual muy practico, sobre como realizar utilizar un ejb,
persistencia y servlet, no quiero decir nada mas porque todo
sale explicado en el manual.

http://nachxs.wordpress.com/2009/04/28/tutorial-ejb-persistencia-y-postgresql-en-netbeans-65/

aplicando el ejemplo en la parte de llamar el ejb desde el servlet
no me aparece la opcion que me muestra el ejemplo, pero lo realize
asi
ademas en el servlet se llama al objeto que representa a la tabla de
la base de dato, para ello tenemos que importar desde el ejb y el
mismo netbeans nos pregunta si queremos importar este objeto.

XDoclet concepto importante para EJB

XDoclet es una herramienta de código abierto, diseñada
para generar código java. Está diseñada según la programación
orientada a atributos, de tal manera que podemos añadir más
funcionalidad simplemente agregando nuevos atributos (metadata)
al código Java. Los atributos no son más que tags de JavaDoc.

Esta herramienta es suamamente utilizada en los ejb 2.0, pero
en ejb 3.0 ya viene incorporado no como XDoclet, esta herramienta
viene a solucionar la complejidad de los ejb 2.0.

http://xdoclet.sourceforge.net/xdoclet/index.html
http://www.adictosaltrabajo.com/tutoriales/tutoriales.php?pagina=strutsxdoclet
http://www.adictosaltrabajo.com/tutoriales/tutoriales.php?pagina=XDocletJBossIDE
http://www.imaginaworks.com/publicaciones/10-programacion-orientada-a-aspectos

Empezando con los EJB

Los EJB son componentes del contexto de servidor que cubren
la necesidad de intermediar entre la capa web y diversos sistemas
empresariales, ademas tenemos que tener claro que no tienen nada
que ver con los java beans( de las clases con get y set), bueno como
el tema es muy largo y muy tecnico solamente dejare unos buenos link
para entrar bien en detalle sobre el tema.

observacion: la version de ejb 2.0 y 3.0 son diferentes, la forma que
ellos acceden a los datos es la principal diferencias, hay muchas
empresas que ocupan todavia ejb 2.0 asi que no seria
malo saber manipular las dos versiones de ejb. (en j2ee 1.5 se
añade ejb 3.0)


http://www.theserverside.com/tt/books/wiley/masteringEJB3/index.tss
http://www.di.uniovi.es/~dflanvin/docencia/dasdi/teoria/Transparencias/13.%20Introducci%C3%B3n%20EJBs.pdf
http://www.jtech.ua.es/j2ee/ejemplos/ejb/sesion01-apuntes.htm
http://educnet.decom-uv.cl/educnet/uploads/C19_EJB3.pdf?nombre=p284/C19_EJB3.pdf
http://java.sun.com/products/ejb/
http://www.dosideas.com/java/528-ejb-31-un-paso-importante-hacia-la-madurez.html
http://soyunjuncohueco.wordpress.com/2009/04/23/introduccion-a-ejb-3/
http://www.devarticles.com/c/a/Java/Getting-Started-with-Enterprise-Java-Beans-EJB-30/
http://www.ibm.com/developerworks/java/library/j-ejb3jpa.html

login para JSF

Como siempre ocuparemos nuestro querido IDE netbeans, lo
primer a destacar que este ejemplo esta desarrollado sin BD y
sin el visual web, osea a lo machito jajajaj

para empezar tenemos que ver un articulo anterior llamado
primera aplicacion con JSF, donde explico como crear un proyecto
de tipo JSF

primero vamos a explicar un ejemplo muy sencillo, pero practico
para entender unas ideas.

obs: en este ejemplo se utiliza el servidor glassfish v2

Ejemplo JSF Netbeans (sencillo)

1.- primero creamos una pagina inicio_ejemplo.jsp, no vamos a
ocupar la pagina de inicio que crea el proyecto.



2.- creamos un beans llamado persona.

3.- ahora creamos otra pagina llamada pagina_dos.jsp



4.- para que funcione nuestra aplicacion tenemos que ir a modificar nuestro
faces-config.xml

con el boton derecho del maldito roedor(jejej, tenemos la opcion
JavaServer Faces, estas tres opciones las vamos a utilizar
a continuacion.

5.- add navigation rule

6.- add navigation case


7.- add managed beans


8.- el faces-config.xml tiene que ser asi, tenemos que tener claro
que el usuario es el indentificador de nuestra clase persona, es por
ello que en el codigo de jsp se accede a la variable persona nombre
con identifica



Observacion : como eliminamos el jsp de inicio tenemos que indicar el
jsp de inicio para nuestra aplicacion.


Ahora el ejemplo login

vamos a crear dos archivos java de tipo beans, usuario y
control_usuario


ahora las dos paginas que corresponden al inicio dado por el proyecto
que es welcomeJSF


y la pagina correspondiente al paso del login


ahora el face-config.xml nos tiene que quedar asi


en este ejemplo tenemos que tener encuenta que el parametro scope
corresponde a session, ademas una parte clave es el from-outcome
que corresponde al String que entrega la clase que controla el login.

Para empezar con Struts

JSF (Java Server Faces) es un framework de desarrollo basado en el patrón MVC (Modelo Vista Controlador)

Al igual que Struts, JSF pretende normalizar y estandarizar el desarrollo de aplicaciones web. Hay que tener en cuenta JSF es posterior a Struts, y por lo tanto se a nutrido de la experiencia de este, mejorando algunas sus deficiencias. De hecho el creador de Struts (Craig R. McClanahan) también es líder de la especificación de JSF. esta explicacion y el desarrollo de un ejemplo en JSF lo podemos encontrar en:

http://www.adictosaltrabajo.com/tutoriales/tutoriales.php?pagina=jsf

Realmente no puedo dar una opinion cual de los framework es mejor, pero viendo el mercado me dado cuenta que igual solicitan mucha gente que tenga el dominion del framework Struts, podria suponer que es dado porque es mas antiguo que JSF.

Buscando cosas sobre JSF encontre un manual de Struts muy bueno y amerita nombrarlo porque esta paso tras paso como realizar un login, con el cual podemos entender de forma clara como es la estructura de este framework.

http://elrebusque.wordpress.com/2009/03/16/frameworks-struts-con-netbeans-65/

ademas un otro link para generar un pool de conexion con Struts

http://www.programacion.net/simple/articulo/ale_poolstruts/

http://nachxs.wordpress.com/2008/11/15/manejo-de-sesiones-con-struts-en-netbeans-61/

http://eljavero.blogspot.com/2007/06/struts-con-javabeans-i.html

http://www.netbeans.org/kb/61/web/quickstart-webapps-struts.html

y por ultimo el link oficial

http://struts.apache.org/

Distintas implementaciones de JSF

Actualmente existen muchas librerías de etiquetas JSF que
pueden complementar a la implementación de la especificación
oficial. La elección no tiene porqué cerrarse sobre una de ellas
sino que pueden combinarse según interese.

MyFaces Tomahawk

Desarrollado por Apache: http://myfaces.apache.org/tomahawk/
Este conjunto de componentes también es compatible con la
implementación de SUN, así como con cualquier implementación
compatible con JSF 1.1. Pueden verse los distintos componentes de
MyFaces Tomahawk en el siguiente enlace:

• http://www.irian.at/myfaces/

Además pueden consultarse las principales características
del proyecto Tomahawk en la siguiente dirección web:

• http://www.marinschek.com/myfaces/tiki/tiki-index.php?page=Features

MyFaces Sandbox

Desarrollado por Apache: http://myfaces.apache.org/sandbox/
Sandbox es un subproyecto de MyFaces que sirve como base
de pruebas para las nuevas incorporaciones al proyecto de
Tomahawk. Consiste sobre todo en componentes, pero como el
proyecto de Tomahawk, puede también contener otras utilidades
para JSF. Los distintos componentes pueden consultarse en
el siguiente enlace:

http://www.irian.at/myfaces-sandbox/

ICEfaces

Desarrollado por ICEsoft: http://www.icesoft.com/products/icefaces.html
ICEFaces proporciona un entorno de presentación web para
aplicaciones JSF que mejora el framework JSF estándar y el ciclo
de vida con características interactivas basadas en AJAX. Para
trabajar con ICEfaces puede elegirse cualquiera de las dos
implementaciones estándar. En la siguiente dirección web pueden
encontrarse demos sobre sus componentes:

http://www.icesoft.com/products/demos_icefaces.html

RichFaces

Rich Faces es un framework de código abierto que añade capacidad
Ajax dentro de aplicaciones JSF existentes sin recurrir a JavaScript.
Rich Faces incluye ciclo de vida, validaciones, conversores y la gestión
de recursos estáticos y dinámicos. Los componentes de Rich Faces
están construidos con soporte Ajax y un alto grado de personalización
del ##look-and-feel## que puede ser fácilmente incorporado dentro
de las aplicaciones JSF.

http://labs.jboss.com/jbossrichfaces/

AJAX blueprints components

Desarrollado por java.net: https://blueprints.dev.java.net/ajaxcomponents.html
Consiste en una serie de componentes AJAX basados en la tecnología JSF.
Tienen dos librerías de componentes JSF. Una basada en la versión 1.2
de JSF y que puede ser usada en un servidor de aplicaciones JEE5.
El otro conjunto tiene componentes basados en JSF 1.1 y que pueden
ejecutarse en servidores de aplicaciones J2EE 1.4. En la página oficial
presentan demos de algunos componentes

JSF Extensions

Desarrollado por java.net: https://jsf-extensions.dev.java.net/nonav/mvn/
Este proyecto almacena el desarrollo de software para extender las
capacidades de la especificación JSF. El software de este proyecto está
pensado para que funcione en cualquier implementación que cumple la
especificación JSF, aunque según la página oficial las capacidades se
mejoran cuando se ejecuta con la implementación de SUN. Este proyecto
está dividido en tres, pudiendo trabajar de forma conjunta o por separado.
La separación es en función del ciclo de vida del desarrollo: run time, test
time y design time.

Ajax4jsf

Fue desarrollado por java.net y patrocinado por Exadel. A partir
del 05/03/2007 Exadel y Red Hat decidieron colaborar en el desarrollo
de esta y otras tecnologías. La página oficial del proyecto se ha movido a:

http://labs.jboss.com/jbossajax4jsf/ Actualmente el proyecto se
encuentra dentro del proyecto RichFaces. Ajax4JSF es una extensión
opensource para el estándar JSF que añade capacidades AJAX a las
aplicaciones JSF sin la necesidad de escribir código Javascript. RichFaces
es una librería de componentes para JSF construida sobre Ajax4jsf.
Permite una integración fácil de capacidades AJAX en el desarrollo
de aplicaciones

de negocio. RichFaces mejora el framework Ajax4jsf de dos formas
importantes. Primero, aumenta el número de componentes visuales
listos para usar. En segundo lugar, implementa completamente la
característica skinnability de incluir un gran número de temas (skins)
predefinidos. Con esta característica resulta mucho más fácil gestionar
el look-and-feel de una aplicación. Pueden visualizarse algunos ejemplos
en la siguiente URL:

http://livedemo.exadel.com/richfaces-demo/welcome.jsf

RC Faces (Rich Client Faces)

Desarrollado por Vedana: http://www.rcfaces.org/ RC Faces es
una librería JSF que proporciona un conjunto de componentes para
construir la siguiente generación de aplicaciones web. RC Faces
usa tecnologías AJAX y una API de Javascript orientada a objetos
para construir páginas de forma dinámica. Es compatible con la
implementación estándar de JSF. Desde la página oficial se muestran
algunos ejemplos de esta librería:

http://www.rcfaces.org/starter/index.jsf

ADF Faces Todos los componentes de ADF Faces han sido donados
por Oracle a la Fundación Apache, la cual lo acogió bajo el proyecto
Trinidad y ahora se hace el lanzamiento de Apache MyFaces Trinidad
Core 1.2.1. Proporciona un amplio conjunto de componentes JSF,
siempre permitiendo las interacciones con AJAX, que simplifican
radicalmente el desarrollo de aplicaciones web.

primera aplicacion con JSF

Este ejemplo es una introduccion para empezar con JSF en nuestro
IDE netbeans , ademas añadir unos link para entrar mas en detalle a
esta plataforma.

en todas las secuencas de pasos que se muestran en la figura siguiente
se selecciona siguiente.
1)
2)

3)

4)


en la ultima lamina tengo seleccionada dos frameworks que
corresponden a JSF, uno es para una gestionador visual y el otro
para trabajar a lo hombresito jajajaj ( solo codigo).

La realidad que con esto no hacemos nada, es por ello que tenemos
que darnos un tiempo para entrar en detalle de esta tecnologia, es
por ello que como siempre dare unos link interesantes para entrar
en detalle en JSF.

http://www.sicuma.uma.es/sicuma/Formacion/documentacion/JSF.pdf
http://www.adeideas.com/paquito/archives/269/Principios_de_JSF.htm
http://java.sun.com/javaee/javaserverfaces/
http://www.roseindia.net/jsf/netbeans/index.shtml
http://www.netbeans.org/kb/61/web/jastrologer-intro.html
http://jsfcompref.com/code_download.html
http://blogs.sun.com/enterprisetechtips/entry/true_abstraction_composite_ui_components
http://www.oracle.com/technology/tech/java/jsf.html
http://www.netbeans.org/kb/60/web/web-jpa.html
http://www.netbeans.org/kb/60/web/intro.html
http://www.netbeans.org/kb/60/web/helloweb.html
http://wiki.netbeans.org/UsingHibernateWithJPA
http://weblogs.java.net/blog/maxpoon/archive/2007/06/extending_the_n.html