Servlet y Jsp

Vamos a ver un ejemplo de conectar un jsp con un servlet.

Nos creamos nuestra prueba.jsp y en el form le ponemos la ruta del servlet.

prueba.jsp


RecogeForm.java

Ruby

http://www.rubyonrails.org.es/

http://www.ruby-lang.org/es/

http://tryruby.hobix.com/

WEB-INF , META-INF

Estas dos carpetas tienes datos de la configuración de la aplicación,
Su ruta son : /src/main/resources/META-INF y src/main/webapp/WEB-INF

El META-INF tienes los archivos de persistencia.

El WEB-INF contiene toda la información de configuración necesarias para la aplicación Web, y todos los archivos de clase para su servlets y las clases que se llaman por su JSP (Java Server Pages). Este directorio es un componente vital para la aplicación web ,que sin él no funcionaria.

Context.xml

Archivo de configuración de un contexto( un contexto es una aplicación dentro de un servidor tomcat).

En este fichero se mete los datos de configuración de ese contexto, se tiene que poner {path_tomcat}/conf/catalina/localhost/nombreContext.xml

Aquí es donde se configura los poll de conexiones entre otras cosas.

DataSource

Fuente de datos tanto de fichero como de base de datos.
Es un depósito de datos sobre el cual podemos almacenar y recuperar información.

Junto con el Connection Pool permite realizar muchas conexiones a base de datos sin sobrecargar el servidor.Para mas información de estas conexión mirar este blog Metalklesk

Arrancar varios Tomcat con Eclipse

Para ello nos vamos a la carpeta del disco duro donde tenemos instalado y lo copiamos N veces como queramos tener.

En el Ecplise, en el menú Windows/Preference/Server/Installed Runtime le damos a añadir elegimos la version del tomcat que tenemos, le ponemos la ruta del tomcat que hemos copiado.

Ahora en el proyecto en site/docs/server creamos una nueva carpeta para la configuración del tomcat copiamos un serverl.xml de otra carpeta y lo metemos en la nueva.

Al proyecto le damos Run As... elegimos Manually define... en la pestaña server Runtime elegimos el tomcat nuevo que hemos creado , el siguiente paso es elegir la aplicación para ese tomcat y terminamos.

Luego picamos sobre el nuevo server, le damos la ruta de la nueva carpeta serve de la aplicación y para que no haya conflictos entre distintos server le cambiamos los puertos.

Por ejemplo yo he teniado que hacer esto porque tenia dos aplicaciones que se tenia que comunicar y tenia que tener las dos arrancadas.

Eclipse

Es un entorno de desarrollo integrado de código abierto multiplataforma.

He encontrado en la wikipedia esta definición Definición Eclipse

Conexión a base de datos

Para ello vamos a utlizar tres clases:

1. Connection -->para realizar la conexión a la base de datos,
   
2. PreparedStatement--> que será la que contenga la sentencia SQL.
   
3. ResultSet --> que será la que contenga el resultado,es una especie de matriz (filas x columnas) y para acceder a las columnas se utiliza el método getXXX, getString() para cadenas de texto, getDouble() para decimales.getDate() para fechas.......
   

Vamos a ver los pasos que hay que hacer para la conexión:

1. Primero tenemos que ver donde se encuentra la base de datos,mediante IP o JDBC-ODBC, por ejemplo dbc:db2:10.0.1.80:50000/BD1 (referencia directa) o jdbc:odbc:BD1 (referencia por ODBC).
2. Cargar el driver correspondiente mediante Class.forName("driver"), por ejemplo Class.forName("sun.jdbc.odbc.JdbcOdbcDriver").newInstance();
3. Realizamos la conexión para ello necesitaremos el login ,password y url de la base de datos y lo haremos con la siguiente clase Connection con = DriverManager.getConnection(jdbc:odbc:BD1, "myLogin", "myPassword");

Resumen
Class.forName("sun.jdbc.odbc.JdbcOdbcDriver");
Connection con = DriverManager.getConnection(jdbc:odbc:BD1, "myLogin", "myPassword");

Un objeto Statement es el que envía nuestras sentencias SQL al controlador de la base de datos. Simplemente creamos un objeto Statement y lo ejecutamos, suministrando el método SQL apropiado con la sentencia SQL que queremos enviar. Para una sentencia select el método a ejecutar es executeQuery. Para sentencias que crean o modifican tablas, el método a utilizar es executeUpdate.

Ya tenemos nuestra conexión a la base de datos ahora vamos a ver como se hacen las consultas.
Por ejemplo si queremos crear una tabla seria de la siguiente manera:

Statement stmt = con.createStatement();
String tabla="CREATE TABLE nombretabla " + "(nombreCampo1 tipo, nombreCampo2 tipo nombreCampo3 tipo, ...)";
stmt.executeUpdate(tabla);

Para insertar datos en la tabla seria de la siguiente forma:
stmt.executeUpdate("INSERT INTO nombre_tabla " +"VALUES ('valor1', valor2,valor3,,,,)");

Para sacar datos de la tabla seria:
ResultSet rs = stmt.executeQuery("SELECT campo1,campo2,campo3,... FROM nombre_tabla");
while(rs.next()){
System.out.println(rs.getString(campo1));
}

JavaDoc

Sirve para explicar qué hace un código y se escriben comenzando por /** y terminando con */ , pudiendo ocupar varias líneas y están destinados a describir, principalmente, clases y métodos. Los comentarios JavaDoc siguen una estructura prefijada,por ejeplo eben incluir unos indicadores especiales, que comienzan siempre por '@' y se suelen colocar al comienzo de línea.

1. @author nombreAutor descripción
   
2. @version número de version descripción
   
3. @param nombreParámetro descripción.
4. @return descripción.
5. @see nombre descripción. Cuando el trozo de código comentado se encuentra relacionada con otra clase o método, cuyo nombre se indica en nombre.
   
6. @throws nombreClaseExcepción descripción.Cuando un método puede lanzar una excepción se indica así.
7. @deprecated descripcion -->Indica que el método ya no se usa y se ha sustituido por otro.

Para generar javadocs desde eclipse le damos al menu Proyect --> Generate Javadoc

Debug

Eclipse da apoyo completo a la tare de depuración a través de su perspectiva "Debug" ("Window > Open Perspective > Debug" o seleccionando el icono del "bicho" en el margen izquierdo). Dentro de esta perspectiva de depuración, haciendo clic en el margen izquierdo del editor de código aparecerá un menú contextual. Seleccionando "Add/Remove Breakpoint" añadirá o quitará un punto de ruptura, mientras que "Toggle Breakpoint" cambiará el estado de activación del punto de ruptura. Los puntos de ruptura marcan líneas en que la ejecución del programa se detendrá de manera que sea posible comprobar el valor de las variables en ese instante, identificando así posibles errores.

Cuando hacemos un debug tenemos 4 botón el de play y 3 flechas.

El play no hace el debug ejecuta el programa normalmente, no lo analiza.

La flecha de la izquierda es el step into que lo que hace es entrar dentro del método directamente.
La flecha del centro es el step que ejecuta el código linea a linea, así ves paso a paso que hace el programa.
la flecha de la derecha llamada step over se va directamente a lo que devuelve el método.

DTD (Document Type Definition)

Define estructura y sintaxis de un documento XML o SGML, como especificar restricciones en la estructura y sintaxis del mismo.
Un esquema basado en una DTD tiene bastantes limitaciones,no permite definir elementos locales que sólo sean válidos dentro de otros elementos.

Groovy

Groovy es un lenguaje de programación orientado a objetos implementado sobre la plataforma Java. Tiene características similares a Python, Ruby, Perl y Smalltalk. La especificación JSR 241 se encarga de su estandarización para una futura inclusión como componente oficial de la plataforma Java.

Para mas información http://es.wikipedia.org/wiki/Groovy_(Lenguaje_de_Programaci%C3%B3n)

Grails

Grails es un framework dinámico para aplicaciones web construido en Java y Groovy que integra las mejores APIs de la esfera Java EE incluyendo Spring, Hibernate y SiteMesh

XML(eXtensible Markup Language)

Es un meta lenguaje que nos permite crear leguajes de marcas para usos concretos, es decir que el usuario pueda crearse etiquetas propias que deben de tener un significado coherente y sigan las reglas adecuadas.

XMLHttpRequest

Es un API que implementan los navegadores Web.
Su función es crear un canal de comunicación, paralelo al usual, entre la página Web que se muestra en el navegador del cliente y el servidor que la ofrece.
El objeto XMLHttpRequest se puede invocar desde distintos lenguajes de programación.
En concreto, se utilizará el lenguaje JavaScript para acceder a este objeto.

la W3C en Abril del 2006 creó la primera especificación completa para el objeto XMLHttpRequest. Sin embargo, muchos navegadores ya habían implementado el objeto de una u otra forma. Por ello, al crear una nueva instancia del objeto en el código JavaScript de la página, se deben tener en cuenta estas implementaciones si se desean aplicaciones compatibles entre los distintos navegadores.
Para realizar este proceso se debe utilizar una función JavaScript que permita encapsular la creación de la instancia del objeto XMLHttpRequest.

WebKit

Es un framework para aplicaciones que funciona como base para el navegador web Safari y Google Chrome, que facilita a los desarrolladores incluir gran parte de las funcionalidades de Safari en sus propias aplicaciones. Basado originalmente en el motor de renderizado KHTML del navegador web del proyecto KDE: Konqueror, el cual a su vez (a partir de su versión 4.2) se preve que use WebKit.

PERMGEN

Es una memoria usada por la máquina virtual Java para almacenar el código estático de las aplicaciones que corren en ella.

Wrapper

Es una clase.
Dota a los datos primitívos con un envoltorio que permita tratarlos como objetos.

Las clases envoltorio que trae la API son :

• Byte --> byte Interger --> int
  
• Short --> short Long --> long
  
• Boolean --> boolean Float --> float
  
• Double --> double Character --> char

Uso:
Integer i = new Integer(5);
int x = i.nextValue();

Adapter

Es un patrón de diseño.
Una clase Clase1 convierte la interface de otra clase Clase2 para ser lo que la Clase1 espera.

Builds

El término build software se refiere ya sea para el proceso de conversión de archivos de código fuente en el artefacto de software independiente (s) que se puede ejecutar en un equipo, o el resultado de hacerlo

Uno de los pasos más importantes de construir un software es el proceso de compilación en archivos de código fuente se convierte en código ejecutable.

Integración Contínua

La integración contínua es un concepto que surge a partir de la idea de realización de builds diarios.

Es una metodología que consiste en hacer integraciones automáticas de un proyecto lo más a menudo posible para así poder detectar fallos cuanto antes. Entendemos por integración la compilación y ejecución de tests de todo un proyecto.

El proceso suele ser, cada cierto tiempo (horas), descargarse las fuentes desde el gestor de versiones (por ejemplo CVS, Subversion o Visual Source Safe) compilarlo, ejecutar tests y generar informes.

Para esto se utilizan aplicaciones como Continuum, Hudson, CruiseControl o Anthill (para proyectos Java) o CruiseControl.Net para .Net, que se encargan de controlar las ejecuciones, apoyadas en otras herramientas como Ant o Maven (también para proyectos Java), o Nant (para .Net) que se encargan de realizar las compilaciones, ejecutar los tests y realizar los informes.

DOM (Document Object Model)

Explicación técnica de la wiki:

Es un modelo computacional a través del cual los programas y scripts pueden acceder y modificar dinámicamente el contenido, estructura y estilo de los documentos HTML y XML. Su objetivo es ofrecer un modelo orientado a objetos para el tratamiento y manipulación en tiempo real (o de forma dinámica) a la vez que de manera estática de páginas de Internet.

Esto es lo que yo he entendido:

DOM es el árbol del documento. Un documento que siga las normas XML, (como HTML, JSF, etc.), se compone de una serie de nodos, (padres, hijos, etc.), que forman un árbol.
Gracias a DOM, el documento se ve como un árbol de objetos, y permite modificarlo de forma más sencilla.

Enumeration

Es como una constante que puede tener muchos valores.


public enum EnumerationTipoColores {

ROJO("Color rojo"),
AZUL("Color azul"),
AMARILLO("Color amarillo");

private final String value;

EnumerationTipoColores(String v) {
value = v;
}

public String value() {
return value;
}

public static EnumerationTipoColores fromValue(String v) {
for (EnumerationTipoColores c: EnumerationTipoColores.values()) {
if (c.value.equals(v)) {
return c;
}
}
throw new IllegalArgumentException(v);
}

}

JQuery, YUI, ExtJs

Vamos a dar una pequeña explicación de cada uno:

• JQuery --> no es sólo un framework,”es un nuevo tipo de libreria Javascript” con su propia API. Este ha sustituido javascript por su facil forma de trabajar simplifica el código muchisimo y por ejemplo no hay que escribir tanto código para decir que un elemento se oculte utilizando css.
• YUI --> se rige por los mismo patrones que Javascript, tiene increible librerias que puedes utilizar desde código para crear sin necesidad de html innumerables controles (desde botones, containers, menu, tabview,...). Su código es más extenso que JQuery.
  
• ExtJs -->es una biblioteca JavaScript para la construcción ricamente interactivo de aplicaciones web utilizando técnicas tales como AJAX, DHTML y DOM scripting.

Pom.xml

Se trata de un archivo XML que contiene información sobre el proyecto y los detalles de la configuración utilizada por Maven para generar el proyecto. Contiene los valores por defecto para la mayoría de los proyectos.
Ejemplos de esto es el directorio, que es objetivo, el directorio de fuentes, que es src / main / java, el directorio de fuentes de prueba, que es src / main / prueba, y así sucesivamente.

El POM fue rebautizado en project.xml de Maven 1 a pom.xml en Maven 2. En lugar de tener un maven.xml archivo que contiene los objetivos que se pueden ejecutar, los objetivos o plugins son ahora configurado en el pom.xml.
Cuando la ejecución de una tarea u objetivo, Maven busca el POM en el directorio actual.Se lee el POM, se necesita la información de configuración y, a continuación, ejecuta el objetivo.

Algunos de los que la configuración se puede especificar en el POM son las dependencias del proyecto, los plugins o metas que pueden ser ejecutadas, la construcción de perfiles, y así sucesivamente.Otros datos como la versión del proyecto, la descripción, los desarrolladores, listas de correo, así como también puede ser especificado.

JackRabbit

Es una aplicación de repositorio de contenido para la tecnología Java API (JCR).

Un repositorio de contenido es un almacén de contenido jerárquica con el apoyo de estructura y contenido no estructurado, búsqueda de texto completo, de versiones, las transacciones, la observación, y mucho más.
Las aplicaciones típicas que utilizan repositorios de contenido incluyen gestión de contenidos, gestión de documentos, registros y sistemas de gestión.

Jetty

Es un servidor y un contenedor de servlets (http) escrito en java y es de software libre bajo licencia Apache 2.0

Wicket (Apache)

Es una framework de desarrollo web para Java, separa la lógica de la vista , y son Html acompañados de clases Java.

Artifactory

Es un repositorio de Maven2, este sirve como proxy cache de los repositorios de maven y además también sirve como repositorio para los propios proyectos desarrollados por los programadores.

Está basado en JCR(JackRabbit) , tiene un UI basado en wicket y usa jetty para una implementacion rápida aunque también se puede implementar sobre tomcat.

Además baja las dependencias de Internet, cachea los proyectos y en caso de colapso viene muy bien.

Apache Ivy

Ivy es una herramienta para la gestión (registro, seguimiento, resolución y presentación de informes) de las dependencias del proyecto.
Se caracteriza por:

1. Flexibilidad y configurabilidad - Ivy es esencialmente un proceso agnóstico y no está vinculada a ninguna estructura o metodología. En lugar de ello, proporciona la necesaria flexibilidad y configurabilidad que adaptarse a una amplia gama de la gestión de la dependencia y construir procesos.
2. Estrecha integración con Apache Ant - mientras está disponible como una herramienta independiente, Ivy funciona particularmente bien con Apache Ant proporcionar una serie de poderosos Ant tareas que van desde la dependencia de la resolución a la dependencia la presentación de informes y publicación.
3. Ivy es de código abierto y puesto en libertad en virtud de una muy permisiva licencia Apache.
   
4. Ivy puede ser configurado para usar un montón de diferentes repositorios.

Ivy tiene un montón de potentes características, la más popular y útil es su flexibilidad, la integración con Ant y su fuerte dependencia transitiva de gestión de motor.La gestión de las dependencias transitiva es una característica que le permite obtener las dependencias de sus dependencias, transitively. A fin de abordar esta problemática hiedra para encontrar las necesidades de los metadatos acerca de sus módulos, por lo general en un archivo de hiedra. Para encontrar estos metadatos y sus dependencias artefactos.

Para más información http://ant.apache.org/ivy/history/latest-milestone/index.html

BreadCrumbs

Es el menú de links (normalmente horizontal) que indica por las páginas que has pasado desde el index hasta llegar a esa.Su objetivo es que el usuario vuelva exactamente por donde ha venido.

Por ejemplo:
noelia-java.blogspot.com --> Jsf --> BreadCrumbs

Comparaciones JSF

Soporta cualquiera de estas:

. } [ > gt <>= ge <= le == eq != ne && and || or * + - ? / div % mod (

Web.xml

El archivo web.xml proporciona la configuración y el despliegue de información para los componentes Web que conforman una aplicación web.
Ejemplos de componentes Web son los parámetros de servlet, Servlets y JavaServer Pages (JSP) definiciones, y Localizadores Uniformes de Recursos (URL) mapeos.

El archivo web.xml debe residir en el WEB-INF directorio en el contexto de la jerarquía de directorios que existen para una aplicación Web.
Por ejemplo, si la solicitud es client.war, entonces el archivo web.xml se coloca en el raíz_instalación / cliente guerra / WEB-INF directorio.

Faces-Config.xml

Es el archivo de configuración central de los JavaServer Faces.

Se espacifican los eventos, acciones , beans de respaldo (backend bean, bean que almacena las propiedades de los componentes UI de la página y los métodos asociados).

ui:fragment

Esta etiqueta nos sirve para introducri una nuevo UI Componente en un JSF
Básicamente sirve para los rendered.

CheckBox con JSF

If y else con Jstl

Para ello utilizamos las etiquetas c:when y c:otherwise dentro de la etiqueta c:choose

JSTL (JavaServer Pages Standar Tag Library)

No es más que un conjunto de librerías de etiquetas simples y estándares que encapsulan la funcionalidad principal que es usada comúnmente para escribir páginas JSP. Las etiquetas JSTL están organizadas en 4 librerías:

• core: Comprende las funciones script básicas como loops, condicionales, y entrada/salida.
• xml: Comprende el procesamiento de xml
• fmt: Comprende la internacionalización y formato de valores como de moneda y fechas.
• sql: Comprende el acceso a base de datos.

@SuppressWarnings("serial")

Esta anotación se utiliza para evitar un error en tiempo de compilación al implementar la interfaz java.io.Serializable y no tiene el campo llamado serialVersionUI.
Basta con añadir la línea SupressWarnings @ ( serial) antes de que su definición de clase.

¿Cómo realizar las pruebas unitarias?

Debemos probrar todos los métodos que se puedan dar errores, pero ese es a gusto del programador.
Estas pruebas hay que realizarlas al comienzo del ciclo de vida de la aplicación.
Antes y después de integrar,después de un refactor, siempre después de compilar.
Realizamoremos una serie de pruebas en busca de fallos a través de unos criterios que llamaremos pruebas de caja negra y/o de caja blanca, no son excluyentes, sino complementarias, hay que procurar usar las dos.

Esta explicado lo que es la caja negra y blanca en otro post.

Afortunadamente hay muchas herramientas para autmatizar pruebas unitarias: Maven, Ant, IDE's y CIS.

Pruebas Unitarias

Se utiliza para poder probrar que todo esta correcto en un módulo de código asi podemos saber que todo los módulos funcionan bien lo ideal es escribir todos los modulos independientes unos de otros.

Para que una prueba unitaria sea buena se deben cumplir los siguientes requisitos:

• Automatizable: no debería requerirse una intervención manual. Esto es especialmente útil para integración continua.
• Completas: deben cubrir la mayor cantidad de código.
• Repetibles o Reutilizables: no se deben crear pruebas que sólo puedan ser ejecutadas una sola vez. También es útil para integración continua.
• Independientes: la ejecución de una prueba no debe afectar a la ejecución de otra.
• Profesionales: las pruebas deben ser consideradas igual que el código, con la misma profesionalidad, documentación, etc.

Se recomienda seguirlos o de lo contrario las pruebas pierden parte de su función.Pero no es obligatorio.

Los beneficios de escribir pruebas unitarias son muchos:

• El código es menos frágil.
• Hacer cambios es más seguro y fácil.
• Podemos integrar continuamente de manera rápida.
• Podemos hacer refactors agresivamente.
• Tenemos una documentación viva de nuestros APIs.
• Nos permite pensar desde el punto de vista de la interfaz y no de la implementación.
• Los errores están más acotados y son más fáciles de localizar: dado que tenemos pruebas unitarias que pueden desenmascararlos.

Estandares de desarrollo

Nomenclatura:

• Nombres de clases comienzan con mayuscula y continuan con sintaxis de camello
• Nombres de propiedades/objetos comienzan con misnúscula y continuan con sintaxis de camello
• Nombres de paquetes: todas las letras en minúscula.
  

Jerarquía de paquetes:

• carpeta source foder:
• src
• test
• todos los paquetes tendrán como paquete raiz el paquete eticom
• el subpaquete será el que describa el módulo que se está desarrollando
• todas las clases deben estar en un paquete.
  

Resources de proyecto/Recursos comunes a proyectos/ Librerías>

• testNG.jar
• suite de pruebas con las clases de prueba declaradas
• commons-logging.jar
• apache-log4j.jar
• y configuración correcta de log4j.xml.
  

Responsabilidad de clases y métodos:

• una de las reglas de POO es la de unica responsabilidad de las clases más info
  

Generación de una nueva clase:

• añadir atributo Log logger
  

@SuppressWarnings("deprecation")

Esta anotación le indica al compilador para reprimir advertencias específicas que, de otro modo, genera.

Por ejemplo:
Cuando usamos java.util.Date fechaHasta = new java.util.Date("12/31/2099");
Esta clase esta obsoleta ypara evitar que salga el warning se le pone la anotación @SuppressWarnings("deprecation") y listo

Conversation y Long running conversation

Hay que distiguir entre estos dos conceptos:

• Conversation-->es una unidad de trabajo desde el punto de vista del usuario. Tal vez abarcan varias interacciones con el usuario, varias solicitudes, varios de bases de datos y transacciones. Pero para el usuario, una conversación resuelve un solo problema.
  Una conversación tiene estado asociado con "lo que el usuario está haciendo ahora, en esta ventana". Un único usuario puede tener múltiples conversaciones en curso en cualquier momento, por lo general en múltiples ventanas. La conversación contexto nos permite asegurar que el estado de las diferentes conversaciones no chocar y provocar errores.
• Long-running conversation-->unicamente la 2ª mantiene el estado entre diferentes peticiones a lo largo de la realización de la tarea (task).

Link interesante:
http://www.redhat.com/docs/manuals/jboss/jboss-eap-4.2/doc/seam/Seam_Reference_Guide/index.html

CSS estilos de la web

Un link con las propiedades CSS ordenadas alfabéticamente:

http://www.blooberry.com/indexdot/css/propindex/all.htm

Microformatos

Es una forma de marcar contenido en las webs. Usas un XHTML concreto, con unos "class" concretos, etc. Con eso permites que aplicaciones externas, o incluso tu propia aplicación, pueda extraer información de tu XHTML simplemente parseandolo.

Puedes marcar, por ejemplo, datos de contacto.

La aplicación parsea ese XHTML, y puede extraer, por ejemplo, el nombre de la persona, su e-Mail, su teléfono, etc. Porque está marcado siguiendo una especificación.

Gracias Juan por la explicación.

Link interesante:
Microformatos

@RaiseEvent Seam,@Observer

@RaiseEvent-->Inicia un evento en tiempo de ejecución o declara el código que se debe ejecutar al iniciar un evento.

• anotacion para observar un evento @Observer("nombreEvento")
• anotación para lanzar un evento @RaiseEvent("nombreEvento")

Por ejemplo:
Tenemos un método:

@RaiseEvent("nuevaEmpProductora")
public String actionNew(){
//código
}

Yen la misma clase o en otra clase de la aplicación ponemos :

@Observer("nuevaEmpProductora")
public String completarCampos(){
//código
}

El @Observer esta esperando que se lance un evento con el nombre que el tiene y lo ejecuta automaticamente.

@In y @Out Seam

@In
es para inyectar componentes de la aplicación en el componente actual.
La anotación @In puede recibir valores:

• create=true/false que indica si se crea el componente en caso de que no exista (o lo que es lo mismo en caso de que Seam no lo haya creado en una petición anterior),.
  
• required=true/false indicando si el componente debe estar creado con anterioridad, en caso de que no exista la aplicación ha fallado y debería lanzarse una excepción.
• y los relacionados con el scope y el value que son el ámbito y el nombre del componente.

@Out
es para "outyectar" componentes, o dicho de otra forma inyectar hacia fuera y de ahí el término biyección que utiliza Seam.
La anotación @Out puede recibir valores:

• required=true/false.
• scope=relacionado con el ámbito.
  
• value=relaciona con el nombre del contexto
  

Web Services

Los web services son un conjunto de protocolos y estándares que sirven para intercambiar datos entre aplicaciones.

Distintas aplicaciones de software desarrolladas en lenguajes de programación diferentes, y ejecutadas sobre cualquier plataforma, pueden utilizar los servicios web para intercambiar datos en redes de ordenadores como Internet. La interoperabilidad se consigue mediante la adopción de estándares abiertos.

Las organizaciones OASIS y W3C son los comités responsables de la arquitectura y reglamentación de los servicios Web. Para mejorar la interoperabilidad entre distintas implementaciones de servicios Web se ha creado el organismo WS-I, encargado de desarrollar diversos perfiles para definir de manera más exhaustiva estos estándares.

Desplegar un war en un Tomcat

Una vez creado el war nos vamos a la carpeta target del pryecto y copiamos el war que se generó en la carpeta webapp del tomcat.
El tomcat cuando arranca y ver un war,lo despliega y crea su carpeta correspondiente.
Miramos en la carpeta conf/Catalina/localhost del tomcat creamos un archivo xml con el mismo nombre que el de la aplicación y copiamos alli el context que viene en el server.xml de nuestra aplicación.

Ya podemos lanzar nuestro tomcat con la aplicación.

Nos vamos o desde consola o desde modo gráfico a la carpeta bin del tomcat y ejecutamos startup.bat en windows o startup.sh en linux.

Tutorial Facelets

https://facelets.dev.java.net/nonav/docs/dev/docbook.html#template

RichFaces

Inyectar un bean en otro bean con Annotations

Ejemplo de una inyección

@In(create=true)
AdminDireccionController adminDireccionController;

Ejemplo de otra forma de inyección:


@In(value = "#{adminDireccionController}")
private AdminDireccionController adminDireccionController;

Un caso práctico:

Cuando intente inyectar un bean en otro me daba un error:

ERROR org.jboss.seam.jsf.SeamPhaseListener.beforePhase(120) - uncaught exception
javax.el.ELException: javax.el.ELException: org.jboss.seam.NoConversationException: no long-running conversation for @Conversational bean: adminTerceroController

Tuve que poner en el controller1 que voy a inyectar la anotación @Begin en el primer método que utilizaba el otro controller2 ya que mi controler1 era de ámbito conversation para que se inicie la longrunnigconversation

Crear war desde consola de un proyecto Seam

Abrimos una consola y nos vamos a dentro de la carpeta donde esta nuestro proyecto.
Ponemos la siguiente instrucción: mvn clean package.

Escribir ficheros

JNDI(Java Naming Directory Interface)

Es una especificación que permite localizar información en distintos directorios distribuidos (como NDS de Novell), directorios LDAP (como OpenLDAP) o servicios CORBA "(COS)Corba Object Service".Debido a la importancia que tienen los servicios antes mencionados en sistemas empresariales, JNDI es una herramienta que cobrará gran importancia en este tipo de desarrollos

Identity

El componente org.jboss.seam.security.Identity tiene las anotaciones necesarias para ser un componente pre-built, es decir un componente que siempre lo tendrás disponible con el framework de Seam cuando arranques tu aplicación, de hecho se ve la inicialización en consola. Se puede apreciar http://www.redhat.com/docs/manuals/jboss/jboss-eap-4.3/doc/seam/api/org/jboss/seam/security/Identity.html que es un componente de session y que representa la identidad del usuario este viene a concretarse en nuestra aplicación a través del nombreUsuario y clave (más o menos aunque éste se lo han currado con algunas propiedades más). Básicamente se utiliza para utilizarlo en el formulario del login que una vez que se hace click en el boton se llama al componente Authenticator que lleva inyectado el Identity. En dicho método de registro lo más importante es aplicar rol (o roles de usuario ) al componente identity, y en función de dichos roles nuestra aplicación (y sus componentes) permitirán o no ciertas acciones de usuario (una vez inyectado el componente identity en el componente correspondiente que necesita hacer la validación de usuario y rol)

StringBuffer

StringBuffer, se utiliza cuando se quiere manipular el contenido de una cadena.
Mediante el método append() puedes añadir caracteres en la cadena que tengamos.
Ejmplo:
StringBuffer sb = new StringBuffer("Aprendiendo");
sb.insert(12, "Java ");
System.out.println(sb.toString());
Salida. Aprendiendo Java

Otro método que utiliza es el setCharAt(), que selecciona un carácter en la posición especificada del StringBuffer. setCharAt() es útil cuando se reutiliza un StringBuffer.

Enum

Un tipo enum es un tipo cuyos campos consisten en un conjunto fijo de constantes. Los ejemplos más comunes incluyen direcciones (valores de Norte, Sur, Este y Oeste) y los días de la semana.

Debido a que son constantes, los nombres de un tipo enum de los campos son en mayúsculas.

Ejemplo:
public class Card {
public enum Rank { DEUCE, THREE, FOUR, FIVE, SIX,
SEVEN, EIGHT, NINE, TEN, JACK, QUEEN, KING, ACE }

public enum Suit { CLUBS, DIAMONDS, HEARTS, SPADES }

private final Rank rank;
private final Suit suit;
private Card(Rank rank, Suit suit) {
this.rank = rank;
this.suit = suit;
}

public Rank rank() { return rank; }
public Suit suit() { return suit; }
public String toString() { return rank + " of " + suit; }

private static final List protoDeck = new ArrayList();

// Initialize prototype deck
static {
for (Suit suit : Suit.values())
for (Rank rank : Rank.values())
protoDeck.add(new Card(rank, suit));
}

public static ArrayList newDeck() {
return new ArrayList(protoDeck); // Return copy of prototype deck
}
}

Ordenar un HashMap

Un HashMap no tiene ningún método para ordenar sus datos.
Hay varias maneras para ellos,yo he visto más fácil esta que voy a explicar.
Para ello vamos a utilizar el Collection.sort

Voy e poner el caso mio para explicarlo:

Tenemos una lista creada --> operacionesList que es la que vamos a ordenar.
OperacionesComparator es la clase que voy a utilizar para ordenar, esta contiene
public class OperacionesComparator implements Comparator {

public int compare(Object obj1, Object obj2) {
SelectItem p1 = (SelectItem) obj1;
SelectItem p2 = (SelectItem) obj2;
return p1.getLabel().compareTo(p2.getLabel()); } }

Mi lista antes creada es de tipo SelecItem y comparamos por su label,que es lo que se va a mostrar.

Despues de rellenar la lista ponemos la instruccion siguiente y se ordena.

Collections.sort(operacionesList,new OperacionesComparator());

Este enlace esxplica todo si o que queremos ordenar son otros tipos de listas.http://java.sun.com/j2se/1.5.0/docs/api/java/util/Collections.html

OAS

Oracle Application Server,un componente clave de Oracle Fusion Middleware, ofrece la solución más completa del sector para desarrollar, integrar e implementar las aplicaciones, portales y servicios Web de su empresa. Basado en un poderoso servidor J2EE escalable, Oracle Application Server ofrece implementación de aplicaciones líderes, integración de negocios y el mejor software para portales. Oracle Application Server es la única plataforma diseñada para grid computing (inglés), así como soporte total del ciclo de vida de la Arquitectura Orientada a Servicios (SOA).

¿Tomcat o Jboss?

BeanUtils

Cuando se quiere acceder directamente a los metodos de los beans, se suelen usar los correspondientes metodos getXXX o setXXX. Sin embargo,hay casos en lo que se necesita acceder dinamicamente a las propiedades del objeto Java y no tenemos conocimiento de los metodos
getter y setter ni podemos llamarlos.

Es por eso que existen unas APIs que se llaman: Reflection y Introspection, que son bastante complicadas de usar, pero los componentes BeanUtils proveen unos envoltorios de facil uso para poder
utilizar estas dos habilidades sin problemas.

Reflexión e Introespección

Reflexión-->si partimos de la idea de que en java es un lenguaje orientado a objetos, se supone que los objetos son de una clase. Es decir que si tengo un objeto/variable miCoche que es de tipo Coche, pues entonces sabemos que es de la clase Coche. (ya sé que es evidente pero empezamos despacito...)
Pues bien el api de reflexión nos permite a través de la clase Class (ej: miCoche.getClass()) obtener información sobre los métodos y propiedades y anotaciones de dicha clase. A eso se refieren con introspección (se pregunta a si mismo). Pues como os comento, a través de la clase Class (Coche.class o miCoche.getClass()) podemos saber la "metainformación" de la clase en cuestión y por lo tanto de todos los objetos que tengamos de esa clase.
¿para qué sirve esto?...
pues hay situaciones en nuestro programa en tiempo de ejecución (es decir cuando el usuario lo utiliza/ejecuta) en las que nuestros objetos pueden recibir objetos de servicios externos, estos objetos quizá sean de la clase Object y entonces ¿qué hacemos o podemos hacer con un objeto de la clase Object?, pues podemos utilizar la reflexión para saber que propiedades tiene o simplemente que clase o que interfaces, o anotaciones, o metodos (creo que la info que te da es de tipo pública nunca private)....

Introespección-->definición de la palabra para que podamos entender mejor esto :"Observación interior de los propios actos o estados de ánimo o de conciencia".
Los javaBeans estan hechos para existir dentro de un Contenedor de Beans. Son clases Java. El contenedor puede ver las propiedades de un bean, pero cómo las ve?como vería las propiedades de un bean que has creado tú? pues lo que hace es "introspeccionar", "ver el interior" de la clase Bean para buscar los métodos y propiedades que lo conforman,por ejemplo si tienes los métodos getX y setX, el contenedor deducirá que hay una propiedad en el bean llamada X.

Aqui viene mas detallada:
http://www.javahispano.org/contenidos/es/introduccrion_al_api_reflection_reflexrion_de_ja/;jsessionid=8ACC346B5864053D9AC0C8CBBCA58062

Tiempo de compilación y de ejecución

Voy a explicar el tiempo de compilación y el tiempo de ejecución pues he visto que hay gente que no saben lo que es,asi les puede quedar muy clarito.

Tiempo de Compilación-->es el intervalo de tiempo en el que un compilador compila código escrito en un lenguaje de programación a una forma de código ejecutable por una máquina.

Tiempo de Ejecución-->intervalo de tiempo en el que un programa se ejecuta en un sistema operativo. El período comienza cuando el programa es llevado a la memoria primaria y comienzan a ejecutarse sus instrucciones. El período finaliza cuando el programa envía la señal de término (normal o anormal) al sistema operativo.

Suele decirse también que un programa se encuentra "corriendo" mientras está siendo ejecutado.

En tiempo de ejecución pueden darse errores inesperados llamados runtime errors, que pueden ser controlados a través de mecanismos llamados manejos de excepciones.

StringUtils

Cuando hay que comparar dos String:

if (solicitanteProvincia.equals(nombreProvincia)){

Lo recomendable es hacerlo con:
if(StringUtils.equals(solicitanteProvincia, nombreProvincia)){

Con esto te aseguras de que si algo es null la comparación no Explote.


Api:
http://www.euskadi.net/r33-2732/eu/contenidos/informacion/mipago/es_10741/adjuntos/javadoc/r01f/com/ejie/r01f/util/StringUtils.html

Tutorial Hibernate

http://www.visualbuilder.com/java/hibernate/tutorial/

Tutorial Ajax4jsf

http://www.jboss.org/jbossajax4jsf/docs/devguide/en/html/index.html

http://www.exadel.com/tutorial/jsf/jsftags-guide.html -->esta en español y es más reducido

http://www.jboss.org/file-access/default/members/jbossrichfaces/freezone/docs/tlddoc/index.html

http://www.ribosomatic.com/articulos/tecnicas-ajax-mas-buscadas-50-ejemplos-y-tutoriales

Tutorial Seam

http://docs.jboss.com/seam/2.0.0.GA/reference/en/html/index.html

Tutorial JSF

http://www.exadel.com/tutorial/jsf/jsftags-guide.html

http://www.horstmann.com/corejsf/jsf-tags.html

http://www.jsftoolbox.com/documentation/facelets/10-TagReference/

Decorator

El patrón Decorator responde a la necesidad de añadir dinámicamente funcionalidad a un Objeto. Esto nos permite no tener que crear sucesivas clases que hereden de la primera incorporando la nueva funcionalidad, sino otras que la implementan y se asocian a la primera.

Supongamos que tenemos una clase existente Ventana y queremos añadirle funcionalidad para que muestre un borde alrededor. Podemos crear una subclase VentanaConBorde que herede de Ventana.

Hasta aquí todo bien, pero supongamos que surge la necesidad de crear una ventana que muestre un pequeño botón de ayuda con un signo de interrogación (?) en su parte superior. Entonces tenemos las siguientes opciones:

• Crear otra subclase de Ventana: VentanaConBotónDeAyuda.

Problema: No cubre la necesidad de tener ventanas con bordes y botón de ayuda a la vez.

• Crear una subclase de VentanaConBorde: VentanaConBordeYBotonDeAyuda.

Problema: No tenemos una ventana con botón de ayuda y sin borde.

• Crear clases para todas las combinaciones posibles de funcionalidades.

Problema: Con este ejemplo tendríamos cuatro clases: Ventana, VentanaConBorde, VentanaConBotonDeAyuda y VentanaConBordeYBotonDeAyuda; con tres funcionalidades tendríamos ocho clases y con cuatro, ¡dieciséis!

El patrón Decorator soluciona este problema de una manera mucho más sencilla y extensible.

Se crea a partir de Ventana la subclase abstracta VentanaDecorator y, heredando de ella, BordeDecorator y BotonDeAyudaDecorator. VentanaDecorator encapsula el comportamiento de Ventana y utiliza composición recursiva para que sea posible añadir tantas "capas" de Decorators como se desee. Podemos crear tantos Decorators como queramos heredando de VentanaDecorator

Ejemplo:

abstract class Componente
{
     abstract public void Operacion();
}
class ComponenteConcreto extends Componente
{
     public void Operacion()
     {
             System.out.println("ConcreteComponent.Operation()");
     }
}
abstract class Decorator extends Componente
{
     protected Componente componente;
     public void SetComponente(Componente component)
     {
             this.componente = component;
     }
     public void Operacion()
     {
             if (componente != null) componente.Operacion();
     }
}
class DecoradorConcretoA extends Decorator
{
     private String estadoAgregado;
     public void Operacion()
     {
             super.Operacion();
             estadoAgregado = "Nuevo estado";
             System.out.println("DecoradorConcretoA.Operacion()");
     }
}
class DecoradorConcretoB extends Decorator
{
     public void Operacion()
     {
             super.Operacion();
             AgregarComportamiento();
             System.out.println("DecoradorConcretoB.Operacion()");
     }
     void AgregarComportamiento()
     {
             System.out.println("comportamiento añadido B");
     }
}
public class Cliente
{
     public static void main(String[] args)
     {
             ComponenteConcreto c = new ComponenteConcreto();
             DecoradorConcretoA d1 = new DecoradorConcretoA();
             DecoradorConcretoB d2 = new DecoradorConcretoB();
             d1.SetComponente(c);
             d2.SetComponente(d1);
             d2.Operacion();
     }
} 

Converter

Es un interfaz que extiende de Serializable que puede realizar conversiones de Object-a-String y String-a-Objeto utilizando la tecnología JSF, de ahí que uno de los parámetros que recibe el parámetro es el propio contexto de la aplicación web.
Los converters se aplican en el momento en el que nuestra aplicación recibe valores o devuelve valores. Cuando recibimos una solicitud jsf, una de las fases de dicha recepción de la solicitud está la de aplicar converters en función del componente UI, ya que los converters son una propiedad de los componentes. Y por otro lado necesitamos convertir a String los objetos de nuestra aplicación cuando dichos objetos se pintan en la página web correspondiente, es decir no queremos que nos salga el id de objeto ej 1312341...@es.cea.academia.Alumno, sino "matricula:2345"

La libreria es javax.faces.convert.Converter;

Métodos que utiliza:
--public Object getAsObject(FacesContext context,UIComponent component,String value) throws ConverterException-->Convertir el valor, que está asociada con la UIComponent especificado, en un modelo de datos Object de que sea apropiado.

--public String getAsString(FacesContext context,UIComponent component,Object value) throws ConverterException-->convierte el valor que esta asociado al UIComponent en string que es adecuada para ser incluido en la respuesta generada durante la fase de respuesta.

Cuando se crea el converter hay que decirle a la aplicación que existe,eso se hacen el en face-config.xml

Un ejemplo para verlo más claro:

import javax.faces.component.UIComponent;
import javax.faces.context.FacesContext;
import javax.faces.convert.Converter;

public class ProvinciaConverter implements Converter {

public Object getAsObject(FacesContext arg0, UIComponent arg1, String arg2) {
// TODO Auto-generated method stub
return null;
}

public String getAsString(FacesContext arg0, UIComponent arg1, Object arg2) {

return ProvinciasUtil.getInstance().getProvincia((Long)arg2);
}

}

En mi proyecto tengo un archivo jsf que en un column tiene la propiedad converter="ProvinciaConverter"
Este llama a la clase arriba descrita que lo que hace es recibir un long y devolver el nombre asociado a ese numero,es decir un string.(el nombre se recupera en la clase ProvinciasUtil,solo he puesto este trozo de código)

JUnit y TestNG

Son dos framework que se utilizan para la programacion de pruebas unitarias.

• JUnit-->hasta hace poco se utilizaba el JUnit. JUnit tiene DBUnit para pruebas de integración con base de datos,existe HttpUnit para probar que la página que verá el usuario contiene lo que debe contener, es decir formulario, mensaje ....JUnit en sus últimas versiones trabaja con anotaciones pero antes funcionaba por herencia.Se utiliza para pruebas mas simples.
  

• TestNG -->pruebas unitarias en esteroide , tiene todo lo que tiene Junit 4 y más,está basado en Annotations.Maneja los mismos conceptos. Tiene Clases que corren las pruebas y arman reportes. Es mucho más sofisticado. Las pruebas pueden depender unas de otras. Es útil para otro tipo de pruebas más complejas.

Los dos proporcionan plugins para integrar con el IDE preferido es decir: eclipse, netBeans, intellijIdea ....

Leer de fichero y guardar en un HashMap

Map provincias= new HashMap();
try {
FileReader fr = new FileReader("/temp/provincias.txt");
BufferedReader bf = new BufferedReader(fr);
String linea;
while ((linea = bf.readLine()) != null) {
String[] cadenas = linea.split("\t");
provincias.put(cadenas[0], cadenas[1]);
}
fr.close();
System.out.println("Provincias importadas correctamente");
} catch (FileNotFoundException e) {
System.out.println("Fichero no encontrado");
e.printStackTrace();
} catch (IOException e) {
System.out.println("Error de E/S");
e.printStackTrace();
}

}

He tenido un pequeño problema al leer de esta forma los fichero pues los carateres como la ñ o los acentos nolos leia y metia unos simbolos raros,como un combox con una iterrogracion.
Para arreglar este problema he cambiado la forma de leer los ficheros

FileInputStream fis = new FileInputStream("/temp/provincias.txt");
InputStreamReader is = new InputStreamReader(fis, "ISO-8859-1");
BufferedReader bf = new BufferedReader(is);

Asi le indico el tipo de encoding.

Estructura HashMap

Un mapa es una estructura de Java que nos permite almacenar pares clave/valor. De tal manera que para una clave solamente tenemos un valor.

Si añadimos un nuevo elemento clave/valor cuando la clave ya existe, se sobrescribe el valor almacenado anteriormente.

La estructura a listar que utilizamos como mapa es un HashMap. Lo primero que tenemos que hacer es crear el mapa y añadirle elementos:

Map mapa = new HashMap();

mapa.put("String","String");


Si intentamos añadir otro elemento con una clave ya existente, sobreescribe el valor. Ya que no puede haber elementos duplicados.

Para recorrerlo nos apoyaremos sobre un Iterator que será el puntero encargado en recorrer los elementos del mapa. Obtendremos un iterador sobre la estructura invocando los métodos .entrySet() e .iterator(). Usar iteradores permite separar la lógica de la clase de la lógica de la iteración. Los iteradores tienen un comportamiento similar a los enumerados.

Para mover el iterador utilizaremos el método .next() y si queremos comprobar que el iterador ha llegado al final de la estructura tenemos el método .hasNext()


Iterator it = mapa.entrySet().iterator();

while (it.hasNext()) {
Map.Entry e = (Map.Entry)it.next();
System.out.println(e.getKey() + " " + e.getValue());
}

Si queremos sacar un sólo dato,ponemos mapa.get(key que contiene ese valor);

NOTA:
El HashMap espera siempre un Object,lo digo porque me cree uno Map que esperaba 2 string le meti un int y no me daba error,porque espera un object,y ponga lo que ponga no da error,se lo traga,y me volvi loca,buscando que era lo que fallaba. Por qué no me imprimía el dato.Cosas tontas.

AJAX

AJAX es una técnica de desarrollo para crear aplicaciones Web basada en tres tecnologías ya existentes.
No es un lenguaje de programación, como creen algunas personas.
Antes de Ajax estaba el Scripting Remoto.

Las tecnologías que forman AJAX son:

• Html-->las páginas web que son parte de la aplicacion web Ajax se crean con html y css,tambien se puede utilizar Xhtml.
  
• DOM-->esto perimite acceder a los elementos de la web(tabla,formularios) ,mediante javascript permite tratar los elementos como objetos con sus métodos y propiedades.
  
• Xml-->las transmisiones entre el cliente y el servidor se haran de forma asincrona mediante xml.Aunque tambien permite el intercambio con texto plano , pre-formateado...
  

Cómo sabe Hibernate que algo ha cambiado

Las tablas de la base de datos tiene 2 campos un @Id y el otro @Version.
Cada vez que se cambia algo la version se incrementa en 1.
Asi se sabe cuando se ha cambiado los datos y que 2 usuarios no puedan cambiar los datos a la vez.

Más sobre Hibernate

Al arrancar la aplicacion se crea un objeto de SessionFactory(fábrica de sesiones) de ámbito application que a través del método configure() lee las configuraciones de persistencia,pueden estar en archivos xml,hibernate.properties,@anotaciones o podemos configurar hibernate para que al arrancar lea el archivo import.sql.
El tiempo de arranque dependerá del numero de clases persistentes que haya en la aplicación.

Una vez arrancado,se crea un objeto de session que es el que inyectamos en nuestros componentes persistentes a través de la etiqueta @In del EntityManager.

Para que los datos que la session ha creado,eliminado,modificado quede bien reflejado y guardado en la base de datos se tiene que hacer dentro de una transacion hay que abrirla mediante el método session.beginTransaction(); y se cerrará con la sentencia tx.commit();.
Mientras no se cierre la transacción, ésta se considera "caliente" y el programador podra realizar cambios en ella sin preocuparse de la Base de Datos, ya que hibernate las modificará y actualizará automáticamente.

Bean con estado y sin estado

Un Bean con estado da servicio todos los usuarios y a varios beans,
Un Bean sin estado si no tiene estado solo puede dar servicio a un solo usuario.

Esquema Servlet

JDeveloper + JSF Configuración del faces-config.xml

JDeveloper tiene una interface gráfica para poder configurarlo más facilmente.


Con esta ventanita podemos crearnos los beans o las reglas de navegación entre páginas entre otras cosas.
En el caso de los beans tenemos la siguiente ventana:
Le ponemos el nombre que queramos ,elegimos la clase que va a corresponder ese beans y el ambito que va a tener que puede ser:

1. Application
2. Session
3. Request

Voy a poner de la imagen del código que genera esta pantalla de un proyecto que tengo hecho anteriormente:
Cuando queramos inyectar un bean en otro(recordar siempre la dirección de inyecciones de beans que escribi entre post)
Y desde la interface gráfica se pincha en el bean que le queremos inyectar otro beans,le damos a Managed Properties /New,ponemos el nombre de la propieda y la clase,más abajo aparece Managed Property y le ponemos el nombre del bean a inyectar con #{nombre del bean}

Declaración de etiquetas jsp

Las etiquetas JSP son poderosas y encapsulan tareas que serían difíciles o llevarián mucho tiempo de programar.Los lenguajes de script que tenemos disponibles dependen del motor JSP que estemos usando. Con la implementación JSP de Sun, debemos usar el lenguaje Java como lenguaje de script, pero otros motores de JSP de terceras partes podrían incluir soporte para otros lenguajes.

Las etiquetas JSP tienen diferentes categorías:

• Comentarios: <%-- mi comentario --%>

• Declaraciones: se utiliza para declarar variables de tipos simples,objetos y métodos. .Ejemplo: <%! int contador = 0; %&gt. La sintaxis es puro Java y se continua con la vieja regla de "declarar antes de usar".

• Expresiones: al procesar la página la salida es el valor de la expresión delimitada por <%= %>, por ejemplo podemos insertar la expresión dentro de una línea HTML típica

     & ltp&gtLa cuenta es: <%=contador%> &ltp&gtEl cuadrado de la cuenta es: <%=cuadrado( contador )%>  <%-- Llamada a método --%>

• Scriptlets: un conjunto de instrucciones Java. Formato: <% scriptlet %>. Ejemplo:

          <%! int base = 5, altura = 7 ; %>         <% base * altura / 2.0;         new java.util.Date(); %>         &ltBR> Hola HTML         <% System.out.println( "de regreso a scriplets" );      base + altura; %> 

• Directivas: su sintaxis general es <%@ directiva {atributo ="valor"} %> dónde la directiva debe tener al menos un atributo:

  • Directivas page: en función del atributo utilizado sirven para la configuración general: importar clases, definir tipo MIME, etc.

                    <%@ page import="paquete.clase" %>                 <%@ page contentType="tipo MIME" %>                 

    Para contentType los valores por defecto son contentType="text/html; charset=iso-8859-1".

    Algunos atributos:

    • import="package.*,clase.class" Sirve para importar paquetes y clases.

    • session="true|false" Por defecto es true. Indica si mantiene atributos de sesión para la página.

    • isThreadSafe="true|false" Por defecto es true. Si es true cada petición corre en un hilo y por tanto el procesador maneja las peticiones de forma asíncrona ("simultáneamente"). Con false se gestionan las peticiones en un hilo (una por una).

    • info="text" Información de la página a la que se puede acceder a través del método Servlet.getServletInfo()

    • errorPage="pagina_error". Página que manejará las excepciones.

    • isErrorPage="true|false". Indica si es una página que manejará errores.

    Ejemplos:

            <%@ page import=”com.myco.*” buffer=”26k” errorPage=”/oops.jsp”%>

    Para reenviar una excepción a una página tiene: <%@ page errorPage="07_errorPage.jsp"%> En la página de error (07_errorPage.jsp) tenemos una forma de capturar el error por medio del objeto implícito "exception":

    <%@ page isErrorPage="true" %>

    &lthtml>

    &lthead>&lttitle>Ejemplo de errorPage

    &ltbody>

    &lth1>Se ha producido un error

    &ltp>Error: <%= exception %>

    Esta página capta las excepciones. No capta los errores debidos a fallos de enlace (URL).

  • Directivas include: se inserta un fichero en el lugar de la directiva. Matiz: se inserta el fichero, no su valor o resultado. Utiles, entre otras cosas, para insertar código HTML o JSP que se repite. La URL debe ser relativa. Ejemplo:

    <%@ include file="cabecera.html" %>

  • Directivas Taglib: indica la referencia a la librería de etiquetas definidas por el programador (etiquetas personalizadas). El motor JSP utiliza esta librería para saber como interpretar las etiquetas personalizadas de la página JSP.Ejemplo:

    <%@ taglib uri="URI_de_librería" prefix="prefijo_de_etiquetas" %>

    URI es el descriptor único de la librería. No tiene valor por defecto. Si no se especifica aparece una excepción. El prefijo es el prefijo en la expresión prefijo:etiqueta, que sirve para definir la etiqueta personalizada. Cuando el motor de JSP se encuentra en la página con la expresión prefijo_de_etiquetas:etiqueta, entonces se dirige a la librería señalada en URI para interpretar la etiqueta. Las etiquetas personalizadas son importantes en el manejo de JSP.

• Acciones: realizan una tarea en el momento en que se solicita la página. Sirven para acceder a beans, etc. La acción de inclusión, a diferencia de la directiva de inclusión, implica la sustitución por el valor o resultado del archivo en el momento de la petición. Ejemplo:

  &ltjsp:include page="también una URL relativa" flush="true"/>

  Otra acción es jsp:forward, que tiene el mismo comportamiento que javax.servlet.RequestDispatcher. Su sintaxis admite (o no) parámetros. La ejecución de la página invocante se detiene para resolver el forward. Sintaxis:

  &ltjsp:forward page="también una URL relativa">

  &ltjsp:param name="nombre_parametro" value="valor" />

Bijection

Para entender el funcionamiento básico de JBoss Seam debes familiarizarte con dos conceptos: Contexto y Componente.

Un componente es un objeto con estado (normalmente stateful session beans). Una instancia de un componente vive en un contexto y se le asigna un nombre en dicho contexto.
Para asociar la instancia de un componente al nombre de dicho componente en un contexto Seam proporciona el mecanismo de Bijection

          Bijection = Injection + Outjection

El mecanismo de injection permite a un componente A obtener de un contexto una referencia a una
instancia de un componente B, haciendo que el contenedor de aplicaciones ”inyecte” el componente B en una variable del componente A.
El mecanismo de outjection permite que un componente B esté disponible en un contexto para poder ser inyectado en un componente A.
Es decir, mediante outjection se toma una instancia de un componente y se deposita en un contexto
y mediante injection se toma una instancia de un componente de un contexto y se asocia a una
variable de otro componente.

A diferencia del mecanismo de Injection, el mecanismo de Bijection es:

• contextual: Es usada para asociar componentes con estado desde diferentes contextos.
• bidireccional: Los componentes pueden ser depositados en el contexto o tomados de él.
• dinámico: Como los valores de las variables de los contextos cambian con el tiempo y los
  componentes tienen un estado definido, la bijection sucede cada vez que el componente es
  invocado.

Las conversaciones con SEAM

Definición:

Se puede entender por una conversación en Seam algo muy parecido de lo que hacemos cuando conversamos entre personas.
Existe un lugar (AplicationContext), un tiempo (SessionContext) y después una serie de objetos implicados en la conversación. Entre los objetos implicados en la conversación se encuentra el usuario, que participa a través de eventos, de tipo:

• JSF
  
• jBMP
• Seam page actions
• Seam component-drive events

Las clases implicadas son:
org.jboss.seam.core.ConversationEntry
org.jboss.seam.core.ConversationList
org.jboss.seam.core.Manager

Estos datos los he cogido del blog http://enjava.blogspot.com,que es de mi profesor Juan Antonio,un maestro en esto del j2ee.(que pelota no?)
Gracias por compartir tus conocimientos!!!!!

Annotations (Seguimo utilizando JBoss + Seam-gen)

En las etiquetas de persistencias hay: (estas solamente las lees el EntityManager)

1. @Entity en la definición clase .(se utiliza para las transaciones)
2. @Id en la definición de campo que hará de identificador.(se utiliza para las transaciones)
3. @Column para decir que el campo /propieda es persistente aunque sino lo ponemos por el mero hecho de estar en una entidad persisten se considera.
4. @Trasient,si queremos que un componente de la clase no sea persistente se le pone la etiqueta .
5. @ManyToMany(mappedBy="nombre clases relacionar"),son para implementar las relacion mucho a muchos
6. OneToMany(mappedBy="nombre clases relacionar"),. son para las relaciones uno a mucho.
7. @OrderBy("nombre del campo a ordenar").
8. @Scope(CONVERSATION) esto es para decir que el ámbito es de tipo conversacional .esto es una solicitud en los términos de J2EE.Si se coloca un objeto en el período de sesiones los usuarios que estará disponible en todas las páginas afectadas, el usuario formula.

JBOSS + Seam-gen Empezando nuevos proyectos

Si estamos utilizando el framework jboss-seam dentro de esto tenemos una utilizad para generar proyectos.

Dentro de la carpeta jboss-seam/seam-gen/tenemos un archivo llamado build.xml ,lo cogemos y lo arrastramos a la ventana Ant(pluging de eclipse para lanzar tareas).
Lanzamos la tarea seam-gen>reset para resetear la información del archivo seam-gen/build.properties que se utilizará en la generación de la aplicación nueva.

Lanzamos la tarea seam-gen>setup para configurar la información del archivo seam-gen/build.properties:

Nos irá saliendo una ventanitas que tendremos que meter la siguiente información:

• Directorio de workspace: nuestro directorio desde c: al workspace.
• Directorio de jboss: nuestro directorio desde c: al servidor jboss.
• Nombre del proyecto.
• Richfaces skin:blueSky (este sale por defecto).
• Ear o war project: ear .
• El package de nuestra aplicación.
• El package de nuestros EJBs.
• El package de nuestros tests.
• Tipo de Base de datos.
• Hibernate dialect: org.hibernate.dialect.MySQLDialect .
• Path a la libreria de mysql: nuestro directorio desde c: al jar de mysql: mysql-connector-java-5.0.3-bin.jar
• Jdbc driver: com.mysql.jdbc.Driver .
• Jdbc url: jdbc:mysql://localhost/delicious?createDatabaseIfNotExist=true
  user database,clave database,database name.
• Are you working with tables that already exist ...:n .
• Do you want to drop and recreate the database ...: y .
• Enter your icefaces directory: dejar este campo vacio.

Ya tenemos creado las propiedades de nuesta proyecto nuevo

Lanzamos la tarea seam-gen>new-project para generar el proyecto nuevo en el workspace indicado anteriormente y lo abrimos con eclipse.File>new project>java project>create project from existing source>seleccionamos nuestro proyecto en el workspace y le ponemos de nombre al proyecto.

Localizamos el archivo de ant:build.xml de nuestro nuevo proyecto y lo arrastramos a la ventanita de Ant, y a continuación lanzamos la tarea deploy.
Arrancamos nuestro jboss a través de la ventanita servers de nuestro eclipse. Seleccionamos y click en start y cuando acabe de arrancar la aplicación podemos verla en el navegador en la dirección: http://localhost:8080/nombre proyecto dandole al deploy del Ant de nuestro proyecto o al explode(esto esta explicado la diferencia en otro apartado)

Para crearnos las clases(entidades) utilizamos new-entity del archivo build.xml de seam-gen y se nos aparecera 3 ventanitas :

• enter the entity class name: nombre de la entidad a crear.
• enter the master page name: la pagina que va a hacer el listado de objetos de esa entidad
• enter the detail page name: detalle de esos objetos.

Enlas clase que se crean se ven los import de las etiquetas del api de persistencia. Así como un validador de HIbernate: org.hibernate.validator.Length .

Links interesantes de Seam-gem

seam-gen: seam generator
¿qué es seam? http://seamcity.madeinxpain.com/archives/31
biyection: http://seamcity.madeinxpain.com/archives/28
conversaciones: http://seamcity.madeinxpain.com/archives/29
configuración de seam: http://seamcity.madeinxpain.com/archives/30
programación orientada a aspectos: http://ejemplos-seam.blogspot.com/2007/07/crear-estadisticas-en-seam-con.html

JSF -->incluir una página en otra

Para incluir una página dentro de otra se utiliza el código siguiente:


Tenemos quu incluir en las páginas principal y la que vamos a incluir las declaraciones de librerias de etiquetas como aparece en esta foto:

JDeveloper + JSF

Vamos a ver como se crea aplicaciones web con jdeveloper y jsf.
Al abrir el programa jdeveloper, en la parte izquiera tenemos una ventanita donde aparece la palabra Applications.

Pinchamos con el botón derecho y elegimos la opción New Application y se nos abrirá una ventana para poner el nombre,el package,la ruta del directorio de la aplicación y una pestaña llamada Application Template donde elegiremos el tipo de plantilla a utilizar en la aplicación,en este caso elegiremos la opción JSF|EJB.

Al darle aceptar se nos creará la aplicación con JSF con la siguiente estructura:
El archivo faces-config.xml es el archivo de configuración y en la carpeta lib contiene 2 archivos jar que serán los que contengan las clases usadas por los JSF.

Para crear una página JSf pinchamos con el botón dereco sobre ViewController en la opción New elegimos JSF/JSF JSP y al darle aceptar se nos abrirá un asistente paras la configuración de la página.
En una de las ventanas nos pide el nombre de la página y abajo tenemos dos opciones una para crear un jsp simple y otro para crear un jspx(utiliza xml para la representación de los jsp),elegimos este último.
La siguiente pantalla podemos crearnos los beans automaticamente o no, al pulsar siguiente nos abre otra pantalla para elegir librerias que queremos o necesitemos usar para este proyecto.
Y la siguente pantalla es para configurar los stylos de la página.
Ya tenemos nuestra primera página creada!!!!!!!!!