CodeGym /Cursos /Módulo 5. Spring /Configuración de Spring MVC

Configuración de Spring MVC

Módulo 5. Spring

Nivel 10 , Lección 12

Disponible

Java MVC Configuration y MVC XML Namespace proporcionan una configuración predeterminada adecuada para la mayoría de las aplicaciones y una API de configuración para personalizarla.

No es necesario comprender los beans subyacentes producidos por MVC Java Configuration y el espacio de nombres MVC.

Activación de una configuración MVC

En una configuración Java, puede utilizar la anotación @EnableWebMvc para habilitar una configuración MVC, como se muestra en el siguiente ejemplo:

Java


@Configuration
@EnableWebMvc
public class WebConfig {
}

Kotlin


@Configuration
@EnableWebMvc
class WebConfig

En la configuración XML, puede utilizar el <mvc:annotation-driven> elemento para activar la configuración MVC, como se muestra en el siguiente ejemplo:


<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
    xmlns:mvc="http://www.springframework.org/schema/mvc"
    xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
    xsi:schemaLocation="
        http://www.springframework.org/schema/beans
        https://www.springframework.org/schema/beans/spring-beans.xsd
        http://www.springframework.org/schema/mvc
        https://www.springframework.org/schema/mvc/spring-mvc.xsd">
    <mvc:annotation-driven/>
</beans>

El siguiente ejemplo registra una cantidad de beans de infraestructura Spring MVC y se adapta a las dependencias disponibles en el classpath (por ejemplo, convertidores de carga útil para JSON, XML, etc.).

API de configuración MVC

En la configuración de Java, puede implementar la interfaz WebMvcConfigurer, como se muestra en el siguiente ejemplo. :

Java


@Configuration
@EnableWebMvc
public class WebConfig implements WebMvcConfigurer {
// Implementar métodos de configuración...
}

Kotlin


@Configuration
@EnableWebMvc
class WebConfig : WebMvcConfigurer {
    // Implement configuration methods...
}

En XML, puede validar atributos y subelementos <mvc:annotation-driven/>. Puede ver el esquema XML de Spring MVC o utilizar la función de finalización de código en su IDE. para saber qué atributos y subelementos están disponibles.

Conversión de tipos

De forma predeterminada, los formateadores se instalan para varios tipos de números y fechas, junto con soporte de personalización a través de @NumberFormat y @DateTimeFormat para los campos.

Para registrar formateadores y convertidores personalizados en la configuración de Java, utilice lo siguiente:

Java


@Configuration
@EnableWebMvc
public class WebConfig implements WebMvcConfigurer {
    @Override
    public void addFormatters(FormatterRegistry registry) {
        // ...
    }
}

Kotlin


@Configuration
@EnableWebMvc
class WebConfig : WebMvcConfigurer {
    override fun addFormatters(registry: FormatterRegistry) {
        // ...
    }
}

Para hacer lo mismo en la configuración XML, use lo siguiente:


<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
    xmlns:mvc="http://www.springframework.org/schema/mvc"
    xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
    xsi:schemaLocation="
        http://www.springframework.org/schema/beans
        https://www.springframework.org/schema/beans/spring-beans.xsd
        http://www.springframework.org/schema/mvc
        https://www.springframework.org/schema/mvc/spring-mvc.xsd">
    <mvc:annotation-driven conversion-service="conversionService"/>
    <bean id="conversionService"
          class="org.springframework.format.support.FormattingConversionServiceFactoryBean">
        <property name="converters">
            <set>
                <bean class="org.example.MyConverter"/>
            </set>
        </property>
        <property name="formatters">
            <set>
                <bean class="org.example.MyFormatter"/>
                <bean class="org.example.MyAnnotationFormatterFactory"/>
            </set>
        </property>
        <property name="formatterRegistrars">
            <set>
                <bean class="org.example.MyFormatterRegistrar"/>
            </set>
        </property>
    </bean>
</beans>

De forma predeterminada, Spring MVC respeta la configuración regional de la solicitud al analizar y formatear valores de fecha. Esto es cierto para formularios donde las fechas se representan como cadenas con campos de formulario de "entrada". Sin embargo, para los campos de formulario "fecha" y "hora", los navegadores utilizan un formato fijo definido en la especificación HTML. Para tales casos, el formato de fecha y hora se puede configurar de la siguiente manera:

Java


@Configuration
@EnableWebMvc
public class WebConfig implements WebMvcConfigurer {
    @Override
    public void addFormatters(FormatterRegistry registry) {
        DateTimeFormatterRegistrar registrar = new DateTimeFormatterRegistrar();
        registrar.setUseIsoFormat(true);
        registrar.registerFormatters(registry);
    }
}

Kotlin


@Configuration
@EnableWebMvc
class WebConfig : WebMvcConfigurer {
    override fun addFormatters(registry: FormatterRegistry) {
        val registrar = DateTimeFormatterRegistrar()
        registrar.setUseIsoFormat(true)
        registrar.registerFormatters(registry)
    }
}

Validación

Predeterminado, si un Bean de validación está presente en el classpath (por ejemplo, Hibernate Validator), el LocalValidatorFactoryBean se registra como un validador global para su uso con la anotación @Valid y el Propiedad Validated en argumentos para métodos de controlador.

En su configuración de Java, puede configurar una instancia global de Validator, como se muestra en el siguiente ejemplo:

Java


@Configuration
@EnableWebMvc
public class WebConfig implements WebMvcConfigurer {
    @Override
    public Validator getValidator() {
        // ...
    }
}

Kotlin


@Configuration
@EnableWebMvc
class WebConfig : WebMvcConfigurer {
    override fun getValidator(): Validator {
        // ...
    }
}

El siguiente ejemplo muestra cómo obtener la misma configuración en XML:


<?xml version="1.0" encoding="UTF-8"?>
    <beans xmlns="http://www.springframework.org/schema/beans"
    xmlns:mvc="http://www.springframework.org/schema/mvc"
    xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
    xsi:schemaLocation="
        http://www.springframework.org/schema/beans
        https://www.springframework.org/schema/beans/spring-beans.xsd
        http://www.springframework.org/schema/mvc
        https://www.springframework.org/schema/mvc/spring-mvc.xsd">
    <mvc:annotation-driven validator="globalValidator"/>
</beans>

Tenga en cuenta que también es posible registrar implementaciones de Validator localmente, como se muestra en el siguiente ejemplo:

Java


@Controller
public class MyController {
    @InitBinder
    protected void initBinder(WebDataBinder binder) {
        binder.addValidators(new FooValidator());
    }
}

Kotlin


@Controller
class MyController {
    @InitBinder
    protected fun initBinder(binder: WebDataBinder) {
        binder.addValidators(FooValidator())
    }
}

Si es necesario que LocalValidatorFactoryBean se inyectó en algún lugar, cree un bean y márquelo con la anotación @Primary para evitar conflictos con lo que se declaró en la configuración de MVC.

Interceptores

En su configuración de Java, puede registrar interceptores para aplicarlos a las solicitudes entrantes, como se muestra en el siguiente ejemplo:

Java


@Configuration
@EnableWebMvc
public class WebConfig implements WebMvcConfigurer {
    @Override
    public void addInterceptors(InterceptorRegistry registry) {
        registry.addInterceptor(new LocaleChangeInterceptor());
        registry.addInterceptor(new ThemeChangeInterceptor()).addPathPatterns("/**").excludePathPatterns("/admin/**");
    }
}

Kotlin


@Configuration
@EnableWebMvc
class WebConfig : WebMvcConfigurer {
    override fun addInterceptors(registry: InterceptorRegistry) {
        registry.addInterceptor(LocaleChangeInterceptor())
        registry.addInterceptor(ThemeChangeInterceptor()).addPathPatterns("/**").excludePathPatterns("/admin/**")
    }
}

El siguiente ejemplo muestra cómo obtener la misma configuración en XML:


<mvc:interceptors>
    <bean class="org.springframework.web.servlet.i18n.LocaleChangeInterceptor"/>
    <mvc:interceptor>
        <mvc:mapping path="/**"/>
        <mvc:exclude-mapping path="/admin/**"/>
        <bean class="org.springframework.web.servlet.theme.ThemeChangeInterceptor"/>
    </mvc:interceptor>
</mvc:interceptors>

Los interceptores mapeados no son ideales para usar como capa de seguridad debido a la posibilidad de inconsistencia con el controlador de coincidencia de ruta anotado, que también puede negociar de forma transparente barras diagonales y extensiones de ruta, junto con otras opciones de coincidencia de ruta. Muchas de estas opciones ahora están obsoletas, pero persiste la posibilidad de inconsistencia. En general, recomendamos utilizar Spring Security, que incluye un MvcRequestMatcher para la coincidencia de rutas de Spring MVC y también tiene un firewall de seguridad que bloquea muchos caracteres no deseados en las rutas URL.

Tipos de contenido

El método se puede configurar. Spring MVC define los tipos de medios solicitados a partir de la solicitud (como el encabezado Aceptar, la extensión de la ruta URL, el parámetro de solicitud y otros).

De forma predeterminada, solo se muestra el encabezado marque Aceptar.

Si necesita utilizar una resolución de tipo de contenido basada en URL, considere usar una estrategia de parámetros de solicitud en lugar de extensiones de ruta.

En Java configuración, puede configurar la resolución del tipo de contenido solicitado, como se muestra en el siguiente ejemplo:

Java


@Configuration
@EnableWebMvc
public class WebConfig implements WebMvcConfigurer {
    @Override
    public void configureContentNegotiation(ContentNegotiationConfigurer configurer) {
        configurer.mediaType("json", MediaType.APPLICATION_JSON);
        configurer.mediaType("xml", MediaType.APPLICATION_XML);
    }
}

Kotlin


@Configuration
@EnableWebMvc
class WebConfig : WebMvcConfigurer {
    override fun configureContentNegotiation(configurer: ContentNegotiationConfigurer) {
        configurer.mediaType("json", MediaType.APPLICATION_JSON)
        configurer.mediaType("xml", MediaType.APPLICATION_XML)
    }
}

El siguiente ejemplo muestra, cómo obtener la misma configuración en XML:


<mvc:annotation-driven content-negotiation-manager="contentNegotiationManager"/>
<bean id="contentNegotiationManager" class="org.springframework.web.accept.ContentNegotiationManagerFactoryBean">
    <property name="mediaTypes">
        <value>
            json=application/json
            xml=application/xml
        </value>
    </property>
</bean>

Convertidores de mensajes

Puedes configurar HttpMessageConverter en tu configuración de Java anulando configureMessageConverters() (para reemplazar los convertidores predeterminados creados por Spring MVC) o anulando extendMessageConverters() (para personalizar los convertidores predeterminados o agregar convertidores adicionales a los convertidores predeterminados).

El siguiente ejemplo agrega convertidores XML y Jackson JSON con configurado ObjectMapper en lugar de los estándar:

Java


@Configuration
@EnableWebMvc
public class WebConfiguration implements WebMvcConfigurer {
    @Override
    public void configureMessageConverters(List<HttpMessageConverter<?>> converters) {
        Jackson2ObjectMapperBuilder builder = new Jackson2ObjectMapperBuilder()
                .indentOutput(true)
                .dateFormat(new SimpleDateFormat("yyyy-MM-dd"))
                .modulesToInstall(new ParameterNamesModule());
        converters.add(new MappingJackson2HttpMessageConverter(builder.build()));
        converters.add(new MappingJackson2XmlHttpMessageConverter(builder.createXmlMapper(true).build()));
    }
}

Kotlin


@Configuration
@EnableWebMvc
class WebConfiguration : WebMvcConfigurer {
    override fun configureMessageConverters(converters: MutableList<HttpMessageConverter<*>>) {
        val builder = Jackson2ObjectMapperBuilder()
                .indentOutput(true)
                .dateFormat(SimpleDateFormat("yyyy-MM-dd"))
                .modulesToInstall(ParameterNamesModule())
        converters.add(MappingJackson2HttpMessageConverter(builder.build()))
        converters.add(MappingJackson2XmlHttpMessageConverter(builder.createXmlMapper(true).build()))

En el ejemplo anterior Jackson2ObjectMapperBuilder se utiliza para crear una configuración común para MappingJackson2HttpMessageConverter y MappingJackson2XmlHttpMessageConverter con sangría habilitada, formato de fecha configurado y registro de módulo jackson-module-parameter-namesque agrega soporte para acceder a nombres de parámetros (una característica agregado en Java 8).

Esta herramienta de compilación configura las propiedades predeterminadas de Jackson de la siguiente manera:

DeserializationFeature.FAIL_ON_UNKNOWN_PROPERTIES está deshabilitado.
MapperFeature.DEFAULT_VIEW_INCLUSION está deshabilitado.

También registra automáticamente los siguientes módulos conocidos si se encuentran en el classpath:

jackson-datatype-joda: Soporte para tipos Joda Time.
jackson-datatype -jsr310: Compatibilidad con tipos de API de fecha y hora de Java 8.
jackson-datatype-jdk8: admite otros tipos de Java 8, como Opcional.
jackson-module-kotlin: soporte para clases de Kotlin y clases de datos.

Habilitar la sangría con soporte XML de Jackson requiere una dependencia woodstox-core-asl además de jackson-dataformat-xml.

Hay otros módulos interesantes de Jackson:

jackson-datatype-money: Soporte para tipos javax.money (módulo no oficial).
jackson-datatype-hibernate: compatibilidad con tipos y propiedades específicos de Hibernate (incluidos aspectos de carga diferida).

El siguiente ejemplo muestra cómo obtener la misma configuración en XML:


<mvc:annotation-driven>
    <mvc:message-converters>
        <bean class="org.springframework.http.converter.json.MappingJackson2HttpMessageConverter">
            <property name="objectMapper" ref="objectMapper"/>
        </bean>
        <bean class="org.springframework.http.converter.xml.MappingJackson2XmlHttpMessageConverter">
            <property name="objectMapper" ref="xmlMapper"/>
        </bean>
    </mvc:message-converters>
</mvc:annotation-driven>
<bean id="objectMapper" class="org.springframework.http.converter.json.Jackson2ObjectMapperFactoryBean"
      p:indentOutput="true"
      p:simpleDateFormat="yyyy-MM-dd"
      p:modulesToInstall="com.fasterxml.jackson.module.paramnames.ParameterNamesModule"/>
<bean id="xmlMapper" parent="objectMapper" p:createXmlMapper="true"/>

Vista del controlador

Esta es una abreviatura para definir un ParameterizableViewController que, cuando se llama, salta inmediatamente a la vista. Puede usarlo en casos estáticos donde no hay ninguna lógica de controlador Java que deba ejecutarse antes de que la vista genere una respuesta.

El siguiente ejemplo de configuración de Java realiza una solicitud a / en vista llamada home:

Java


@Configuration
@EnableWebMvc
public class WebConfig implements WebMvcConfigurer {
    @Override
    public void addViewControllers(ViewControllerRegistry registry) {
        registry.addViewController("/").setViewName("home");
    }
}

Kotlin


@Configuration
@EnableWebMvc
class WebConfig : WebMvcConfigurer {
    override fun addViewControllers(registry: ViewControllerRegistry) {
        registry.addViewController("/").setViewName("home")
    }
}

El siguiente ejemplo produce lo mismo que el anterior, pero usando XML, usando el elemento <mvc:view-controller>:

<mvc:view-controller path="/" view-name="home"/>

Si un método con la anotación @RequestMapping se asigna a una URL para cualquier método HTTP, entonces el controlador de vista no se puede utilizar para procesar la misma URL. Esto se debe a que una coincidencia de URL con un controlador anotado se considera una indicación lo suficientemente fuerte de la propiedad del punto final como para que se pueda enviar una respuesta 405 (METHOD_NOT_ALLOWED), 415 (UNSUPPORTED_MEDIA_TYPE) o similar al cliente para ayudar en la depuración. Por este motivo, se recomienda evitar dividir el procesamiento de URL en un controlador anotado y un controlador de vista.

Resolvedores de vistas

La configuración de MVC facilita el registro de solucionadores de vistas.

En el siguiente ejemplo, la configuración de Java configura la resolución de vista de negociación de contenido usando JSP y Jackson como View predeterminado para renderizar en formato JSON:

Java

 
@Configuration
@EnableWebMvc
public class WebConfig implements WebMvcConfigurer {
    @Override
    public void configureViewResolvers(ViewResolverRegistry registry) {
        registry.enableContentNegotiation(new MappingJackson2JsonView());
        registry.jsp();
    }
}

Kotlin


@Configuration
@EnableWebMvc
class WebConfig : WebMvcConfigurer {
    override fun configureViewResolvers(registry: ViewResolverRegistry) {
        registry.enableContentNegotiation(MappingJackson2JsonView())
        registry.jsp()
    }
}

El siguiente ejemplo muestra cómo obtener la misma configuración en XML:


<mvc:view-resolvers>
    <mvc:content-negotiation>
        <mvc:default-views>
            <bean class="org.springframework.web.servlet.view.json.MappingJackson2JsonView"/>
        </mvc:default-views>
    </mvc:content-negotiation>
    <mvc:jsp/>
</mvc:view-resolvers>

Sin embargo, tenga en cuenta que FreeMarker, Tiles, Groovy Markup y las plantillas de secuencias de comandos también requieren configuración de la tecnología de presentación.

El espacio de nombres MVC proporciona elementos especiales. El siguiente ejemplo funciona con FreeMarker:

 
<mvc:view-resolvers>
    <mvc:content-negotiation>
        <mvc:default-views>
            <bean class="org.springframework.web.servlet.view.json.MappingJackson2JsonView"/>
        </mvc:default-views>
    </mvc:content-negotiation>
    <mvc:freemarker cache="false"/>
</mvc:view-resolvers>
<mvc:freemarker-configurer>
    <mvc:template-loader-path location="/freemarker"/>
</mvc:freemarker-configurer>

En la configuración de Java, puede agregar el bean Configurer correspondiente, como se muestra en el siguiente ejemplo:

Java


@Configuration
@EnableWebMvc
public class WebConfig implements WebMvcConfigurer {
    @Override
    public void configureViewResolvers(ViewResolverRegistry registry) {
        registry.enableContentNegotiation(new MappingJackson2JsonView());
        registry.freeMarker().cache(false);
    }
    @Bean
    public FreeMarkerConfigurer freeMarkerConfigurer() {
        FreeMarkerConfigurer configurer = new FreeMarkerConfigurer();
        configurer.setTemplateLoaderPath("/freemarker");
        return configurer;
    }
}

Kotlin


@Configuration
@EnableWebMvc
class WebConfig : WebMvcConfigurer {
    override fun configureViewResolvers(registry: ViewResolverRegistry) {
        registry.enableContentNegotiation(MappingJackson2JsonView())
        registry.freeMarker().cache(false)
    }
    @Bean
    fun freeMarkerConfigurer() = FreeMarkerConfigurer().apply {
        setTemplateLoaderPath("/freemarker")
    }
}

Recursos estáticos

Esta opción proporciona una manera conveniente de manejar recursos estáticos desde una lista de ubicaciones basadas en Recurso.

En el siguiente ejemplo, si la solicitud comienza con /resources, la ruta relativa se utiliza para buscar y procesar recursos estáticos relativos a /public en la aplicación web. Root o en el classpath en /static. Los recursos se proporcionan con una fecha de vencimiento de un año para garantizar el uso máximo de la caché del navegador y una reducción en las solicitudes HTTP realizadas por el navegador. La información Last-Modified se deriva de Recurso#lastModified para proporcionar soporte para solicitudes HTTP condicionales con encabezados "Last-Modified".

La siguiente lista muestra cómo hacer esto usando la configuración de Java:

Java


@Configuration
@EnableWebMvc
public class WebConfig implements WebMvcConfigurer {
    @Override
    public void addResourceHandlers(ResourceHandlerRegistry registry) {
        registry.addResourceHandler("/resources/**")
                .addResourceLocations("/public", "classpath:/static/")
                .setCacheControl(CacheControl.maxAge(Duration.ofDays(365)));
    }
}

Kotlin


@Configuration
@EnableWebMvc
class WebConfig : WebMvcConfigurer {
    override fun addResourceHandlers(registry: ResourceHandlerRegistry) {
        registry.addResourceHandler("/resources/**")
                .addResourceLocations("/public", "classpath:/static/")
                .setCacheControl(CacheControl.maxAge(Duration.ofDays(365)))
    }
}

El siguiente ejemplo muestra cómo obtener la misma configuración en XML:


<mvc:resources mapping="/resources/**"
    location="/public, classpath:/static/"
    cache-period="31556926" />

El controlador de recursos también admite el encadenamiento de implementaciones ResourceResolver y ResourceTransformer que puede utilizar para crear un conjunto de herramientas para trabajar con recursos optimizados.

Puede utilizar VersionResourceResolver para versionar las URL de recursos de versión basándose en un hash MD5, calculado a partir del contenido, versión fija de la aplicación u otro. ContentVersionStrategy (hash MD5) es una elección inteligente, con algunas excepciones notables, como los recursos de JavaScript utilizados con el cargador de módulos.

El siguiente ejemplo muestra cómo utilizar VersionResourceResolver en la configuración de Java:

Java


@Configuration
@EnableWebMvc
public class WebConfig implements WebMvcConfigurer {
    @Override
    public void addResourceHandlers(ResourceHandlerRegistry registry) {
        registry.addResourceHandler("/resources/**")
                .addResourceLocations("/public/")
                .resourceChain(true)
                .addResolver(new VersionResourceResolver().addContentVersionStrategy("/**"));
    }
}

Kotlin


@Configuration
@EnableWebMvc
class WebConfig : WebMvcConfigurer {
    override fun addResourceHandlers(registry: ResourceHandlerRegistry) {
        registry.addResourceHandler("/resources/**")
                .addResourceLocations("/public/")
                .resourceChain(true)
                .addResolver(VersionResourceResolver().addContentVersionStrategy("/**"))
    }
}

El siguiente ejemplo muestra cómo obtener la misma configuración en XML:


<mvc:resources mapping="/resources/**" location="/public/">
    <mvc:resource-chain resource-cache="true">
        <mvc:resolvers>
            <mvc:version-resolver>
                <mvc:content-version-strategy patterns="/**"/>
            </mvc:version-resolver>
        </mvc:resolvers>
    </mvc:resource-chain>
</mvc:resources>

Luego puede utilizar ResourceUrlProvider para reescribir las URL y aplicar la cadena completa de solucionadores y solucionadores, por ejemplo, para insertar versiones. La configuración de MVC proporciona un bean ResourceUrlProvider que se puede inyectar en otros beans. También puede hacer que la reescritura sea transparente usando ResourceUrlEncodingFilter para Thymeleaf, JSP, FreeMarker y otros usando etiquetas URL que dependen de HttpServletResponse#encodeURL.

Tenga en cuenta que cuando usando EncodedResourceResolver (por ejemplo, para procesar recursos codificados con métodos de compresión gzip o brotli) y VersionResourceResolver, debe registrarlos en ese orden. Esto permite calcular de forma fiable las versiones basadas en contenido a partir del archivo sin formato.

WebJars También son compatibles con WebJarsResourceResolver, que se registra automáticamente cuando la biblioteca org.webjars:webjars-locator-core está presente en el classpath. El solucionador puede reescribir las URL para incluir la versión jar y también puede hacer coincidir las URL entrantes sin versiones, por ejemplo, desde /jquery/jquery.min.js hasta /jquery/1.2.0/jquery.min.js.

La configuración de Java basada en ResourceHandlerRegistry proporciona capacidades adicionales para un control detallado, como la lógica de último cambio y la resolución optimizada de recursos.

Servlet predeterminado

El marco Spring MVC le permite asignar DispatcherServlet a / (anulando así la representación del servlet contenedor estándar), con las solicitudes estáticas de recursos siendo manejadas por el servlet contenedor estándar. Configura DefaultServletHttpRequestHandler con la asignación de URL /** y la prioridad más baja en relación con otras asignaciones de URL.

Este controlador reenvía todas las solicitudes al servlet predeterminado. Por lo tanto, debe permanecer al final en el orden de todos los demás HandlerMappings para la URL. Esto ocurre cuando se utiliza <mvc:annotation-driven>. Además, si crea su propia instancia HandlerMapping, asegúrese de establecer su propiedad order en un valor menor que DefaultServletHttpRequestHandler, que es Integer.MAX_VALUE.

El siguiente ejemplo muestra cómo habilitar esta característica usando la configuración predeterminada:

Java

 
@Configuration
@EnableWebMvc
public class WebConfig implements WebMvcConfigurer {
    @Override
    public void configureDefaultServletHandling(DefaultServletHandlerConfigurer configurer) {
        configurer.enable();
    }
}

Kotlin


@Configuration
@EnableWebMvc
class WebConfig : WebMvcConfigurer {
    override fun configureDefaultServletHandling(configurer: DefaultServletHandlerConfigurer) {
        configurer.enable()
    }
}

El siguiente ejemplo muestra cómo obtener la misma configuración en XML:

<mvc:default-servlet-handler/>

La advertencia para anular la asignación de servlet / es que el RequestDispatcher para el servlet predeterminado debe encontrarse mediante nombre, y no en el camino. DefaultServletHttpRequestHandler intenta determinar automáticamente el servlet predeterminado para un contenedor en el momento del inicio, utilizando una lista de nombres conocidos para la mayoría de los principales contenedores de servlets (incluidos Tomcat, Jetty, GlassFish, JBoss, Resin, WebLogic y WebSphere). Si el servlet predeterminado se ha configurado de forma personalizada con un nombre diferente, o si está utilizando un contenedor de servlet diferente donde se desconoce el nombre del servlet predeterminado, debe especificar explícitamente el nombre del servlet predeterminado, como se muestra en el siguiente ejemplo:

Java


@Configuration
@EnableWebMvc
public class WebConfig implements WebMvcConfigurer {
    @Override
    public void configureDefaultServletHandling(DefaultServletHandlerConfigurer configurer) {
        configurer.enable("myCustomDefaultServlet");
    }
}

Kotlin


@Configuration
@EnableWebMvc
class WebConfig : WebMvcConfigurer {
    override fun configureDefaultServletHandling(configurer: DefaultServletHandlerConfigurer) {
        configurer.enable("myCustomDefaultServlet")
    }
}

El siguiente ejemplo muestra cómo obtener la misma configuración en XML:

<mvc:default-servlet-handler default-servlet-name="myCustomDefaultServlet"/>

Asignación de rutas

Puede configurar ajustes relacionados con la asignación de rutas y el manejo de URL. Para obtener más información sobre opciones individuales, consulte el javadoc en PathMatchConfigurer.

El siguiente ejemplo muestra cómo configurar la coincidencia de rutas en una configuración de Java:

Java


@Configuration
@EnableWebMvc
public class WebConfig implements WebMvcConfigurer {
    @Override
    public void configurePathMatch(PathMatchConfigurer configurer) {
        configurer
            .setPatternParser(new PathPatternParser())
            .addPathPrefix("/api", HandlerTypePredicate.forAnnotation(RestController.class));
    }
    private PathPatternParser patternParser() {
        // ...
    }
}

Kotlin


@Configuration
@EnableWebMvc
class WebConfig : WebMvcConfigurer {
    override fun configurePathMatch(configurer: PathMatchConfigurer) {
        configurer
            .setPatternParser(patternParser)
            .addPathPrefix("/api", HandlerTypePredicate.forAnnotation(RestController::class.java))
    }
    fun patternParser(): PathPatternParser {
        //...
    }
}

El siguiente ejemplo muestra cómo obtener la misma configuración en XML:


<mvc:annotation-driven>
    <mvc:path-matching
            trailing-slash="false"
            path-helper="pathHelper"
            path-matcher="pathMatcher"/>
</mvc:annotation-driven>
<bean id="pathHelper" class="org.example.app.MyPathHelper"/>
<bean id="pathMatcher" class="org.example.app.MyPathMatcher"/>

Configuración avanzada de Java

@EnableWebMvc importa DelegatingWebMvcConfiguration, que:

Pasa la configuración Spring predeterminada para aplicaciones Spring MVC
Descubre y delega implementaciones de WebMvcConfigurer para configurar esta configuración.

En modo avanzado, puede eliminar el annotation @EnableWebMvc y realice la extensión directamente desde DelegatingWebMvcConfiguration en lugar de implementar WebMvcConfigurer, como se muestra en el siguiente ejemplo:

Java


@Configuration
public class WebConfig extends DelegatingWebMvcConfiguration {
    // ...
}

Kotlin


@Configuration
class WebConfig : DelegatingWebMvcConfiguration() {
    // ...
}

Puedes guardar los métodos existentes en WebConfig, pero ahora también es posible anular las declaraciones de beans de la clase base, y aún es posible tener cualquier número de otras implementaciones de WebMvcConfigurer en el classpath.

Configuración XML extendida

Los nombres de Space MVC no proporcionan un modo extendido. Si necesita establecer una propiedad de bean que no se puede cambiar de ninguna otra manera, puede usar el ciclo de vida BeanPostProcessor interceptor en ApplicationContext para Spring, como se muestra en el siguiente ejemplo:

Java


@Component
public class MyPostProcessor implements BeanPostProcessor {
    public Object postProcessBeforeInitialization(Object bean, String name) throws BeansException {
        // ...
    } puede utilizar
}

Kotlin


@Component
class MyPostProcessor : BeanPostProcessor {
    override fun postProcessBeforeInitialization(bean: Any, name: String): Any {
        // ...
    }
}

Anterior Lección anterior

Siguiente Siguiente lección

Comentarios

TO VIEW ALL COMMENTS OR TO MAKE A COMMENT,
GO TO FULL VERSION