IDE eclipse

bueno no quiero dar detalles pero si encontre muy interesante
que este link que esta en la pagina de eclipse, donde se
puede apreciar varios videos para interiorizarse

http://live.eclipse.org/node/572

todo los video estan relacionados a la plataforma
J2EE

uso de JOptionPane

bueno regresando un poco a j2se quisiera mostrar como se utiliza
un cruado de confirmacion muy sencillo, pero en nuestra aplicacion
nos va ayudar mucho.

int respuesta;

respuesta=JOptionPane.showConfirmDialog(this,"Desea Eliminar el libro "+libro_eliminar,"Confirmacion Eliminacion",JOptionPane.YES_NO_CANCEL_OPTION);

if(respuesta==JOptionPane.YES_OPTION){

}else{

}

como siempre para entrar en mas detalles podemos acceder a
los siguientes link

http://java.sun.com/j2se/1.4.2/docs/api/javax/swing/JOptionPane.html
http://www.chuidiang.com/chuwiki/index.php?title=JOptionPane_y_di%C3%A1logos_modales

Spring Framework

Spring es un framework que facilita el desarrollo de aplicaciones j2ee,
este framework no intenta inventar la rueda sino integra diferentes
tecnologias existentes en un solo framework para dar un desarrollo
mas sencillo.

una de sus caracteristicas es intentar evitar el uso de EJB y fue
creado basado en los siguientes principios:

- El buen diseño es mas importante que la tecnologia
subyacente.

- Los javabeans ligados de una manera mas libre entre
interfaces es un buen modelo.

- El codigo debe ser facil de probar.

bueno estos son detalles generales de este framework, pero
a continuacion unos link para entrar en detalle de este
framework.

http://www.springsource.org/
http://www.palermo.edu/ingenieria/downloads/introduccion_spring_framework_v1.0.pdf
http://www.comunidadjava.org/files/SegundaReunion/Spring.pdf
http://catarina.udlap.mx/u_dl_a/tales/documentos/lis/sanchez_r_ma/capitulo3.pdf

arquitectura de la persistencia hibernate

bueno si vamos a entrar a ocupar persistencia y
principalmente hibernate, tenemos que comprender
su arquitectura, puesto que hacer un simple
ejerccio no significa que sepamos utilizar esta
persistencia.



Para utilizar Hibernate, es necesario para crear clases Java
que representa la tabla en la base de datos y, a continuación,
el mapa de variable de instancia en la clase con las columnas de
la base de datos. Luego de Hibernate puede ser utilizado para
realizar operaciones sobre la base de datos, como seleccionar,
insertar, actualizar y eliminar los registros en la tabla


Hibernate posee tres componentes principales:


Connection Management (Gestión de conexión)

Hibernate proporciona un servicio de gestión de la conexión
para proporcionar una eficiente conexion a la base de dato.
La Conexión de base de datos es la parte más cara de interactuar
ya que requiere una gran cantidad de recursos para abrir y
cerrar la conexión


Transaction management: (Gestión de transacciones)

Proporciona la capacidad al usuario ejecutar más de
una base de datos a la vez.


Object relational mapping: (Mapeo objeto relacional)

es la técnica de cartografía que representa los datos de
un modelo modelo de datos relacional de forma de objeto.
Esta parte de la utiliza para seleccionar, insertar, actualizar
y borrar los registros de la tabla subyacente. Cuando pasamos
de un objeto a un Session.save () método, Hibernate lee el
estado de las variables de ese objeto y ejecuta la consulta
necesaria.

jar, war , ear en J2EE

bueno encontre este articulo bien sencillo que explica
de forma clara estas tres tipos de empaquetamiento,
que podemos encontrar en la plataforma J2EE.

estos son conceptos fundamentales que hay que manejar
al momento de entrar al mundo de j2ee.

http://www.javadabbadoo.org/cursos/infosintesis.net/javaeeav/empaquetadoJavaEE/index.html

implementar un applet

en realidad no utilizado mucho los applet, pero
un dia implemente uno simple, en los cuales los
pasos los podemos encontrar en el siguiente link:

http://www.netbeans.org/kb/61/web/applets.html

pero solamente quiero compartir este detalle que
encuentro que es importante

cuando añadimos el jar a nuestro proyecto web, no
lo tenemos que añadir en libreria, si no que en
build-> packaging


podemos apreciar que netbeans nos apoya con un editor visual
para desarrollar applet, el cual nos podria faciliar el desarrollo de
un applet en particular, quiero recordar que un applet no tiene
main y su formato es muy parecido a los midlet de j2me.

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.