¡Hola Mundo! con Spring

By | 8 agosto 2013

Para este ejemplo, muy simple, de como crear la base de una aplicación con Spring y Maven, va a ser necesario importar las siguientes dependencias en el pom.xml.

<spring-version>3.2.3.RELEASE</spring-version>

<dependencies>

        <!-- SPRING -->

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

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

        <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>

        <!-- END SPRING -->

        <dependency>
            <groupId>javax</groupId>
            <artifactId>javaee-web-api</artifactId>
            <version>6.0</version>
            <scope>provided</scope>
        </dependency>
    </dependencies>

Una vez que Maven haya descargado las librerías, empezaremos a configurar nuestra aplicación con Spring.

Primero crearemos el descriptor de aplicaciones, web.xml, dentro del directorio /web/.

    <display-name>SpringApp</display-name>

    <!-- ContextLoaderListener -->

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

    <context-param>
        <param-name>contextConfigLocation</param-name>
        <param-value>
            /WEB-INF/applicationContext.xml
        </param-value>
    </context-param>

    <!-- End ContextLoaderListener -->

    <!-- DispatcherServlet -->

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

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

    <!-- End DispatcherServlet -->

    <session-config>
        <session-timeout>30</session-timeout>
    </session-config>

Como podemos observar, en el web.xml hemos especificado un DispatcherServlet y un ContextLoaderListener.

A nuestro DispatcherServlet le hemos asignado “springapp” como nombre, podría ser cualquier otro, pero al no especificarle un namespace buscará por defecto en /web/WEB-INF/springapp-servlet.xml la configuración para inicializar sus dependencias.

A nuestro ContextLoaderListener le hemos especificado a través de contextConfigLocation que busque en /web/WEB-INF/applicationContext.xml la descripción de los beans que deberá crear, esa ubicación y nombre del archivo descriptor coinciden con la que Spring asigna por defecto, como me gusta, la he dejado así.

Por ultimo, hemos especificado un nombre descriptivo a través de la etiqueta <display-name /> y  el tiempo en minutos a través de la etiqueta <session-config /> que durara un Thread de Session antes de ser destruido.

El siguiente paso es crear dentro de /web/WEB-INF/ los archivos springapp-servlet.xmlapplicationContext.xml.

Empezaremos por applicationContext.xml, ya que como explicamos en el punto Diferencia entre applicationContext.xml y dispatcher-servlet.xml es el encargado de crear el root Context de la aplicación.

    <!-- Activa la configuracion de componentes mediante anotaciones -->
    <mvc:annotation-driven />

    <!-- Especifica la ubicación de componentes -->
    <context:component-scan base-package="com.pj.springapp.**" />

Para <content:component-scan /> hemos especificado mediante Ant expression el subconjunto de paquetes dentro de los cuales buscará las clases configuradas mediante anotaciones.

Seguidamente configuraremos  springapp-servlet.xml, como explicamos en el punto Diferencia entre applicationContext.xml y dispatcher-servlet.xml es el encargado de crear el servlet context de nuestro DispatcherServlet.

    <!-- Manejador de vistas -->
    <bean id="viewResolver"
              class="org.springframework.web.servlet.view.InternalResourceViewResolver"
              p:prefix="/WEB-INF/jsp/"
              p:suffix=".jsp" />

InternalResourceViewResolver se encarga de seleccionar el recurso, en este caso un JSP, encargado de renderizar las vistas, es invocado por DispatcherServlet una vez que recibe la respuesta del Controlador, el cual le provee de los datos y el nombre de la vista que debe invocar.

El siguiente paso es crear nuestro primer Controlador, muy simple, este debe ir dentro del directorio de paquetes com.pj.springapp.** especificado en nuestro applicationContext.xml. Unicamente agregara en el Model una serie de datos que serán renderizados en la vista, al mismo tiempo que determinará el nombre de esta.

@Controller
public class MainController {

    /**
     * Muestra la pagina de inicio.
     *
     * @param model Objeto de Spring para la carga de atributos.
     * @param request Objeto que contiene todas las propiedades de la llamada.
     * @return String Nombre de la vista.
     */
    @RequestMapping({"/", "/index"})
    public String showHomePage(Model model, HttpServletRequest request) {

        model.addAttribute("author", "Daniel Pardo Ligorred");
        model.addAttribute("website", "http://www.programacionj2ee.com");

        return "home";
    }
}

@Controller es la anotación encargada de informar a ContextLoaderListener que se trata de un Controlador de la aplicación.

@RequestMapping se encarga de especificar a DispatcherServlet de que llamadas se va a encargar, en este caso de dos, “/” y “/index”.

Model y HttpServletRequest son inyectados por Spring IoC en cada llamada, en Model agregaremos la información necesaria para renderizar la vista, mientras que HttpServletRequest nos aporta toda la información relativa a la llamada, en este caso no lo utilizamos para nada y podríamos prescindir de el.

Retornamos un String con el nombre de la vista encargada de renderizar la respuesta al cliente, en este caso será resuelta por nuestro InternalResourceViewResolver.

Por último, tenemos que crear home.jsp dentro de “/WEB-INF/jsp/”, que es el directorio especificado en nuestro InternalResourceViewResolver

<%@page contentType="text/html" pageEncoding="UTF-8"%>
<!DOCTYPE html>
<html>
    <head>
        <meta http-equiv="Content-Type" content="text/html; charset=UTF-8">
        <title>SpringApp | programacionj2ee.com</title>
    </head>
    <body>

        <h1>¡Hola Mundo!</h1>

        <div>
            <p>Autor: ${author} @ ${website}</p>
        </div>

    </body>
</html>

Un JSP se trata de un Servlet con unas características especiales, la directiva @page nos sirve para especificar que tipo de documento y en que codificación va a ser servido como respuesta.

Con Expression Language, recogemos los parámetros del Model necesarios para poder renderizar la vista.

Y esto es todo lo necesario para realizar una primera aplicación de muestra con Spring.

El código fuente de la aplicación lo podéis encontrar aquí.

Comparte esta entrada enShare on LinkedIn0Tweet about this on Twitter0Share on Facebook0Share on Google+0

4 thoughts on “¡Hola Mundo! con Spring

  1. wonga

    I am extremely impressed with your writing skills and also with the layout on your weblog. Is this a paid theme or did you customize it yourself? Anyway keep up the excellent quality writing, it’s rare to see a great blog like this one today..

  2. Elton Caldwell

    Y Spring MVC también tiene su archivo de configuración, al estilo del struts-config.xml de Struts. En este caso el nombre es el nombre de la servlet (<servlet-name>) seguido de “-servlet.xml”. En este caso, holamundo-servlet.xml.

  3. admin Post author

    Hello wonga and thank you very much for cheering me up. Blog theme is based on Graphene theme by Syahir Hakim and something edited by me.

  4. admin Post author

    Hola Elton y gracias por comentar.

    Efectivamente tambien podriamos configurar el ejemplo a través del , pero en mi opinon siempre es mejor configurar ciertos servicios no especificos de DispatchetServlet en ApplicationContext. Si te fijas en esta misma entrada existe una mención al punto del manual Diferencia entre applicationContext.xml y dispatcher-servlet.xml donde explico las diferencias entre ambos y porque de esta decisión.

    ¡Un saludo!

Deja un comentario

Tu dirección de correo electrónico no será publicada. Los campos necesarios están marcados *