Hola Mundo con Spring Framework y Eclipse

Antes de empezar con esta aplicación básica asumimos que ya se conoce la teoría de cómo funciona Spring, pues existen varios conceptos los cuales deberíamos saber antes de desarrollar una aplicación web utilizando este Framework. Una definición muy breve que podemos dar es la siguiente: Spring es un Framework muy popular en java que nos permite desarrollar aplicaciones web más robustas y está dividido en distintos módulos los cuales dan apoyo global al desarrollo de nuestras aplicaciones, es así que, Spring se encarga de la infraestructura mientras que nosotros nos dedicamos solo a la aplicación.

En primer lugar vamos a definir las librerías que necesitamos importar. La siguiente imagen detalle esto:

Los jars de Spring Framework son los mínimos que se requieren para desarrollar nuestra aplicación básica de “Hola Mundo”. Bien, para empezar creamos un nuevo proyecto web dinámico en Eclipse:

Lo nombraremos SpringBasico, seleccionamos el Target Runtime que en este caso es Apache Tomcat v7.0, seleccionamos la última versión que tengamos para Dinamic web module version y para Configuration seleccionamos también la configuración por defecto para apache tomcat.

Hacemos clic en Next y nuevamente Next para marcar la casilla de Generate web.xml deployment descriptor.

Terminamos haciendo clic en Finish y se creará nuestro proyecto con las configuraciones seleccionadas. Una vez creada nuestro proyecto, iniciamos el servidor que establecimos como contenedor de nuestra aplicación haciendo clic en el menú Start.

Agregando nuestra clase controladora

En la ruta de la carpeta src creada en el proyecto, crearemos un nuevo paquete y lo nombramos com.rolandopalermo.blog.controller.

Dentro de nuestro paquete creado agregamos nuestra clase que nombraremos HolaSpringController la cual será la clase que hará de controlador para nuestra aplicación.

Esta clase controladora se basa en las anotaciones @Controller y @RequestMapping, las cuales mapearán a holaMundo para que sea accesible desde la página jsp ejecutando el método holaMundoSpring. Este método retorna una instancia de ModelAndView, el cual representa un modelo (lógica de datos) y una vista (interfaz de usuario) y contiene los objetos correspondientes necesarios para nuestra página jsp.

package com.rolandopalermo.blog.controller;

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

@Controller
public class HolaSpringController {

    @RequestMapping(“/holaMundo”)
    public ModelAndView holaMundoSpring() {
         ModelAndView modelAndView = new ModelAndView();
         String mensaje = “Hola Mundo Spring”;
         modelAndView.addObject(“mensaje”, mensaje);
         modelAndView.setViewName(“holaSpring”);
         return modelAndView;
    }

}

En la línea 1 está el nombre del paquete, de la línea 3 a la 5 se definen los import necesarios para esta clase, en la línea 7 está la anotación @Controller que especifica que se trata de una clase controladora para Spring, en la línea 8 empieza a definirse la clase HolaSpring, la línea 10 tiene la anotación @RequestMapping con la cadena de mapeo "/holaMundo" que es a la que haremos referencia desde nuestra página jsp, en la línea 11 empieza a definirse el método holaMundoSpring a ejecutarse, la línea 13 inicializa el objeto a devolver del tipo ModelAndView, la línea 14 inicializa el mensaje a devolver la cual añadiremos a nuestro ModelAndView en la línea 15, la línea 16 nombra a nuestro objeto vista (mismo nombre de nuestra clase jsp) y la línea 18 retorna este objeto vista.

Creando el index.jsp

Crearemos nuestro index.jsp en el directorio WebContent. Este página tendrá un enlace directo a otra página (holaSpring.jsp) a la que accedemos a través de la referencia holaMundo.html la cual definimos como cadena a mapear en la clase controladora (@RequestMapping(“/holaMundo”)).

<%@ 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>Hola Mundo Spring</title>
</head>
<body>
       <a href="holaMundo.html">Link Spring</a>
</body>
</html>

Crearemos nuestro holaSpring.jsp dentro de un nuevo directorio, para esto creamos una carpeta dentro del directorio de WebContent la cual nombraremos pages. Esta página es a la que se accede al llamar al método referenciado y mapeado en el controlador. Como observamos, en esta página se mostrará el mensaje enviado desde el controlador (modelAndView.addObject(“mensaje”, mensaje)).

<%@ 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>Hola Mundo Spring</title>
</head>
<body>
       <h4>${mensaje}</h4>
</body>
</html>

Adicionalmente y muy importante es la creación de los archivos de configuración para que la aplicación pueda funcionar correctamente bajo el framework de Spring.

WEB.XML

Al crear el proyecto web, se creó también el archivo web.xml dentro del directorio WebContent\WEB-INF. Este archivo contendrá la definición de una entrada servlet de la clase org.springframework.web.servlet.DispatcherServlet. En el servlet definido se muestra un mapeo de DispatcherServlet nombrado springBasico con /, esto indica que se puede mapear con una pagina .html, .htm o cualquier otra extensión a la que se haga referencia en la url.

<?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>SpringBasico</display-name>
       <!-- Spring -->
       <servlet>
             <servlet-name>springBasico</servlet-name>
             <servlet-class>org.springframework.web.servlet.DispatcherServlet</servlet-class>
             <load-on-startup>1</load-on-startup>
       </servlet>
       <servlet-mapping>
             <servlet-name>springBasico</servlet-name>
             <url-pattern>/</url-pattern>
       </servlet-mapping>
   <welcome-file-list>
             <welcome-file>index.jsp</welcome-file>
   </welcome-file-list>
</web-app>

Tener en cuenta que el servlet nombrado en la etiqueta debe ser el mismo que el archivo xml que configuraremos a continuación terminando con el sufijo -servlet.xml. Esto se realiza debido a que cuando el DispatcherServlet se iniciliza, buscará a nuestro archivo springBasico-servlet.xml en el directorio WEB-INF de la aplicación. Entonces agreguemos un nuevo archivo xml: springBasico-servlet.xml.

<?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.rolandopalermo.blog" />
       <bean id="jspViewResolver"
             class="org.springframework.web.servlet.view.InternalResourceViewResolver">
             <property name="viewClass"
                    value="org.springframework.web.servlet.view.JstlView" />
             <property name="prefix" value="/pages/" />
             <property name="suffix" value=".jsp" />
       </bean>
</beans>

El archivo springBasico-servlet.xml define la etiqueta lo que permite a Spring cargar todos los componentes desde paquete com.rolandopalermo.blog y esto hará que cargue nuestra clase controladora HolaSpringController. También definimos el jspViewResolver el cual interpretará la vista y agregará el prefijo /pages/ y el sufijo .jsp a la vista en ModelAndView retornada desde nuestro controlador (modelAndView.setViewName(“holaSpring”)). Por lo tanto al retornar holaSpring como nombre de la vista desde el controlador, se interpretará como: /pages/holaSpring.jsp.

Finalmente nuestro proyecto debería quedar estructurado de la siguiente manera:

Finalmente cuando ejecutamos nuestro proyecto, tendremos la siguiente vista en nuestro navegador, cuyo enlace nos lleva a otra página utilizando Spring.

Podría parecer que estamos utilizando muchas cosas para realizar un simple enlace que nos lleve hacia otra página, pero utilizar este Framework en aplicaciones reales y de más envergadura obviamente nos mostrará su verdadera potencia.

Y como siempre, fiel al estilo de este blog, aquí les dejo las fuentes del proyecto.

Recuerden de seguir a este blog a través de su página en Facebok para enterarse de nuestras nuevas publicaciones. Un saludo a todos.