Spring MVC Creación de aplicaciones web

Spring Web MVC es un sub-proyecto Spring que esta dirigido a facilitar y optimizar el proceso creación de aplicaciones web utilizando el patrón MVC (Modelo-Vista-Controlador), donde el Modelo representa los datos o información que manejará la aplicación web, la Vista son todos los elementos de la UI (Interfaz de Usuario), con ellos el usuario interactúa con la aplicación, ejemplo: botones, campos de texto, etc., finalmente el Controlador será el encargado manipular los datos en base a la interacción del usuario.

La pieza central de Framework Spring MVC es el DispatcherServlet que extiende la clase HttpServlet este componente es el encargado de recibir las peticiones HTTP y generar la respuesta adecuada a dicha petición, tradicionalmente se configura utilizando el archivo web.xml aunque utilizando la especificación Servlet 3.0+ es posible configurar programáticamente, su funcionamiento básico se muestra en el siguiente diagrama:

servlet spring mvc

Funcionamiento básico del DispatcherServlet:

1. El proceso inicia cuando el usuario envía una petición, normalmente abre el navegador y escribe la URL que identifica nuestra aplicación, ejemplo: http://localhost:8084/tutoriales/spring, esta petición es manejada por el Front Controller quien se encarga  analizar la URL para determinar cual es el controlador adecuado para la misma.

2. El Controller o controlador usualmente accede a la base de datos y rellena el modelo (model) con los datos requeridos para generar la vista, el modelo es enviado de regreso al Front Controller junto con el nombre lógico de la vista.

3. El componente encargado de generar las vistas es el View Template este utilizará el modelo y la tecnología de vista que hayamos configurado para generar la vista final, que puede ser HTML, PDF, XLS, etc., cuando la vista esté preparada será devuelta al Front Controller quien la pondrá a disposición del usuario.

Crear una aplicación web con spring

Nuestra primera aplicación Spring MVC la crearemos con el IDE Netbeans 8.x, usaremos la tecnología Apache Maven para manejar dependencias mas fácilmente aunque puedes seguir el tutorial con Apache Ant solo o con Apache Ivy.

Para crear la estructura inicial del proyecto usaremos un Maven Archetype, que no es mas que una plantilla base para un proyecto, para hacerlo creamos un nuevo proyecto en Netbeans 8.x y seleccionamos Maven | Project from Archetype.

Crear un proyecto web spring con maven archetype

Lo siguiente que debemos hacer es indicar el archetype que deseamos utilizar, pues existen montones para distintos tipos de proyectos, nosotros usaremos: maven-archetype-webapp.

crear proyecto web con spring mvc

En la siguiente ventana solo indicamos los datos propios del proyecto.

crear aplicación web con spring mvc

Al presionar el botón Finish tendremos el siguiente proyecto:

proyecto spring mvc

Antes de empezar a escribir código, como siempre debemos agregar las dependencias necesarias, para ello editamos el archivo pom.xml, puedes abrirlo haciendo clic derecho sobre el proyecto luego seleccionando la opción Open POM.

<dependencies>
    <dependency>
        <groupId>org.springframework</groupId>
        <artifactId>spring-webmvc</artifactId>
        <version>${spring.version}</version>
    </dependency>
</dependencies>

También debemos declarar el DispatcherServlet y establecer el patrón para las URL admitidas, por lo que editamos el archivo web.xml.

<web-app version="3.1" xmlns="http://xmlns.jcp.org/xml/ns/javaee"
         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://xmlns.jcp.org/xml/ns/javaee
                             http://xmlns.jcp.org/xml/ns/javaee/web-app_3_1.xsd">
    <servlet>
        <servlet-name>springmvc</servlet-name>
        <servlet-class>
            org.springframework.web.servlet.DispatcherServlet
        </servlet-class>
        <load-on-startup>1</load-on-startup>
    </servlet>
    
    <servlet-mapping>
        <servlet-name>springmvc</servlet-name>
        <url-pattern>/</url-pattern>
    </servlet-mapping>
    
</web-app>

Este es el estándar de configuración para los Java EE Servlet.

<web-app version="3.1" xmlns="http://xmlns.jcp.org/xml/ns/javaee"
         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://xmlns.jcp.org/xml/ns/javaee
                             http://xmlns.jcp.org/xml/ns/javaee/web-app_3_1.xsd">

</web-app>

Esta es la etiqueta raíz, aquí definimos la versión a utilizar, Servlet 3.1, además de los namespaces.

<servlet>
    <servlet-name>springmvc</servlet-name>
    <servlet-class>
        org.springframework.web.servlet.DispatcherServlet
    </servlet-class>
    <load-on-startup>1</load-on-startup>
</servlet>

Ahora vemos la declaración del Servlet, con <servlet-name /> le damos un nombre, para este ejemplo springmvc, con <servlet-class /> definimos la clase que implementa el Servlet, además vemos la etiqueta <load-on-startup /> esta nos sirve para definir el orden de inicio de los Servlets, lo establecemos a 1 pues este debe ser el primero en iniciar.

<servlet-mapping>
    <servlet-name>springmvc</servlet-name>
    <url-pattern>/</url-pattern>
</servlet-mapping>

La etiqueta <servlet-mapping /> nos sirve para definir las URL que serán admitidas por este Servlet, primero debemos indicar el Servlet que deseamos configurar indicando su nombre en <servlet-name /> recordemos que nuestro el nuestro se llama springmvc y luego usamos <url-pattern /> para definir el patrón de las URL válidas, en este ejemplo " / " indica que se admiten todas las peticiones HTTP.

Un patrón URL como *.html nos permitiría manejar todas las peticiones que terminen en .html por ejemplo: http://localhost:8084/SpringWebMvc/hello.html con el patrón / se admiten todas las peticiones HTTP, algunos ejemplos:

http://localhost:8084/SpringWebMvc/hello.html http://localhost:8084/SpringWebMvc/hello.htm http://localhost:8084/SpringWebMvc/hello.mvc

Los siguiente que necesitamos es la configuración Spring para el Servlet, necesitamos añadir un archivo que debe tener el nombre {servlet-name}-servlet.xml donde {servlet-name} debe ser el nombre del Servlet que estamos configurando, para nosotros sería: springmvc-servlet.xml, este archivo debe ubicarse en el mismo directorio que el archivo web.xml.

<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xmlns:context="http://www.springframework.org/schema/context"
       xsi:schemaLocation="http://www.springframework.org/schema/beans
                        http://www.springframework.org/schema/beans/spring-beans-4.0.xsd
                        http://www.springframework.org/schema/context
                        http://www.springframework.org/schema/context/spring-context-4.0.xsd">
    
    <context:component-scan base-package="carmelo.spring.webmvc" />
    <context:annotation-config />
    
    <bean class="org.springframework.web.servlet.view.InternalResourceViewResolver">
        <property name="prefix" value="/WEB-INF/views/" />
        <property name="suffix" value=".jsp" />
    </bean>
    
</beans>

Lo que tenemos aquí es la configuración XML para el contenedor web Spring (WebApplicationContext) ya la hemos visto en cursos anteriores por lo que si deseas una explicación detallada del mismo, ve a: Configurar Spring Framework con XML, lo que no hemos visto es el bean de tipo InternalResourceViewResolver este es el encargado de determinar el nombre físico de la vista, recordemos que un controlador indica el nombre lógico de la vista, este nombre es usado por el InternalResourceViewResolver para obtener el archivo físico.

Ejemplo: si el controlador devuelve el nombre lógico, hello, el archivo físico obtenido sería, /WEB-INF/views/hello.jsp, ya que la propiedad prefix define normalmente la ubicación de las vistas y la propiedad sufix la extensión.

Debemos saber que InternalResourceViewResolver es una implementación de ViewResolver que da soporte a vistas basadas en JSP, pero existes muchas otras implementaciones que nos permiten trabajas con diferentes tecnologías como: Thymeleaf, Velocity, Freemarker, etc..

Vamos a crear el archivo usado para generar la vista, como hemos mencionado, estos deben ubicarse en la carpeta /WEB-INF/views/ y tener extensión .jsp, según lo establecido por el ViewResolver.

Creamos un archivo llamado hello.jsp para ello damos clic derecho sobre la carpeta WEB-INF y seleccionamos New | JSP....

agregar una vista jsp a spring mvc

Con lo que hemos hecho hasta ahora tenemos lo siguiente:

spring mvc agregar vista jsp

Editamos el archivo hello.jsp para agregar el código que vemos en la imagen.

Analizando el código del archivo hello.jsp veremos ${...} este es el método utilizado en JSP para acceder a los datos del modelo, debemos indicar el nombre identificador del dato al que deseamos acceder, recordemos que el modelo es creado por el controlador y es utilizado para generar la vista.

Lo siguiente que haremos será crear el controlador, primero creamos un paquete Java donde lo ubicaremos, en el archivo springmvc-servlet.xml habilitamos el escaneo de componentes con <context:component-scan base-package="carmelo.spring.webmvc" /> por lo que debemos ubicar el controlador en este paquete para que Spring puede ubicarlo.

agregar paquete java

Dentro de este paquete creamos la clase llamada HelloController.

package carmelo.spring.webmvc;

import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.servlet.ModelAndView;

@Controller
public class HelloController {

    @RequestMapping(value = "/hello")
    public ModelAndView saluda() {
        ModelAndView mv = new ModelAndView();
        mv.addObject("titulo", "Tutoriales Spring MVC");
        mv.addObject("mensaje", "Mi Primera Aplicacion Web Spring MVC");
        mv.setViewName("hello");
        
        return mv;
    }
}

La anotación @Controller la hemos visto es tutoriales anteriores, cuando Spring la detecte creará un bean de esta clase que será utilizado como controlador, otra anotación que podemos ver es la que se encuentra en el método saluda(), @RequestMapping(value = "/hello"), ella nos sirve para definir cual es la petición HTTP a la que responderá el método saluda(), por ejemplo: la siguiente petición será manejada por este método, http://localhost:8084/tutorial_web_mvc/hello.

Usamos la clase ModelAndView para crear el modelo e indicar la vista, el método addObject nos permite agregar un dato al modelo, recordemos que nuestra vista hello.jsp espera dos datos uno llamado titulo y otro mensaje, para indicar el nombre lógico de la vista usamos setViewName.

Si hemos hecho todo bien ya podemos probar la aplicación, para hacerlo damos clic derecho sobre el proyecto y presionamos Run.

desplegar aplicación spring mvc en servidor apache tomcat

Aquí seleccionamos el servidor donde desplegaremos la aplicación, usaremos Apache Tomcat 8.x y presionamos OK, si todo está correcto abrimos en navegador, tecleamos la URL indicada y veremos:

desplegar spring mvc en apache tomcat

Listo, con esto has creado tu primera aplicación web con Spring MVC, si te parece, tedioso, largo y confuso en siguientes tutoriales veremos como simplificar y agilizar este proceso utilizando Spring Boot.

Comentarios

Entradas populares de este blog

Conectar SQL Server con Java

Detección de rostros

Instalar OpenCV para Python en Windows