Ejemplo de Spring MVC

Tutoriales
Spring

Bienvenido a Spring MVC Example. Hace algún tiempo, en el Tutorial de Spring MVC, expliqué cómo crear una aplicación Spring MVC usando Spring Tool Suite. Pero hoy, estaré creando una aplicación básica de Spring MVC “hello world” usando Maven y Eclipse.

Ejemplo de Spring MVC

Spring MVC se basa en la arquitectura Modelo-Vista-Controlador. La siguiente imagen muestra la arquitectura de Spring MVC a un nivel alto. DispatcherServlet es la clase controladora frontal que recibe todas las peticiones y las procesa. Debemos configurarlo en el archivo web.xml. Su trabajo es pasar la petición a la clase controladora adecuada y enviar la respuesta de vuelta cuando las páginas de vista han renderizado la página de respuesta. HomeController.java será la única clase controladora en nuestra aplicación de ejemplo de Spring MVC. home.jsp, user.jsp son las páginas de vista en nuestra aplicación de ejemplo de Spring MVC “hello world”. User.java será la única clase de modelo que tendremos en nuestra aplicación web de ejemplo de Spring MVC.

Ejemplo de Proyecto Hello World de Spring MVC en Eclipse

La siguiente imagen muestra nuestro proyecto de ejemplo de Spring MVC en Eclipse. Comencemos y creemos nuestro proyecto desde cero.

Configuración del Proyecto Eclipse de Ejemplo de Spring MVC

Dado que se trata de una aplicación web y queremos utilizar Maven para la gestión de dependencias, primero tenemos que crear una aplicación web dinámica y luego convertirla en un proyecto Maven. A continuación, se muestran imágenes de cómo hacer esto y preparar la estructura básica de nuestro proyecto. Haz clic con el botón derecho en la ventana del explorador de proyectos y selecciona “Nuevo -> Proyecto web dinámico”, como se muestra en la imagen siguiente. En la siguiente ventana emergente, proporciona el nombre “spring-mvc-example”, el resto de las opciones no deberían requerir cambios. En la siguiente página, proporciona la carpeta de origen como “src/main/java”. Es posible que debas eliminar la carpeta “src” de la lista antes de agregarla. Luego, en la página del módulo web, proporciona la raíz del contexto de la aplicación como “spring-mvc-example” y asegúrate de marcar la opción “Generar descriptor de implementación web.xml”. Haz clic en “Finalizar” y tendrás un nuevo Proyecto web dinámico en el explorador de proyectos de Eclipse.

Convirtiendo Proyecto Web Dinámico a Proyecto Maven

Queremos usar Maven para gestionar fácilmente nuestras dependencias de Spring MVC. Así que vamos a convertir nuestro proyecto web a Maven. Haz clic derecho en el proyecto y selecciona “Configurar -> Convertir a Proyecto Maven”. A continuación, proporciona las configuraciones del archivo pom.xml como se muestra a continuación. Nuestro esqueleto de código del proyecto de aplicación web de Maven está listo. Ahora podemosempezar a hacer cambios en él y crear nuestro ejemplo de aplicación “Hola Mundo” de Spring MVC.

Dependencias de Spring MVC en pom.xml

Necesitamos agregar las dependencias spring-web y spring-webmvc en el archivo pom.xml, también agregar las dependencias servlet-api, jsp-api y jstl. Nuestro archivo pom.xml final será como el siguiente.

<project xmlns="https://maven.apache.org/POM/4.0.0" xmlns:xsi="https://www.w3.org/2001/XMLSchema-instance"
	xsi:schemaLocation="https://maven.apache.org/POM/4.0.0 https://maven.apache.org/xsd/maven-4.0.0.xsd">
	<modelVersion>4.0.0</modelVersion>
	<groupId>com.journaldev.spring.mvc</groupId>
	<artifactId>spring-mvc-example</artifactId>
	<version>0.0.1-SNAPSHOT</version>
	<packaging>war</packaging>
	<name>Spring MVC Example</name>
	<description>Spring MVC Hello World Example</description>

	<!-- Add Spring Web and MVC dependencies -->
	<dependencies>
		<dependency>
			<groupId>org.springframework</groupId>
			<artifactId>spring-webmvc</artifactId>
			<version>4.3.9.RELEASE</version>
		</dependency>
		<dependency>
			<groupId>org.springframework</groupId>
			<artifactId>spring-web</artifactId>
			<version>4.3.9.RELEASE</version>
		</dependency>
		<!-- Servlet -->
		<dependency>
			<groupId>javax.servlet</groupId>
			<artifactId>servlet-api</artifactId>
			<version>2.5</version>
			<scope>provided</scope>
		</dependency>
		<dependency>
			<groupId>javax.servlet.jsp</groupId>
			<artifactId>jsp-api</artifactId>
			<version>2.1</version>
			<scope>provided</scope>
		</dependency>
		<dependency>
			<groupId>javax.servlet</groupId>
			<artifactId>jstl</artifactId>
			<version>1.2</version>
		</dependency>
	</dependencies>

	<build>
		<plugins>
			<plugin>
				<artifactId>maven-compiler-plugin</artifactId>
				<version>3.6.1</version>
				<configuration>
					<source>1.8</source>
					<target>1.8</target>
				</configuration>
			</plugin>
			<plugin>
				<artifactId>maven-war-plugin</artifactId>
				<version>3.0.0</version>
				<configuration>
					<warSourceDirectory>WebContent</warSourceDirectory>
				</configuration>
			</plugin>
		</plugins>
		<finalName>${project.artifactId}</finalName> <!-- added to remove Version from WAR file -->
	</build>
</project>

Observa la configuración finalName en la compilación, para que el nombre de nuestro archivo WAR no tenga detalles de versión. Cuando el proyecto se compile con Eclipse, notarás que todos los archivos JAR aparecerán en la sección de dependencias de Maven.

DispatcherServlet de Spring MVC como controlador frontal

Debemos agregar el framework Spring MVC a nuestra aplicación web, para eso necesitamos configurar DispatcherServlet en web.xml como se muestra a continuación.

<?xml version="1.0" encoding="UTF-8"?>
<web-app xmlns:xsi="https://www.w3.org/2001/XMLSchema-instance" xmlns="https://java.sun.com/xml/ns/javaee" xsi:schemaLocation="https://java.sun.com/xml/ns/javaee https://java.sun.com/xml/ns/javaee/web-app_3_0.xsd" id="WebApp_ID" version="3.0">
  <display-name>spring-mvc-example</display-name>

	<!-- Add Spring MVC DispatcherServlet as front controller -->
	<servlet>
        <servlet-name>spring</servlet-name>
        <servlet-class>
                org.springframework.web.servlet.DispatcherServlet
        </servlet-class>
        <init-param>
       		<param-name>contextConfigLocation</param-name>
       		<param-value>/WEB-INF/spring-servlet.xml</param-value>
    		</init-param>
        <load-on-startup>1</load-on-startup>
    </servlet>
 
    <servlet-mapping>
        <servlet-name>spring</servlet-name>
        <url-pattern>/</url-pattern> 
    </servlet-mapping>
    
 </web-app>

El parámetro de inicialización contextConfigLocation se utiliza para proporcionar la ubicación del archivo de configuración de beans de Spring.

Archivo de configuración de beans de ejemplo de Spring MVC

El siguiente paso es crear el archivo de configuración de beans de Spring spring-servlet.xml como se muestra a continuación.

<?xml version="1.0" encoding="UTF-8"?>
<beans:beans xmlns="https://www.springframework.org/schema/mvc"
	xmlns:xsi="https://www.w3.org/2001/XMLSchema-instance" xmlns:beans="https://www.springframework.org/schema/beans"
	xmlns:context="https://www.springframework.org/schema/context"
	xsi:schemaLocation="https://www.springframework.org/schema/mvc https://www.springframework.org/schema/mvc/spring-mvc.xsd
		https://www.springframework.org/schema/beans https://www.springframework.org/schema/beans/spring-beans.xsd
		https://www.springframework.org/schema/context https://www.springframework.org/schema/context/spring-context.xsd">

	<!-- DispatcherServlet Context: defines this servlet's request-processing 
		infrastructure -->

	<!-- Enables the Spring MVC @Controller programming model -->
	<annotation-driven />
	<context:component-scan base-package="com.journaldev.spring" />

	<!-- Resolves views selected for rendering by @Controllers to .jsp resources 
		in the /WEB-INF/views directory -->
	<beans:bean
		class="org.springframework.web.servlet.view.InternalResourceViewResolver">
		<beans:property name="prefix" value="/WEB-INF/views/" />
		<beans:property name="suffix" value=".jsp" />
	</beans:bean>

</beans:beans>

Existen tres configuraciones importantes.

  1. La configuración annotation-driven indica a DispatcherServlet que busque clases de controlador usando la @Controller anotación.
  2. La configuración context:component-scan indica a DispatcherServlet dónde buscar clases de controlador.
  3. InternalResourceViewResolver configuración del bean para especificar la ubicación de las páginas de vista y el sufijo utilizado. Los métodos de la clase del controlador devuelven el nombre de la página de vista y luego se agrega el sufijo para determinar la página de vista que se usará para renderizar la respuesta.

Clase Controladora de Spring MVC

Tenemos una única clase controladora para responder a dos URIs: “/” para la página de inicio y “/usuario” para la página de usuario.

package com.journaldev.spring.controller;

import java.text.DateFormat;
import java.util.Date;
import java.util.Locale;

import org.springframework.stereotype.Controller;
import org.springframework.ui.Model;
import org.springframework.validation.annotation.Validated;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RequestMethod;

import com.journaldev.spring.model.User;

@Controller
public class HomeController {

	/**
	 * Simply selects the home view to render by returning its name.
	 */
	@RequestMapping(value = "/", method = RequestMethod.GET)
	public String home(Locale locale, Model model) {
		System.out.println("Home Page Requested, locale = " + locale);
		Date date = new Date();
		DateFormat dateFormat = DateFormat.getDateTimeInstance(DateFormat.LONG, DateFormat.LONG, locale);

		String formattedDate = dateFormat.format(date);

		model.addAttribute("serverTime", formattedDate);

		return "home";
	}

	@RequestMapping(value = "/user", method = RequestMethod.POST)
	public String user(@Validated User user, Model model) {
		System.out.println("User Page Requested");
		model.addAttribute("userName", user.getUserName());
		return "user";
	}
}

Tenga en cuenta que por simplicidad, no he utilizado ningún marco de registro como log4j.

Clase Modelo de Spring MVC

Tenemos una clase modelo simple con una única variable y sus métodos getter-setter. Es una simple clase POJO.

package com.journaldev.spring.model;

public class User {
	private String userName;

	public String getUserName() {
		return userName;
	}

	public void setUserName(String userName) {
		this.userName = userName;
	}
}

Páginas de Vista de Spring MVC

Tenemos dos páginas de vista definidas a continuación. home.jsp

<%@ page language="java" contentType="text/html; charset=UTF-8"
	pageEncoding="UTF-8"%>
<%@ taglib uri="https://java.sun.com/jsp/jstl/core" prefix="c"%>
<%@ page session="false"%>
<html>
<head>
<title>Home</title>
</head>
<body>
	<h1>Hello world!</h1>

	<P>The time on the server is ${serverTime}.</p>

	<form action="user" method="post">
		<input type="text" name="userName"><br> <input
			type="submit" value="Login">
	</form>
</body>
</html>

user.jsp

<%@ page language="java" contentType="text/html; charset=UTF-8"
    pageEncoding="UTF-8"%>
<!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "https://www.w3.org/TR/html4/loose.dtd">
<html>
<head>
<meta http-equiv="Content-Type" content="text/html; charset=UTF-8">
<title>User Home Page</title>
</head>
<body>
<h3>Hi ${userName}</h3>
</body>
</html>

Ten en cuenta que Spring MVC se encarga de mapear las variables del formulario a las variables de la clase del modelo, por eso tenemos el mismo nombre de variable en ambos lugares. Eso es todo, nuestro proyecto de ejemplo de spring mvc está listo para ser desplegado y probado.

Implementación del Proyecto Spring MVC en Eclipse

Podemos usar la opción de exportación como archivo WAR en Eclipse para desplegarlo directamente en el directorio webapps de cualquier servidor tomcat en ejecución. Sin embargo, también puedes utilizar la línea de comandos para construir el proyecto y luego copiarlo en el directorio de despliegue de tu contenedor de servlets favorito.

Prueba del Ejemplo de Spring MVC

Una vez que se haya implementado el proyecto Spring MVC, podemos acceder a la página de inicio en https://localhost:8080/spring-mvc-example/. Cambie el puerto y el context-root de Tomcat según sea necesario. Eso es todo para el ejemplo de Spring MVC, he tratado de mantenerlo lo más simple posible. Pero si aún encuentra algún problema, hágamelo saber a través de los comentarios y trataré de ayudarlo. Puede descargar el proyecto final de ejemplo de Spring MVC desde el siguiente enlace.

Descargar Proyecto de Ejemplo de Spring MVC

Referencias: Página Oficial

Source:
https://www.digitalocean.com/community/tutorials/spring-mvc-example