Spring MVC Configuración sin XML

En el primer tutorial Spring Web MVC vimos la configuración XML, esta, es la que tradicionalmente se utiliza, aunque no es la única, en este curso exploraremos la configuración mediante anotaciones la cual requiere utilizar XML y anotaciones, y también veremos la configuración programática de Spring MVC, desde código Java, por lo que eliminamos por completo la necesidad de utilizar XML.

Para este tutorial utilizaremos el proyecto de ejemplo creado anteriormente el cual adaptaremos para configurarlo primero usando anotaciones y luego programáticamente.

Configuración con anotaciones

Esta configuración nos permite reemplazar el archivo XML {servlet-name}-servlet.xml utilizado para configurar el WebApplicationContext por una clase Java anotada con @Configuration la cual sirve para indicar que una clase será utilizada para configurar el contendor Spring, para informaciones más detallada sobre la configuración con anotaciones en general puedes ver los tutoriales: Configuración del Contenedor Spring IoC.

configurar spring mvc con anotaciones

La clase AppConfig se define de la siguiente manera:

import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.ComponentScan;
import org.springframework.context.annotation.Configuration;
import org.springframework.web.servlet.view.InternalResourceViewResolver;

@Configuration
@ComponentScan(basePackages = {"carmelo.spring.webmvc"})
public class AppConfig {

    @Bean
    public InternalResourceViewResolver getInternalResourceViewResolver() {
        InternalResourceViewResolver resolver = new InternalResourceViewResolver();
        resolver.setPrefix("/WEB-INF/views/");
        resolver.setSuffix(".jsp");
        return resolver;
    }
}

La anotación @ComponentScan indica el o los paquetes donde se encuentran los controladores de nuestra aplicación web, debemos definir el bean ViewResolver que es utilizado para resolver el nombre físico de la vista, donde setPrefix("/WEB-INF/views/") indica el directorio donde se encuentran las vistas y setSuffix(".jsp") establece la extensión de las mismas.

Para terminar debemos modificar el archivo web.xml para indicarle que la configuración la haremos desde la clase e indicaremos cual es esta clase.

Primero usamos contextClass para indicar cual es la clase que implementa ApplicationContext, la que usaremos para crear un contenedor Spring Web MVC, para instanciar el contenedor a partir de una clase con anotaciones requerimos: AnnotationConfigWebApplicationContext.

<init-param>
    <param-name>contextClass</param-name>
    <param-value>
        org.springframework.web.context.support.AnnotationConfigWebApplicationContext
    </param-value>
</init-param>

El siguiente parámetro es contextConfigLocation usado para indicar donde se encuentra la configuración, no solo con anotaciones, también puede ser usado para indicar el archivo XML cuando tenga un nombre o ubicación distinto al definido por el estándar.

<init-param>
    <param-name>contextConfigLocation</param-name>
    <param-value>
        carmelo.spring.config.AppConfig
    </param-value>
</init-param>

Finalmente el archivo web.xml completo queda de la siguiente manera:

<web-app version="3.1" xmlns="http://xmlns.jcp.org/xml/ns/javaee"
         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://xmlns.jcp.org/xml/ns/javaee
                             http://xmlns.jcp.org/xml/ns/javaee/web-app_3_1.xsd">
    <servlet>

        <servlet-name>springmvc</servlet-name>
        <servlet-class>
            org.springframework.web.servlet.DispatcherServlet
        </servlet-class>

        <init-param>
            <param-name>contextClass</param-name>
            <param-value>
                org.springframework.web.context.support.AnnotationConfigWebApplicationContext
            </param-value>
        </init-param>

        <init-param>
            <param-name>contextConfigLocation</param-name>
            <param-value>
                carmelo.spring.config.AppConfig
            </param-value>
        </init-param>

        <load-on-startup>1</load-on-startup>

    </servlet>
    
    <servlet-mapping>
        <servlet-name>springmvc</servlet-name>
        <url-pattern>/</url-pattern>
    </servlet-mapping>
    
</web-app>

Con el siguiente tipo de configuración eliminamos por completo la necesidad de utilizar XML, por lo que el archivo web.xml ya no será necesario.

Configuración sin XML

Este tipo de configuración está disponible en la especificación Servlet 3.0+, en versiones anteriores debemos seguir usando el archivo web.xml, la configuración programática desde Java es posible gracias a la interface WebApplicationInitializer, las clases que la implementen serán detectadas automáticamente y serán utilizadas para inicializar el Servlet.

Creamos una clase que implemente la interface WebApplicationInitializer, e implementamos el método onStartup(ServletContext sc) aquí debemos crear el WebApplicationContext, registrar el Servlet y configurar el mapeo de las URL.

import javax.servlet.ServletContext;
import javax.servlet.ServletRegistration;

import org.springframework.web.WebApplicationInitializer;
import org.springframework.web.context.support.AnnotationConfigWebApplicationContext;
import org.springframework.web.servlet.DispatcherServlet;
import org.springframework.web.servlet.support.AbstractAnnotationConfigDispatcherServletInitializer;

public class MyWebApplicationInitializer implements WebApplicationInitializer {

    @Override
    public void onStartup(ServletContext container) {
        AnnotationConfigWebApplicationContext appContext = new AnnotationConfigWebApplicationContext();
        appContext.setConfigLocation("carmelo.spring.config.AppConfig");

        ServletRegistration.Dynamic registration
                = container.addServlet("springmvc", new DispatcherServlet(appContext));
        registration.setLoadOnStartup(1);
        registration.addMapping("/");
    }
}

Para inicializar el contenedor web Spring (WebApplicationContext) con la configuración Java usando clases anotadas, la clase creada previamente AppConfig, lo hacemos del siguiente modo:

AnnotationConfigWebApplicationContext appContext = new AnnotationConfigWebApplicationContext();
appContext.setConfigLocation("carmelo.spring.config.AppConfig");

El siguiente fragmento muestra como crear el contenedor web Spring a partir del archivo de configuración XML indicado, en este ejemplo: /WEB-INF/springmvc-servlet.xml que hemos creado en el tutorial anterior.

XmlWebApplicationContext appContext = new XmlWebApplicationContext();
appContext.setConfigLocation("/WEB-INF/springmvc-servlet.xml");

El último fragmento de código es usado para registrar el Servlet, establecer su orden de inicio a 1 y agregar el patrón de URL a mapear, para nosotros /.

ServletRegistration.Dynamic registration
        = container.addServlet("springmvc", new DispatcherServlet(appContext));
registration.setLoadOnStartup(1);
registration.addMapping("/");

El método addServlet añade un Servlet indicamos primero un nombre para el mismo, luego el DispatcherServlet creado a partir del WebApplicationContext que acabamos de crear.

Para utilizar esta configuración debemos agregar la siguiente dependencia en el archivo pom.xml.

<dependency>
    <groupId>javax</groupId>
    <artifactId>javaee-web-api</artifactId>
    <version>7.0</version>
</dependency>

Otra forma de crear y simplificar la configuración programática Java es extender la clase AbstractAnnotationConfigDispatcherServletInitializer la cual implementa la interface WebApplicationInitializer, debemos sobre-escribir los métodos necesarios.

public class MyWebApplicationInitializer extends AbstractAnnotationConfigDispatcherServletInitializer {

    @Override
    protected Class<?>[] getRootConfigClasses() {
        return null;
    }

    @Override
    protected Class<?>[] getServletConfigClasses() {
        return new Class[]{ AppConfig.class };
    }

    @Override
    protected String[] getServletMappings() {
        return new String[]{ "/" };
    }
}

En el método getServletConfigClasses() indicamos las clases usadas para configurar el contenedor web, sobre-escribimos el método getRootConfigClasses() e indicamos cual es la clase de configuración no web, en getServletMapping() indicamos el patrón para las URL.

Si todo esta correcto damos clic derecho sobre el proyecto y presionamos Run, en el navegador web veremos algo como:

desplegar-spring-mvc-en-apache-tomca

De momento es todo, en el próximo tutorial veremos en detalle la creación y configuración de los controladores de nuestra aplicación web.

Comentarios

Entradas populares de este blog

Conectar SQL Server con Java

Entrenar OpenCV en Detección de Objetos

Acceso a la webcam con OpenCV

JavaFx 8 Administrar ventanas

Analizador Léxico