Spring MVC konfiguratsiyasi

Java'da MVC konfiguratsiyasi va XML'dagi MVC nom maydoni ko'pchilik ilovalarga mos keladigan standart konfiguratsiyani va uni sozlash uchun konfiguratsiya API'ni taqdim etadi.

Java MVC konfiguratsiyasi va MVC nom maydoni tomonidan yaratilgan asosiy bean'larni tushunishingiz shart emas.

MVC konfiguratsiyasi faollashtirilishi

Java-konfiguratsiyada @EnableWebMvc anotatsiyasidan foydalanib, MVC konfiguratsiyasini faollashtirishingiz mumkin, quyidagi misolda ko'rsatilgani kabi:

@Configuration
@EnableWebMvc
public class WebConfig {
}

@Configuration
@EnableWebMvc
class WebConfig

XML-konfiguratsiyada <mvc:annotation-driven> elementidan foydalanib, MVC konfiguratsiyasini faollashtirishingiz mumkin, quyidagi misolda ko'rsatilgani kabi:

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

Quyidagi misolda Spring MVC komponentlari va sinf yo'lida mavjud bo'lgan bog'liqliklarga (masalan, JSON, XML va boshqalarga ma'lumot konvertorlari) mos ravishda ro'yxatdan o'tkaziladi.

MVC konfiguratsiya API

Java-konfiguratsiyada, WebMvcConfigurer interfeysini amalga oshirish orqali, quyidagi misolda ko'rsatilgani kabi:

@Configuration
@EnableWebMvc
public class WebConfig implements WebMvcConfigurer {
    // Konfiguratsiya metodlarni amalga oshiramiz...
}

@Configuration
@EnableWebMvc
class WebConfig : WebMvcConfigurer {
    // Konfiguratsiya metodlarni amalga oshiramiz...
}

XML'da <mvc:annotation-driven/> elementining atributlari va subelementlarini tekshirishingiz mumkin. Spring MVC XML-sxemasini ko'ring yoki kod avtomatik to'ldirish funktsiyasidan foydalaning, sizning IDE'da qanday atributlar va subelementlar mavjudligini bilish uchun.

Tiplarni konversiya qilish

Standart ravishda, turli sonlar va sanalarning formatlash vositalari o'rnatilgan bo'lib, ular @NumberFormat va @DateTimeFormat orqali mos sozlamalarni qo'llab-quvvatlaydi.

Java-konfiguratsiyada maxsus formatlash vositalari va konvertorlarni ro'yxatga olish uchun quyidagi usuldan foydalaning:

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

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

XML-konfiguratsiyada buni quyidagi usulda bajaring:

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

Spring MVC dastlabki qiymatlarni tahlil qilish va formatlashda so'rovning regional sozlamalarini inobatga oladi. Bu, masalan, sanalar ko'rinishida stringlar bilan "input" shaklidagi formalar uchun to'g'ri keladi. Biroq, brauzerlar "date" va "time" shaklidagi maydonlar uchun HTML xususiyatiga muvofiq belgilanadigan qat'iy formatdan foydalanadi. Ushbu holatlar uchun sanani va vaqtni formatlash quyidagicha sozlanishi mumkin:

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

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

Validatsiya

Agar classpath'da Bean Validation (masalan, Hibernate Validator) mavjud bo'lsa, LocalValidatorFactoryBean global validator sifatida ro'yxatdan o'tadi va u @Valid anotatsiyasi va metod argumentlari uchun Validated xususiyatlarini ishlatishda foydalanilishi mumkin.

Java-konfiguratsiyasida global Validator ni quyidagi uslubda sozlashingiz mumkin:

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

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

Quyidagi misolda XML bilan bunday konfiguratsiyani qanday olish mumkinligi ko'rsatilgan:

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

Shuni ta'kidlashingiz kerakki, Validator implementatsiyalarini lokal ro'yxatga olish ham mumkin, quyidagi misolda ko'rsatilgani kabi:

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

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

Interceptor'lar

Java-konfiguratsiyada kiruvchi so'rovlarga qo'llash uchun interceptor'larni ro'yxatdan o'tkazishingiz mumkin, quyidagi misolda ko'rsatilgani kabi:

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

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

Quyidagi misolda XML bilan bunday konfiguratsiyani qanday olish mumkinligi ko'rsatilgan:

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

Kontent turlari

Spring MVC, so'rovdan (masalan, Accept header, URL yo'lni kengaytmasi, request parametri va boshqalar) muhit turini aniqlash uslubini sozlashingiz mumkin.

Odatiy bo'lib, faqat Accept header tekshiriladi.

Agar URL asosida kontent turini aniqlash kerak bo'lsa, yo'lni kengaytmasi o'rniga so'rov parametrlarini ishlatishni ko'rib chiqishingiz mumkin.

Java-konfiguratsiyada so'ralgan kontent turini aniqlashni sozlashingiz mumkin, quyidagi misolda ko'rsatilgani kabi:

@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);
    }
}

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

Quyidagi misolda XML bilan bunday konfiguratsiyani qanday olish mumkinligi ko'rsatilgan:

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

Xabar konvertorlari

Java-konfiguratsiyada HttpMessageConverter'ni sozlashingiz mumkin, quyidagi usulni overrayd qilib (Spring MVC tomonidan yaratilgan oddiy konvertorlar o'rniga)

Quyidagi misolda XML va Jackson JSON konvertorlari standart emas, balki maxsus sozlangan ObjectMapper bilan qo'shilgan:

@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()));
    }
}

@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()))

Yuqoridagi misolda Jackson2ObjectMapperBuilder JSP uchun View sifatida ishlatiladigan MappingJackson2HttpMessageConverter va MappingJackson2XmlHttpMessageConverter uchun umumiy konfiguratsiyani yaratish uchun ishlatilgan bo'lib, indentatsiya yoqilgan, sana formati sozlangan va moduli ro'yxatdan o'tgan.

Ushbu quruvchi Jackson xususiyatlarini quyidagicha sozlaydi:

• DeserializationFeature.FAIL_ON_UNKNOWN_PROPERTIES o'chirilgan.

• MapperFeature.DEFAULT_VIEW_INCLUSION o'chirilgan.

U shuningdek, quyidagi ma'lum modullarni sinf yo'lida topilgan taqdirda avtomatik ravishda ro'yxatdan o'tkazadi:

• jackson-datatype-joda: Joda-Time turlarini qo'llab-quvvatlash.

• jackson-datatype-jsr310: Java 8 sana va vaqt API turlarini qo'llab-quvvatlash.

• jackson-datatype-jdk8: Java 8'ning boshqa turlarini qo'llab-quvvatlash, masalan, Optional.

• jackson-module-kotlin: Kotlin sinflarini va ma'lumot sinflarini qo'llab-quvvatlash.

Yana bir nechta qiziqarli Jackson modullari mavjud:

• jackson-datatype-money: javax.money turlarini qo'llab-quvvatlash (norasmiy modul).

• jackson-datatype-hibernate: Hibernate uchun o'ziga xos turlar va xususiyatlar (shu jumladan kechiktirilgan yuklab olish jihatlari).

Quyidagi misolda XML bilan bunday konfiguratsiyani qanday olish mumkinligi ko'rsatilgan:

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

Ko'rinishni boshqarish

Bu ParameterizableViewController ni belgilash uchun qisqacha tavsiya. Chaqqiruda darhol ko'rinishga o'tadi. Statik holatlarda foydalanishingiz mumkin, Java-kontroller mantiqi bajarilgunga qadar ko'rinish javobni yaratadi.

Java-konfiguratsiyasidagi quyidagi misolda / dagi so'rov home nomli ko'rinishga kiradi:

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

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

Quyidagi misolda, oldingi misolda ko'rsatilgan narsani XML yordamida olish mumkin, <mvc:view-controller> elementidan foydalanib:

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

Agar @RequestMapping annotatsiyasi qaysidir bir URL manzilga mos kelgan bo'lsa, har qanday HTTP usuli uchun ko'rinishni boshqaruvchi sifatida ishlatilishi mumkin emas. Bu URL-manzil bilan annotatsiyalangan kontroller bilan moslik etarli darajada bo'lganligi sababli, bu oxirgi nuqta ekanligini bildiradi, shuning uchun mijozga 405 (METHOD_NOT_ALLOWED), 415 (UNSUPPORTED_MEDIA_TYPE) yoki boshqa shunga o'xshash javoblar yuborilishi mumkin, bu esa oʻzgarishlarni tekshirish uchun. Shuning uchun, URL manzili bilan ishlashni annotatsiyalangan nazoratchi va ko'rinish nazoratchisi sifatida bo'lishdan saqlanish tavsiya etiladi.

Ko'rinishni aniqlash

MVC konfiguratsiyasi ko'rinish aniqlovchilarini ro'yxatdan o'tkazishni osonlashtiradi.

Java-konfiguratsiyasidagi quyidagi misolda JSP va Jackson uchun View sifatida ko'rinishni kontent kelishuvini sozlash ko'rsatilgan:

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

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

Quyidagi misolda XML bilan bunday konfiguratsiyani qanday olish mumkinligi ko'rsatilgan:

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

Biroq, FreeMarker, Tiles, Groovy Markup va boshqa script shablonlari ham ko'rinish texnologiyasiga mos kelishini talab qiladi.

MVC nom maydoni maxsus elementlarni taqdim etadi. Quyidagi misol FreeMarker bilan ishlaydi:

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

Java-konfiguratsiyada mos Configurer bean'ini qo'shishingiz mumkin, quyidagi misolda ko'rsatilgani kabi:

@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;
    }
}

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

Statik resurslar

Ushbu imkoniyat Resource asosida joylashuvlar ro'yxatidan statik resurslarni boshqarish uchun qulay usulni taqdim etadi.

Quyidagi misolda, agar so'rov /resources bilan boshlangan bo'lsa, nisbiy yo'l web ilovasining ildizi /public ga yoki /static ga classpath ichidan statik resurslarni qidirish va boshqarish uchun ishlatiladi. Resurslar bir yilga amal qilish muddati bilan taqdim etiladi, bu brauzer keshini maksimal darajada ishlatish va brauzer tomonidan qilingan HTTP so'rovlarini kamaytirish uchun. Last-Modified ma'lumotlari Resource#lastModified dan olinadi, bu esa shartli HTTP so'rovlarini "Last-Modified" headerlari bilan ta'minlaydi.

Quyidagi ro'yxatda Java-konfiguratsiyasi bilan buni qanday qilish kerakligi ko'rsatilgan:

@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)));
    }
}

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

Quyidagi misolda XML bilan bunday konfiguratsiyani qanday olish mumkinligi ko'rsatilgan:

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

Resurslarni boshqaruvchi ushbu resurslar optimallashtirish uchun ResourceResolver va ResourceTransformer ga mos keluvchi toolkitchani yaratish uchun zanjirli implementatsiyalar qo'llab-quvvatlanadi.

VersionResourceResolver ni resursli URL-larni, masalan, kontentdan hisoblangan MD5 hash asosida ko'rsatiladigan yoki o'zgarmaydigan dastur versiyasi asosida ishlatishingiz mumkin. ContentVersionStrategy (MD5 hash) bir necha oz xos istisnolarga qaraganda yaxshi tanlovdir, masalan, moduli yuklash vositasi bilan ishlatiladigan JavaScript resurslari.

Quyidagi misolda, VersionResourceResolver ni Java-konfiguratsiyada qanday ishlatish kerakligi ko'rsatilgan:

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

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

Quyidagi misolda XML bilan bunday konfiguratsiyani qanday olish mumkinligi ko'rsatilgan:

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

Keyinchalik ResourceUrlProvider ni URL manzillarini qayta yozish va to'liqligicha aniqlash va transformatorlar zanjirini qo'llash uchun foydalanishingiz mumkin. MVC konfiguratsiyasi ResourceUrlProvider bean'ini taqdim etadi, uni boshqa bean'larda qo'llash mumkin. Shuningdek, ResourceUrlEncodingFilter ni Thymeleaf, JSP, FreeMarker va boshqalarga shaffof qo'llashni mumkin qiladi, ularda URL teglar HttpServletResponse#encodeURL ga tayanadi.

Shuni esda tutingki, EncodedResourceResolver (masalan, gzip, brotli yoki boshqa siqilgan resurslarni boshqarish uchun) va VersionResourceResolver ni birga ishlatish holatida, ular aynan shu tartibda ro'yxatdan o'tkazilishi kerak. Bu asosiy fayl asosidagi kontentni ishonchli ravishda hisoblashni ta'minlaydi.

WebJars ham, sinf yo'lida org.webjars:webjars-locator-core mavjud bo'lganda avtomatik ravishda ro'yxatdan o'tadigan WebJarsResourceResolver orqali qo'llab-quvvatlanadi. Aniqlovchi URL manzillarni qayta yozishi mumkin, jumladan, Jar versiyasini o'z ichiga olishi mumkin, shuningdek, /jquery/jquery.min.js dan /jquery/1.2.0/jquery.min.js ga mos kelishi mumkin.

Standart servlet

Spring MVC freymvorki DispatcherServlet ni / ga ko'chirish imkonini beradi (shu bilan konteyner standart servlet ko'chirishini qayta yozib), statik resurs so'rovlarini konteyner standart servleti boshqaradi. U DefaultServletHttpRequestHandler ni /** URL ko'chirish va boshqa URL ko'chirishlarga nisbatan eng past ustuvorlik bilan sozlaydi.

Ushbu boshqaruvchi barcha so'rovlarni standart servletga yo'naltiradi. Shuning uchun u boshqa URL ko'chirishlaridan avval o'rta bo'lishi kerak. Bu <mvc:annotation-driven> ishlatilganda sodir bo'ladi. Shuningdek, agar HandlerMapping ni o'zingiz yaratgan bo'lsangiz, uning order xususiyatini DefaultServletHttpRequestHandler dan kamroq qiymatga o'rnatishni unutmang. Bu Integer.MAX_VALUE dir.

Quyidagi misolda, ushbu funksiyani standart sozlamalarni ishlatib faollashtirish qanday ko'rsatilgan:

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

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

Quyidagi misolda XML bilan bunday konfiguratsiyani qanday olish mumkinligi ko'rsatilgan:

<mvc:default-servlet-handler/>

/ ko'chirishni qayta yozishda ogohlantirish shundaki, standart servlet uchun RequestDispatcher nom orqali topilishi kerak, yo'l bilan emas. DefaultServletHttpRequestHandler konteyner uchun standart servletni ishga tushirish vaqtida avtomatik ravishda aniqlash uchun mashhur nomlar ro'yxatini ishlatadi, aksariyat asosiy servlet konteynerlari uchun (Tomcat, Jetty, GlassFish, JBoss, Resin, WebLogic va WebSphere shu jumladan). Agar standart servlet boshqa nom bilan maxsus konfiguratsiyalangan yoki standart servlet nomi noma'lum bo'lgan boshqa servlet konteyneri ishlatilayotgan bo'lsa, quyidagi misolda ko'rsatilganidek, standart servlet nomini aniq ko'rsating:

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

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

Quyidagi misolda XML bilan bunday konfiguratsiyani qanday olish mumkinligi ko'rsatilgan:

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

Yo'l moslamalari

Yo'l moslamalari va URLni qayta ishlash bilan bog'liq variantlarni sozlashingiz mumkin. Har bir variant haqida batafsil ma'lumotni PathMatchConfigurer javadoc'da topasiz.

Quyidagi misolda, Java-konfiguratsiyada yo'l moslamalarini qanday sozlashni ko'rsatadi:

@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() {
        // ...
    }
}

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

Quyidagi misolda XML bilan bunday konfiguratsiyani qanday olish mumkinligi ko'rsatilgan:

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

Kengaytirilgan Java konfiguratsiyasi

@EnableWebMvc DelegatingWebMvcConfiguration'ni import qiladi, bu:

• Spring ilovalari uchun standart Spring konfiguratsiyasini taqdim etadi

• WebMvcConfigurer implementatsiyalarini aniqlaydi va ushbu konfiguratsiyani sozlash uchun delegat qiladi.

Kengaytirilgan rejimda, @EnableWebMvc annotatsiyasini olib tashlashingiz va DelegatingWebMvcConfigure'dan to'g'ridan-to'g'ri foydalanishingiz mumkin, quyidagi misolda ko'rsatilganidek:

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

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

Sizning WebConfig dagi hozirgi metodlarni saqlab qolishingiz mumkin, ammo endi asosiy sinfning bean e'lonlarini override qilishingiz va classpathda boshqa har qanday WebMvcConfigurer implementatsiyalariga ega bo'lishingiz mumkin.

Kengaytirilgan XML-konfiguratsiyasi

MVC nom maydoni kengaytirilgan rejimni ta'minlamaydi. Agar boshqa usul bilan o'zgartirib bo'lmaydigan bean xususiyatini sozlash talab qilinsa, BeanPostProcessor lifecycle interceptor'idan foydalanib, Spring ApplicationContextda quyidagi misolda ko'rsatilganidek foydalanishingiz mumkin:

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

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