- Struts 2 con anotaciones sin Maven

En este tutorial describiré los pasos necesarios para realizar un proyecto Struts 2 con anotaciones sin la herramienta de gestión y construcción MAVEN, lo cual quiere decir que obtendremos nosotros mismos las librerías necesarias para nuestros proyecto así como configuraremos nuestro entorno de desarrollo para que todos los componentes sean tomadas correctamente en nuestra aplicación. Ademas usaremos anotaciones lo cual quiere decir que no configuraremos el comportamiento de nuestra aplicación a través del fichero struts.xml.

Introducción a Struts 2

Es un framework en JAVA que se usa para realizar proyectos MVC que básicamente es un patrón de arquitectura Modelo - Vista - Controlador cuyos componentes están definidos de la siguiente manera:

Figura 1.1 – P.S Imagen copiada de  : javatutoriales

1. Inicialmente nuestra página realiza la petición HTTP a nuestro Filter Dispatcher.
2. El Filter Dispatcher envía los datos a los interceptores para que estos puedan realizar las respectivas validaciones con respecto a la data que estamos enviando.
3. Los interceptores una vez que hayan validado la información de la data enviada procederán a invocar al Action.
4. Se invoca al Action respectivo según la configuración que en el Filter Dispatcher el cual se encargará de realizar la lógica respectiva ya sea de procesar una información y/o devolver algún dato necesario.
5. Una vez terminado el trabajo del Action devolverá la información requerida al result para que posteriormente el Filter Dispatcher sepa cual será el siguiente paso ya sea un jsp o otro Action.
6. Los resultados serán validados por los interceptores.
7. Los interceptores envían el resultado al Filter Dispatcher.
8. El Filter Dispatcher envía el resultado ya sea vía WEB para que el usuario lo visualice o lo redirigirá a otra Acción.

Para este proyecto vamos a usar anotaciones lo cual quiere decir que no crearemos el fichero struts.xml y la configuración de los action las realizaremos dentro de cada acción (método). Esto nos lo permite la librería struts2-convention-plugin. donde se encuentras los componentes que necesitamos para hacerlo. Con respecto a su uso, es de diferentes gustos, personalmente me agrada mas puesto que me confundo menos al crear una nueva acción y ya lo puedo configurar dentro de su propio método, sin embargo algunos veteranos de struts no están muy de acuerdo, es simplemente cuestión de gustos. 

Proyecto en Struts 2

1. Eclipse Kepler
2. Apache Tomcat 7.0
3. Librerías Struts 2

Como indiqué anteriormente no explicaré como se realiza la instalación del Eclipse con su respectivo JDK ni el Tomcat por lo que se asume que ya tenéis el entorno instalado.

Primero que todo creamos un proyecto WEB en el eclipse: File -> New -> Dynamic Web Project
y el siguiente nombre al proyecto ProyectoStruts2AnotacionesTutorial y a continuación Finish para crear el proyecto tal como podemos verlo en la imagen:

A continuación creamos en /ProyectoStruts2AnotacionesTutorial/src los siguientes paquetes:

1. com.victor.elliott.humala.action
2. com.victor.elliott.humala.formulario
3. com.victor.elliott.humala.dao

Luego creamos las siguientes clases en los paquetes respectivos

1. com.victor.elliott.humala.action->  UsuarioAction.java
2. com.victor.elliott.humala.action  ->  ComponenteAction.java
3. com.victor.elliott.humala.formulario -> UsuarioForm.java
4. com.victor.elliott.humala.formulario -> ComponenteForm.java
5. com.victor.elliott.humala.dao-> ComponenteDAO.java
6. com.victor.elliott.humala.dao-> ComponenteDAOImpl.java

Una vez creadas las clases creamos las paginas y xml's respectivos.

1. Creamos primero que todo la carpeta jsp en /ProyectoStruts2AnotacionesTutorial/WebContent/
2. Creamos index.jsp en /ProyectoStruts2AnotacionesTutorial/WebContent
3. Creamos login.jsp en /ProyectoStruts2AnotacionesTutorial/WebContent/jsp
4. Creamos agregarComponentes.jsp en /ProyectoStruts2AnotacionesTutorial/WebContent/jsp
5. Creamos mostrarComponentes.jsp en /ProyectoStruts2AnotacionesTutorial/WebContent/jsp
6. Creamos web.xml en /ProyectoStruts2AnotacionesTutorial/WebContent/WEB-INF

Una vez creadas nuestras clases, paginas y componentes que usaremos, la estructura de proyecto debe de quedar de la siguiente manera:

Ahora que ya tenemos casi todos los elementos necesarios para empezar a desarrollar nuestro proyecto haremos la configuración con Struts2 para empezar a usar el framework sin errores y para esto primero bajemos las librerías necesarias que os la podéis descargar desde el siguiente link:

1. Librerías Struts 2

Una vez descargado lo descomprimimos y lo añadiremos a nuestro proyecto de la siguiente manera:

Click derecho en ProyectoStruts2AnotacionesTutorial-> Properties -> Java Build Path -> Libraries -> Add Library -> User Library -> Next -> User Libraries -> New  y a continuación escriben Struts2 y OK que sera el nombre de la librería, inmediatamente sin salir de la ventana presionamos Add External JARs vamos a la carpeta donde descomprimimos las librerías, seleccionamos todos los jars presionamos Abrir y finalmente OK. Saliendo de esa ventana pondremos Finish y ya tendremos nuestras librerías de Struts2 agregadas al proyecto tal como se muestra:

Por ultimo tendremos que hacer que las librerías tengan efecto inmediato en todas las clases de nuestro proyecto y que no haya problemas de compilación ni de ejecución:

Click derecho en ProyectoStruts2AnotacionesTutorial -> Deployment Assembly -> Add seleccionamos la librería Struts 2 y OK y quedará tal como se muestra en la imagen.

Ahora si podemos empezar a codificar nuestro proyecto. Primero que todo modificamos com.victor.elliott.humala.formulario.UsuarioForm que básicamente contendrá los atributos nombre y clave sus getter y setter respectivos y dos constructores.

package com.victor.elliott.humala.formulario;

public class UsuarioForm{

 private String nombre;
 private String clave;
 
 
 public UsuarioForm(){
  this.nombre = "";
  this.clave = "";
 }
 public UsuarioForm(String nombre, String clave){
  this.nombre = nombre;
  this.clave = clave;
 }
 public String getNombre() {
  return nombre;
 }
 public void setNombre(String nombre) {
  this.nombre = nombre;
 }
 public String getClave() {
  return clave;
 }
 public void setClave(String clave) {
  this.clave = clave;
 }
}

Ahora modificamos com.victor.elliott.humala.action.UsuarioAction de la siguiente manera:

package com.victor.elliott.humala.action;

import com.victor.elliott.humala.formulario.UsuarioForm;
import com.opensymphony.xwork2.ActionSupport;
import org.apache.struts2.convention.annotation.Action;
import org.apache.struts2.convention.annotation.Result;

public class UsuarioAction extends ActionSupport{
  
 private static final long serialVersionUID = 1L;
  //Con esto indicamos que nuestro Usuario y clave seran Usuario y Clave respectivamente
     private static UsuarioForm usuario = new UsuarioForm("Victor","Elliott");
     private UsuarioForm usuarioForm;
     //private static ComponenteForm componenteForm = new ComponenteForm();     

  @Action( value="LOGIN", results= {
     @Result(name=SUCCESS, type="dispatcher", location="/jsp/login.jsp") } )
  public String inicializarUsuario() {
   
   //usuarioForm=new UsuarioForm();
      System.out.println("Si hemos llegado aqui quiere decir que la pagina index.jsp ha invocado a este metodo inicializarUsuario");
      addActionMessage("Ingrese Usuario");
      return SUCCESS;
     }
 
     @Action( value="verificarUsuarioAccion", results= {
        @Result(name=SUCCESS, type="dispatcher", location="/jsp/agregarComponentes.jsp"), 
        @Result(name=ERROR, type="dispatcher", location="/jsp/login.jsp") } )    
     public String verificarUsuario() {
         String mensaje=null;
      System.out.println("Si hemos llegado aqui quiere decir que la pagina login.jsp ha invocado a este metodo verificarUsuario");
      if("".equals(usuarioForm.getNombre())||"".equals(usuarioForm.getClave())){
        System.out.println("Se coloco el usuario y clave vacios");
        mensaje="Debe de llenar los campos de Usuario y Clave";
        addActionError(mensaje);
        return ERROR;
      }
      else if(usuario.getNombre().equals(UsuarioAction.usuario.getNombre())&&usuarioForm.getClave().equals(UsuarioAction.usuario.getClave())){
       System.out.println("Se coloco al usuario y clave correctamente y va a la pagina de agregarComponentes");
       addActionMessage("Usuario Correcto: "+usuarioForm.getNombre());
       return SUCCESS;
      }
      else{
       System.out.println("Se coloco al usuario y clave incorrectamente y regresamos a la pagina de login con el mensaje de Usuario Incorrecto");
       mensaje="Usuario Incorrecto";
       addActionError(mensaje);
       return ERROR;
      }
     }

     public UsuarioForm getUsuarioForm() {
   return usuarioForm;
  }

  public void setUsuarioForm(UsuarioForm usuarioForm) {
   this.usuarioForm = usuarioForm;
  }

}

Ahora describo rápidamente el action:

1. Todos los import son importantes puesto que son las librerías de Struts 2 que necesitamos para desarrollarlo. 
2. Definimos el atributo UsuarioForm usuario para que guarde el usuario y clave a validar en el login.
3. Definimos el atributo UsuarioForm usuarioForm con sus respectivos getter y setter para obtener el formulario del usuario desde la página de login.
4. Aquí están las anotaciones y vamos a indicar que el método (inicializarUsuario) que vamos a definir en el siguiente punto se trata de un una acción (@Action) que la podremos invocar desde un jsp u otra acción a partir de su alias (LOGIN) y los posibles resultados de esta acción en este caso solo sera un (SUCCESS) que me envía a la página login.jsp.
5. Definimos el método inicializarUsuario que será invocado desde el Filter Dispatcher donde devolveremos el único mensaje de texto que me pida ingresar los datos del usuario y el result será SUCCESS. El Filter Dispatcher a partir de este resultado me enviará a la pagina de login respectiva.
6. Definimos anotaciones y vamos a indicar que el método (verificarUsuario) que vamos a definir en el siguiente punto se trata de un una acción (@Action) que la podremos invocar desde un jsp u otra acción a partir de su alias (verificarUsuarioAccion) y los posibles resultados de esta acción serán (SUCCESS) que me envía a la página agregarComponentes.jsp, (ERROR) que me envía a la página login.jsp. 
7. Definimos el método verificarUsuario que será invocado desde el Filter Dispatcher donde validaremos que los datos obtenidos del formulario UsuarioForm usuarioForm son correctos a partir de UsuarioForm usuario.En caso de que los datos estén vacios o no coincidan con el usuario devolvere el mensaje addActionError respectivo y retornare el result como ERROR. Caso contrario devolveré el mesaje de éxito addActionMessage y retornaré el result como SUCCESS. El Filter Dispatcher a partir de este resultado me enviará a la pagina respectiva.

Ahora modificamos nuestros jsp:
/ProyectoStruts2AnotacionesTutorial/WebContent/index.jsp:

<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.0 Transitional//EN">
<html>
<head>
    <META HTTP-EQUIV="Refresh" CONTENT="0;URL=LOGIN.action">
</head>
<body>
<p>El proyecto se esta cargando, espere un segundo</p>
</body>
</html>

Donde básicamente redireccionamos esta página a través la etiqueta META al action respectivo que será recibido por el Filter Dispatcher.

/ProyectoStruts2AnotacionesTutorial/WebContent/jsp/login.jsp

<%@ page language="java" contentType="text/html; charset=ISO-8859-1"
    pageEncoding="ISO-8859-1"%>
<%@taglib uri="/struts-tags" prefix="s"%> 
<!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=ISO-8859-1">
<title>Proyecto Struts 2 Tutorial by Victor Elliott Humala</title>
</head>
<body>
<s:if test="hasActionErrors()">
   <div class="errors">
      <s:actionerror/>
   </div>
</s:if>
  
<s:form id="login" method="post" action="verificarUsuarioAccion">
  <s:textfield  name="usuarioForm.nombre" label="Nombre"/>
  <s:textfield  name="usuarioForm.clave" label="Clave"/>
  <s:submit id="submit" value="Login" />
</s:form>

</body>
</html>

1. Declaramos la librería para nuestros tags de struts "struts-tags"
2. Preguntamos si exísten errores hasActionErrors y si es asi mostramos el mensaje de error actionerror que definimos en el action respectivo.
3. Finalmente agregamos un form para que puedas llenarse los datos necesarios del usuario (usuarioForm) y al hacer submit vaya al action respectivo verificarUsuarioAction que lo recibirá el Filter Dispatcher.

/ProyectoStruts2AnotacionesTutorial/WebContent/jsp/agregarComponentes.jsp

<%@ page language="java" contentType="text/html; charset=ISO-8859-1"
    pageEncoding="ISO-8859-1"%>
<%@taglib uri="/struts-tags" prefix="s"%> 
<!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=ISO-8859-1">
<title>Agregar Componentes</title>
</head>
<body>
<s:if test="hasActionMessages()">
   <div class="welcome">
      <s:actionmessage />
   </div>
</s:if>
</body>
</html>

1. En esta página por ahora solo mostraremos la bienvenida al usuario donde al hacer hasActionMessage preguntamos si existe algun mensaje de exito recibido y si es así el caso mostramos el mensaje actionmessage.

Ahora modifiquemos nuestros ficheros de configuración xml:

/ProyectoStruts2AnotacionesTutorial/WebContent/WEB-INF/web.xml

<?xml version="1.0" encoding="UTF-8"?>
<web-app xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns="http://java.sun.com/xml/ns/javaee" xmlns:web="http://java.sun.com/xml/ns/javaee/web-app_2_5.xsd" xsi:schemaLocation="http://java.sun.com/xml/ns/javaee http://java.sun.com/xml/ns/javaee/web-app_2_5.xsd" id="WebApp_ID" version="2.5">
  <display-name>ProyectoStruts2AnotacionesTutorial</display-name>
  <filter>
  <filter-name>struts2</filter-name>
  <filter-class>
   org.apache.struts2.dispatcher.ng.filter.StrutsPrepareAndExecuteFilter</filter-class>
 </filter>
 <filter-mapping>
  <filter-name>struts2</filter-name>
  <url-pattern>/*</url-pattern>
 </filter-mapping>

 <welcome-file-list>
  <welcome-file>index.jsp</welcome-file>
 </welcome-file-list>
</web-app>

Con esto estamos indicandole a nuestro descriptor de despliegue que vamos a trabajar con el framework de struts2.

Ahora ya estamos listos para ejecutar nuestro proyecto en el servidor Tomcat, antes de ello verificar que no haya ningún error de compilación y una vez ejecutado en el servidor ningún error de ejecución. Si todo esta bien podrán visualizar las siguientes páginas:

Ahora continuo con la segunda parte del tutorial.

Una vez que ya tenemos el login realizado, nos disponemos a crear una lista de componentes que cargaremos una a una para luego poder verlas todas juntas.

Modificamos:

/ProyectoStruts2AnotacionesTutorial/src/com/victor/elliott/humala/dao/ComponenteDAO.java

package com.victor.elliott.humala.dao;

import com.victor.elliott.humala.formulario.ComponenteForm;
import java.util.List;

public interface ComponenteDAO {
 public void addComponente(ComponenteForm componente);
 public List<ComponenteForm> getComponente();
}

Aqui simplemente estamos creando un DAO de tipo Interface donde solo declaramos dos métodos addComponente para agregar el componente y getComponente para recuperar todos los componentes.
Ahora creamos su implementación respectiva modificando:

/ProyectoStruts/src/com/victor/elliott/humala/dao/ComponenteDAOImpl.java

package com.victor.elliott.humala.dao;

import java.util.ArrayList;
import java.util.List;
import com.victor.elliott.humala.formulario.ComponenteForm;

public class ComponenteDAOImpl implements ComponenteDAO {
 private static List<ComponenteForm> listaComponentes=new ArrayList<ComponenteForm>();
 @Override
 public void addComponente(ComponenteForm componente) {
  listaComponentes.add(componente);
 }

 @Override
 public List<ComponenteForm> getComponente() {
  return listaComponentes;
 }
}

De esta forma implementamos los métodos de la interface primero declarando un atributo estático List<ComponenteForm> listaComponentes que me guardará todos los datos que ingrese en mi lista y no se perderá y luego con los metodos addComponente agrego un componente a la lista y con getComponente recupero toda la lista estática.
En consiguiente modificamos la clase:

/ProyectoStruts2AnotacionesTutorial/src/com/victor/elliott/humala/formulario/ComponenteForm.java

package com.victor.elliott.humala.formulario;

public class ComponenteForm {
 private String nombre;
 private String version;
 private String tipo;
 private String extension;
 
 public String getNombre() {
  return nombre;
 }
 public void setNombre(String nombre) {
  this.nombre = nombre;
 }
 public String getVersion() {
  return version;
 }
 public void setVersion(String version) {
  this.version = version;
 }
 public String getTipo() {
  return tipo;
 }
 public void setTipo(String tipo) {
  this.tipo = tipo;
 }
 public String getExtension() {
  return extension;
 }
 public void setExtension(String extension) {
  this.extension = extension;
 }

}

Clase que contiene todos los datos que deseo guardar de un componente. Finalmente modifico los action:

/ProyectoStruts2AnotacionesTutorial/src/com/victor/elliott/humala/action/UsuarioAction.java

package com.victor.elliott.humala.action;

import com.victor.elliott.humala.formulario.UsuarioForm;

import java.util.Map;
import org.apache.struts2.convention.annotation.Action;
import org.apache.struts2.convention.annotation.Result;
import org.apache.struts2.interceptor.SessionAware;
import com.opensymphony.xwork2.ActionSupport;

public class UsuarioAction extends ActionSupport implements SessionAware{
  
 private static final long serialVersionUID = 1L;
  //Con esto indicamos que nuestro Usuario y clave seran Usuario y Clave respectivamente
     private static UsuarioForm usuario = new UsuarioForm("Victor","Elliott");
     private UsuarioForm usuarioForm;
     private Map<String, Object> sesion;
     //private static ComponenteForm componenteForm = new ComponenteForm();     

      @Action( value="LOGIN", results= {
        @Result(name=SUCCESS, type="dispatcher", location="/jsp/login.jsp") } )
  public String inicializarUsuario() {
   
   //usuarioForm=new UsuarioForm();
      System.out.println("Si hemos llegado aqui quiere decir que la pagina index.jsp ha invocado a este metodo inicializarUsuario");
      addActionMessage("Ingrese Usuario");
      return SUCCESS;
     }
      @Action( value="verificarUsuarioAccion", results= {
        @Result(name=SUCCESS, type="dispatcher", location="/jsp/agregarComponentes.jsp"), 
        @Result(name=ERROR, type="dispatcher", location="/jsp/login.jsp") } )     
     public String verificarUsuario() {
         String mensaje=null;
      System.out.println("Si hemos llegado aqui quiere decir que la pagina login.jsp ha invocado a este metodo verificarUsuario");
      if("".equals(usuarioForm.getNombre())||"".equals(usuarioForm.getClave())){
        System.out.println("Se coloco el usuario y clave vacios");
        mensaje="Debe de llenar los campos de Usuario y Clave";
        addActionError(mensaje);
        return ERROR;
      }
      else if(usuario.getNombre().equals(UsuarioAction.usuario.getNombre())&&usuarioForm.getClave().equals(UsuarioAction.usuario.getClave())){
       System.out.println("Se coloco al usuario y clave correctamente y va a la pagina de agregarComponentes");
       sesion.put("usuarioForm", usuarioForm);
       addActionMessage("Usuario Correcto: "+usuarioForm.getNombre());
       return SUCCESS;
      }
      else{
       System.out.println("Se coloco al usuario y clave incorrectamente y regresamos a la pagina de login con el mensaje de Usuario Incorrecto");
       mensaje="Usuario Incorrecto";
       addActionError(mensaje);
       return ERROR;
      }
     }

  public Map<String, Object> getSession() {
   return sesion;
  }

  public void setSession(Map<String, Object> sesion) {
   this.sesion = sesion;
  }

     public UsuarioForm getUsuarioForm() {
   return usuarioForm;
  }

  public void setUsuarioForm(UsuarioForm usuarioForm) {
   this.usuarioForm = usuarioForm;
  }

}

1. Todos los import son importantes puesto que son las librerías de Struts 2 que necesitamos para desarrollarlo. 
2. Implementamos la clase SessionAware donde sobrescribiremos su método setSession(Map<String, Object> sesion). Esta implementación nos sirve para poder guardar el usuarioForm en la sesion y no perderla cuando cambiemos de paginas haciendo request. 
3. Definimos el atributo UsuarioForm usuario para que guarde el usuario y clave a validar en el login.
4. Definimos el atributo UsuarioForm usuarioForm con sus respectivos getter y setter para obtener el formulario del usuario desde la página de login.
5. Definimos el atributo Map<String, Object> sesion donde pondremos los datos que necesitemos para que se guarde en la sesion.
6. Aquí están las anotaciones y vamos a indicar que el método (inicializarUsuario) que vamos a definir en el siguiente punto se trata de un una acción (@Action) que la podremos invocar desde un jsp u otra acción a partir de su alias (LOGIN) y los posibles resultados de esta acción en este caso solo sera un (SUCCESS) que me envía a la página login.jsp.
7. Definimos el método inicializarUsuario que será invocado desde el Filter Dispatcher donde devolveremos el único mensaje de texto que me pida ingresar los datos del usuario y el result será SUCCESS. El Filter Dispatcher a partir de este resultado me enviará a la pagina de login respectiva.
8. Definimos anotaciones y vamos a indicar que el método (verificarUsuario) que vamos a definir en el siguiente punto se trata de un una acción (@Action) que la podremos invocar desde un jsp u otra acción a partir de su alias (verificarUsuarioAccion) y los posibles resultados de esta acción serán (SUCCESS) que me envía a la página agregarComponentes.jsp, (ERROR) que me envía a la página login.jsp. 
9. Definimos el método verificarUsuario que será invocado desde el Filter Dispatcher donde validaremos que los datos obtenidos del formulario UsuarioForm usuarioForm son correctos a partir de UsuarioForm usuario.En caso de que los datos estén vacios o no coincidan con el usuario devolvere el mensaje addActionError respectivo y retornare el result como ERROR. Caso contrario devolveré el mesaje de éxito addActionMessage y retornaré el result como SUCCESS. El Filter Dispatcher a partir de este resultado me enviará a la pagina respectiva. Como poderis apreciar en el caso de SUCCESS estamos guardando el formulario del usuario ingresado sesion.put("usuarioForm", usuarioForm); ya que nos interesa su información una vez ingrese al login.

/ProyectoStruts2AnotacionesTutorial/src/com/victor/elliott/humala/action/ComponenteAction.java

package com.victor.elliott.humala.action;


import java.util.List;
import java.util.Map;

import org.apache.struts2.convention.annotation.Action;
import org.apache.struts2.convention.annotation.Result;
import com.opensymphony.xwork2.ActionContext;
import com.opensymphony.xwork2.ActionSupport;
import com.victor.elliott.humala.formulario.ComponenteForm;
import com.victor.elliott.humala.formulario.UsuarioForm;
import com.victor.elliott.humala.dao.ComponenteDAO;
import com.victor.elliott.humala.dao.ComponenteDAOImpl;



public class ComponenteAction extends ActionSupport{
 private static final long serialVersionUID = 1L;
 private ComponenteDAO componenteDAO= new ComponenteDAOImpl();
 private ComponenteForm componenteForm;
 private List<ComponenteForm> componenteLista;
 
 String mensaje=null;
 
 @Action( value="agregarComponentesAccion", results= {
   @Result(name=SUCCESS, type="dispatcher", location="/jsp/mostrarComponentes.jsp"), 
   @Result(name=ERROR, type="dispatcher", location="/jsp/agregarComponentes.jsp") } )
 public String agregarComponentes() {
  ActionContext contexto = ActionContext.getContext();
  Map<String, Object> sesion = contexto.getSession();
  UsuarioForm usuarioForm=(UsuarioForm) sesion.get("usuarioForm");
  System.out.println("Ingreso a guardar componente");
     if("".equals(componenteForm.getNombre())||"".equals(componenteForm.getTipo())||"".equals(componenteForm.getVersion())||
       "".equals(componenteForm.getExtension())){
      System.out.println("Faltan datos al componente");
      mensaje="Faltan datos al componente";
      addActionMessage("Usuario Correcto: "+usuarioForm.getNombre());
      addActionError(mensaje);
      return ERROR;
     }
     else{
   componenteDAO.addComponente(componenteForm);
   System.out.println("Componente guardado");
   componenteLista=componenteDAO.getComponente();
   return SUCCESS;
     }
 }
 
 @Action( value="volverComponenteAccion", results= {
   @Result(name=SUCCESS, type="dispatcher", location="/jsp/agregarComponentes.jsp")})
 public String volverComponente() {
  ActionContext contexto = ActionContext.getContext();
  Map<String, Object> sesion = contexto.getSession();
  UsuarioForm usuarioForm=(UsuarioForm) sesion.get("usuarioForm");
  addActionMessage("Usuario Correcto: "+usuarioForm.getNombre());
  return SUCCESS;
 }

 public ComponenteForm getComponenteForm() {
  return componenteForm;
 }

 public List<ComponenteForm> getComponenteLista() {
  return componenteLista;
 }

 public void setComponenteLista(List<ComponenteForm> componenteLista) {
  this.componenteLista = componenteLista;
 }

 public void setComponenteForm(ComponenteForm componenteForm) {
  this.componenteForm = componenteForm;
 }
 
}

1. Todos los import son importantes puesto que son las librerías de Struts 2 que necesitamos para desarrollarlo. 
2. Definimos el atributo ComponenteDAO componenteDAO para obtener los datos de los componentes ingresados o insertar uno nuevo.
3. ComponenteForm componenteForm con sus respectivos getter y setter para obtener los datos de un componente ingresado, realizar sus validaciones e ingresarlo a nuestra lista de componentes a traves de componenteDAO
4. List<ComponenteForm> componenteLista para obtener nuestra lista de componentes cuando queramos consultarlo en el jsp mostrarComponentes.jsp.
5. Definimos anotaciones y vamos a indicar que el método (agregarComponentes) que vamos a definir en el siguiente punto se trata de un una acción (@Action) que la podremos invocar desde un jsp u otra acción a partir de su alias (agregarComponentesAccion) y los posibles resultados de esta acción serán (SUCCESS) que me envía a la página mostrarComponentes.jsp, (ERROR) que me envía a la página agregarComponentes.jsp. 
6. Definimos el método agregarComponentes que será invocado desde el Filter Dispatcher donde validaremos que los datos obtenidos del formulario ComponenteForm componenteForm son correctos.En caso de que los datos estén mal ingresados devolvere el mensaje addActionError respectivo, addActionMessage para indicar el usuario logueado y retornare el result como ERROR. Caso contrario guardaré el componente en mi lista estática a través de componenteDAO.addComponente(componenteForm); una vez guardado obtendré la lista completa con  componenteLista=componenteDAO.getComponente(); y retornaré el result como SUCCESS. El Filter Dispatcher a partir de este resultado me enviará a la pagina respectiva.
7. Definimos anotaciones y vamos a indicar que el método (volverComponente) que vamos a definir en el siguiente punto se trata de un una acción (@Action) que la podremos invocar desde un jsp u otra acción a partir de su alias (volverComponenteAccion) y los posibles resultados de esta acción en este caso solo sera un (SUCCESS) que me envía a la página agregarComponentes.jsp.
8. Definimos el método volverComponente que será invocado desde el Filter Dispatcher donde simplemente recuperamos los datos del usuario obteniendo primero que todo el contexto ActionContext.getContext() y recuperando los datos de la sesion contexto.getSession() y lo añadimos al mensaje a mostrar en el jsp de agregar componente addActionMessage. Hay que percatarse de que en este caso siempre el resultado será SUCCESS por que no hay otra opción ya que en esta página no se hace nada, solo se visualiza.

Ahora modificamos los jsp:

/ProyectoStruts2AnotacionesTutorial/WebContent/jsp/agregarComponentes.jsp

<%@ page language="java" contentType="text/html; charset=ISO-8859-1"
    pageEncoding="ISO-8859-1"%>
<%@taglib uri="/struts-tags" prefix="s"%> 
<!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=ISO-8859-1">
<title>Agregar Componentes</title>
</head>
<body>
<s:property value="usuarioForm.nombre"/>
<s:if test="hasActionMessages()">
   <div class="welcome">
      <s:actionmessage />
   </div>
</s:if>
<s:if test="hasActionErrors()">
   <div class="errors">
      <s:actionerror/>
   </div>
</s:if>
</body>
<h4>Agregar Componente</h4>
<s:form id="agregar" method="post" action="agregarComponentesAccion">
 <s:textfield  name="componenteForm.nombre" label="Nombre"/>
 <s:textfield  name="componenteForm.version" label="Version"/>
 <s:textfield  name="componenteForm.tipo" label="Tipo"/>
 <s:textfield  name="componenteForm.extension" label="Extension"/>
 <!--<s:hidden name="usuarioForm"/>-->
 <s:submit id="submit" value="Registrar" />
</s:form>
</html>

1. En esta página mostraremos la bienvenida al usuario donde al hacer hasActionMessage preguntamos si existe algun mensaje de exito recibido y si es así el caso mostramos el mensaje actionmessage.
2. Verificamos si existe algún mensaje de error hasActionErrors y si se diera el caso mostramos el caso respectivo de error.
3. Finalmente agregamos un form para que puedas llenarse los datos necesarios del componente a registrar (componenteForm) y al hacer submit vaya al action respectivo agregarComponentesAccion que lo recibirá el Filter Dispatcher.

/ProyectoStruts2AnotacionesTutorial/WebContent/jsp/mostrarComponentes.jsp

<%@ page language="java" contentType="text/html; charset=UTF-8"
    pageEncoding="UTF-8"%>
    <%@taglib uri="/struts-tags" prefix="s"%> 
<!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "http://www.w3.org/TR/html4/loose.dtd">
<html>
<head>
<s:hidden name="usuarioForm"/>
<meta http-equiv="Content-Type" content="text/html; charset=UTF-8">
<title>Lista de Componentes</title>
</head>
<body>
<center>
<br><br><br><br><br><br>
<div style="color: teal;font-size: 30px">Lista de Componentes 2</div>
<br><br>
<table border="1" bgcolor="black" width="600px">
    <tr style="background-color: teal;color: white;text-align: center;" height="40px">
        <th><s:text name="Nombre"/></th>
        <th><s:text name="Version"/></th>
        <th><s:text name="Tipo"/></th>
        <th><s:text name="Extensión"/></th>
    </tr>
    <s:iterator value="componenteLista" status="status">
        <tr style="background-color:white;color: black;text-align: center;" height="30px" >
            <td class="nowrap"><s:property value="nombre"/></td>
            <td class="nowrap"><s:property value="version"/></td>
            <td class="nowrap"><s:property value="tipo"/></td>
            <td class="nowrap"><s:property value="extension"/></td>
        </tr>    
  </s:iterator>
</table>
<br>
<a href="volverComponenteAccion" >Agrega un nuevo componente</a>
</center>
</body>
</html>

1. Nos recorremos la lista componenteLista y pintamos los datos respectivos
2. Creamos una referencia para poder volver al Action volverComponenteAccion.

Recordar que para este caso de struts2 con anotaciones no necesitamos crear struts.xml.

Si has compilado todo bien y no hay problemas de ejecución te deberían salir las siguientes páginas después del Login y después de haber agregado varios componentes.

El código del proyecto os lo podéis bajar del siguiente link

ProyectoStruts2AnotacionesTutorial