El descriptor de despliegue de una aplicación web se encuentra tradicionalmente en el directorio 'src/main/webapp/WEB-INF', y tiene como fichero principal el archivo 'web.xml'. En este tutorial, utilizaremos una aproximación más actual basada en el uso de anotaciones y clases de configuración.

En primer lugar, vamos a definir un DispatcherServlet cuya misión será controlar hacia dónde serán enrutadas todas nuestras solicitudes. Para ello creamos el paquete 'com.companyname.springapp' dentro de 'src/main/java' y añadimos la siguiente clase, que se lanzará automáticamente a través de la funcionalidad javax.servlet.ServletContainerInitializer del API de Servlet 3 (para más información podéis consultar esta guía rápida sobre configuración web en Spring).

'springapp/src/main/java/com/companyname/springapp/SpringappWebApplicationInitilizer.java':

package com.companyname.springapp;

import org.springframework.web.servlet.support.AbstractAnnotationConfigDispatcherServletInitializer;

import com.companyname.springapp.business.SpringappBusinessConfig;
import com.companyname.springapp.web.SpringappWebConfig;


public class SpringappWebApplicationInitializer extends AbstractAnnotationConfigDispatcherServletInitializer {

    @Override
    protected Class<?>[] getRootConfigClasses() {
        return new Class<?>[] { SpringappBusinessConfig.class };
    }

    @Override
    protected Class<?>[] getServletConfigClasses() {
        return new Class<?>[] { SpringappWebConfig.class };
    }

    @Override
    protected String[] getServletMappings() {
        return new String[] { "/" };
    }

}

Como se puede observar, esta clase depende de la creación de dos clases de configuración en los paquetes 'com.companyname.springapp.business' y 'com.companyname.springapp.web'. La primera clase definirá la configuración del contexto general de la aplicación y la segunda el contexto de la capa web, es decir, las definiciones de los beans usados por el DispatcherServlet.

'springapp/src/main/java/com/companyname/springapp/business/SpringappBusinessConfig.java':

package com.companyname.springapp.business;

import org.springframework.context.annotation.ComponentScan;
import org.springframework.context.annotation.Configuration;

@Configuration
@ComponentScan
public class SpringappBusinessConfig {

}

'springapp/src/main/java/com/companyname/springapp/web/SpringappWebConfig.java':

package com.companyname.springapp.web;

import org.springframework.context.annotation.ComponentScan;
import org.springframework.context.annotation.Configuration;
import org.springframework.web.servlet.config.annotation.EnableWebMvc;

@Configuration
@ComponentScan
@EnableWebMvc
public class SpringappWebConfig {

}

1.7. Crear el Controlador

Vamos a crear una clase anotada con la etiqueta @Controller (a la que llamaremos HelloController.java) y que estará definida dentro del paquete 'com.companyname.springapp.web.controllers' del directorio 'src/main/java'

'springapp/src/main/java/com/companyname/springapp/web/controllers/HelloController.java':

package com.companyname.springapp.web.controllers;

import org.apache.commons.logging.Log;
import org.apache.commons.logging.LogFactory;
import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.servlet.ModelAndView;

@Controller
public class HelloController {

    protected final Log logger = LogFactory.getLog(getClass());

    @RequestMapping(value="/hello.htm")
    public ModelAndView handleRequest() {
        logger.info("Returning hello view");
        return new ModelAndView("hello.jsp");
    }
}

De momento, esta implementación del controlador mediante la anotación @Controller, es muy básica. Más adelante la iremos expandiendo. En Spring Web MVC, los componentes @Controller manejan las solicitudes gracias al mapeo de métodos con múltiples de firmas posibles (para más información sobre la variedad de parámetros de entrada y de posibles valores de retorno consultad este enlace de la documentación oficial). En este caso, el método anotado @RequestMapping devuelve un objeto ModelAndView, cuya vista hace referencia al fichero 'hello.jsp' que vamos a crear a continuación. El objeto devuelto es resuelto a través del ViewResolver. Puesto que no hemos definido explicítamente un ViewResolver, vamos a obtener uno por defecto de Spring que simplemente redigirá a una dirección URL que coincida con el nombre de la vista especificada. Más tarde modificaremos este comportamiento. Además, hemos especificado un logger de manera que podemos verificar que pasamos por el manejador en cada momento. Usando STS, estos mensajes de log deben mostrarse en la pestaña 'Console'.

1.8. Escribir un test para el Controlador

Los tests son una parte vital del desarrollo del software. El mejor momento para escribir los tests es durante el desarrollo, no después, de manera que aunque nuestro controlador no contiene lógica demasiado compleja vamos a escribir un test para probarlo. Esto nos permitirá hacer cambios en el futuro con total seguridad. Vamos a crear (si no existiera) un nuevo directorio de tipo 'Source Folder' llamado 'src/test/java'. Aquí es donde alojaremos todos nuestros tests, en una estructura de paquetes que será idéntica a la estructura de paquetes que tenemos en 'src/main/java'.

Creamos una clase de test llamada 'HelloControllerTests' dentro del paquete 'com.companyname.springapp.web.controllers'.

'springapp/src/test/java/com/companyname/springapp/web/controllers/HelloControllerTests.java':

package com.companyname.springapp.web.controllers;

import static org.junit.Assert.*;

import org.junit.Test;
import org.junit.runner.RunWith;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.test.context.ContextConfiguration;
import org.springframework.test.context.junit4.SpringRunner;
import org.springframework.test.context.web.WebAppConfiguration;
import org.springframework.web.servlet.ModelAndView;

import com.companyname.springapp.business.SpringappBusinessConfig;
import com.companyname.springapp.web.SpringappWebConfig;

@RunWith(SpringRunner.class)
@ContextConfiguration(classes = {SpringappBusinessConfig.class, SpringappWebConfig.class})
@WebAppConfiguration
public class HelloControllerTests {

    @Autowired
    private HelloController controller;

    @Test
    public void testHandleRequestView() {	
        ModelAndView modelAndView = controller.handleRequest();		
        assertEquals("hello.jsp", modelAndView.getViewName());
    }
}

Para ejecutar el test (y todos los tests que escribamos en el futuro), basta con que seleccionemos 'Run as > JUnit Test' sobre el menú contextual que aparece cuando se pincha el botón derecho sobre la clase de test. Si el test se ejecuta de forma satisfactoria podrás ver una barra verde que lo indica.

1.9. Crear la Vista

Ahora es el momento de crear nuestra primera vista. Como hemos mencionado antes, estamos redirigiendo hacia una página JSP llamada 'hello.jsp'. Para empezar, crearemos este fichero en el directorio 'src/main/webapp'.

'springapp/src/main/webapp/hello.jsp':

<html>
  <head><title>Hello :: Spring Application</title></head>
  <body>
    <h1>Hello - Spring Application</h1>
    <p>Greetings.</p>
  </body>
</html>

1.10. Compilar, desplegar y probar la aplicación

Para ejecutar la aplicación de nuevo, seleccionamos de nuevo 'Run as > Run on Server' sobre el menú contextual que aparece cuando se pincha el botón derecho sobre el nombre proyecto. (En algunos casos, es necasario reiniciar el servidor para asegurar que la aplicación se actualiza correctamente).

Probemos esta nueva versión de la aplicación. Desde el navegador que ofrece STS, o desde cualquier otro navegador, abrir la URL http://localhost:8080/springapp/hello.htm.

La aplicación actualizada

1.11. Resumen

Echemos un vistazo rápido a las partes de nuestra aplicacioón que hemos creado hasta ahora.

1. Una página de inicio, 'index.jsp', la página de bienvenida de nuestra aplicación. Fue usada para comprobar que nuestra configuración era correcta. Más tarde la cambiaremos para proveer un enlance a nuestra aplicación.

2. Un controlador frontal, DispatcherServlet, con las correspondientes clases de configuración: SpringappWebApplicationInitializer, SpringappBusinessConfig, SpringappWebConfig.

3. Un controlador de página, HelloController, con funcionalidad limitada – simplemente devuelve un objeto ModelAndView. Actualmente tenemos un modelo vacío, más tarde proveeremos un modelo completo.

4. Una unidad de test para la página del controlador, HelloControllerTests, para verificar que el nombre de la vista es el que esperamos.

5. Una vista, 'hello.jsp', que de nuevo es extremadamente sencilla. Las buenas noticias son que el conjunto de la aplicación funciona y que estamos listos para añadir más funcionalidad.

A continuación puedes ver una captura de pantalla que muestra el aspecto que debería tener la estructura de directorios del proyecto después de seguir todas las instrucciones anteriores.

La estructura de directorios del proyecto al final de la parte 1

---

Anterior	Inicio	Siguiente
Descripcion	Autor: Francisco Grimaldo Moreno	Capítulo 2. Desarrollando y Configurando la Vista y el Controlador