Tipicamente cuando incursionamos con un nuevo framework o lenguaje de programacion queremos rapidamente hacer funcionar algo, y como estoy dedicando una serie de articulos a Spring Framework, no podia faltar uno dedicado al simple y bien ponderado "Hola Mundo"... La idea es mostrar como construir el Skeleton fundamental para que nuestra aplicacion Spring MVC funcione...
Para realizar este ejemplo como la mayoria de los publicados aqui usaré:
- Eclipse (Juno) como IDE
- Maven (plugin de eclipse) para incluir facilmente librerias y dependencias
- Tomcat 7
- Spring Framework (en este ejemplo la version 3.01)
Configurando el nuevo proyecto
Lo primero es crear un nuevo proyecto, para esto podemos usar clic derecho la ventana de Package Explorer o bien en
Archivo->New->Project y seleccionar
Maven Project
Luego seleccionado Maven Project le damos
Next, para seleccionar el nombre y la ubicacion del proyecto, en esta oportunidad todos los valores quedan por defecto y ademas debemos seleccionar el checkbox "
Create a simple project (skip archetype selection)" para saltarnos la selección de arquetipo puesto que lo crearemos nosotros mismos...
Ahora introducimos informacion de configuracion del proyecto como el grupo, artefacto, version y forma de empaquetamiento, en este caso el Group Id es com.codelious.mimvc, el Artifact Id es MiMVC y en Packaging seleccionamos war, la version queda por defecto...
Luego damos clic en Finish y deberiamos tener nuestro proyecto creado con una estructura basica que incluye los directorios
src/main/webapp y tambien se ha creado nuestro archivo
pom.xml que nos permitira el facil manejo de dependencias con Maven.
Dentro de nuestro directorio webapp debemos crear manualmente algunos directorios y archivos para que se vea finalmente una estructura como la de la imagen abajo...
Incluyendo dependencias Maven
Ahora debemos incluir algunas dependencias y las librerias de Spring Framework en nuestro archivo pom.xml para que Maven las cargue a nuestro proyecto, editemos el contenido del pom.xml para que quede asi:
<project xmlns="http://maven.apache.org/POM/4.0.0"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xsi:schemaLocation="http://maven.apache.org/POM/4.0.0
http://maven.apache.org/xsd/maven-4.0.0.xsd">
<modelVersion>4.0.0</modelVersion>
<groupId>com.codelious.mimvc</groupId>
<artifactId>MiMVC</artifactId>
<version>0.0.1-SNAPSHOT</version>
<packaging>war</packaging>
<dependencies>
<dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-webmvc</artifactId>
<version>3.0.1.RELEASE</version>
</dependency>
<dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-context</artifactId>
<version>3.0.1.RELEASE</version>
</dependency>
<dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-core</artifactId>
<version>3.0.1.RELEASE</version>
</dependency>
<dependency>
<groupId>commons-logging</groupId>
<artifactId>commons-logging</artifactId>
<version>1.1.1</version>
</dependency>
<dependency>
<groupId>javax.servlet</groupId>
<artifactId>jstl</artifactId>
<version>1.2</version>
</dependency>
</dependencies>
</project>
Configurando nuestra aplicación
Luego de añadir las dependencias, debemos codificar nuestro archivo
web.xml que es el descriptor de despliegue, y ahi debemos incluir las referencias a nuestro
Dispatcher Servlet que es basicamente el
despachador de solicitudes a controladores.
<?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_3_0.xsd"
id="WebApp_ID" version="3.0">
<display-name>MiMVC</display-name>
<welcome-file-list>
<welcome-file>index.jsp</welcome-file>
</welcome-file-list>
<servlet>
<servlet-name>despachador</servlet-name>
<servlet-class>org.springframework.web.servlet.DispatcherServlet</servlet-class>
<load-on-startup>1</load-on-startup>
</servlet>
<servlet-mapping>
<servlet-name>despachador</servlet-name>
<url-pattern>*.html</url-pattern>
</servlet-mapping>
</web-app>
Como se puede notar en el
web.xml arriba, tenemos un
<servlet> y un
<servlet-mapping>, el servlet-mapping trabaja direccionando todos los patrones de url que incluyan extension
.html a nuestro dispatcher servlet llamado
despachador que es de clase
org.springframework.web.servlet.DispatcherServlet, por tanto no es coincidencia que hayamos creado un archivo
despachador-servlet.xml, ya que spring buscará un archivo con nombre compuesto por el nombre del servlet añadiendo "
-servlet.xml" o sea si en el archivo
web.xml estamos declarando el dispatcher servlet con
<servlet-name>mascotas</servlet-name> entonces se buscará el archivo
mascotas-servlet.xml
También tenemos
<welcome-file-list> que permite indicar la pagina de entrada a la aplicacion, la que en este caso sera
index.jsp
Ahora codificamos el dispatcher servlet llamado
despachador-servlet.xml añadiendo bean viewResolver y un component-scan:
<?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:context="http://www.springframework.org/schema/context"
xsi:schemaLocation="http://www.springframework.org/schema/beans
http://www.springframework.org/schema/beans/spring-beans-3.0.xsd
http://www.springframework.org/schema/context
http://www.springframework.org/schema/context/spring-context-3.0.xsd">
<context:component-scan
base-package="com.codelious.mimvc.controller" />
<bean id="viewResolver"
class="org.springframework.web.servlet.view.UrlBasedViewResolver">
<property name="viewClass"
value="org.springframework.web.servlet.view.JstlView" />
<property name="prefix" value="/WEB-INF/jsp/" />
<property name="suffix" value=".jsp" />
</bean>
</beans>
El bean
context:component-scan resaltado arriba permitirá escanear automáticamente todos los controladores ubicados en el paquete
com.codelious.mimvc.controller, tambien es posible declarar varios beans por separado que invocan directamente a cada controlador.
El bean
viewResolver nos permitirá resolver las vistas de nuestra aplicación cuando las invoquemos desde nuestros controladores y en este caso indica la ubicacion de las vistas.
Codificando la pagina de entrada
Como mencionamos en el archivo de configuracion web.xml declaramos una pagina de entrada a la aplicacion, para esto agreguemos el siguiente codigo a index.jsp
<%@ page language="java" contentType="text/html; charset=ISO-8859-1"
pageEncoding="ISO-8859-1"%>
<!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>MiMVC</title>
</head>
<body>
<h1>Bienvenido a MiMVC</h1>
<p>
Presiona el link para ver el <a href="saludar.html">saludo</a>
</p>
</body>
</html>
Creando el controlador
Vamos a crear un contralador llamado "Saludo" que recibira nuestra solicitud desde la pagina de entrada
index.jsp y luego nos direccionará a la vista de saludo, para esto debemos crear en
src/main/java el paquete
com.codelious.mimvc.controller donde crearemos la clase
SaludoController.java y le agregaremos el siguiente codigo:
package com.codelious.mimvc.controller;
import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.servlet.ModelAndView;
@Controller
public class SaludoController {
@RequestMapping("/saludar")
public ModelAndView saludar(){
String mensaje = "Hola Mundo Maravilloso";
return new ModelAndView("saludo", "mensaje", mensaje);
}
}
En el codigo hemos creado un metodo saludar() que devuelve
ModelAndView y es el metodo que procesará nuestra solicitud y nos direccionará a la vista deseada, luego hemos puesto un par de anotaciones de Spring, la primera es
@Controller e indica que la clase es un controlador, la segunda es
@RequestMapping("/saludar") que permite mapear la solicitud desde la url. El metodo saludar() nos retornará un objeto ModelAndView al cual le indicamos la vista que en nuestro caso sera saludo.jsp, luego incluimos un mensaje que estará disponible en nuestra vista para accederlo mediante tags jstl.
Creando la vista
Para nuestra vista crearemos en WEB-INF/jsp el archivo saludo.jsp en el cual agregaremos nuestro codigo:
<%@ page language="java" contentType="text/html; charset=ISO-8859-1"
pageEncoding="ISO-8859-1"%>
<!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>MiMVC</title>
</head>
<body>
<h1>${mensaje}</h1>
</body>
</html>
Probando la aplicacion
Hecho todo lo anterior deberiamos tener una estructura similar a la siguiente:
y entonces ya podemos probar nuestra aplicación en un navegador web, para eso podemos dar clic derecho sobre la raiz de nuestro proyecto y seleccionar Run As->Run on Server y verlo en la direccion http://localhost:18080/MiMVC/ (reemplazar el puerto 18080 por el que uses)
Si damos clic al link saludo estaremos haciendo la llamada al controlador y este nos devolvera la pagina saludo.jsp
Y esto sería todo, ya tenemos nuestro hola mundo MVC en Spring Framework. Si quieres descargar el proyecto completo puedes hacerlo en github:
https://github.com/codelious/MiMVC
