Controladores creados con Spring, usando Anotaciones y que son depurables (debugeables) en Netbeans

Probado en Ubuntu.

A partir de la versión 2.5 del framework spring, es posible utilizar anotaciones java para configurar las aplicaciones y de esta manera reducir la cantidad de XML utilizado (es decir, lo que antes había que escribir como configuración xml pasa a ser configuración expresada a través de anotaciones escritas directamente en las clases Java, cool trick ah?).

Vamos a crear una aplicación sencilla (Un Portlet) con Spring (usando modelo-vista-controlador de Spring), que conste de una vista y un controlador, partiendo del supuesto que no hemos instalado ninguno de los componentes necesarios para lograrlo: el IDE netbeans, los plugins de netbeans para el desarrollo web, las librerías spring y el servidor de aplicaciones apache-tomcat.

Sí se asume que tenemos el jdk de java instalado (versión 6 al momento de escribir este documento).

1. Primero descargamos el netbeans (versión 6.7.1 al momento de escribir este documento), accedemos al sitio de descargas de Netbeans y escogemos la tercera opción que incluye soporte para aplicaciones web en Java y que incluye servidores de aplicaciones.

2. Abrimos una consola y navegamos hasta la carpeta dónde se descargó el archivo, por ejemplo si se descargó en /home/usuario/descargas:

   cd /home/usuario/descargas

3. Ahora vamos a darle permisos de ejecución al archivo, para ello digitamos en consola:

   chmod a+rwx netbeans-[número versión]-ml-java-linux.sh

   y ejecutamos el instalador:

   ./netbeans-[número versión]-ml-java-linux.sh

   esto iniciará un instalador gráfico:
   

4. Damos click en el botón personalizar (customize) y a continuación seleccionamos sólamente las opciones que nos interesan, estas son: Base IDE, Java SE, JavaScript Debugger, Java Web and EE, Features on Demand y el Apache Tomcat (versión 6 al momento de escribir):
   
   Damos click en ok y luego en next, aceptamos el contrato de licencia y escogemos el lugar dónde se instalará el netbeans y el servidor apache tomcat, por último damos click en Install.

5. Seguidamente, necesitamos agregar al Netbeans los plugins para el desarrollo de Servlets y Portlets con el uso del framework Spring, para ello descargamos el netbeans portal pack de aquí, actualmente de aquí.
   Elegimos la tercera opción (el paquete all).
   Una vez descargado, lo descomprimimos.

6. Abrimos el netbeans y vamos al menú Tools > Plugins, esto abre una ventana, de ella seleccionamos la pestaña que dice Downloaded (descargados), damos click al botón Add Plugins… y navegamos hasta la carpeta que se creó en el paso anterior:
   
   
   Seleccionamos todos los plugins (archivos con extension .nbm, damos click en Aceptar y luego en Install (si nos dice que algún plugin no está firmado, simplemente elegimos Continuar).
   Ya están instalados los plugins necesarios.

7. Creamos desde Netbeans un proyecto nuevo y lo elegimos como Java Web > Web Application, le ponemos un nombre y elegimos el lugar dónde se va a guardar, seleccionamos el servidor web como Apache Tomcat y marcamos las opciones Portlet Support y Spring Web MVC 2.5:
   
   damos click en Finish.

8. Aunque el netbeans agregó automáticamente las librerías del Spring al proyecto recién creado, algunas de ellas dan problemas a la hora de realizar un deploy al servidor, vamos a reemplazar las que den problema, primero descargamos las librerías del Spring desde: la página del spring, debemos descargar la versión que trae dependecias. Una vez descargadas, las descomprimimos.

9. Las librerías que generan problemas son:

   • Portlet 2.0(JSR 286) Library – portlet-api-2.0.jar
   • Spring Framework 2.5 – spring-2.5.jar
   • Spring Web MVC 2.5 – spring-webmvc-2.5.jar

   Debemos reemplazarlas por las siguientes librerías que se encuentran en la carpeta generada en el paso anterior (con las rutas relativas a la carpeta):

   • portlet-api-2.0.jar : /spring-framework-2.5.6.SEC01/lib/portlet
   • spring.jar : /spring-framework-2.5.6.SEC01/dist
   • spring-webmvc.jar : /spring-framework-2.5.6.SEC01/dist/modules

   Además debemos de agregar la librería:
   spring-webmvc-portlet.jar : /spring-framework-2.5.6.SEC01/dist/modules
   
   

10. Ahora agregamos el controlador, para ello agregamos el paquete mipaquete.web y dentro de él creamos la clase MiController:
    

    La clase MiController contendrá lo siguiente (copiar-pegar):

    
package mipaquete.web;

    import org.springframework.beans.factory.annotation.Autowired;
    import org.springframework.stereotype.Controller;
    import org.springframework.ui.ModelMap;
    import org.springframework.web.bind.annotation.RequestMapping;

    @Controller
    @RequestMapping("VIEW")
    public class MiController {

    @Autowired
    public MiController() {
    }

    @RequestMapping // acción por omisión, renderizado (action=mostrarFormulario)
public String mostrarFormulario(ModelMap model) {
return "miIndex";
}
}

11. Abrimos el archivo dispatcher-servlet.xml y sustituimos su contenido por lo siguiente (copiar-pegar):

    <?xml version="1.0" encoding="UTF-8"?>
    <beans xmlns="http://www.springframework.org/schema/beans"
           xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
           xmlns:p="http://www.springframework.org/schema/p"
           xmlns:aop="http://www.springframework.org/schema/aop"
           xmlns:tx="http://www.springframework.org/schema/tx"
           xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-2.5.xsd
           http://www.springframework.org/schema/aop http://www.springframework.org/schema/aop/spring-aop-2.5.xsd
    http://www.springframework.org/schema/tx http://www.springframework.org/schema/tx/spring-tx-2.5.xsd">
    
        <bean class="org.springframework.web.portlet.mvc.annotation.DefaultAnnotationHandlerMapping">
            <property name="interceptors">
                <!-- Este interceptor envía el parámetro del request desde un ActionRequest para ser usado como un parámetro del renderizado. -->
                <bean class="org.springframework.web.portlet.handler.ParameterMappingInterceptor" />
            </property>
        </bean>
    
        <bean id="indexController" class="mipaquete.web.MiController"/>
    
        <bean id="urlMapping" class="org.springframework.web.servlet.handler.SimpleUrlHandlerMapping">
            <property name="mappings">
                <props>
                    <prop key="index.htm">indexController</prop>
                </props>
            </property>
        </bean>
    
        <bean id="viewResolver"
              class="org.springframework.web.servlet.view.InternalResourceViewResolver"
              p:prefix="/WEB-INF/jsp/"
              p:suffix=".jsp" />
    
    </beans>
    

12. Agregamos en la carpeta que contiene los Jsps del proyecto (/WEB-INF/jsp) un jsp nuevo al que llamamos miIndex(que es el nombre de vista que se devuelve desde el controlador). Netbeans lo agregará con un Hello World de contenido.

    Para probar damos click en el nombre del proyecto y elegimos la opción Run (ejecutar), debe verse una página html con el Hello World.

Por último, si se coloca un breakpoint en el código y debbugeamos la aplicación, esta se va a detener al llegar a él, es decir, es posible debuggear.

Listo listo

Enjoy!