Programación en Java

Primer Ejemplo en Video de Struts2

2011-12-18T19:32:00.001-06:00

Aqui les dejamos la versión en video del primer ejemplo de Struts2

Anti Patrones Java - Manejo de XML

2011-09-14T19:07:00.000-05:00

Una mala práctica en el manejo de documentos XML es no hacer uso de parsers o analizadores. El siguiente código muestra un escenario común:

int inicio = xml.indexOf("<nombre>");
int fin = xml.indexOf("</nombre>");
String nombre = xml.substring(inicio, fin);

El método anterior que en apariencia funciona, tiene los siguientes inconvenientes:

Puede haber mas de un nodo "name" en el documento.
El contenido de "name" puede no estar hecho de caracteres de datos solamente.
Puede haber caracteres escapados en los datos.
Si los datos contenidos en el nodo son CDATA puede no devolver el resultado esperado.
El documento XML puede tener namespaces.

En general un documento XML es mucho mas complejo que es un String de java, por el tipo de operaciones que están implícitas en la lectura. Para leer de forma correcta el contenido de un documento XML existen analizadores como Xerces que ademas son muy ligeros. El equivalente en JDOM es el siguiente:

SAXBuilder builder = new SAXBuilder(false);
Document doc = doc = builder.build(new StringReader(xml));
String nombre = doc.getRootElement().getChild("nombre").getText();

Otra mala práctica en el manejo de XML que es muy común es en la construcción del documento, haciendo algo como esto:

String nombre = ...
String atriburo = ...
String xml = "<root>"
            +"<nombre atr=\""+ attribute +"\">"+ nombre +"</nombre>"
            +"</root>";

Cuando lo correcto es hacer mas bien lo siguiente:

Element root = new Element("root");
root.setAttribute("atr", atributo);
root.setText(nombre);
Document doc = new Documet();
doc.setRootElement(root);
XmlOutputter out = new XmlOutputter(Format.getPrettyFormat());
String xml = out.outputString(root);

Olvidandonos de escapar caracteres y con la sentecia XmlOutputter out = new XmlOutputter(Format.getPrettyFormat()) le damos el formato visual adecuado a nuestro documento. También podremos agregar namespaces a nuestros nodos sin ningún problema. JDom es sin duda una magnifica opción para manejar documentos XML.

Java y Chuck Norris

2011-09-01T13:57:00.000-05:00

Unos cuantos hechos acerca de Chuck Norris, que quizá te convenga saber para tu examen de certificación SCJP.

Chuck Norris puede crear clases que son ambas cosas: abstract y final.
Chuck Norris no despliega aplicaciones, las mete a patadas en el servidor.
Chuck Norris puede usar cualquier clase en java.util.* para matarte y sin leer los javadocs.
Chuck Norris puede golpear tan duro a tu aplicación web que la convierte en una aplicación swing con iconos en forma de cráneos humanos.
Chuck Norris contó el mismo para llegar al valor Float.POSITIVE_INFINITY y demostrar que es correcto, dos veces.
synchronized no protege de Chuck Norris, si él lo necesita lo toma.
Chuck Norris no usa javac, el escribe sus aplicaciones directamente en código binario.
El código java de Chuck Norris nunca necesita optimizarse.
Su código es tan rápido que rompe la velocidad de la luz y durante las pruebas mata a 37 personas en los laboratorios de Sun.
El código de Chuck Norris nunca tiene un error. ¡Nunca!
Cuando alguien intenta usar un método deprecated de Chuck Norris, reciben automáticamente una patada voladora en tiempo de compilación.
El paquete java.lang, originalmente contenía la clase Chuck Norris, pero fue retirada luego de una revisión de diseño y una patada voladora propinada a Bill Joy, el diseñador a cargo.
Chuck Norris no escribe código. El simplemente se sienta frente al monitor y lo mira hasta que obtiene lo que quiere.
El código corre mejor cuando Chuck Norris lo mira.
Si tú obtienes una ChuckNorrisException probablemente morirás.
Los objetos de Chuck Norris puede lanzar patadas voladoras a cualquier objeto privado de otro paquete.
Los niveles de visibilidad son public, default, protected, private y “protectedbyChuckNorris”, ¡No intentes acceder a campos con el último modificador!
Chuck Norris puede dividir por cero.
El Garbage Collector solo pasa sobre el código de Chuck Norris cuando hay cuerpos que recolectar.
Chuck Norris implementa “Indestructible”. Todas las demás criaturas implementan “Killable”
Chuck Norris puede hacer herencia múltiple en java.
El código de Chuck Norris usa generics desde la versión 1.3 de java.
Cuando se ejecuta una clase de Chuck Norris, el CPU la corre al doble de velocidad.

Chuck Norris y Java

El código de Chuck Norris no puede ser decompilado, no te molestes en tratar.

Plantillas en Facelets (5.4)

2011-08-26T00:35:00.003-05:00

La tecnología JavaServer Faces provee las herramientas para implementar interfaces que son fáciles de extender y reutilizar. El uso de plantillas es una características de Facelets que permite crear una página que puede actuar como parase, o plantilla, para otras páginas en una aplicación. Usando plantillas, es posible reutilizar código y liberarse de volver a crear paginas similares. Las plantillas permiten incluso establecer un estándar para el look and feel en una aplicación con un número de páginas grande.

La siguiente tabla enlista las etiquetas Facelets que son usadas para las plantillas con su respectiva funcionalidad.

Etiqueta	Función
ui:component	Defines a component that is created and added to the component tree.
ui:composition	Defines a page composition that optionally uses a template. Content outside of this tag is ignored.
ui:debug	Defines a debug component that is created and added to the component tree.
ui:decorate	Similar to the composition tag but does not disregard content outside this tag.
ui:define	Defines content that is inserted into a page by a template.
ui:fragment	Similar to the component tag but does not disregard content outside this tag.
ui:include	Encapsulate and reuse content for multiple pages.
ui:insert	Inserts content into a template.
ui:param	Used to pass parameters to an included file.
ui:repeat	Used as an alternative for loop tags, such as c:forEach or h:dataTable.
ui:remove	Removes content from a page.

Para mas información sobre las etiquetas, vea la documentación en
http://download.oracle.com/javaee/6/javaserverfaces/2.1/docs/vdldocs/facelets/

La librería de etiquetas de Facelets incluye la etiqueta de plantilla principal ui:insert. Una página plantillas que es creada con esta etiqueta permite definir una estructura default para una página. Una página plantilla es usada como plantilla para otras páginas usualmente referidas como páginas cliente.

Aquí hay un ejemplo de una plantilla salvada como template.xhtml.

<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN"

  "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">

<html xmlns="http://www.w3.org/1999/xhtml"

  xmlns:ui="http://java.sun.com/jsf/facelets"

  xmlns:h="http://java.sun.com/jsf/html">



<h:head>

    <meta http-equiv="Content-Type"

          content="text/html; charset=UTF-8" />

    <link href="./resources/css/default.css"

          rel="stylesheet" type="text/css" />

    <link href="./resources/css/cssLayout.css"

          rel="stylesheet" type="text/css" />

    <title>Facelets Template</title>

</h:head>



<h:body>

    <div id="top" class="top">

        <ui:insert name="top">Top Section</ui:insert>

    </div>

    <div>

    <div id="left">

         <ui:insert name="left">Left Section</ui:insert>

    </div>

    <div id="content" class="left_content">

         <ui:insert name="content">Main Content</ui:insert>

    </div>

    </div>

</h:body>

</html>

La página de ejemplo define una página XHTML que es dividida en tres secciones: una sección superior, una sección izquierda y una sección principal. Estas secciones tiene una hoja de estilos asociada a ellas. La misma estructura puede ser reutilizada en otras páginas de la aplicación.

La página cliente invoca la plantilla usando la etiqueta ui:composition. En el siguiente ejemplo, una página cliente llamada templateclient.xhtml invoca la plantilla llamada template.xhtml del ejemplo precedente. Una página cliente puede insertar contenido con la ayuda de la etiqueta ui:define.



<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN"

"http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">

<html xmlns="http://www.w3.org/1999/xhtml"

  xmlns:ui="http://java.sun.com/jsf/facelets"

  xmlns:h="http://java.sun.com/jsf/html">



<h:body>

    <ui:composition template="./template.xhtml">

        <ui:define name="top">

            Welcome to Template Client Page

        </ui:define>



        <ui:define name="left">

            <h:outputLabel value="You are in the Left Section"/>

        </ui:define>



        <ui:define name="content">

            <h:graphicImage value="#{resource['images:wave.med.gif']}"/>

            <h:outputText value="You are in the Main Content Section"/>

        </ui:define>

    </ui:composition>

</h:body>

</html>

Se puede utilizar la IDE NetBeans para crear plantillas de Facelets y páginas cliente. Para mas información ver http://netbeans.org/kb/docs/web/jsf20-intro.html

Anti-Patrones Java - Concatenación de cadenas

2011-08-23T08:20:00.004-05:00

Veamos el siguiente ejemplo.

String s = "";

for (Persona p : personas) {

  s += ", " + p.getNombre();

}

s = s.substring(2); //Quita la primera coma

Este código muestra un ejemplo claro de una mala práctica que puede afectar el rendimiento óptimo de una aplicación, su tiempo de ejecución es de orden aproximado O(personas.length²). La concatenación repetitiva de cadenas en ciclos causa exceso de basura y copiado de arreglos. Además es necesario remover la última coma, lo cual es evidentemente un parte fea del código.

La siguiente sería una mejor práctica:

StringBuilder sb = new StringBuilder(personas.size() * 16); // Con una estimacion inicial del tamaño del buffer

for (Persona p : personas) {

  if (sb.length() > 0) sb.append(", ");

  sb.append(p.getNombre);

}

Que incluye además una estimación inicial del tamaño del buffer.

Invocar al recolector de basura

2011-08-22T08:53:00.002-05:00

Java y otros lenguajes tienen un mecanismo de liberación de memoria llamado Garbage Collector, el cual permite reutilizar la memoria durante la ejecución de un programa. Se puede llamar al recolector de basura utilizando System.gc() o Runtime.getRuntime.gc(). Aunque hacer esto no se considera buena práctica ya que tiene repercusiones importantes en el rendimiento de una aplicación. La mejor práctica es no tener que llamar a estos métodos haciendo un buen diseño y uso de los recursos.

La descripción en la documentación para estos métodos es la siguiente:

System.gc()

Hace correr al recolector de basura.
Al llamar al método gc se sugiere a la máquina virtual realice un esfuerzo de reciclaje de objetos no utilizados con el fin de hacer que la memoria que estos objetos ocupan esté disponible para su uso rápido. Cuando se devuelve el control de la llamada al método, la maquina virtual de java ha hecho su mejor esfuerzo para recuperar el espacio de los objetos desechados.
La llamada System.gc() es efectivamente equivalente a la llamada Runtime.getRuntime.gc()

Runtime.getRuntime.gc()

Hace correr al recolector de basura. Al llamar a este método se sugiere a la maquina virtual realice su mayor es fuerzo de reciclaje de objetos no utilizados con el fin de hacer que la memoria que estos objetos ocupan esté disponible para su uso rápido. Cuando se devuelve el control de la llamada a al método, la máquina virtual ha hecho su mejor esfuerzo para recuperar el espacio de los objetos desechados.

La maquina virtual lleva a cabo este proceso de reciclaje de forma automática cuando es necesario, en un hilo separado, incluso si el método gc no se invoca explícitamente.

El método System.gc() es el medio convencional y conveniente de la invocación de este proceso. En algunas ocasiones esta invocación no tendrá mayor efecto, ya que la liberación de recursos nunca está garantizada.

Desarrollando una Aplicación Simple con Facelets (5.3)

2011-08-18T15:54:00.004-05:00

Esta sección describe, de manera general, los pasos que deben seguirse en el desarrollo de una aplicación con JavaServer Faces. Las tareas usualmente requeridas son las siguientes:

Desarrollar los beans manejadores
Crear las páginas usando etiquetas
Se define la navegación entre páginas
Se mapea la instancia FacesServlet
Se agregan declaraciones en los bean manejadores

Crear una Aplicación Facelets

El ejemplo usado en este tutorial es la aplicación guestnumber. La aplicación se presenta con una página que pregunta a los visitantes un número entre 0 y 10, valida la entrada contra un número aleatorio generado y responde con otra página que informa si el visitante dio un número correcto o incorrecto.

Desarrollar un Bean Manejador

En una aplicación típica de JavaSever Faces, cada página de la aplicación esta vinculada a un bean manejador. El bean manejador define los métodos y propiedades que son asociadas a los componentes.

La siguiente clase manejadora, UserNumberBean.java, genera un número aleatorio entre 0 y 10:

package guessNumber;



import java.util.Random;

import javax.faces.bean.ManagedBean;

import javax.faces.bean.SessionScoped;



@ManagedBean

@SessionScoped

public class UserNumberBean {



  Integer randomInt = null;

  Integer userNumber = null;

  String response = null;

  private long maximum=10;

  private long minimum=0;



  public UserNumberBean() {

      Random randomGR = new Random();

      randomInt = new Integer(randomGR.nextInt(10));

      System.out.println("Duke's number: " + randomInt);

  }



  public void setUserNumber(Integer user_number) {

      userNumber = user_number;

  }



  public Integer getUserNumber() {

      return userNumber;

  }



  public String getResponse() {

      if ((userNumber != null) && (userNumber.compareTo(randomInt) == 0)) {

          return "Yay! You got it!";

      } else {

          return "Sorry, " + userNumber + " is incorrect.";

      }

  }



  public long getMaximum() {

      return (this.maximum);

  }



  public void setMaximum(long maximum) {

      this.maximum = maximum;

  }



  public long getMinimum() {

      return (this.minimum);

  }



  public void setMinimum(long minimum) {

      this.minimum = minimum;

  }

}

Note el uso de la anotación @ManagedBean, la cual registra al bean manejador como recurso en la implementación de JavaServer Faces. La anotación @SessionScoped registra el alcance del bean como session.

Crear Vistas Facelets

Crear un página o vista es parte de la responsabilidad del autor de la página. Esta tarea involucra agregar componentes en las páginas, vincular esos componentes con valores y propiedades del bean manejador y registrar convertidores, validadores o escuchadores sobre esos componentes.

Para la aplicación de ejemplo, las páginas XHTML sirven como vista. La primera página de la aplicación ejemplo es una página llamada greeting.xhtml. Una mirada mas de cerca a las distintas secciones de esta página nos da mas información.

La primera sección especifica el lenguaje de la página XHTML, se declaran los namespace XML para las librerías de etiquetas usadas en la página web:

<html lang="en"

    xmlns="http://www.w3.org/1999/xhtml"

    xmlns:h="http://java.sun.com/jsf/html"

    xmlns:f="http://java.sun.com/jsf/core">

La siguiente sección usa varias etiquetas para insertar componentes en la página:

<h:head>

      <title>Guess Number Facelets Application</title>

  </h:head>

  <h:body>

      <h:form>

          <h:graphicImage value="#{resource['images:wave.med.gif']}"

                          alt="Duke waving his hand"/>

          <h2>

              Hi, my name is Duke. I am thinking of a number from

              #{userNumberBean.minimum} to #{userNumberBean.maximum}.

              Can you guess it?

          </h2>

          <p><h:inputText

                  id="userNo"

                  title="Type a number from 0 to 10:"

                  value="#{userNumberBean.userNumber}">

                  <f:validateLongRange

                      minimum="#{userNumberBean.minimum}"

                      maximum="#{userNumberBean.maximum}"/>

              </h:inputText>

        

              <h:commandButton id="submit" value="Submit"

                              action="response.xhtml"/>

          </p>

          <h:message showSummary="true" showDetail="false"

                     style="color: #d20005;

                     font-family: 'New Century Schoolbook', serif;

                     font-style: oblique;

                     text-decoration: overline"

                     id="errors1"

                     for="userNo"/>

      </h:form>

  </h:body>

Note el uso de las siguientes etiquetas:

Etiquetas de Faceletes HTML (Algunas de las cuales comienzan con h:) para agregar componentes
La etiqueta de Facelets f:validateLongRance para validar la entrada del usuario.

Un componente inputText acepta la entrada del usuario y establece el valor de una propiedad de bean userNumber a través de la expresión EL #{userNumberBean.userNumber}. El valor de entrada es validado por el validador de rangos estándar f:validateLongRange de JavaServer Faces.

La imagen wave.med.gif, es agregada a la página como un recurso. Para mas detalle acerca de la accesibilidad a recursos, vea el tema Recursos.

Un componente commandButton con la ID submit comienza la validación de los datos de entrada cuando el usuario da click en el botón. Usando navegación implícita, el componente redirige al cliente a la página response.xhtml, la cual muestra la respuesta a la entrada.

<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN"

  "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">



<html lang="en"

    xmlns="http://www.w3.org/1999/xhtml"

    xmlns:h="http://java.sun.com/jsf/html">



  <h:head>

      <title>Guess Number Facelets Application</title>

  </h:head>

  <h:body>

      <h:form>

          <h:graphicImage value="#{resource['images:wave.med.gif']}"

                          alt="Duke waving his hand"/>

          <h2>

              <h:outputText id="result" value="#{userNumberBean.response}"/>

          </h2>

          <h:commandButton id="back" value="Back" action="greeting.xhtml"/>

      </h:form>

  </h:body>

</html>

Configuración de la Aplicación

Configurar una aplicación JavaServer Faces involucra mapear al ServletFaces en el archivo descriptor de despliegue web.xml y la posibilidad de agregar declaraciones de beans manejadores, reglas de navegación y archivos de recursos en el archivo de configuración de la aplicación faces-config.xml.

Si esta usando la IDE NetBeans, un archivo descriptor de despliegue es creado automáticamente. En el archivo web.xml creado, debe cambiar la página de saludo index.xhtml, por greeting.xhtml. Aquí mostramos un ejemplo de archivo web.xml, detallando el cambio.

<?xml version="1.0" encoding="UTF-8"?>

<web-app version="3.0" xmlns="http://java.sun.com/xml/ns/javaee"

xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"

xsi:schemaLocation="http://java.sun.com/xml/ns/javaee

http://java.sun.com/xml/ns/javaee/web-app_3_0.xsd">

  <context-param>

      <param-name>javax.faces.PROJECT_STAGE</param-name>

      <param-value>Development</param-value>

  </context-param>

  <servlet>

      <servlet-name>Faces Servlet</servlet-name>

      <servlet-class>javax.faces.webapp.FacesServlet</servlet-class>

      <load-on-startup>1</load-on-startup>

  </servlet>

  <servlet-mapping>

      <servlet-name>Faces Servlet</servlet-name>

      <url-pattern>/faces/*</url-pattern>

  </servlet-mapping>

  <session-config>

      <session-timeout>

          30

      </session-timeout>

  </session-config>

  <welcome-file-list>

      <welcome-file>faces/greeting.xhtml</welcome-file>

  </welcome-file-list>

</web-app>

Note el uso del parámetro de contexto PROJECT_STAGE. Este parámetro identifica el estatus de la aplicación JavaServer Faces en el ciclo de vida del software.

El escenario de una aplicación puede afectar el comportamiento de la aplicación. Por ejemplo, si el escenario del proyecto es definido como Development, la información de debug es generada automáticamente para el usuario. Si no se define por el usuario, el escenario por default es Production.

Construir, Empaquetar, Desplegar y Correr la Aplicación Facelets de Ejemplo

Se puede usar la IDE NetBeans o Ant para construir, empaquetar, desplegar y correr el ejemplo guessnumber. El código para este ejemplo esta disponible en el directorio tut-install/examples/web/guessnumber.

Para construir, empaquetar y desplegar el ejemplo usando NetBeans

Desde el menú File, elija Abrir Proyecto
En la ventana de dialogo, navegue hasta: tut-install/examples/web
Seleccione la carpeta guessnumber
De click en el checkbox “Abrir como proyecto principal”
Abra el proyecto
En el tab de proyectos, de click derecho al proyecto guessnumber y seleccione Deploy.

Esta opción construye y despliega el ejemplo sobre una instancia de GlassFish

Para construir, empaquetar y desplegar el ejemplo guessnumber usando Ant

En una ventana de consola, buscar la ruta: tut-install/examples/web/guessnumber
Escriba el siguiente comando: ant, este comando llama al target default, el cual construye y empaqueta la aplicación en un archivo WAR, guessnumber.war, que estará localizado en el directorio dist.
Asegúrese de tener GlassFish corriendo.
Para desplegar la aplicación, escriba el comando: ant deploy

Para correr el ejemplo

Abra el navegador
Escriba la siguiente URL en el navegador: http://localhost:8080/guessnumber, una página se abrirá
En el campo de texto escriba un numero entre 0 y 10 y de click en submit. Otra página aparecerá, reportando si el visitante escribió un valor correcto o incorrecto.
Si el visitante esta equivocado, puede dar click en el botón de regreso a la página principal

Podrá continuar hasta que obtenga la respuesta correcta.

Java versión 7

2011-08-17T09:22:00.002-05:00

Oracle ha lanzado la versión 7 de Java. Algunas de las mejoras las listamos a continuación.

Maquina Virtual

JSR 292: Soporte para lenguajes escritos dinámicamente (InvokeDynamic)
Revisión estricta de archivos clase

Lenguaje

JSR 334: Mejoras pequeñas al lenguaje (Project Coin)

Core

Actualización de la arquitectura de carga de clases
Método para cerrar un URLClassLoader
Actualizaciones a concurrencia y colecciones (jsr166y)

Internacionalización

Soporte a Unicode 6.0
Mejoras en la API Locale
Localización de usuario separada y localización interfaz de usuario

IO y Networking

JSR 203: Nuevas APIs IO para la plataforma Java (NIO.2)
Un proveedor de sistema de archivos NIO.2 para archivos zip/jar
SCTP (Protocolo de transmisión de control de flujos)
SDP (Protocolo directo de sockets )
Uso de la pila IPv6 de Windows Vista
Soporte para TLS 1.2

Seguridad y Criptografía

Implementación de criptografía elliptic-curve (ECC)

Conectividad y Bases de Datos

JDBC 4.1

Cliente

XRender para Java 2D
Permite crear nuevas plataformas para gráficas 6u10
Nuevo look-and-feel Nimbus
Componente JLayer para Swing
Sintetizador de sonido Gervill

Web

Actualización de la pila de XML

Administración

MBeans mejorados

Mejoras diferidas a la versión de JDK8 o superiores

JSR 294: Soporte a la máquina virtual y al lenguaje para programación modular
JSR308: Anotaciones sobre tipos de java
JSR TBD: Proyecto Lambda
Modularización (Proyecto Jigsaw)
JSR 296: Marco de trabajo para aplicaciones Swing
Componente Swing JDatePicker

Puedes ver mas detalle en el artículo original de openjdk.java.net en:

http://openjdk.java.net/projects/jdk7/features/

Tips - commons-io-x.jar

2011-08-15T13:01:00.007-05:00

En muchas soluciones de la vida real es necesario manipular y leer el contenido de archivos y es muy común que en un principio se trate de utilizar solo las clases del paquete java.io, esto esta bien si se quiere optimizar la lectura o manipulación de archivos o se requiere una solución a un problema especifico. Sin embargo existen los Apache Commons, que es un conjunto de librerías para una gran variedad de problemas y una de esas librerías es commons-io.jar que viene con la clase FileUtils y que facilita el manejo de archivos. Aquí enlistamos algunas de las funciones de esa clase que la hacen bastante útil.

Permite escribir a un archivo
Leer desde un archivo
Crear directorios, incluyendo directorios padres (de forma recursiva)
Copiar archivos y directorios
Borrar archivos y directorios
Covertir hacia o desde una URL
Listar archivos y directorios con filtros y extensión
Comparar el contenido de archivos
Obtener el última fecha de actualizacion
Calcular checksum, entre otras.

Aqui un pequeño ejemplo para convertir un archivo de texto a String o traer una lista de archivos desde un directorio y filtrando extensiones.

import org.apache.commons.io.FileUtils;

import java.io.File;

import java.io.IOException;

import java.util.Collection;

import java.util.Iterator;



public class Prueba {

  public static void main(String[] args) {

    //Leer el contenido de un archivo de texto y depositarlo en un String

    File archivo = new File("ejemplo.txt");



    //Traer una lista de archivos filtrando la extensión

    File root = new File("/proy");

    try {

        // Leer el contenido de un archivo y copiarlo a un String

        String content = FileUtils.readFileToString(archivo);

        System.out.println("File content: " + content);

    

        //Obtener una lista de archivos de forma recursiva contenida en un directorio

        String[] extensiones = {"xml", "java", "dat"};

        boolean recursivo = true;



        Collection lisaArchivos = FileUtils.listFiles(root, extensiones, recursivo);

        for (Iterator iterator = lisaArchivos.iterator(); iterator.hasNext();) {

            File archivoAux = (File) iterator.next();

            System.out.println("> " + archivoAux.getAbsolutePath());

        }

    } catch (IOException e) {

        e.printStackTrace();

    }

  }

}

Que es Facelets (5.2)

2011-08-10T11:45:00.000-05:00

Que es Facelets

Facelets es un lenguaje de declaración de páginas, poderoso pero ligero, que es usado para construir vistas de JavaServer Faces usando plantillas de estilo de HTML y construyendo arboles de componentes. Las características que Facelets incluyen son algunas de las siguientes:

· Uso de XHTML para crear páginas web

· Soporte para librerías de etiquetas Facelets que se suman a las librerías de JavaServer Faces y JSTL

· Soporte para el Lenguaje de Expresiones (EL por su siglas en ingles)

· Plantillas para componentes y páginas

Las ventajas que Facelets incluye para el desarrollo de proyectos de gran escala son las siguientes:

· Soporte para reutilización de código por medio de plantillas y componentes compuestos.

· Extensibilidad funcional de componentes y otros objetos del lado del server por configuración.

· Tiempo de compilación rápido.

· Validación de EL en tiempo de compilación.

· Rendereo de alto performance.

En resumen, el uso de Facelets reduce el tiempo y esfuerzo que se necesita para el desarrollo y despliegue de aplicaciones.

Las vistas de Facelets son usualmente creadas como páginas XHTML. Las implementaciones de JavaServer Faces soportan páginas creadas en XHTML de acuerdo con la XHTML Transitional document Type Definition (DTD), como se enlista en http://www.w3.org/TR/xhtml1/#a_dtd_XHTML-1.0-Transitional. Por convención, las páginas web construidas con XHTML tienen una extensión .xhtml

La tecnología JavaServer Faces soporta varias librerías de etiquetas para agregar componentes a una página web. Para soportar el mecanismo de librerías de JavaServer Faces, Facelets usa declaración de namespaces de XML. La siguiente tabla de librerías de etiquetas son soportadas por Facelets.

Librería	URI	Prefijo	Ejemplo	Contenido
JavaServer Faces Facelets Tag Library	http://java.sun.com/jsf/facelets	ui:	ui:component ui:insert	Tags for templating
JavaServer Faces HTML Tag Library	http://java.sun.com/jsf/html	h:	h:head h:body h:outputText h:inputText	JavaServer Faces component tags for allUIComponents
JavaServer Faces Core Tag Library	http://java.sun.com/jsf/core	f:	f:actionListener f:attribute	Tags for JavaServer Faces custom actions that are independent of any particular RenderKit
JSTL Core Tag Library	http://java.sun.com/jsp/jstl/core	c:	c:forEach c:catch	JSTL 1.1 Core Tags
JSTL Functions Tag Library	http://java.sun.com/jsp/jstl/functions	fn:	fn:toUpperCase fn:toLowerCase	JSTL 1.1 Functions Tags

Adicionalmente, Faceletes soporta etiquetas para componentes compuestos por cualquier prefijo configurado que declare. Para mas información sobre componentes compuestos, vea el tema Componentes Compuestos.

Basado en el soporte de la sintaxis del Expression Language (EL), Facelets usa expresiones EL para referenciar propiedades o métodos del bean de respaldo. Las expresiones EL pueden ser usadas para ligar objetos componentes o valores a métodos o propiedades de los beans de respaldo. Para mas información sobre el uso de expresiones EL , vea el tema Usando expresiones EL para referenciar Beans Manejadores.

Introducción a Facelets (5.1)

2011-08-05T17:52:00.001-05:00

Capitulo 5

Introducción a Facelets

El termino Faceltes se refiere a la vista del lenguaje de declaración para la tecnología JavaServer Faces. La tecnología JavaServer Pages (JSP), previa a la presentación de JavaServer Faces, no soporta todas las características disponibles en JavaServer Faces 2.0. La tecnología de JSPs es considerada una tecnología para JSF obsoleta (deprecated). Facelets es una parte de la especificación de JavaServer Faces es además la tecnología de presentación preferida para construir aplicaciones basadas en JavaServer Faces.

En este capitulo se cubrirán los siguientes temas:

· Que es Facelets

· Desarrollando una aplicación Facelets simple

· Plantillas

· Componentes compuestos

· Recursos

Que es Facelets

Facelets es un lenguaje de declaración de página, poderoso pero ligero, que es usado para construir vistas de JavaServer Faces usando plantillas de estilo de HTML y construyendo arboles de componentes. Las características de Facelets incluyen son algunas de las siguientes:

· Uso de XHTML para crear páginas web

· Soporte para librerías de etiquetas Facelets que se suman a las librerías de JavaServer Faces y JSTL

· Soporte para el Lenguaje de Expresiones EL

· Plantillas para componentes y páginas

Las ventajas que Facelets incluye para el desarrollo de proyectos de gran escala son las siguientes:

· Soporte para reutilización de código por medio de plantillas y componentes compuestos.

· Extensibilidad funcional de componentes y otros objetos del lado del server por configuración

· Tiempo de compilación rápido

· Validación de EL en tiempo de compilación

Crear una aplicación JavaServer Faces simple (4.4)

2011-08-05T17:29:00.003-05:00

Crear una aplicación JavaServer Faces simple

El proceso de crear aplicaciones web con JavaServer Faces es fácil y amigable. Desarrollar una aplicación requiere típicamente de las siguientes tareas:

· Desarrollar beans manejadores

· Agregar declaraciones de manejo de bean

· Crear páginas web utilizando de etiquetas

· Mapear la instancia FacesServlet

Esta sección describe esas tareas creando una aplicación en JavaServer Faces simple.

El ejemplo es la aplicación Hello que incluye un backing bean y una página web. Cuando el cliente accede, la página web imprime un mensaje de HelloWord. La aplicación ejemplo está localizada en el directorio tut-install/examples/web/hello. Las tareas involucradas en el desarrollo de esta aplicación pueden examinarse revisando los componentes en detalle.

Creando El Bean de Respaldo (Backing Bean)

Como se mencionó anteriormente en este capitulo, el backing bean, es un componente JavaBean que es gestionado por la tecnología JavaServer Faces. Los componentes en una página son asociados a un backing bean, que provee la lógica de la aplicación. El backing bean del ejemplo Hello.java contiene el siguiente código:

 package hello; 
import javax.faces.bean.ManagedBean; 
@ManagedBean 
public class Hello { 
  final String world = "Hello World!"; 
  public String getworld() { 
    return world; 
  } 
}

El backing bean establece el valor de la variable world con la cadena “Hello World” La anotación @ManagedBean registra al backing bean como un recurso en la implementación de JavaServer Faces. Para mas información sobre beans gestionados y anotaciones, ver el capitulo 9, Desarrollo con la Tecnología JavaServer Faces.

Creando la Página Web

En una aplicación Facelets típica, las páginas son creadas en XHTML. El la página web de ejemplo, beanjello.xhtml, es una pagina en XHTML simple. Esta tiene el siguiente contenido.

 package hello; 
import javax.faces.bean.ManagedBean; 
@ManagedBean 
<html xmlns="http://www.w3.org/1999/xhtml" 
   xmlns:h="http://java.sun.com/jsf/html"> 
  <h:head> 
    <title>Facelets Hello World</title> 
  </h:head> 
  <h:body> 
    #{hello.world} 
  </h:body> 
</html>

Una página XHTML Facelets puede contener otros elementos diversos, los cuales se cubrirán mas adelante en este tutorial.

La página web conecta el backing bean, por medio del lenguaje de expresiones EL (Expression Language), la expresión con el valor #{hello.world}, el cual recupera el valor de la propiedad world del backing bean Hello. Note que se usa la referencia hello al backing bean Hello. Si no se especifica nombre en la anotación @ManagedBean, se puede llamar al backing bean con el mismo nombre y la primera letra de la clase en minúsculas.

Para mas información sobre el uso de expresiones EL, vea el Capítulo 6, Lenguaje de Expresiones. Para mas información acerca del la tecnología Facelets, vea el Capítulo 5, Introducción a los Facelets. Para mas información acerca del modelo de programación y construcción de páginas web usando JavaServer Faces, vea el Capítulo 7, Uso de la Tecnología JavaServer Faces en Páginas Web.

Mapeando la instancia FacesServlet

La tarea final requiere mapear el servlet FacesServlet, lo cual se consigue modificando el deployment descriptor (web.xml) . Un mapeo típico del servlet FacesServlet es como sigue:

 <servlet> 
  <servlet-name>Faces Servlet</servlet-name> 
  <servlet-class>javax.faces.webapp.FacesServlet</servlet-class> 
  <load-on-startup>1</load-on-startup> 
</servlet> 
<servlet-mapping> 
  <servlet-name>Faces Servlet</servlet-name> 
  <url-pattern>/faces/*</url-pattern> 
</servlet-mapping>

El segmento de archivo precedente, representa parte de un archivo de descripción de despliegue típico. El descriptor de despliegue puede contener además, otros contenidos relevantes para la configuración de una aplicación con JavaServer Faces, pero esa información no se cubre en esta sección.

El mapeo de FacesServlet es automáticamente hecho si se usa un IDE como Netbeans IDE.

El Ciclo de Vida de la Aplicación Hello

Cada aplicación web tiene un ciclo de vida. Las tareas comunes como el manejo de peticiones entrantes, decodificación de parámetros, modificación y almacenamiento de estado y rendereo de páginas web hacia el navegador, son todas ejecutadas durante el ciclo de vida de la aplicación. Algunos marcos de trabajo web ocultan los detalles del ciclo de vida mientras que otros requieren ser manejados manualmente.

Por default, JavaServer Faces maneja automáticamente la mayoría de las acciones de ciclo de vida de una página web. No obstante, es posible acceder a los diferentes escenarios de la petición de un ciclo de vida y es modificar o ejecutar diversas acciones si la aplicación así lo requiere.

No es necesario para quien esta comenzando, conocer todo el ciclo de vida de una aplicación en JavaServer Faces, pero esta información puede ser muy útil para quien desea crear aplicaciones mas complejas.

El ciclo de vida de una aplicación JavaServer Faces comienza y termina con la siguiente actividad: El cliente hace una petición a la página web, y el server responde con una página. El ciclo consiste de dos faces principales: ejecutar y renderear.

Durante la fase de ejecución, diversas acciones son ejecutadas:

· La vista de la aplicación es construida o restaurada.

· Los valores de parámetros de petición son aplicados.

· Conversiones y validaciones son ejecutadas para los valores de los componentes.

· Los beans de respaldo son actualizados con los valores de los componentes.

· La lógica de la aplicación es invocada.

Para una primera petición (initial), solo se construye la vista. Para peticiones subsecuentes (postback), algunas o quizá todas las acciones pueden tener lugar.

En la fase de rendering, la vista solicitada es rendereada como respuesta al cliente. El rendering es típicamente el proceso de generación de salidas, que pueden ser HTML o XHTML, y pueden ser leídas por el cliente, usualmente un navegador.

A continuación daremos una descripción corta del ejemplo en JavaServer Faces donde haremos una revisión resumida de la actividad detrás de escena que se realiza en el ciclo de vida del ejemplo.

El ejemplo hello atraviesa por los siguientes escenarios cuando es desplegada en el servidor GlassFish.

1. Cuando la aplicación hello es construida y desplegada en GlassFish, la aplicación se encuentra en un estado no inicializado.

2. Cuando un cliente hace una petición inicial a la página beanhello.xhtml, la aplicación hello Facelets es complilada.

3. La aplicación Facelets ya compilada es ejecutada, y un nuevo árbol de componentes es construido para la aplicación hello y es puesto en un FacesContext.

4. El árbol de componentes es poblado con el componente y la propiedad del bean de respaldo asociada a el, representada por la expresión EL hello.world.

5. Una nueva vista es construida, basada en el árbol de componentes.

6. La vista es rendereada como respuesta a las peticiones del cliente.

7. El árbol de componentes es destruido automáticamente.

8. En subsecuentes peticiones (postback), el árbol de componentes es reconstruido, y el estado almacenado se aplica.

Para información mas detallada sobre el ciclo de vida de JavaServer Faces, vea JavaServer Faces Specification, Version 2.0.

Para Construir, Empaquetar, Desplegar y Correr la Aplicación en NetbeanIDE

1. En el opción File del menú principal, elija Open Project.

2. En la ventana de dialogo de Open Project, navegue hasta:

Tut-install/examples/web

3. Seleccione el folder hello.

4. Seleccione el check box Open as Main Project.

5. De click en Open Project.

6. In el tab Projects, de click derecho a el proyecto hello y ejecute.

Estos pasos compilan, ensamblan y despliegan la aplicación y después abren una ventana del navegador donde se hace petición a la siguiente URL:

http://localhost:8080/hello

la salida que se despliega es la siguiente:

Hello World!

Información Adicional acerca de la tecnología JavaServer Faces

Para mas información acerca de JavaServer faces, vea:

· Especificación de JavaServer Faces 2.0:

http://jcp.org/en/jsr/detail?id=314

· Página web de la tecnología JavaServer Faces:

http://www.oracle.com/technetwork/java/javaee/javaserverfaces-139869.html

· Página de descarga JavaServer Faces 2.0:

http://www.oracle.com/technetwork/java/javaee/download-139288.html

· Notas de Mojarra (JavaServer Faces 2.0):

http://javaserverfaces.java.net/nonav/rlnotes/2.0.0/index.html

Beneficios de la tecnología JavaServer Faces (4.3)

2011-08-05T17:26:00.001-05:00

Beneficios de la tecnología JavaServer Faces

Una de las grandes ventajas de la tecnología JavaServer Faces es que ofrece una separación limpia entre el comportamiento y la presentación de una aplicación web. Una aplicación JavaServer Faces puede mapear peticiones http hacia manejadores de eventos y manejar componentes como objetos de estado en el servidor. La tecnología JavaServer Faces permite construir aplicaciones web que implementan la separación a grano fino entre el comportamiento y la presentación, que es tradicionalmente resuelta en las arquitecturas UI del lado del cliente.

La separación de la capa de lógica de la presentación permite además, que cada miembro del equipo de desarrollo se enfoque en una simple pieza de el proceso de desarrollo y provee de un modelo simple de programación para ligar las piezas. Por ejemplo, desarrolladores de paginas con poca experiencia para programar pueden usar etiquetas de JavaServer Faces en una página web que se vinculen a objetos del lado del servidor sin la ayuda de scripts.

Otra meta importante de tecnología JavaServer Faces es la de ser una herramienta que resulte familiar sin que limite al desarrollador a usar un lenguaje de scripts o de marcado. La tecnología JavaServer Faces ha sido puesta directamente encima de la API de los Servlets como se muestra en la siguiente figura.

Esta separación de capas permite la implementación de diversos casos de uso, crear componentes propios directamente de las clases y generar salidas para diferentes dispositivos.

La tecnología Facelets, disponible como parte de JavaServer Faces 2.0, es ahora la tecnología presentación deseada para construir aplicaciones web basadas en JavaServer Faces. Para mas información sobre las características de Facelets, vea el capitulo siguiente.

La tecnología Facelets ofrece varias ventajas:

· El código puede ser reutilizado y ampliado para los componentes a través de la plantilla y características compuestas de componentes.

· Cuando se usan las anotaciones de JavaServer Faces, es posible registrar el bean de respaldo como un recurso disponible para aplicaciones JavaServer Faces. Además, las reglas de Navegación Implícita permiten a los desarrolladores configurar rápidamente la navegación de la aplicación. Estas características reducen el proceso de configuración manual para aplicaciones.

· Mas importante, JavaServer Faces provee una arquitectura rica para manejar el estado de los componentes, procesando datos de los componentes, validando entradas de usuarios y manejando eventos.

¿Que es una aplicación JavaServer Faces? (4.2)

2011-08-05T17:25:00.002-05:00

¿Que es una aplicación JavaServer Faces?

La funcionalidad que provee una aplicación hecha con JavaServer Faces es similar a cualquier otra aplicación. Una aplicación típica de JavaServer Faces incluye las siguientes partes:

· Un conjunto de páginas en las cuales se disponen los componentes.

· Un conjunto de etiquetas para agregar componentes a una página web.

· Un conjunto de beans de apoyo o de respaldo (backing beans), que son JavaBeans que definen las propiedades y funciones para los componentes en la página.

· Un descriptor de despliegue web (web.xml)

· Opcionalmente, uno o mas archivos de configuración de la aplicación, tales como el archivo faces-config.xml, el cual es usado para definir reglas de navegación y configurar beans y configurar otros objetos, como componentes personalizados.

· Opcionalmente, un conjunto de objetos personalizados, los cuales pueden incluir componentes personalizados, validadores, convertidores, escuchadores, creados por el desarrollador de la aplicación.

· Un conjunto de etiquetas personalizadas para representar objetos personalizados en una página.

Figura 4.1 Muestra la interacción entre el cliente y el servidor en un aplicación JavaServer Faces típica. En respuesta a la petición del cliente, una página web es rendereada por el contenedor web que implementa la tecnología JavaServer Faces.

La página web, myfacelet.xhtml, es construida usando etiquetas de componentes JavaServer Faces. Las etiquetas de componentes son usadas para agregar componentes a la vista (representada por myUI en el diagrama), la cual es la representación del lado del servidor, de la página. Adicionalmente a los componentes, la página web hace referencia a objetos, tales como:

· Cualquier escuchador, validador, y convertidores que son registrados en los componentes.

· Los componentes JavaBeans que capturan los datos y procesan la funcionalidad especifica de los componentes de la aplicación.

Con una petición del lado del cliente, la vista es rendereada como respuesta. El rendering es el proceso mediante el cual, basado en la vista de lado del servidor, el contenedor web genera una salida, que puede ser HTML o XHTML, que a su vez puede ser leída y mostrada por el navegador.

JavaServer Faces 2.0 (4.1)

2011-08-05T17:19:00.002-05:00

El contenido de este articulo es la traducción del tutorial publicado por Orale y disponible en:

http://download.oracle.com/javaee/6/tutorial/doc/bnaph.html

Capitulo 4

Tecnología JavaServer Faces

La tecnología de JavaServer Faces es un marco de trabajo (Framework) del lado de servidor cuya funcionalidad permite construir aplicaciones Web.

La tecnología JavaServer Faces consiste de lo siguiente:

· Una API para representar componentes y manejar su estado; manejar eventos, validaciones del lado del servidor y conversión de datos; permite definir la navegación entre páginas; suporte para internacionalización y accesibilidad; también permite extender todas estas características.

· Librerías de etiquetas para agregar componentes a páginas web y para conectar componentes con objetos del lado del servidor.

La tecnología JavaServer Faces provee un modelo de programación bien definido y varias librerías de etiquetas. Estas características facilitan la carga de construcción y mantenimiento de aplicaciones web con interfaces de usuario del lado del servidor. Con mínimo esfuerzo, se pueden realizar las siguientes tareas.

· Crear páginas web

· Insertar componentes en una página usando etiquetas.

· Ligar componentes de una página a datos de lado del servidor.

· Ligar eventos generados por componentes a código de lado del servidor.

· Salvar y restablecer el estado de la aplicación mas allá de la vida de los requests al servidor.

· Reusar y extender componentes personalizándolos.

Este capítulo provee de un resumen de la tecnología de JavaServer Faces. Después de explicar que es una aplicación JavaServer Faces y revisar algunos de los principales beneficios de usar esta tecnología, se describe el proceso de crear una aplicación en JavaServer Faces simple. Este capitulo muestra también una aplicación que ejemplifica los estados del ciclo de vida de JavaServer Faces.

Se cubren los siguientes tópicos:

· ¿Que es una aplicación de JavaServer Faces?

· Beneficios de la tecnología JavaServer Faces

· Crear una aplicación simple en JavaServer Faces

· Información adicional acerca del la tecnología JavaServer Faces

indice de temas

2010-04-19T12:13:00.006-05:00

Struts 2

Comparativo entre Struts2 y Struts1

Struts2 vs Struts1

Hola Mundo

Manejo de Sesión

Carga de Archivo

Interceptor FileUlopad

JavaServer Faces

Ejemplos Java-Web

Verificación Visual en Formularios CAPTCHA

Errores comunes en la ejecución de proyectos de TI

2010-03-02T13:05:00.004-06:00

¿Quién no ha incurrido en estos errores? Si ya llevas algún tiempo desarrollando, seguro has sufrido por alguno de ellos.

La lista de errores más frecuentes encontrados en la ejecución de los proyectos de TI:

Errores relacionados con la gente

Miembros del equipo desmotivados
Falta de capacitación de la gente involucrada en el desarrollo
Personas problemáticas en el equipo
Agregar más programadores a un proyecto ya retrasado
Oficinas ruidosas y aglomeradas
Fricciones entre quienes desarrollan y el cliente
Expectativas poco realistas
Falta de un líder efectivo para el proyecto
Falta de participación del usuario
Falta de acuerdo antes que el desarrollo de inicio
Las “Ilusiones”

Errores relacionados con los procesos

Planeación demasiado optimista
Falta de administración de riesgos
Falla en los contratos
No hay suficiente planeación
Abandono del plan bajo presión
Pérdida de tiempo al inicio del proyecto
Saltarse las tareas iniciales
Diseño no adecuado
Falta de supervisión por parte de los responsables
Falta de estimaciones adecuadas
Errores relacionados con el producto
Requerimientos excesivos
Cambio de requerimientos
Developers muy meticulosos

Errores relacionados con la tecnología

Síndrome de la panacea
Sobre-estimación de las ventajas del uso de una nueva herramienta
Cambio de herramientas a mitad del proyecto
Falta de un control de código fuente automático

Seguramente ya hay muchos mas

Ahora algunas de las razones no tan serias :)

Errores relacionados con la gente

Miembros del equipo desmotivados. Es casi imposible encontrar gente que se enamore de todos los proyectos.
Falta de capacitación de la gente involucrada en el desarrollo. La gente que va comenzando es la que cobra menos, ¿Por qué no meter solo becarios?
Personas problemáticas. Dime si no has estado junto al clásico que cree saber más que el líder de proyecto, pero no lleva más de unas semanas en un proyecto real (los de la escuela no cuentan). O bien, gente que simplemente no está bien con la vida ¡Y se dedicó a programar!
Agregar más programadores a un proyecto ya retrasado. Y como además no es necesario capacitarlos, explicarles las reglas de negocio, explicarles lo que quisieron hacer los otros programadores (que seguro ya no se acuerdan o ya ni están).
Oficinas ruidosas y aglomeradas. Son programadores, no personas y solo necesitan una PC delante de ellos, lo demás con unas mesas de SAMs y unos manteles se arregla.
Fricciones entre los developers y el cliente. La gente de TI siempre sabe lo que el cliente realmente necesita.
Expectativas poco realistas. Nunca falta el que quiere que le fabriquen un Word y pagar solo lo que cuesta el CD pirata.
Falta de un líder efectivo para el proyecto. Bueno, la gente de TI no nació para administrar proyectos, ¡Por eso programa! Pero casi nadie respeta a un líder de proyecto que no ha programado, por eso debe ser una especie de super administrador-programador-buena-gente.
Falta de participación del usuario. El usuario solo quiere sentarse y que su programa funcione y que no le quite tiempo para entrar al facebook.
Falta de acuerdo antes que el desarrollo de inicio. Y es que, ¿Cómo podemos estar de acuerdo con todas las tonterías que el cliente pide?
Las “Ilusiones”. El usuario piensa que le darán un automóvil, el líder de proyecto cree que solo le dará tiempo para hacer una bicicleta, los programadores tienen problemas para construir las ruedas de unos simples patines, y al final el usuario va a terminar caminando (como siempre lo ha hecho (el usuario es el incauto que trabaja para el que contrató a tu empresa, le vas a quitar tiempo y al final harás mas difícil su trabajo)

Errores relacionados con los procesos

Planeamiento demasiado optimista. ¡Claro! Hacemos un módulo por día y el último integramos todo.
Falta de administración de riesgos. ¿Alguien conoce a los que se dedican a administrar esas cosas?
Falla en los contratos. Lo bueno de usar plantillas es que todas incluyen las letras chiquitas donde no nos hacemos responsables de errores o vicios ocultos después de seis o más meses. Cuando calculas más o menos que base de datos se va al carajo.
No hay suficiente planeamiento. Muchas veces solo se tiene el texto que viene en la propuesta comercial.
Abandono del planeamiento bajo presión. Sobre todo cuando le dices al usuario que hacer un facebook o un twitter es normalmente más caro que hacer una simple página web.
Pérdida de tiempo al inicio del proyecto. Y cuando pasa el pánico y comienza la negación.
Saltarse las tareas iniciales. Nunca analizas y nunca diseñas, esa es tarea de ñoños.
Diseño no adecuado. Así me enseñaron en la escuela y los profesores son gente muy capacitada que lleva años en la industria del desarrollo de sistemas.
Falta de supervisión. Porque el gestor y el líder llevan como veinte proyectos al mismo tiempo y todavía no terminan otros que ya se entregaron. Y por supuesto los programadores se pueden enseñar solitos sobre lo que el cliente quiere.
Falta de estimaciones. La autoestima de los programadores es lo que se al carajo cuando fallan los proyectos.

Errores relacionados con el producto

Requerimientos excesivos. Si no está clara la propuesta el cliente te va a meter todas las funcionalidades que pueda y si puede hacer todo su trabajo, mejor.
Cambio de requerimientos. Porque claro, el mercado cambia constantemente y hay que ser competitivos y ajustarse a esos cambios. Pero la verdad es que, es hasta que el usuario comienza a usar el sistema, que se da cuenta de que nadie tenía idea de lo que se tenía que hacer realmente.
Developers muy meticulosos. Todos los programmers somos obsesivos compulsivos, es lo que nos metió en esto desde un principio.

Errores relacionados con la tecnología

Síndrome de la panacea. Es que le tienes que meter Struts, Spring y Hibernate siempre y ya con eso quedan todos los sistemas.
Sobre-estimación de las ventajas del uso de una nueva herramienta. Como cuando usas una de esas herramientas de business intelligence o un CMS, que según el vendedor harán prácticamente todo lo que el cliente te pida.
Cambio de herramientas a mitad del proyecto. Si no funciona Struts usa JSF, porque es mejor, si no funciona tampoco pues usa Spring MVC, porque es más simple, si no funciona mete Flex, porque se ve bien, si no funciona...
Falta de un control de código fuente automático. Te apuesto que eso si no te lo enseñaron en la escuela. Y que flojera da meter subversión y que todos se conecten la primera vez.

JavaServer Faces 2.0 CRUD

2010-02-23T12:26:00.081-06:00

Mostraremos como hacer la funcionalidad en JavaServer Faces 2.0 para crear, leer, actualizar y borrar registros en una base datos de MySQL.

En este ejemplo haremos uso de las siguientes tecnologías:

JavaServer Faces (JSF) 2.0
Java Persistence API (JPA) 2.0
Enterprise JavaBeans (EJB) 3.1

Será necesario tener instalado el siguiente software:

NetBeans IDE 6.8, o superior.
Java Development Kit (JDK) 6, o superior.
GlassFish Application Server v3, o superior.
MySQL 5.x o superior

Para este ejemplo seguiremos los siguientes pasos:

Crear la base de datos
Examinar la estructura de base de datos
Crear el proyecto Web
Generar las clases de entidad desde la base de datos
Generar los JSF desde las clases de entidad
Explorando la aplicación

Crear la base de datos

Si ya has creado una base de datos en MySQL antes, quizá sabes también que hay mas de una forma o herramienta para hacerlo. Aqui te mostraremos como hacerlo desde la sección de servicios de NetBeans. Si abres la ventana de Servicios de NetBeans y después das click en Databases, podrás ver que existe predefinido un item solo para MySQL, para iniciar el servicio en NetBeans, debes dar click derecho y despues en propiedades para completar los datos de conexión.

En tu caso los datos de acceso serán los que hayas definido cuando instalaste MySQL

cuando hayas teminado de llenar los datos para conectarte, simplemente da click derecho al mouse y despues en conectar.

Ya que te hayas conectado es posible crear una nueva base de datos en las opciones del submenu con click derecho:

Al crear la base de datos, también se crea una conexión a la misma y es posible ejecutar comandos de SQL sobre la nueva base.

Para este ejemplo te proporcionamos dos scripts de SQL que te permitirán crear las tablas necesarias y llenarlas de datos de ejemplo para ejecutar el ejercicio adecuadamente.

Te dejamos la liga de los scripts aqui:

script

Examinar la estructura de base de datos Una vez que has ejecutado los scripts puedes explorar la base de datos para ver las tablas y el contenido que has creado. No olvides refrescar el estado de la conexión.

Se han creado y poblado las tablas que necesitaremos.

La siguiente es una descripción de las tablas:

Tabla	Descripción	Características
CLIENTE	Cliente de la agencia de consultoria	No-generada, llave primaria compuesta (cuyos campos no constituyen una llave foranea)
CONSULTOR	Un empleado de la agencia de consultoría que los clientes pueden contratar sobre una base contractual	Incluye un campo resumen de tipo LONG VARCHAR
ESTATUS_CONSULTOR	El estado de un consultor con la agencia de consultoría (por ejemplo, activos e inactivos son estados posibles)	No-generada, llave primaria de tipo CHAR
RECLUTADOR	Un empleado de la agencia consultora responsable de la conexión de los clientes y consultores
PROYECTO	Un proyecto de los clientes con consultores de la agencia.	No-generada, llave compuesta que incluye dos campos constituyendo una llave foranea para la tabla CLIENTE
FACTURABLE	Un conjunto de horas trabajadas por un consultor en un proyecto, para los que la consultoría de proyectos factura al cliente en cuestión	Incluye un campo artefacto de tipo CLOB
DIRECCION	Dirección de Facturación
CONSULTOR_PROYECTO	Tabla de Union que indica que consultores están asignados a que proyectos.	Referencia-cruzada PROYECTO y CONSULTOR, los primeros tienen una clave primaria compuesta

La base de datos incluye una variedad de relaciones. Al crear clases de entidad de una base de datos, el IDE genera automáticamente las propiedades del tipo de Java adecuada basada en el tipo de SQL de las columnas. La siguiente tabla describe las relaciones de entidades para consultar la base de datos. (Relaciones inversas no se muestran)

Entidad	Entidad Relacionada	Información	Descripción
CLIENTE	RECLUTADOR	nullable con edición manual; nullable uno-a-muchos si no.	CLIENTE tiene muchos RECLUTADORES y RECULTADOR tiene cero o un CLIENTE (si no es editado manualmente)
CLIENTE	DIRECCION	non-nullable uno-a-uno	CLIENTE tiene una DIRECCION y DIRECCION tiene cero o un CLIENTE
CLIENTE	PROYECTO	non-nullable uno-a-muchos; en una entidad Proyecto, el valor del campo cliente es parte de la llave primaria del Proyecto	CLIENTE tiene muchos PROYECTOs y un PROYECTO tiene un CLIENTE
CONSULTOR	PROYECTO	muchos-a-muchos	CONSULTOR tiene muchos PROYECTOs y PROYECTO tiene muchos CONSULTORES
CONSULTOR	FACTURABLE	non-nullable uno-a-muchos	CONSULTOR tiene muchas FACTURABLEs y FACTURABLE tiene un CONSULTOR
ESTATUS_CONSULTOR	CONSULTOR	non-nullable uno-a-muchos	ESTATUS_CONSULTOR tiene muchos CONSULTOREs y CONSULTOR tiene un ESTATUS_CONSULTOR
CONSULTOR	RECLUTADOR	nullable uno-a-muchos	CONSULTOR tiene cero o un RECLUTADOR y RECLUTADOR tiene muchos CONSULTOREs
FACTURABLE	PROYECTO	non-nullable uno-a-muchos	FACTURABLE tiene un PROYECTO y PROYECTO tiene muchos FACTURABLEs

Crear el proyecto Web

Ahora es momento de crear el proyecto Web utilizando el framework de JSF

En el menú superior debes elegir: File> New Project (Ctrl-Shift-N).
Selecciona Web Application de la categoría Java Web. Da click en Next.
Escribe el nombre del proyecto y la hubicación, para este ejemplo usamos el nombre ejemploJSF2. Despues da click en el botón Next
Selecciona el servidor GlassFish v3 y especifica la versión de Java EE con la Java EE 6 Web. Da un click en Next.
En el panel de Frameworks, selecciona la opción de JavaServer Faces. Da click en Finish.

Cuando das click en Finish, el IDE genera el proyecto de tipo Web y abre index.xhtml en el editor.

Generar las clases de entidad desde la base de datos

1.- Despues de conectar la IDE a la base de datos, usaremos el asistente o wizard que obtiene entidades de la base de datos para generar de forma rápida las clases basadas en las tablas de la base de datos. El IDE puede generar clases de entidad de cada tabla que selecciones, y puede generar además, cualquier clase de entidades para relacionar las tablas.

2.- En la ventana de Proyectos, dando un click derecho al nodo de ejemploJSF2, y seleccionando New> Entity Classes from Database. (Si esta opción no está en la lista, ejliga Otra. Despues, en el Wizard de File, seleccione la categoría de Persistence, después Entity Classes from Database)

3.- Selecciona New Data Source from the Data Source, arrastra la lista para abrir la ventana de dialogo Create Data Source.

4.- Selecciona el nombre JNDI jdbc/ejemploJSF2 y selecciona jdbc:mysql://localhost:3306/ejemploJSF2 como la base de conexión.

5.- Las tablas de la base de datos deberán aparecer en la lista de Tablas disponibles.

6.- Da click en el boton Add All para seleccionar todas las tablas. Da click en Next.

7.- Escribe jpa.ent como nombre de paquete. Asegurate que el checkbox para generar consultas con nombre se ha seleccionado "Generate Named Query Annotations".

8.- Da click en el boton Create Persistence Unit para abrir la ventana de dialogo Create Persistence Unit.

Puedes dejar los valores por default que vienen. da click en Create.

8.- Finalmente das click en Finish y el IDE comenzará a crear las entidades en el paquete que especificamos.

Al utilizar el asistente para crear clases de entidad de una base de datos, el IDE examina las relaciones entre las tablas de base de datos. En la ventana de Proyectos, si se expande el nodo del paquete jpa.ent, se puede ver que el IDE genera una clase de entidad para cada tabla, excepto para la tabla de PROYECTO_CONSULTOR. El IDE no ha creado una clase de entidad para PROYECTO_CONSULTOR porque la tabla es una union de tablas.

El IDE también ha generado dos clases adicionales para las tablas con llaves primarias compuestas: CLIENTE y PROYECTO. Las clases de llave primaria de estas tablas (ClientPK.java y ProjectPK.java) tiene PK concatenado.

Si nos fijamos en el código generado para las clases de entidad se puede ver que el asistente añade anotaciones @GeneratedValue a los campos auto generados de ID y las anotaciones @Basic (optional = "false") a algunos de los campos en las clases de entidad. En base a las anotaciones @Basic (optional = "false"), las páginas que el asistente JSF Pages from Entity Classes genera, incluyen un código con controles para prevenir las violaciónes para columnas con valor no nulo.

Generando los JSF desde las clases de entidad

Ahora que hemos creado las clases de entidad, haremos la interfaz web para mostrar y modificar los datos. Usaremos el asistente JSF Pages from Entity Classes para generar páginas JavaServer Faces. El código generado por el asistente o wizzard se basa en las anotaciones de persistencia contenidas en las clases de entidad.

Para cada clase de entidad, el asistente genera lo siguiente:

Un bean de sesión sin estado para la creación, lectura, modificación y eliminación de entidades.
Un bean JSF manejador, session-scoped,
Un directorio que contiene cuatro archivos Facelets para realizar de CRUD (Create.xhtml, Edit.xhtml, List.xhtml, y View.xhtml)
Clases que serán usadas por los beans JSF manejadores (JsfUtil, PaginationHelper)
Un paquete de propiedades para los mensajes localizados, y una entrada correspondiente en el archivo de configuración del proyecto (faces-config.xml se crea si no existe)
Archivos Web auxiliares, incluyendo una hoja de estilos predeterminada para renderear componentes y un archivo plantilla para Facelets.

Para generar las páginas JSF

1.- En la ventana Proyectos, haz click en el nodo del proyecto y elije New> JSF Pages from Entity Classes para abrir el asistente. (Si esta opción no aparece en la lista, elije Otro. Luego, en el asistente de archivos, selecciona la categoría JavaServer Faces, a continuación, JSF Pages from Entity Classes)

La lista de clases de entidad disponibles muestra las siete clases de entidad que figuran en el proyecto. El cuadro no muestra las clases ClientPK.java y ProjectPK.java.

2.- Haz click en Agregar todo para mover todas las clases a la Selección de cuadro de clases de entidad.
Haz click en Siguiente.

3.- En el paso 3 del asistente, Generamos páginas JSF y clases, escriba jpa.ses el paquete de JPA Session Bean.

4.- Escribe jsf para el nombre del paquete de clases JSF.

5.- Escribe 'recursos/Bundle' en el campo "Localization Bundle Name". Esto generará un paquete llamado recursos en donde estará el archivo Bundle.properties (Si se deja en blanco, el paquete de propiedades, se creará en el paquete default del proyecto.)

Para que el IDE se adapte mejor a tus convenciones de proyecto, puedes personalizar los archivos generados por el asistente. Haz click en el enlace Customize Template para modificar el archivo de plantillas utilizadas por el asistente.

5.- En general, puedes acceder y realizar cambios en todas las plantillas gestionada por el IDE usando el Administrador de plantillas (Tools > Templates).

6.- Haz click en Finish. El IDE genera los beans de sesión sin estado en el paquete de jpa.ses, y los beans JSF manejadores session-scoped, en el paquete de jsf. Cada bean de sesión sin estado maneja las operaciones para la clase de entidad correspondiente, incluyendo la creación, edición, y los casos de borrado de la entidad a través de la API de persistencia de Java. Cada bean JSF manejador implementa la interfaz javax.faces.convert.Converter y realiza la tarea de convertir a las instancias de la clase de entidad que corresponde a los objetos String y viceversa.

Si expandes el nodo Web Pages, veras que el IDE genera una carpeta para cada una de las clases de entidad. Cada carpeta contiene los archivos de Create.xhtml, Edit.xhtml, List.xhtml y View.xhtml. El IDE también modificó el archivo index.xhtml insertando los enlaces a cada una de las páginas List.xhtml.

Cada bean JSF manejador es específico para los cuatro archivos Facelets correspondientes e incluye el código que invoca métodos en el bean de sesión adecuado.

Expande el nodo o folder de recursos para localizar la hoja de estilos jsfcrud.css que fue generado por el asistente. Si abres la página de la aplicación de bienvenida (index.xhtml) o el archivo Facelets de plantilla (template.xhtml) en el editor, verás que contiene una referencia a la hoja de estilos.

El archivo Facelets de plantilla es usado por cada uno de los cuatro archivos de Facelets para cada clase de entidad.

<h:outputStylesheet name="css/jsfcrud.css"/>

Si expandes los paquetes fuente del nodo se pueden ver los beans de sesión, los bean JSF manejadores, clases de utilidad, y archivos de propiedades que el asistente genera.

El asistente también genera un archivo de configuración de Faces (faces-config.xml) para registrar la ubicación del paquete de propiedades. Si expandes el nodo de archivos de configuración y abres faces-config.xml en el editor de XML, se puede ver que se incluye la siguiente entrada.

    <application>
<resource-bundle>
<base-name>recursos/Bundle</base-name>
<var>bundle</var>
</resource-bundle>
</application>

Además, si exploras el paquete de recursos, encontrarás en el archivo de Bundle.properties, mensajes para el idioma del cliente por defecto. Los mensajes se derivan de las propiedades de la entidad de clase.

Para agregar un paquete de propiedades nuevas haz click en el archivo Bundle.properties y selecciona Customize. La ventana de diálogo Customizer te permite añadir nuevas configuraciones regionales para la aplicación.

Explorando la Aplicación

Ahora que el proyecto contiene las clases de entidad, los EJBs de sesión para controlar las clases de entidad, y JSF de front-end para mostrar y modificar la base de datos, intenta ejecutar el proyecto para ver los resultados.

En seguida se presentan algunos ejercicios opcionales que te ayudarán a familiarizarte con la aplicación, así como las características y funcionalidad que el IDE.

Examinar el proyecto terminado
Rellenar la base de datos con una secuencia de comandos de SQL
Explorar el Editor de Facelets
Exploración de la integridad de base de datos, con validación de campo
Edición de clases de la entidad

Examinar el proyecto terminado

1.- Para ejecutar el proyecto, haz click derecho en el nodo del proyecto en la ventana de proyectos y selecciona Run o Ejecutar.

Cuando se muestra la página de bienvenida de la aplicación, se proporciona una lista de enlaces que permite ver las entradas que figuran en cada tabla de base de datos.

Nuevos enlaces se han añadido a la página de bienvenida (index.xhtml) con ayuda del asistente. Los enlaces creados se ofrecen como puntos de entrada a las páginas de Facelets que proporcionan la funcionalidad CRUD sobre la base de datos de la aplicación.

<?xml version='1.0' encoding='UTF-8' ?>
<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
<html xmlns="http://www.w3.org/1999/xhtml"
    xmlns:h="http://java.sun.com/jsf/html">
  <h:head>
      <title>Facelet Title</title>
<h:outputStylesheet name="css/jsfcrud.css"/>
  </h:head>
  <h:body>
      Hello from Facelets
                  <h:form>
                  <h:commandLink action="/cliente/List" value="Show All Cliente Items"/>
              </h:form>
              <h:form>
                  <h:commandLink action="/consultor/List" value="Show All Consultor Items"/>
              </h:form>
              <h:form>
                  <h:commandLink action="/direccion/List" value="Show All Direccion Items"/>
              </h:form>
              <h:form>
                  <h:commandLink action="/estatusConsultor/List" value="Show All EstatusConsultor Items"/>
              </h:form>
              <h:form>
                  <h:commandLink action="/facturable/List" value="Show All Facturable Items"/>
              </h:form>
              <h:form>
                  <h:commandLink action="/proyecto/List" value="Show All Proyecto Items"/>
              </h:form>
              <h:form>
                  <h:commandLink action="/reclutador/List" value="Show All Reclutador Items"/>
              </h:form>
</h:body>
</html>

2.- Haz click en el vínculo Show All Consultor Items. Tomando en cuenta el código anterior, puedes ver que la página de destino es /consultor/List (En JSF 2.0, la extensión de archivo se infiere debido a la navegación implícita)

Si no olvidaste ejecutar el segundo script de SQL que se encarga de rellenar algunas tablas podrás ver algunos datos, para el caso de Consultores se muestra al menos un registro.

Como podrás ver, las ociones: crear, ver, editar y elimimar son generadas también por el asistente.

Explorar en el Editor de páginas Facelets

1.- Abra el archivo /consultor/List.xhtml en el editor. Línea 8 indica que la página se basa en el archivo Facelets template.xhtml para crearse.

2.- Usa la opción de Ir a archivo del IDE para abrir template.xhtml. Presiona Alt-Shift-O, y luego comenzar a escribir la plantilla.

Presiona Enter para entrar.

3.- La plantilla se aplica la etiqueta

<ui:insert>

para insertar contenido de otros archivos en su título y el cuerpo. Coloca el cursor en la etiqueta

<ui:insert>

, a continuación, pulsa Ctrl-Espacio para invocar una ventana emergente de documentación.

Puedes presionar Ctrl-Espacio en las etiquetas JSF y sus atributos para invocar un pop-up de documentación. La documentación que se ve es tomada de la descripción oficial de JSF Tag Library Documentation.

4.- Regresa al archivo List.xhtml (presiona Ctrl-Tab). La etiqueta ui:define ui:define se utiliza para definir el contenido que se aplicarán al título de la plantilla y el cuerpo. Este patrón se utiliza para todos los cuatro archivos de Facelets (Create.xhtml, Edit.xhtml, List.xhtml, y View.xhtml) generados para cada clase de entidad.

5.- Coloca el cursor sobre cualquiera de las expresiones EL que usan los mensajes localizados contenida en el archivo Bundle.properties. Presiona Ctrl-Espacio para ver el mensaje localizado.

6.- Desplazate hasta el final del archivo y busca el código para el enlace Crear nuevo consultor (Línea 92). Este es el siguiente:

<h:commandLink action="#{consultorController.prepareCreate}" value="#{bundle.ListConsultorCreateLink}"/>

7.- Presiona Ctrl-Espacio en la acción del atributo commandLink para invocar el pop-up de la documentación.

El atributo action indica el método que controla la solicitud cuando se hace click en el enlace en el navegador. La siguiente documentación se proporciona:

MethodExpression representa la acción de la aplicación que se invoca cuando este componente es activado por el usuario. La expresión debe evaluar un método público que no toma parámetros y devuelve un objeto (el método toString () se llama para obtener el resultado lógico), que se pasa a NavigationHandler para esta aplicación.

En otras palabras, el valor de acción generalmente se refiere a un método en un bean JSF manejador que se evalúa a una cadena. La cadena es utilizada por NavigationHandler de JSF de remitir la solicitud a la vista apropiada. Podrás verificar esto en los siguientes pasos.

8.- Pon el cursor en consultorController y presione Ctrl-Space. La funcionalidad de completado del editor, indica que consultorController es un bean JSF controlador.

9.- Mueve el cursor a prepareCreate y pulsa Ctrl-Espacio. La función de completado de código enumera los métodos que figuran en el bean ConsultorController.

Explorando la integridad de base de datos con validación de campos

1.- Desde la página con la Lista de Consultores en el navegador, haz click en 'Create New Consultor". Deberá aparecer el formulario de creación de Consultores.

2.- Ingresa los siguientes datos en el formulario. Por el momento, dejar los campos RecruiterId y StatusId en blanco.

Campo	Valor
ConsultorId	2
Email	jorge.listo@consultores.com
Password	jorge.listo
TarifaPor	75
TarifaPorHoraFacturable	110
FechaContratacion	07/22/2008
Resumen	Soy el mejor ¡Contratame!
ReclutadorId	---
EstatusId	---

3.- Haz click en Guardar. Al hacerlo, un error de validación se marca para el campo EstatusId.

¿Por qué ocurrió esto? Reexamina el diagrama entidad-relación de la base de datos. Como se indica en la tabla de relaciones, CONSULTOR y ESTATUS_CONSULTOR comparten una relación no-nula, uno-a-muchos. Por lo tanto, cada entrada en la tabla CONSULTOR debe contener una referencia a una entrada en la tabla ESTATUS_CONSULTOR. Esto se denota por la clave externa consultor_fk_estatus_consultor que une las dos tablas.
4.- Para superar el error de validación,selecciona entity.ConsultorStatus [EstatusId = A] de la lista de EstatusId desplegable.

Nota: Puedes dejar el campo en blanco RecruiterId. Como se indica en el diagrama de relación, la relación entre CONSULTOR y la tabla de RECLUTADOR puede ser nula, uno-a-muchos, lo que significa que las entradas de CONSULTOR no necesitan estar asociadas con una entrada en RECLUTADOR.

5.- Haz click en Guardar. Aparecerá un mensaje indicando que la entrada consultor se ha guardado correctamente. Si haces click en Show All Consultor Items, verás la entrada que se ha guardado en la tabla.

En general, las páginas Facelets generadas, proveen de errores para facilitar la entrada que el usuario introduce:

* Campos vacíos para campos no-nulas.
* Modificaciones a los datos que no puede ser alterados (por ejemplo, las claves primarias).
* Introducción de datos que no son del tipo correcto.
* Modificaciones a los datos cuando la vista de un usuario ya no está sincronizada con la base de datos.

Editando las Clases de Entidad

En la seccion anterior vimos cómo la lista desplegable de EstatusId no era muy amigable. Quizá ya te has dado cuenta de que el texto que se muestra para cada elemento es una representación en cadena de cada entidad EstatusConsultor encontrada.

Veremos cómo usar completamente el editor de código, documentación y apoyo a la navegación como conclusión. También modificaremos el mensaje que se envía al usuario para que sea más amigable.

1.- Abre el archivo /consultor/Create.xhtml. Este es el formulario Create New Consultor que acabas de ver en el navegador. Desplazate hacia abajo para ver el código del la lista desplegable EstatusId (en negrita a continuación).

                    <h:selectOneMenu id="reclutadorId" value="#{consultorController.selected.reclutadorId}" title="#{bundle.CreateConsultorTitle_reclutadorId}" >
                     <f:selectItems value="#{reclutadorController.itemsAvailableSelectOne}"/>
                 </h:selectOneMenu>
                    <h:outputLabel value="#{bundle.CreateConsultorLabel_estatusId}" for="estatusId" />
                    <h:selectOneMenu id="estatusId" value="#{consultorController.selected.estatusId}" title="#{bundle.CreateConsultorTitle_estatusId}" required="true" requiredMessage="#{bundle.CreateConsultorRequiredMessage_estatusId}">
                        <f:selectItems value="#{estatusConsultorController.itemsAvailableSelectOne}"/>
                    </h:selectOneMenu>

2.- Examina el valor aplicado a la etiqueta . El atributo "valor" determina el texto que se muestra para cada elemento de la lista desplegable.

3.- Presione Ctrl-Espacio en itemsAvailableSelectOne. La función de completar código del editor indica que getItemsAvailableSelectOne() de EstatusConsultorController devuelve un arreglo de objetos selectItem.

4.- Coloca el cursor sobre el valor de retorno selectItem[] en la firma del método, y pulsa Ctrl-Space para invocar la documentación pop-up.

Si lo deseas haz click en el navegador web (el icono del navegador web) para abrir la documentación Javadoc en un navegador web externo.

Como puedes ver, la clase SelectItem pertenece al freamwork de JSF. El componente de UISelectOne, como se menciona en la documentación, está representado por la etiqueta de que se examinó en el paso 1.

5.- Presiona Ctrl, a continuación, pasa el ratón sobre el metodo findAll(). Un pop-up aparece mostrando la firma del método.

Puedes ver que aquí ejbFacade.findAll() devuelve una lista de objetos ConsultantStatus.

6.- Desplazate sobre a JsfUtil.getSelectItems. Mueve el ratón sobre getSelectItems y presiona la tecla Ctrl, a continuación, haz click en el enlace que aparece.

Nota: Recuerda que JsfUtil es una de las clases de que se genera cuando se completó del asistente para JSF Pages from Entity Classes.

El método que itera a través de la lista de entidades (es decir, la lista de objetos EstatusConsulor), creando un SelectItem para cada uno. Como se indica en negrita a continuación, cada SelectItem se crea usando el objeto de entidad y una etiqueta para el objeto.

    public static SelectItem[] getSelectItems(List<?> entities, boolean selectOne) {
      int size = selectOne ? entities.size() + 1 : entities.size();
      SelectItem[] items = new SelectItem[size];
      int i = 0;
      if (selectOne) {
          items[0] = new SelectItem("", "---");
          i++;
      }
      for (Object x : entities) {
          items[i++] = new SelectItem(x, x.toString());
      }
      return items;
  }

La etiqueta se crea usando el método toString(), y es la representación del objeto. (Véase la definición Javadoc para el constructor SelectItem (valor java.lang.Object, java.lang.String etiqueta))

Ahora que has comprobado que es el resultado de toString() es lo que se representa en el navegador al ver los elementos en una lista desplegable, modificaremos el método toString () de EstatusConsultor.

7.- Abre la clase EstatusConsultor en el editor. Modifica el método toString() para devolver el estatusId y descripcion. Estos son corresponden a las dos columnas de la tabla ESTATUS_CONSULTOR.

    @Override
  public String toString() {
      return estatusId + ", " + descripcion;
  }

8.- Ejecuta el proyecto de nuevo. Cuando el navegador muestra la página de bienvenida, haz click en el vínculo Mostrar todos los artículos de consultores, a continuación, haz click en Crear nuevo consultor.

Inspecciona la lista desplegable EstatusId. Verás que ahora muestra el ID de estado y la descripción para el expediente de la que figura en el cuadro ESTATUS_CONSUTOR de la base de datos.

Listo, teminamos. Este post esta basado en la traducción del ejemplo:

http://netbeans.org/kb/docs/web/jsf20-crud.html

para JSF 2.0 y NetBeans 6.8

Espero que este ejemplo sea de utilidad para ustedes.

Ejemplo de JavaServer Faces 2.0, Hola Mundo

2010-01-30T18:48:00.010-06:00

Que tal!, en esta ocasión les traigo este ejemplo de JavaServer Faces 2.0, un "Hola Mundo". Se trata de un ejemplo sencillo para familiarizarse con el framework.

Para hacer el ejemplo necesitas tener instalados previamente:

JDK 1.6 o superior
NetBeans 6.8 o superior

Y los puedes descargar en:

Para este ejemplo he creado un video que espero te sea de utilidad.

Si tienes problemas para ver el video da click en la opción de Fullscreen que aparece en las opciones de reproducción del YouTube.

Por lo sencillo del ejemplo no he dejado una liga con el código, espero tener ejemplos mas elaborados y dejen claro las capacidades de esta tecnología.

Hasta el próximo post.

JSF2 Java Server Faces 2.0 y NetBeans

2009-10-13T23:58:00.009-05:00

A partir de la version 6.8 de Netbeans es posible crear aplicaciones Web con el Framework de Sun para aplicaciones JSF en la versión 2.0.

A la fecha de publicación de este blog, la versión disponible de NetBeans es la 6.8.

http://www.netbeans.com/

Una de las grandes ventajas de usar NetBeans es que las tecnologias de Sun para Java estan disponibles y bien integradas a la IDE, de tal forma que no es necesario preocuparse por instalar librerias o servidores Web para correr ejemplos o proyectos completos. La gente de Sun se ha preocupado por integrar las tecnologías de mayor uso en el mercado, no importa si no son creadas o promocionadas por ellos mismos. Sin embargo son los Frameworks de Sun los mejor integrados.

JSF 2.0 presentará novedades en cuatro áreas principales: facilidad de desarrollo, desempeño, adopción y nuevas características. Seguidamente un resumen de éstas.

Facilidad de desarrollo: esta área permitirá la creación de componentes por medio de agregación, reducirá la configuración por medio de descriptores, remplazándola por un uso extensivo de anotaciones las cuales se usarán al desarrollar componentes, navigation rules etc. Por último se eliminará el desarrollo de Tag Handlers gracias a la integración con facelets.
Nuevas características: entre las nuevas características se puede ver una expansión del ciclo de vida del request para brindar soporte a peticiones Ajax, además se ofrecerá soporte de primera clase para el manejo de los recursos utilizados por los componentes JSF.
Desempeño: se propone renderizar deltas de los componentes JSF según se necesite en lugar de un renderizado completo de los componentes, se mejorará el manejo de eventos mediante PhaseListener y los componentes serán sin estado por defecto.
Adopción: para tener una mejor adopción JSF pretende mejorar la interoperabilidad entre librerías de diferentes vendedores, se agregará soporte para JSR 311, Skinning o Themeing entre otros.

Tomada de: http://www.javahispano.org/

Espero tener un ejemplo sencillo muy pronto.

Verificación Visual en Formularios, CAPTCHA

2009-09-30T19:26:00.013-05:00

Seguramente sabes que significa Captcha . Bueno yo tampoco sabía, según Wikipedia es el acrónimo de Completely Automated Public Turing test to tell Computers and Humans Apart ó Prueba de Turing pública y automática para diferenciar máquinas y humanos.

En algunas ocasiones te habrás topado con algún formulario donde aparece una imagen extraña donde debes teclear un código que en teoría solo un humano puede reconocer. De esta forma se evita que robots entren y agreguen publicidad indeseada de forma automática en comentarios de blogs o en algunos foros.

Haremos un ejemplo sencillo para mostrar esta funcionalidad, desde luego Struts2 no tiene un método directo para hacerlo y de hecho la solución que damos puede ser usada sin ningún framework, pero aun asi veremos como se configura el Action para recibir la respuesta del usuario.

Para este ejemplo debes descargarte la libreria SimpleCaptcha-1.1.1.jar y agregarla junto con las demas librerias de tu proyecto. La puedes encontrar y descargar aqui:

Este proyecto creado por James Childers es sencillo y fácil de utilizar, permite crear la imagen con el código de verificación utilizando un servlet que debe darse de alta en el archivo web.xml de nuestro proyecto.

Te muestro el archivo a continuación.

<?xml version="1.0" encoding="UTF-8"?>
<web-app version="2.5" xmlns="http://java.sun.com/xml/ns/javaee" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="http://java.sun.com/xml/ns/javaee http://java.sun.com/xml/ns/javaee/web-app_2_5.xsd">

   <servlet>
       <servlet-name>SimpleCaptcha</servlet-name>
       <servlet-class>nl.captcha.servlet.SimpleCaptchaServlet</servlet-class>
   </servlet>
   <servlet-mapping>
       <servlet-name>SimpleCaptcha</servlet-name>
       <url-pattern>/simpleImg.jpg</url-pattern>
   </servlet-mapping>

   <filter>
       <filter-name>struts2</filter-name>
       <filter-class>org.apache.struts2.dispatcher.FilterDispatcher</filter-class>
   </filter>
   <filter-mapping>
       <filter-name>struts2</filter-name>
       <url-pattern>/*</url-pattern>
   </filter-mapping>

   <session-config>
       <session-timeout>
           30
       </session-timeout>
   </session-config>
   <welcome-file-list>
       <welcome-file>index.jsp</welcome-file>
   </welcome-file-list>
</web-app>

Agregamos el Action en struts.xml

<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE struts PUBLIC "-//Apache Software Foundation//DTD Struts Configuration 2.0//EN" "http://struts.apache.org/dtds/struts-2.0.dtd">
<struts>
   <constant name="struts.enable.DynamicMethodInvocation" value="false" />
   <constant name="struts.devMode" value="false" />

   <package name="default" namespace="/" extends="struts-default">
       <action name="Inicio">
           <result>/index.jsp</result>
       </action>
       <action name="Validar" class="ejemplos.struts2.actions.AccionValidarCodigo">
           <result name="input">/index.jsp</result>
           <result name="error">/index.jsp</result>
           <result>/validacionExitosa.jsp</result>
       </action>
   </package>
</struts>

Puedes ver que solo agregamos un servlet, sin embargo, la librería SimpleCapcha tiene algunas opciones mas para soportar tamaños especificos de imagenes y juegos de caracteres.

Aqui te muestro la clase Action que usaremos: AccionValidarCodigo.


package ejemplos.struts2.actions;
import com.opensymphony.xwork2.ActionContext;
import com.opensymphony.xwork2.ActionSupport;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpSession;
import nl.captcha.Captcha;

public class AccionValidarCodigo extends ActionSupport {
   @Override
   public String execute() throws Exception {
       HttpServletRequest request = (HttpServletRequest) ActionContext.getContext().get(org.apache.struts2.StrutsStatics.HTTP_REQUEST);
       HttpSession session = request.getSession();
       Captcha captcha = (Captcha) session.getAttribute(Captcha.NAME);
       request.setCharacterEncoding("UTF-8");
       String answer = request.getParameter("answer");
       if (captcha.isCorrect(answer)) {
           return SUCCESS;
       } else {
           addActionError("Código inválido, trate nuevamente.");
           return ERROR;
       }
   }
}

Como puedes ver, el servlet que dimos de alta guarda en la sesión la variable que será cotejada con el dato de entrada del formulario.
Puedes ver que es muy sencilla, lo importante que debes notar es que el servlet de SimpleCaptcha es la que se encarga de generar la imagen con el código de verificación, siempre y cuando la llames igual que como la definiste en el archivo web.xml, es

Usaremos dos JSPs parar este ejemplo, el que se encarga de mostrar el sencillo formulario y el que muestra el mensaje de validación exitosa.

index.jsp

<%@page contentType="text/html" pageEncoding="UTF-8"%>
<%@ taglib prefix="s" uri="/struts-tags" %>
<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "http://www.w3.org/TR/html4/loose.dtd">
<html>
   <head>
       <title>Validacion Capcha</title>
       <style>
           .errorMessage {
               color: red;
               font-size: 0.8em;
           }
           .label {
               color:#000000;
           }
       </style>
   </head>
   <body>
       <table>
           <tr>
               <td>
                   <h1>Validacion Capcha</h1>
                   <s:form action="Validar" namespace="/" method="POST">
                       <s:actionerror />
                       <img src="simpleImg.jpg" border="0">
                       <s:textfield label="Code" name="answer" size="20" maxlength="10"/>
                       <s:submit value="Verify" align="center" />
                   </s:form>
               </td>
           </tr>
       </table>
   </body>
</html>

El jsp con el mensaje de éxito. validacionExitosa.jsp

<%@page contentType="text/html" pageEncoding="UTF-8"%>
<%@ taglib prefix="s" uri="/struts-tags" %>

<html>
   <head>
       <title>Validacion Capcha</title>
   </head>
   <body>
       <table><tr><td><h1>Validación exitosa</h1></td></tr></table>
   </body>
</html>

Al ejecutar el ejemplo, la pantalla del navegador lucirá asi:

Si se ingresa el código correcto el Framework nos redirige a la página de éxito.

En caso de error vuelver a aparecer el formulario.

Bueno espero que sea de interés este post, dejen sus comentarios.

Espero poner pronto el código. Hasta el próximo post.

Carga de archivo, Interceptor FileUpload con Struts2

2009-08-19T12:47:00.011-05:00

En este ejemplo veremos nuevamente el uso interceptores, como ya hemos mencionado en otros post, Struts2 posee una amplia gama de funciones que permiten hacer mas ágil el desarrollo y que están puestas a disposición de los desarrolladores a través de los interceptores que vienen por default.

En esta ocasión veremos un interceptor que nos permite realizar una de las funciones con la que comúnmente nos topamos en el desarrollo de aplicaciones empresariales, se trata de la carga de archivos.

El interceptor FileUpload está dado de alta en la pila de interceptores del paquete default que maneja Struts2.

org.apache.struts2.interceptor.FileUploadInterceptor

Si ya tenemos configurado nuestro proyecto solo es necesario agregar estas librerías:

commons-fileupload-1.2.1.jar
commons-io-1.3.2.jar

Si no recuerdas que otras librerías son requeridas o como configurar tu proyecto para usar Struts2 puedes regresar al primer ejemplo que vimos en este mismo blog sobre como hacerlo:

El primer ejemplo de Struts2

Lo primero que haremos es crear un formulario de carga de archivos, el código lo muestro a continuación:

<%@page contentType="text/html" pageEncoding="UTF-8"%>
<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN"
 "http://www.w3.org/TR/html4/loose.dtd">
<%@ taglib prefix="s" uri="/struts-tags" %>
<html>
  <head>
      <meta http-equiv="Content-Type" content="text/html; charset=UTF-8">
      <title>Carga de archivos con interceptores</title>
  </head>
  <body>
      <h1>Carga de archivos con interceptores</h1>
      <s:form action="CargaArchivo" method="post" enctype="multipart/form-data">
          <s:file name="archivo" label="Carga Archivo"/>
          <s:submit value="Subir" align="center"/>
      </s:form>
  </body>
</html>

Despues creamos la clase AccionCargaArchivo que se encargará de recibir y manejar el contenido del archivo.

package ejemplos.struts2.accion;
import com.opensymphony.xwork2.ActionSupport;
import java.io.BufferedReader;
import java.io.File;
import java.io.FileReader;

public class AccionCargaArchivo extends ActionSupport {
  private File archivo;
  private String archivoContentType;
  private String archivoFileName;
  private String datos = "";

  public String execute() {
      try{
          BufferedReader entrada = new BufferedReader( new FileReader( archivo ) );
          if ( archivoContentType.equals("text/plain")){
              String aux;
              while((aux = entrada.readLine()) != null){
                  datos += aux + "\n";
              }
          }
      }catch(Exception e){
          e.printStackTrace();
      }
      return SUCCESS;
  }

  public File getArchivo() {
      return archivo;
  }

  public void setArchivo(File archivo) {
      this.archivo = archivo;
  }

  public String getArchivoContentType() {
      return archivoContentType;
  }

  public void setArchivoContentType(String archivoContentType) {
      this.archivoContentType = archivoContentType;
  }

  public String getArchivoFileName() {
      return archivoFileName;
  }

  public void setArchivoFileName(String archivoFileName) {
      this.archivoFileName = archivoFileName;
  }

  public String getDatos() {
      return datos;
  }

  public void setDatos(String datos) {
      this.datos = datos;
  }
}

Del la clase Action anterior observa cuidadosamente las siguientes variables:

File nombreDeArchivo;
String nombreDeArchivoContentType;
String nombreDeArchivoFileName;

Como puedes ver la variable de tipo File tiene un nombre arbitrario, sin embargo las otras dos deben cumplir con un formato establecido para que el interceptor pueda encontrarlas y establecer los datos correspondientes al tipo de contenido y al nombre del archivo.

archivo - Es el nombre del archivo.
archivoContentType - Contiene el tipo de contenido del archivo.
archivoFileName - Contiene el nombre del archivo tal como fue almacenado en el servidor.

Esto es todo lo que debe hacerse para que el Framework a través del inteceptor tome el archivo y lo relacione con las variables que declaramos en el Action.

También haremos la jsp de respuesta, que solo mostrará algunos datos del archivo que se esta subiendo al servidor.

El código es el siguiente:

<%@page contentType="text/html" pageEncoding="UTF-8"%>
<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN"
 "http://www.w3.org/TR/html4/loose.dtd">
<%@ taglib prefix="s" uri="/struts-tags" %>
<html>
  <head>
      <meta http-equiv="Content-Type" content="text/html; charset=UTF-8">
      <title>JSP Page</title>
  </head>
  <body>
      <h1>El archivo fu&eacute; recibido con exito!</h1>
      El tipo del contenido es : <s:property value="archivoContentType"/><br>
      Nombre del archivo es : <s:property value="archivoFileName"/><br>
      Nombre del archivo temporal : <s:property value="archivo.name"/><br>
      Contenido del archivo :<br>
          <s:textarea name="dat" value="%{datos}" cols="50" />
  </body>
</html>

y por último haremos cambios necesarios en el archivo de configuración de Struts2 para hacer referencia a las clases y jsps que acabamos de crear.

<!DOCTYPE struts PUBLIC "-//Apache Software Foundation//DTD Struts Configuration 2.0//EN" "http://struts.apache.org/dtds/struts-2.0.dtd">
<struts>
  <constant name="struts.enable.DynamicMethodInvocation" value="false" />
  <constant name="struts.devMode" value="false" />
  <package name="default" namespace="/" extends="struts-default">
      <action name="FormularioCargaArchivo" >
          <result>/formularioDeCargaDeArchivo.jsp</result>
      </action>
      <action name="CargaArchivo" class="ejemplos.struts2.accion.AccionCargaArchivo">
          <result>/archivoCargado.jsp</result>
          <result name="input">/formularioDeCargaDeArchivo.jsp</result>
      </action>
  </package>
</struts>

El código fuente de todos los archivos aqui:

Si corres el ejemplo y mandas llamar al formulario de carga de archivo debe aparecerte algo como lo siguiente:

formularioDeCargaDeArchivo.jsp

Como puedes ver nos aparece el campo para especificar el archivo que queremos subir.

Para este ejemplo solo cargaremos archivos de texto plano y visualizaremos el contenido.

Damos click en el boton de Subir y tendremos una respuesta como esta:

En esta jsp mostramos el tipo de datos del archivo, el nombre del archivo y el nombre que tendrá temporalmente en el servidor mientras es procesado durante el tiempo que se ejecute nuestra acción.

Despues mostramos simplemente el contenido. Listo ya tenemos el ejemplo.

Es importante que sepas que el archivo temporal se removera del servidor una vez que el ciclo de llamada a la acción termine.

Espero que te sirva este ejemplo, si tienes alguna duda o comentario hazmelo saber. Hasta el proximo post.

Struts1 vs Struts2

2009-07-30T19:14:00.007-05:00

La siguiente es una comparación tomada y traducida de la página de Rose India, un pequeño articulo que anima a los desarrolladores de Struts1 a comenzar a usar Struts2
Les pongo la liga de la página.

http://www.roseindia.net

También puedes encontrar muchos otros ejemplos de programación en Java.

Struts1 vs Struts2

Clases Action

Struts1
Se Requiere extender de la una clase Action abstracta. El problema común en Struts1 es que se programan clases abstractas en lugar de interfaces.
Struts2
Un Action puede implementar una interfaz Action, además de otras interfaces que le permitan integrar mas servicios. Struts2 provee de una clase base ActionSupport que implementa las interfaces comúnmente usadas. Además esta interfaz no es requerida. Cualquier POJO con un método de ejecución puede ser usado como Action en Struts2

Modelo de hilos

Struts1
Las Actions implementan el patrón singleton y deben ser thread-safe por lo que puede haber solo una instancia de una clase para manejar todas las peticiones para ese Action. La estrategia singleton pone restricciones sobre lo que podemos hacer con los Actions de Struts1 y se requiere un cuidado extra para desarrollar. Los recursos usados para los Actions deben ser thread-safe o sincronized.
Struts2
Los objetos Action son instanciados por cada petición, por lo que no hay problemas de tipo con la seguridad de hilos. En la práctica, los contenedores de servlets generan muchas instancias, así que un objeto mas no representa problemas de rendimiento y de impacto en el garbage collection

Dependencia de los Servlets

Struts1
Las Actions tiene dependencias de la API de Servlets dado que HttpServletRequest y HttpServletResponse son pasados al método excecute cuando la Action es invocada.
Struts2
Las Actions no están acopladas al contenedor. A menudo el contexto de los servlets esta representado por simples Maps, permitiendo a las Actions ser probadas de forma aislada. Las Actions de Struts2 puede mantener el uso del request y el response si se requiere. De cualquier forma, otros elementos de la arquitectura reducen o eliminan la necesidad de acceder a HttpServetRequest o a HttpServletResponse directamente.

Manejo de pruebas

Struts1
El principal obstáculo para las Actions de Struts1 es que la ejecución de métodos requiere de la API de Servlets. Una extensión de terceras partes, como Struts TestCase, que ofrece un conjunto de simuladores para objetos de Struts1.
Struts2
Las Actions pueden ser probadas instanciado la Action, estableciendo propiedades e invocando métodos. El soporte a la Inyección de Dependecias permite hacer las pruebas de forma simple.

Recolección de datos de entrada

Struts1
Es necesario el uso de un objeto ActionForm para capturar las entradas. Como las Actions, todos los ActionForm deben extender de una clase. Como algunos JavaBeans no implementan de ActionForm los desarrolladores a menudo crean clases redundantes para capturar a las entradas. Los DynaBeans pueden ser usados de forma alternativa para crear clases ActionForm convencionales, pero, los desarrolladores deben JavaBeans existentes.
Struts2
Usa las propiedades de las Actions para manejar las entradas, elimina la necesidad de un segundo objeto de entrada. las propiedades de entrada pueden ser objetos de una amplia variedad que incluso pueden tener sus propias variables. Las propiedades de las Action pueden usadas por la pagina Web por medio de los TagLibs. Struts2 soporta incluso el patrón de ActionForm, asi como objetos y acciones POJO. Tipos de objetos, incluyendo negocios o objetos de dominio, pueden ser usados como objetos en entrada y salida. La característica ModelDriven simplifica las referencias por taglib a objetos POJO.

Lenguaje de Expresiones

Struts1
Esta integrado con JSTL, así que usa el JSTL EL. El EL tiene una traza grafica de objetos básica y una relativamente pobre colección e indexación de soporte a propiedades.
Struts2
Puede usarse JSTL, pero el marco de trabajo soporta ademas un lenguaje de expresiones mas poderoso y flexible llamado "Object Graph Notation Language" (OGNL)

Vinculación de objetos de la vista

Struts1
Usa el mecanismo estándar de JSPS para el vincular objetos en el contexto de las páginas.
Struts2
Usa una tecnología llamada "ValueStack" donde los taglibs pueden acceder a valores sin estar acoplados a la vista donde el tipo de objeto se renderea. La estrategia del "ValueStack" permite reutilizar vistas gracias al rango de variables que pueden tener el mismo nombre pero tipo diferente tipos de propiedades.

Conversion de tipo

Struts1
Las propiedades de los ActionForm son usualmente Strings. Struts1 usa comúnmente Commons-Beanutils para la conversión de tipos. Las conversiones son configurables por clase y no por instancia.
Struts2
Usa OGNL para la conversión de tipos. El marco de trabajo incluye convertidores para objetos básicos y tipos primitivos.

Validación

Struts1
Soporta validación manual por medio de métodos en el ActionForm, o a través de una extensión de los Commons Validator. Las clases pueden tener diferentes contextos de validación para la misma clase, pero no pueden encadenar validaciones en sub objetos.
Struts2
Soporta validación manual por medio de métodos y por el marco de trabajo XWork Validation. El XWork soporta encadenamiento de validaciones en las subpropiedades usando las validaciones definidas para las propiedades de la clase y el contexto de validación.

Control de la ejecución del Action

Struts1
Soporta Request Porcessors (Ciclos de vida) separados por cada módulo, pero todas las Actions en el módulo deben compartir el mismo ciclo de vida.
Struts2
Soporta ciclos de vida diferentes, uno por Action por medio de la pila de interceptores. Pilas configurables pueden ser creadas y usadas con diferentes Actions si es necesario.

Esta es una tabla excelente para observar solo algunas de las mejoras en Struts2, sin embargo yo pondría especial énfasis en las ventajas que ofrecen los interceptores en Struts2, ya que permiten aislar gran parte de operaciones de control que son comunes en todas las aplicaciones Web, entre ellas una muy importante, el manejo de la sesión y la restricción de acceso a usuarios con permisos. Aislando estas operaciones es mas fácil reutilizar el código en otras aplicaciones.
Además los interceptores que vienen por default en el marco de trabajo resuelven y aislan una gran cantidad trabajo, como carga de archivos, validaciones, intenacionalizacion y mas. Solo tendremos que usar lo que los desarrolladores de Struts2 ponen a nuestra disposición.

Espero que este post les sea de utilidad, no olviden dejar sus comentarios si tienen alguna duda sobre los ejemplos o si tienen alguna sugerencia para el blog.

Hasta el próximo post.

2.1 - Manejo de Sesión en Struts2

2009-06-27T11:24:00.024-05:00

2.1.- Primeros Pasos
2.2.- La configuración de struts.xml
2.3.- La clase Action que desplegará la lista
2.4.- El Interceptor y la sesión

En este ejemplo, el segundo de Struts2, veremos como restringir el acceso a páginas privadas mediante el uso de la sesión y de los interceptores, también mostraremos como desplegar una lista de resultados utilizando las etiquetas de Struts2.

Antes de comenzar es necesario tener a la mano el código del ejemplo anterior pues lo usaremos como base, puedes verlo dando click acá:

El Primer Ejemplo

Haremos algunos cambios en el código, pero es necesario que notes algunas cosas que el primer ejemplo adelantaba sobre el manejo de la sesión.

Como podrás ver la clase AccionEntrar.java esta extendiendo de ActionSupport y también se implementan los métodos de la interfaz SessionAware, esta última es la que nos permitirá hacer uso de la sesión dentro del marco de trabajo.

public class AccionEntrar extends ActionSupport implements SessionAware{
  private Map session;
  private String mensajeError;
  private String usr;
  private String pas;
…

Al implementar SessionAware se definen los métodos:

        public Map getSession() {
          return session;
      }

      public void setSession(Map session) {
          this.session = session;
      }

y desde luego declaramos la variable session, que es de la clase Map.

En nuestra clase AccionEntrar verificamos los datos del usuario. De ser válidos daremos acceso a la página de bienvenida, si son incorrectos redirigimos a la página de entrada nuevamente. Todo este flujo también esta definido en nuestro archivo de configuración struts.xml.

Pero que pasa si ahora queremos que en nuestra aplicación se despliegue una lista de datos privados que solo pueda verse después de una autenticación válida, mostraremos como hacer eso. Comencemos por agregar una liga para desplegar una lista de usuarios en nuestra página de bienvenida.

Después de la etiqueta de bienvenida agrega esta línea:

<s:a href="DesplegarLista.action">Desplegar lista de productos</s:a>

El código de tu jsp deberá quedar así:

<%@page contentType="text/html" pageEncoding="UTF-8"%>
<%@ taglib prefix="s" uri="/struts-tags" %>
<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN"
 "http://www.w3.org/TR/html4/loose.dtd">
<html>
  <head>
      <meta http-equiv="Content-Type" content="text/html; charset=UTF-8">
      <title>Pagina de Bienvenida</title>
  </head>
  <body>
      <h1>Bienvenido, has entrado al sistema!</h1>
      <s:a href="DesplegarLista.action">Desplegar lista de usuarios</s:a>
  </body>
</html>

para descargar paginaBienvenida.jsp

No olvides poner la declaración de etiquetas de Struts2 cuando sea necesario.

<%@ taglib prefix="s" uri="/struts-tags" %>

2.1.- Primeros Pasos
2.2.- La configuración de struts.xml
2.3.- La clase Action que desplegará la lista
2.4.- El Interceptor y la sesión

2.2 - Manejo de Sesión en Struts2

2009-06-27T11:22:00.013-05:00

2.1.- Primeros Pasos
2.2.- La configuración de struts.xml
2.3.- La clase Action que desplegará la lista
2.4.- El Interceptor y la sesión

La configuración de struts.xml

También debemos modificar el archivo de configuración struts.xml. Debes agregar la siguiente linea:

<include file="sistema.xml"/>

Tu archivo debe quedar asi al final:

<!DOCTYPE struts PUBLIC "-//Apache Software Foundation//DTD Struts Configuration 2.0//EN" "http://struts.apache.org/dtds/struts-2.0.dtd">
<struts>
  <constant name="struts.enable.DynamicMethodInvocation" value="false" />
  <constant name="struts.devMode" value="false" />

  <package name="default" namespace="/" extends="struts-default">
      <action name="FormularioEntrada">
          <result>/formularioEntrada.jsp</result>
      </action>
      <action name="Entrar" class="ejemplos.struts2.action.AccionEntrar">
          <result name="input">/formularioEntrada.jsp</result>
          <result name="error">/formularioEntrada.jsp</result>
          <result>/paginaBienvenida.jsp</result>
      </action>
  </package>
  <include file="sistema.xml"/>
</struts>

Como podrás ver ahora hacemos referencia a otro archivo de configuración de Struts2 en donde están las peticiones que se hacen solo por usuarios que están identificados por nuestra aplicación como válidos. El archivo sistema.xml deberá ser algo como esto:

<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE struts PUBLIC "-//Apache Software Foundation//DTD Struts Configuration 2.0//EN" "http://struts.apache.org/dtds/struts-2.0.dtd">
<struts>
  <package name="sistema" namespace="/" extends="struts-default">
      <interceptors>
          <interceptor name="iterceptorAtuenticacion" class="ejemplos.struts2.inter.InterAutenticacion" />
          <interceptor-stack name="secureStack">
              <interceptor-ref name="iterceptorAtuenticacion" />
              <interceptor-ref name="defaultStack" />
          </interceptor-stack>
      </interceptors>
      <default-interceptor-ref name="secureStack" />

      <global-results>
          <result name="login" type="redirect">/FormularioEntrada.action</result>
      </global-results>

      <action name="DesplegarLista" class="ejemplos.struts2.action.AccionDesplegarLista">
          <result name="error">/formularioEntrada.jsp</result>
          <result>/desplegarLista.jsp</result>
      </action>
  </package>
</struts>

Hay algunas cosas nuevas en este archivo de configuración. Ahora estamos creando un “paquete” de declaración para nuestros Actions.

    <package name="sistema" namespace="/" extends="struts-default">

También estamos haciendo la declaración de nuestro interceptor InterAutenticacion, el cual aún no hemos creado.

        <interceptors>
          <interceptor name="iterceptorAtuenticacion" class="ejemplos.struts2.inter.InterAutenticacion" />
          <interceptor-stack name="secureStack">
              <interceptor-ref name="iterceptorAtuenticacion" />
              <interceptor-ref name="defaultStack" />
          </interceptor-stack>
      </interceptors>

Otra cosa importante que hacemos es declarar una pila de interceptores nueva, que agrega nuestro nuevo interceptor a la lista de interceptores que existen por default en el marco de trabajo. Este paso es importante.

    <default-interceptor-ref name="secureStack" />

También hemos agregado un redireccionamiento global para los casos en que no axista una sesión válida y que devuelve al usuario al formulario de entrada:

        <global-results>
          <result name="login" type="redirect">/FormularioEntrada.action</result>
      </global-results>

Y por último, la declaración de nuestra acción DesplegarLista

        <action name="DesplegarLista" class="ejemplos.struts2.action.AccionDesplegarLista">
          <result name="error">/formularioEntrada.jsp</result>
          <result>/desplegarLista.jsp</result>
      </action>

Bien, hemos terminado con la configuración del archivo nuevo sistema.xml. Pero ahora debemos crear la clase que se encargará de desplegar la lista y del interceptor que nos permitirá discriminar las peticiones válidas de las que no lo son.

2.1.- Primeros Pasos
2.2.- La configuración de struts.xml
2.3.- La clase Action que desplegará la lista
2.4.- El Interceptor y la sesión

2.3 - Manejo de Sesión en Struts2

2009-06-27T11:20:00.011-05:00

2.1.- Primeros Pasos
2.2.- La configuración de struts.xml
2.3.- La clase Action que desplegará la lista
2.4.- El Interceptor y la sesión

La clase Action que desplegará la lista

Nuestra clase Action será algo como esto:

package ejemplos.struts2.action;
import ejemplos.struts2.beans.Usuario;
import java.util.Map;
import java.util.List;
import java.util.ArrayList;
import com.opensymphony.xwork2.ActionSupport;
import org.apache.struts2.interceptor.SessionAware;
import ejemplos.struts2.utilidades.UsuarioHabilitado;

public class AccionDesplegarLista extends ActionSupport implements SessionAware,UsuarioHabilitado{
  private Map session;
  private Usuario usuario;
  private String mensajeError;
  private List miLista;

  public String execute() throws Exception {
      llenarArreglo();
      return SUCCESS;
  }

  public void llenarArreglo(){
      miLista = new ArrayList();
      Usuario usuario1 = new Usuario();
      Usuario usuario2 = new Usuario();
      Usuario usuario3 = new Usuario();
      Usuario usuario4 = new Usuario();
      usuario1.setNombre("Fulano de tal 1");
      usuario2.setNombre("Fulano de tal 2");
      usuario3.setNombre("Fulano de tal 3");
      usuario4.setNombre("Fulano de tal 4");
      miLista.add(usuario1);
      miLista.add(usuario2);
      miLista.add(usuario3);
      miLista.add(usuario4);
  }

  public List getMiLista(){
      return miLista;
  }

  public Map getSession() {
      return session;
  }

  public void setSession(Map session) {
      this.session = session;
  }

  public void setUsuario(Usuario usuario){
      this.usuario = usuario;
  }

  public Usuario getUsuario(){
      return usuario;
  }

  public void setMensajeError(String mensajeError) {
      this.mensajeError = mensajeError;
  }
}

Para descargar AccionDesplegarLista.java

Hay varias cosas que se deben notar en esta clase, la primera de ellas es que aunque tenemos declarada una variable de sesión, no verificamos si es nula o no, simplemente la usamos, mas adelante veremos porque.

    usuario = (Usuario)session.get("usuario");

No hacemos ninguna validación sobre si existe o no sesión y por lo tanto, tampoco verificamos si hay una instancia de “usuario” referenciada en la sesion. Será el interceptor el que se encargue de hacer la validación. En esta clase simplemente llenamos un arreglo con los datos de nuestra lista.

    public String execute() throws Exception {
      usuario = (Usuario)session.get("usuario");
      llenarArreglo();
      return SUCCESS;
  }

  public void llenarArreglo(){
      miLista = new ArrayList();
      Usuario usuario1 = new Usuario();
      Usuario usuario2 = new Usuario();
      Usuario usuario3 = new Usuario();
      Usuario usuario4 = new Usuario();
      usuario1.setNombre("Fulano de tal 1");
      usuario2.setNombre("Fulano de tal 2");
      usuario3.setNombre("Fulano de tal 3");
      usuario4.setNombre("Fulano de tal 4");
      miLista.add(usuario1);
      miLista.add(usuario2);
      miLista.add(usuario3);
      miLista.add(usuario4);
  }

Antes de ver como es el interceptor, mostraremos como debe quedar el jsp que se encarga de desplegar los datos.

<%@page contentType="text/html" pageEncoding="UTF-8"%>
<%@ taglib prefix="s" uri="/struts-tags" %>
<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN"
  "http://www.w3.org/TR/html4/loose.dtd">

<html>
  <head>
      <meta http-equiv="Content-Type" content="text/html; charset=UTF-8">
      <title>Ejemplos con Struts 2</title>
  </head>
  <body>
      <h1>Lista de usuarios del sistema</h1>
      Usuario:<s:property value="usuario.nombre" /><br>
      <s:iterator value="miLista">
          <s:property value="nombre" /><br>
      </s:iterator>
  </body>
</html>

Para descargar desplegarLista.jsp

El jsp es muy sencillo, pero debes notar que estamos haciendo uso de dos de las instancias a las que hacemos referencia o creamos en nuestra clase AccionDesplegarLista, y son:

usuario.nombre

miLista

Te preguntarás como llegarán hasta ahí esos datos cuando se despliegue el jsp, no te preocupes el framework se encargará de “llenar” tu jsp con los valores correctos siempre y cuando estén declarados con el mismo nombre en la clase AccionDesplegarLista.

2.1.- Primeros Pasos
2.2.- La configuración de struts.xml
2.3.- La clase Action que desplegará la lista
2.4.- El Interceptor y la sesión

2.4 - Manejo de Sesión en Struts2

2009-06-27T11:18:00.033-05:00

2.1.- Primeros Pasos
2.2.- La configuración de struts.xml
2.3.- La clase Action que desplegará la lista
2.4.- El Interceptor y la sesión

El Interceptor y la sesión

Ahora veremos como debe ser el interceptor. El código se muestra a continuación:

package ejemplos.struts2.inter;
import com.opensymphony.xwork2.Action;
import com.opensymphony.xwork2.ActionInvocation;
import com.opensymphony.xwork2.interceptor.Interceptor;
import java.util.Map;
import ejemplos.struts2.beans.Usuario;
import ejemplos.struts2.utilidades.UsuarioHabilitado;

public class InterAutenticacion implements Interceptor {

  public void destroy() { }
  public void init() { }
  public String intercept(ActionInvocation actionInvocation) throws Exception {
      Map session = actionInvocation.getInvocationContext().getSession();
      Usuario usuario = (Usuario) session.get("usuario");
      if (usuario == null) {
          return Action.LOGIN;
      } else {
          Action action = (Action) actionInvocation.getAction();
          if (action instanceof UsuarioHabilitado) {
              ((UsuarioHabilitado) action).setUsuario(usuario);
          }
          return actionInvocation.invoke();
      }
  }
}

Se hacen algunas cosas interesantes, la primera de ellas es que se toma la sesión y se verifica si ya existe una instancia de la clase Usuario, buscando al objeto referenciado por la cadena "usuario".

        Map session = actionInvocation.getInvocationContext().getSession();
      Usuario usuario = (Usuario) session.get("usuario");
      if (usuario == null) {

Si todo está bien y se hace una petición a una acción a la que el usuario tiene permiso, entonces pasamos la referencia del objeto usuario a la acción para que la pueda usar. Para eso tenemos que hacer que nuestras acciones implementen de UsuarioHabilitado.

            Action action = (Action) actionInvocation.getAction();
          if (action instanceof UsuarioHabilitado) {
              ((UsuarioHabilitado) action).setUsuario(usuario);
          }

Implementar de esta interfaz podría permitirnos hacer una validación adicional, para aseguramos que solo cuando nuestras clases implementen a UsuarioHabilitado podran ser llamadas, de lo contrario se cambia el flujo al formulario de entrada. En nuestro ejemplo solo sirve para pasar los datos del usuario a la acción.

La interfaz se muestra a continuación:

package ejemplos.struts2.utilidades;
import ejemplos.struts2.beans.Usuario;

public interface UsuarioHabilitado {
  public void setUsuario(Usuario usuario);
}

Para descargar UsuarioHabilitado.java

En donde se declara un solo método setUsuario y servirá para pasar la referencia del objeto usuario que le corresponda al usuario que esta haciendo la petición de datos.

Y eso es todo. Ya podemos echar a andar nuestro ejemplo, no olvides como siempre, verificar que las clases que hemos creado estén en los paquetes correctos y si vas a crear tus propias clases sin copiar el código, no olvides ser cuidadoso con los nombres de tus clases al crear los archivos de configuración de Struts2, ya que es muy común equivocarse con las mayusculas y las cosas tardan en funcionar.

Al correr el ejemplo y después de pasar por el formulario de username y password deberá aparecer lo siguiente

Despues das click en desplegar lista

¡Aparace la lista de usuarios!

Pero si intentas llamar a DesplegarLista desde el navegador sin haber pasado por el formulario de entrada de forma directa...

http://localhost:8080/Struts2Ejemplo2/DesplegarLista.action

Podras ver como el marco de trabajo te envía nuevamente al formulario de entrada

(Quiza deberás reiniciar el servidor web para observar esto)

Es el interceptor el que se encargará de redirigir al usuario al formulario de entrada.

Este es un ejemplo bastante simple como podras ver, los flujos de redirección de páginas dependerán mucho de como diseñes tu aplicación. Espero que este ejemplo te sirva para darte una idea de como hacerlo.

Todo el código lo podras descargar de aqui.

¡Listo! Eso es todo por el momento, espero que el ejemplo sea de utilidad. Hasta el próximo post.

2.1.- Primeros Pasos
2.2.- La configuración de struts.xml
2.3.- La clase Action que desplegará la lista
2.4.- El Interceptor y la sesión

1.1 - Ejemplo de Struts2, el hola mundo

2009-06-17T15:47:00.025-05:00

1.1.- Requisitos
1.2.- Crear el proyecto en NetBeans
1.3.- Configurar el proyecto para usar Struts 2
1.4.- La vista de nuestro proyecto
1.5.- La capa de negocios
1.6.- Ejecutar el proyecto

Struts 2 es un marco de trabajo (o framework en ingles) que ofrece muchas ventajas para desarrollar aplicaciones Web con Java y cuenta con nuevas características que facilitan el desarrollo aún mas que en la versión de Struts anterior. Haremos un ejemplo sencillo paso a paso de tal forma que puedas comenzar a trabajar con el marco de trabajo sin demasiada teoria.

Nuestro ejemplo de Struts2 será algo asi como el Hola Mundo, aunque no tan básico y lo haremos siguiendo estos pasos:

Requisitos

Utilizaremos la IDE de Sun Microsystems NetBeans 6.5.1 para hacer el ejemplo, si no lo tienes puedes descargar la última versión en el siguiente link: http://www.netbeans.org/downloads/index.html. Para evitarte problemas, baja la version completa, asi te aseguras que tiene lo necesario para crear tu proyecto Web. Cuando instales NetBeans, asegurate tambien de incluir Tomcat 6.x en la lista de servidores que puede manejar, ya que es con ese servidor web con el que haremos nuestro ejemplo

Deberás descargar de la pagina de Struts 2 las siguientes librerias

commons-fileupload-1.2.2.jar
commons-io-2.0.1.jar
commons-lang-2.5.jar
commons-logging-1.1.1.jar
freemarker-2.3.16.jar
javassist-3.11.0.GA.jar
ognl-3.0.1.jar
struts2-core-2.2.3.1.jar
xwork-core-2.2.3.1.jar

Las puedes obtener aqui: http://apache.mirrors.tds.net/struts/library/, toma en cuenta que estas librerias van actualizandose con el tiempo y las últiias versiones de estos archivos pueden cambiar, te recomiendo que bajes solo las Essential Dependencies que es un archivo comprimido que contienen solo las librerias de Struts2 necesarias. Es importante que bajes las versiones que vienen en estos paquetes, de lo contrario prodrias tener problemas de compatibilidad entre los mismos, este es un problema común al usar las librerias de Apache.

Essential Dependencies http://apache.webxcreen.org/struts/library/struts-2.2.3.1-lib.zip
Comencemos con nuestro Hola Mundo de Struts2, espero que les sea de utilidad.

1.1.- Requisitos
1.2.- Crear el proyecto en NetBeans
1.3.- Configurar el proyecto para usar Struts 2
1.4.- La vista de nuestro proyecto
1.5.- La capa de negocios
1.6.- Ejecutar el proyecto

1.2 - Ejemplo de Struts2, el hola mundo

2009-06-17T15:46:00.012-05:00

1.1.- Requisitos
1.2.- Crear el proyecto en NetBeans
1.3.- Configurar el proyecto para usar Struts 2
1.4.- La vista de nuestro proyecto
1.5.- La capa de negocios
1.6.- Ejecutar el proyecto

Crear el proyecto en NetBeans

Una vez instalado NetBeans, crea un nuevo proyecto Web con el nombre EjemploStruts2.

File>New Project>Java Web>Web Application

Cuando estes creando el proyecto usa un folder dedicado para almacenar tus librerias, habilita el checbox Use Dedicated Folder for Storing Libraries para almacenar mas tarde las librerias de Struts 2.

Selecciona Apache Tomcat 6.0.18 o la versión que esté disponible superior a la 6.

Esa es toda la configuración que necesitaremos, asi que puedes dar click al boton de finish al asistente de NetBeans.

Una vez hecho esto hay que crear la carpeta en la que alojaremos las librerias de Struts 2, te sugiero que lo llames Struts2. Aunque puedes mandar llamar las librerias desde donde quieras a veces es mejor poner todo lo necesario en la misma carpeta que tu proyecto y dejar que NetBeans las ponga en el lugar correcto.

Despues de creado el proyecto, importa las librerias dandole click derecho a la carpeta de proyecto, despues en propiedades, librerias y por último selecciona los archivos de Struts donde las hayas despositado y agregalos.

1.1.- Requisitos
1.2.- Crear el proyecto en NetBeans
1.3.- Configurar el proyecto para usar Struts 2
1.4.- La vista de nuestro proyecto
1.5.- La capa de negocios
1.6.- Ejecutar el proyecto

1.3 - Ejemplo de Struts2, el hola mundo

2009-06-17T15:45:00.013-05:00

1.1.- Requisitos
1.2.- Crear el proyecto en NetBeans
1.3.- Configurar el proyecto para usar Struts 2
1.4.- La vista de nuestro proyecto
1.5.- La capa de negocios
1.6.- Ejecutar el proyecto

Configurar el proyecto para usar Struts 2

Al crear tu proyecto en NetBeans, se creará por default un archivo web.xml que tendremos que modificar para agregar el filtro mediante el cual se gestionarán las peticiones a Struts 2. Estas son las lineas que te permitirán hacer dar de alta el filtro:

<filter>
   <filter-name>struts2</filter-name>
   <filter-class>org.apache.struts2.dispatcher.FilterDispatcher</filter-class>
</filter>
<filter-mapping>
   <filter-name>struts2</filter-name>
   <url-pattern>/*</url-pattern>
</filter-mapping>

Puedes descargar el archivo web.xml, pero trata de modifcarlo directamente en tu proyecto.

Otro archivo que será necesario crear es struts.xml, este archivo es uno de los mas importantes para el marco de trabajo de Struts 2. Lo debes crear en el paquete default del proyecto.

<!DOCTYPE struts PUBLIC "-//Apache Software Foundation//DTD Struts Configuration 2.0//EN" "http://struts.apache.org/dtds/struts-2.0.dtd">
<struts>
   <constant name="struts.enable.DynamicMethodInvocation" value="false" />
   <constant name="struts.devMode" value="false" />

   <package name="default" namespace="/" extends="struts-default">

   //Declaracion de Acciones

   </package>
</struts>

Como podras ver le aún le faltan algunas cosas al archivo, pero lo completaremos a continuación.

1.1.- Requisitos
1.2.- Crear el proyecto en NetBeans
1.3.- Configurar el proyecto para usar Struts 2
1.4.- La vista de nuestro proyecto
1.5.- La capa de negocios
1.6.- Ejecutar el proyecto

1.4 - Ejemplo de Struts2, el hola mundo

2009-06-17T15:44:00.018-05:00

1.1.- Requisitos
1.2.- Crear el proyecto en NetBeans
1.3.- Configurar el proyecto para usar Struts 2
1.4.- La vista de nuestro proyecto
1.5.- La capa de negocios
1.6.- Ejecutar el proyecto

La vista de nuestro proyecto

Lo primero que haremos será modificar el archivo index.jsp

<%@page contentType="text/html" pageEncoding="UTF-8"%>
<%@ taglib prefix="s" uri="/struts-tags" %>
<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN"
   "http://www.w3.org/TR/html4/loose.dtd">
  
<html>
   <head>
       <meta http-equiv="Content-Type" content="text/html; charset=UTF-8">
       <title>Ejemplos con Struts 2</title>
   </head>
   <body>
       <h1>Pagina de Inicio</h1>
       <s:a href="FormularioEntrada.action">Formulario Entrada</s:a>
   </body>
</html>

En este archivo jsp estamos incluyendo una linea que hace uso de las etiquetas de Struts2.

<s:a href="FormularioEntrada.action">Formulario Entrada</s:a>

Esta etiqueta hace referencia a nuestra primera acción y solo se encarga de llamar al formulario de login y password. Asi que también tendremos que modificar el archivo struts.xml para que haga correctamente esta petición.

Para descargar el archivo da click aqui: index.jsp

Entre las etiquetas del paquete default de struts.xml deberás insertar las siguientes lineas:

        <action name="FormularioEntrada">
           <result>/formularioEntrada.jsp</result>
       </action>

Como te habrás dado cuenta nos hace falta crear el jsp donde se encuentra el formulario de entrada o de login y password.

<%@page contentType="text/html" pageEncoding="UTF-8"%>
<%@ taglib prefix="s" uri="/struts-tags" %>
<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN"
   "http://www.w3.org/TR/html4/loose.dtd">

<html>
   <head>
       <title>Ejemplos con Struts 2</title>
       <link href="<s:url value="/css/main.css"/>" rel="stylesheet" type="text/css"/>
   </head>
   <body>
       <s:form action="Entrar" namespace="/" method="POST">
           <tr>
               <td colspan="2">Introduzca su login y su password</td>
           </tr>
           <tr>
               <td colspan="2">
                   <s:actionerror />
                   <s:fielderror />
               </td>
           </tr>
           <s:textfield name="usr" label="Username"/>
           <s:password name="pas" label="Password"/>
           <s:submit value="Login" align="center"/>
       </s:form>
   </body>
</html>

Para descargar el archivo `a click aqui: formularioEntrada.jsp

Tambien necesitaremos nuestra página de bienvenida para el usuario que entra con sus datos correctos.

<%@page contentType="text/html" pageEncoding="UTF-8"%>
<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN"
  "http://www.w3.org/TR/html4/loose.dtd">

<html>
   <head>
       <meta http-equiv="Content-Type" content="text/html; charset=UTF-8">
       <title>Pagina de Bienvenida</title>
   </head>
   <body>
       <h1>Bienvenido, has entrado al sistema!</h1>
   </body>
</html>

Para descargar el archivo da click aqui: paginaBienvenida.jsp

El archivo formularioEntrada.jsp contiene mas etiquetas de Struts2, la etiqueta form, hace petición a la accion Entrar, misma que deberemos declarar en nuestro archivo struts.xml nuevamente.

        <action name="Entrar" class="ejemplos.struts2.action.AccionEntrar">
           <result name="input">/formularioEntrada.jsp</result>
           <result name="error">/formularioEntrada.jsp</result>
           <result>/paginaBienvenida.jsp</result>
       </action>

Con estas declaraciones estamos diciendo al marco de trabajo cual es la clase que se encargará de atender la peticion Entrar y también estamos definiendo cual será el flujo de trabajo que deberá seguir en caso de que la petición sea exitosa o que suceda un error.

Con la creación de estas páginas nuestro archivo de configuración de Struts debe ser modificado nuevamente para que puedan ser llamadas desde una acción:

&ht;!DOCTYPE struts PUBLIC "-//Apache Software Foundation//DTD Struts Configuration 2.0//EN" "http://struts.apache.org/dtds/struts-2.0.dtd">
<struts>
   <constant name="struts.enable.DynamicMethodInvocation" value="false" />
   <constant name="struts.devMode" value="false" />

   <package name="default" namespace="/" extends="struts-default">
       <action name="FormularioEntrada">
           <result>/formularioEntrada.jsp</result>
       </action>
       <action name="Entrar" class="ejemplos.struts2.action.AccionEntrar">
           <result name="input">/formularioEntrada.jsp</result>
           <result name="error">/formularioEntrada.jsp</result>
           <result>/paginaBienvenida.jsp</result>
       </action>
   </package&ct;
</struts>

Descarga struts.xml

1.1.- Requisitos
1.2.- Crear el proyecto en NetBeans
1.3.- Configurar el proyecto para usar Struts 2
1.4.- La vista de nuestro proyecto
1.5.- La capa de negocios
1.6.- Ejecutar el proyecto

1.5 - Ejemplo de Struts2, el hola mundo

2009-06-17T15:43:00.011-05:00

1.1.- Requisitos
1.2.- Crear el proyecto en NetBeans
1.3.- Configurar el proyecto para usar Struts 2
1.4.- La vista de nuestro proyecto
1.5.- La capa de negocios
1.6.- Ejecutar el proyecto

La Capa de Negocios

Como habrás podido ver aún nos falta definir una parte importante en el proyecto y es la clase que se encargará de atender la petición del formulario de entrada. Para eso usaremos la siguiente clase:

package ejemplos.struts2.action;
import ejemplos.struts2.beans.Usuario;
import java.util.Map;
import com.opensymphony.xwork2.ActionSupport;
import org.apache.struts2.interceptor.SessionAware;

public class AccionEntrar extends ActionSupport implements SessionAware{
   private Map session;
   private String mensajeError;
   private String usr;
   private String pas;

   public String execute() throws Exception {
      
       if (getUsr() != null && getPas() != null){    //Verificamos que los datos no sean nulos

           Usuario usuario = null;
           // Aqui haremos como que buscamos a nuestro usuario en la base de datos.
           // Si el login y password coinciden normalmente devolveriamos una instancia
           // de usuario con los datos de la cuenta
           // Esto normalmente no se haria en esta capa de codigo!
               if(getUsr().equals("user") && getPas().equals("123")){
                   usuario = new Usuario();
                   usuario.setId(1l);
                   usuario.setNombre("Invitado");
                   usuario.setLogin("user");
                   usuario.setPassword("123");
               }
           //Fin de busqueda

           if(usuario != null){    //Si el usuario se encuentra se agrega a la sesion
               session.put("usuario",usuario);
           }else{                    //Si no se encuentra se devuelve un error
               addActionError("No existe esta cuenta");
               setMensajeError("No existe esta cuenta");
               return ERROR;
           }
       } else {
           addActionError("Inserte datos correctos");
           setMensajeError("Inserte datos correctos");
           return ERROR;
       }
       return SUCCESS;
   }


   public Map getSession() {
       return session;
   }
   public void setSession(Map session) {
       this.session = session;
   }
   public String getUsr() {
       return usr;
   }
   public void setUsr(String usr) {
       this.usr = usr;
   }
   public String getPas() {
       return pas;
   }
   public void setPas(String pas) {
       this.pas = pas;
   }
   public void setMensajeError(String mensajeError) {
       this.mensajeError = mensajeError;
   }
}

descargar: AccionEntrar.java

Hay muchas cosas que aprender de la clase AccionEntrar, sin embargo por el momento solo comentaremos que, entre otras cosas, se encarga de manejar los parametros de entrada del formulario y si son validos los datos, de redirigir al usuario a una página de bienvenida o si no de regresarlo nuevamente al formulario de entrada.

Necesitamos una clase mas, que nos permitirá guardar y controlar la sesión en nuestro proyecto. Aunque en este ejemplo no tiene mayor efecto.

package ejemplos.struts2.beans;
public class Usuario {
   private Long id;
   private String nombre;
   private String login;
   private String password;

   public Long getId() {
       return id;
   }
   public void setId(Long id) {
       this.id = id;
   }
   public String getNombre() {
       return nombre;
   }
   public void setNombre(String nombre) {
       this.nombre = nombre;
   }
   public String getLogin() {
       return login;
   }
   public void setLogin(String login) {
       this.login = login;
   }
   public String getPassword() {
       return password;
   }
   public void setPassword(String password) {
       this.password = password;
   }
}

descargar: Usuario.java

La clase Usuario solo tiene sentido si consideras en un futuro el uso de sesiones para restringir el acceso a páginas privadas y que requieran autenticación. Por el momento no tiene mayor efecto.

No olvides depositar a cada clase en su paquete correspondiente.

1.1.- Requisitos
1.2.- Crear el proyecto en NetBeans
1.3.- Configurar el proyecto para usar Struts 2
1.4.- La vista de nuestro proyecto
1.5.- La capa de negocios
1.6.- Ejecutar el proyecto

1.6 - Ejemplo de Struts2, el hola mundo

2009-06-17T15:39:00.013-05:00

1.1.- Requisitos
1.2.- Crear el proyecto en NetBeans
1.3.- Configurar el proyecto para usar Struts 2
1.4.- La vista de nuestro proyecto
1.5.- La capa de negocios
1.6.- Ejecutar el proyecto

Ejecutar el proyecto

Ya tenemos todo lo necesario para correr nuestro primer ejemplo, esta es una vista final de como quedarian nuestros archivos en el proyecto de NetBeans:

Ahora solo tienes que dar un click derecho en la carpeta de proyecto y darle otro click a la opción de correr o "Run"

En nuestro navegador se desplegará la siguiente pantalla

Si le damos a la liga para ir al formulario de entrada en nuestro navegador aparecerá lo siguiente:

Si se ponen datos incorrectos en el formulario de login, el framework se engargará de gestionar la petición y nos enviará a la pantalla de error gracias al flujo que hemos definido en el archivo de struts.xml y al manejo de los datos que hace nuestra clase AccionEntrar.java

Si se introducen los datos correctos, una pantalla de bienvenida se desplegará.

¡Listo! Ya tenemos nuestro primer ejemplo terminado.

Struts2 provee a los desarrolladores de herramientas muy poderosas para facilitar su trabajo, algunas de ellas son los interceptores, que te permiten hacer muchas cosas que normalmente se tenian que programar enteramente en Struts1, por ejemplo, el manejo de la session para usuarios con permisos o la carga de archivos desde el cliente. Los interceptores son una pieza fundamental en este marco de trabajo y haremos algunos ejemplos mas adelante.

Por el momento es todo, espero que este pequeño ejemplo les sirva para familiarizarse con Struts2. Hasta el siguiente post

1.1.- Requisitos
1.2.- Crear el proyecto en NetBeans
1.3.- Configurar el proyecto para usar Struts 2
1.4.- La vista de nuestro proyecto
1.5.- La capa de negocios
1.6.- Ejecutar el proyecto