2.1 – Manejo de Sesión en Struts2

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

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

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

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.

(function(d, s, id) {
var js, fjs = d.getElementsByTagName(s)[0];
if (d.getElementById(id)) {return;}
js = d.createElement(s); js.id = id;
js.src = «//connect.facebook.net/en_US/all.js#xfbml=1»;
fjs.parentNode.insertBefore(js, fjs);
}(document, ‘script’, ‘facebook-jssdk’));

 

¡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

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.

 

Puedes seguir los pasos de este ejemplo divido en cinco post o también puedes ver el video para darte una mejor idea de como está organizado el proyecto.

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

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

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

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

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

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