De nuevo estamos aquí con otra pequeña demo, en esta ocasión vamos a utilizar el archiconocido SpringMVC para realizarla. Creo que no hay nada que decir sobre esto ya que a día de hoy es prácticamente un estandar de facto para muchas compañías pero, por si acaso hay algún despitado, SpringMVC es un framework para el desarrollo de apliciones basadas en el patrón MVC. Además, implementa otras muchas cosas, pero esto es una descripción totalmente genérica. Algo así como que la Tierra es un planeta. Los más puristas no os metáis conmigo y centraros en la demo.

Como venimos haciendo hasta ahora, vamos a utilizar Eclipse, Maven y GlashFish para la implementación y ejecución de esta pequeña demo. Sin más, vamos a empezar.

Lo primero es crear un proyecto Maven en Eclipse sin arquetipo en el cual pasaremos a rellenar el fichero pom.xml con el siguiente contenido:

pom.xml

<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.wordpress.infow</groupId>
    <artifactId>springMVC</artifactId>
    <version>1.0</version>
    <packaging>war</packaging>
    <name>springMCV</name>

    <repositories>
        <repository>
            <id>JBoss</id>
            <name>JBoss Repsitory</name>
            <layout>default</layout>
            <url>http://repository.jboss.org/nexus/content/groups/public/</url>
        </repository>
    </repositories>
    <properties>
        <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
        <spring.version>3.2.3.RELEASE</spring.version>
    </properties>
    <dependencies>
        <!-- Spring 3 dependencies -->
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-core</artifactId>
            <version>${spring.version}</version>
        </dependency>

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

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

    <build>
        <plugins>
            <plugin>
                <groupId>org.apache.maven.plugins</groupId>
                <artifactId>maven-compiler-plugin</artifactId>
                <configuration>
                    <source>1.7</source>
                    <target>1.7</target>
                </configuration>
            </plugin>
        </plugins>
    </build>
</project>

El siguiente fichero que vamos a crear es el mvc-dispatcher-servlet.xml en la ruta habitual de las configuraciones cuando estamos en una aplicación web webapp/WEB-INF/. El contenido de este fichero será el siguiente:

mvc-dispatcher-servlet.xml

<beans xmlns="http://www.springframework.org/schema/beans"
    xmlns:context="http://www.springframework.org/schema/context"
    xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
    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.wordpress.infow.spring.controller" />

    <bean class="org.springframework.web.servlet.view.InternalResourceViewResolver">
        <property name="prefix">
            <value>/WEB-INF/pages/</value>
        </property>
        <property name="suffix">
            <value>.jsp</value>
        </property>
    </bean>
</beans>

Y como no, vamos a meter aquí tambíen nuestro fichero web.xml con el siguiente contenido:

web.xml

<web-app id="WebApp_ID" version="2.4"
    xmlns="http://java.sun.com/xml/ns/j2ee" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
    xsi:schemaLocation="http://java.sun.com/xml/ns/j2ee
    http://java.sun.com/xml/ns/j2ee/web-app_2_4.xsd">

    <display-name>SpringMVC - ¡Hola Mundo!</display-name>

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

    <servlet-mapping>
        <servlet-name>mvc-dispatcher</servlet-name>
        <url-pattern>/</url-pattern>
    </servlet-mapping>

    <context-param>
        <param-name>contextConfigLocation</param-name>
        <param-value>/WEB-INF/mvc-dispatcher-servlet.xml</param-value>
    </context-param>

    <listener>
        <listener-class>org.springframework.web.context.ContextLoaderListener</listener-class>
    </listener>
</web-app>

No creo que ninguno de los dos fichero necesite ningún tipo de explicación ya que ambos, por su contenido, son auto explicativos. De todas formas, como siempre, os animo a preguntar ante cualquier duda.

El siguiente de los ficheros a implementar es la página jsp que nos va a mostrar nuestro mensaje. A partir de aquí, cuando veáis el resto del código váis a pensar que el proyecto tiene poco de MVC, y váis a tener razón, ya que dada la poca extensión del ejemplo no había mucho más que implementar, pero la idea de esto, no olvidemos, era montar un ejemplo con la tecnología y no hacer unos ejemplo complejos, esto ya vendrá más adelante cuando empecemos a implementar proyectos más grandes. Pero bueno, que me voy por las ramas, el siguiente fichero tendrá este contenido:

hello.jsp

<html>
    <head>
        <title>SpringMVC - Hola Mundo!</title>
    </head>
    <body>
        <p>Message: ${message}</p>
    </body>
</html>

Y finalmente, la clase java que va encargarse de generar el mensaje:

MessageController.java

@Controller
@RequestMapping("/message")
public class MessageController {

    @RequestMapping(method = RequestMethod.GET)
    public String showMessage(ModelMap model) {
        model.addAttribute("message", "¡Hola Mundo!");

        return "hola";
    }
}

Lo único digno de comentar aquí son las anotaciones, aunque son bastante intuitivas:

• @Controller: Marca la clase como un controlador de Spring.
• @RequestMapping: Será la URL que apunte a esta clase. Nivel de clase.
• @RequestMapping: Tipo de petición que se recibirá. Nivel de método.

La cuestión es que al acceder a la URL de la clase se generará y asignará el atributo “message” que se mostrará luego en la página JSP.

Como siempre os dejo el código para que podáis ver el proyecto completo.

Código SpringMVC Hello Wordl: SpringMVC

Sin más, hasta aquí hemos llegado hoy. Nos vemos.