Guide til Spring Handler Mappings

1. Introduksjon

I vår MVC, den DispatcherServlet fungerer som frontkontroller - mottar alle innkommende HTTP-forespørsler og behandler dem.

Enkelt sagt, behandlingen skjer ved å sende forespørslene til den aktuelle komponenten ved hjelp av kartleggere.

HandlerMapping er et grensesnitt som definerer en kartlegging mellom forespørsler og behandlerobjekter. Mens Spring MVC framework gir noen ferdige implementeringer, kan grensesnittet implementeres av utviklere for å tilby tilpasset kartleggingsstrategi.

Denne artikkelen diskuterer noen av implementeringene som Spring MVC har gitt BeanNameUrlHandlerMapping, SimpleUrlHandlerMapping, ControllerClassNameHandlerMapping, deres konfigurasjon og forskjellene mellom dem.

2. BeanNameUrlHandlerMapping

BeanNameUrlHandlerMapping er standard HandlerMapping gjennomføring. BeanNameUrlHandlerMapping kart forespørsel URL-er til bønner med samme navn.

Denne spesielle kartleggingen har støtte for direkte navnesamsvar og også for mønstermatching ved bruk av "*" -mønsteret.

For eksempel en innkommende URL “/ Foo” kart til en bønne som heter “/ Foo”. Et eksempel på mønsterkartlegging er kartleggingsforespørsler til “/ Foo *” til bønner med navn som begynner med “/ Foo” som “/ Foo2 /” eller “/ FooOne /”.

La oss konfigurere dette eksemplet her og registrere en bønnekontroller som håndterer forespørsler til “/ BeanNameUrl”:

@Configuration public class BeanNameUrlHandlerMappingConfig {@Bean BeanNameUrlHandlerMapping beanNameUrlHandlerMapping () {return new BeanNameUrlHandlerMapping (); } @Bean ("/ beanNameUrl") public WelcomeController welcome () {return new WelcomeController (); }}

Dette er XML-ekvivalenten til den ovennevnte Java-baserte konfigurasjonen:

Det er viktig å merke seg at i begge disse konfigurasjonene, definere en bønne for BeanNameUrlHandlerMapping er ikke obligatorisk som det er levert av Spring MVC. Hvis du fjerner denne bønnedefinisjonen, vil det ikke føre til problemer, og forespørsler vil fortsatt bli kartlagt til deres registrerte handlerbønner.

Nå alle forespørsler til “/ BeanNameUrl” vil bli videresendt av DispatcherServlet til "WelcomeController“. WelcomeController returnerer et visningsnavn som heter “Velkommen“.

Følgende kode tester denne konfigurasjonen og sørger for at riktig visningsnavn returneres:

public class BeanNameMappingConfigTest {// ... @Test public void whenBeanNameMapping_thenMappedOK () {mockMvc.perform (get ("/ beanNameUrl")). andExpect (status (). isOk ()). and Exppect (view (). name (" Velkommen")); }}

3. SimpleUrlHandlerMapping

Neste, den SimpleUrlHandlerMapping er den mest fleksible HandlerMapping gjennomføring. Det tillater direkte og erklærende kartlegging mellom enten bønneinstanser og URL-er eller mellom bønnenavn og URL-er.

La oss kartlegge forespørsler “/ SimpleUrlWelcome” og “/ * / SimpleUrlWelcome” til "Velkommen" bønne:

@Configuration public class SimpleUrlHandlerMappingConfig {@Bean public SimpleUrlHandlerMapping simpleUrlHandlerMapping () {SimpleUrlHandlerMapping simpleUrlHandlerMapping = new SimpleUrlHandlerMapping (); Kart urlMap = ny HashMap (); urlMap.put ("/ simpleUrlWelcome", velkommen ()); simpleUrlHandlerMapping.setUrlMap (urlMap); returner simpleUrlHandlerMapping; } @Bean public WelcomeController welcome () {return new WelcomeController (); }}

Alternativt er her den tilsvarende XML-konfigurasjonen:

   / simpleUrlWelcome = velkommen / * / simpleUrlWelcome = velkommen 

Det er viktig å merke seg at i XML-konfigurasjonen, en kartlegging mellom “” tag må gjøres i et skjema som er godtatt av java.util.Eiendommer klasse og den skal følge syntaksen: sti = Handler_Bean_Name.

URL-adressen skal normalt være med en skråstrek, men hvis banen ikke begynner med en, legger Spring MVC den automatisk til.

En annen måte å konfigurere eksemplet ovenfor i XML er å bruke "Rekvisitter" eiendom i stedet for "verdi". Rekvisitter har en liste over "rekvisitt" tag der hver definerer en kartlegging hvor "nøkkel" referert til den tilordnede URL-en, og verdien på koden er navnet på bønnen.

   Velkommen velkommen 

Følgende testsak sørger for at forespørsler om “/simpleUrlWelcome”Håndteres av“WelcomeController ” som returnerer et kalt visningsnavn "Velkommen" :

public class SimpleUrlMappingConfigTest {// ... @Test public void whenSimpleUrlMapping_thenMappedOK () {mockMvc.perform (get ("/ simpleUrlWelcome")). andExpect (status (). isOk ()). andExpect (view (). name (" Velkommen")); }}

4. ControllerClassNameHandlerMapping (fjernet våren 5)

De ControllerClassNameHandlerMapping tilordner URL til en registrert controller bønne (eller en controller merket med @Kontrollør merknad) som har, eller starter med, samme navn.

Det kan være mer praktisk i mange scenarier, spesielt for enkle kontrollerimplementeringer som håndterer en enkelt forespørselstype. Konvensjonen som brukes av Spring MVC er å bruke navnet på klassen og fjerne “Kontroller” endelse, endre deretter navnet til små bokstaver og returnere det som kartleggingen med en ledende “/”.

For eksempel “WelcomeController” ville komme tilbake som kartlegging til "/Velkommen*", dvs. til hvilken som helst URL som starter med "Velkommen".

La oss konfigurere ControllerClassNameHandlerMapping:

@Configuration public class ControllerClassNameHandlerMappingConfig {@Bean public ControllerClassNameHandlerMapping controllerClassNameHandlerMapping () {return new ControllerClassNameHandlerMapping (); } @Bean public WelcomeController welcome () {return new WelcomeController (); }}

Noter det ControllerClassNameHandlerMapping er utfaset fra våren 4.3 til fordel for annoteringsdrevne behandlingsmetoder.

En annen viktig merknad er at kontrollerenavn alltid vil bli returnert med små bokstaver (minus "Controller" -suffikset). Så hvis vi har en kontroller som heter “Velkommen BaeldungController“, Den vil bare håndtere forespørsler til “/ Welcomebaeldung” og ikke til “/ VelkommenBaeldung”.

I både Java config og XML config nedenfor definerer vi ControllerClassNameHandlerMapping bønner og registrer bønner for kontrollerne som vi vil bruke til å håndtere forespørsler. Vi registrerer også en bønne av typen “WelcomeController” og den bønnen vil håndtere alle forespørsler som begynner med "/Velkommen".

Her er den tilsvarende XML-konfigurasjonen:

Når du bruker konfigurasjonen ovenfor, ber du om å “/Velkommen”Vil bli håndtert av“WelcomeController“.

Følgende kode vil sørge for at forespørsler om “/Velkommen*" som for eksempel "/velkomstprøve”Håndteres av“ WelcomeController ”som returnerer et visningsnavn som heter“Velkommen“:

public class ControllerClassNameHandlerMappingTest {// ... @Test public void whenControllerClassNameMapping_thenMappedOK () {mockMvc.perform (get ("/ welcometest")). andExpect (status (). isOk ()). andExpect (view (). name (" Velkommen")); }}

5. Konfigurere prioriteringer

Vår MVC rammeverk tillater mer enn én implementering av HandlerMapping grensesnitt samtidig.

La oss lage en konfigurasjon og registrere to kontrollere, begge tilordnet URL “/ velkomst”, bare ved å bruke forskjellige kartlegginger og returnere forskjellige visningsnavn:

@Configuration public class HandlerMappingDefaultConfig {@Bean ("/ welcome") public BeanNameHandlerMappingController beanNameHandlerMapping () {return new BeanNameHandlerMappingController (); } @Bean public WelcomeController welcome () {return new WelcomeController (); }}

Uten eksplisitt kartlegging av handler er registrert, standard BeanNameHandlerMapping vil bli brukt. La oss hevde denne oppførselen med testen:

@Test offentlig ugyldig nårConfiguringPriorities_thenMappedOK () {mockMvc.perform (get ("/ welcome")). OgExpect (status (). IsOk ()). AndExpect (view (). Name ("bean-name-handler-mapping") ); } 

Hvis vi eksplisitt registrerer en annen handlermapper, blir standardmapperen overstyrt. Det er imidlertid interessant å se hva som skjer når to kartleggere er eksplisitt registrert:

@Configuration public class HandlerMappingPrioritiesConfig {@Bean BeanNameUrlHandlerMapping beanNameUrlHandlerMapping () {BeanNameUrlHandlerMapping beanNameUrlHandlerMapping = new BeanNameUrlHandlerMapping (); return beanNameUrlHandlerMapping; } @Bean offentlig SimpleUrlHandlerMapping simpleUrlHandlerMapping () {SimpleUrlHandlerMapping simpleUrlHandlerMapping = ny SimpleUrlHandlerMapping (); Kart urlMap = ny HashMap (); urlMap.put ("/ velkommen", simpleUrlMapping ()); simpleUrlHandlerMapping.setUrlMap (urlMap); returner simpleUrlHandlerMapping; } @Bean offentlig SimpleUrlMappingController simpleUrlMapping () {returner ny SimpleUrlMappingController (); } @Bean ("/ velkommen") offentlig BeanNameHandlerMappingController beanNameHandlerMapping () {returner ny BeanNameHandlerMappingController (); }}

For å få kontroll over hvilken kartlegging som brukes, blir prioriteringene satt ved hjelp av setOrder (int rekkefølge) metode. Denne metoden tar en int parameter der lavere verdi betyr høyere prioritet.

I XML-konfigurasjon kan du konfigurere prioriteringer ved å bruke en eiendom som heter "rekkefølge":

La oss legge til rekkefølge egenskaper til handler kartleggingsbønner, via følgende beanNameUrlHandlerMapping.setOrder (1) og simpleUrlHandlerMapping.setOrder (0). Den lavere verdien av rekkefølge eiendom gjenspeiler høyere prioritet. La oss hevde ny oppførsel med testen:

@Test offentlig annullert nårConfiguringPriorities_thenMappedOK () {mockMvc.perform (get ("/ welcome")) .andExpect (status (). IsOk ()). AndExpect (view (). Name ("simple-url-handler-mapping") ); }

Når du tester konfigurasjonen ovenfor, ser du det ber om "/Velkommen" vil bli håndtert av SimpleUrlHandlerMapping bønne som kaller en SimpleUrlHandlerController og kommer tilbake simple-url-handler-mapping utsikt. Vi kan enkelt konfigurere BeanNameHandlerMapping å ha forrang ved å justere verdiene til rekkefølge eiendom.

6. Konklusjon

I denne artikkelen diskuterte vi hvordan URL-kartlegging håndteres i Spring MVC framework ved å utforske de forskjellige implementeringene i rammeverket.

Koden som følger med denne artikkelen, finner du på GitHub.