streamalism.org

1. Introduktion

I foråret MVC, den DispatcherServlet fungerer som frontcontroller - modtager alle indgående HTTP-anmodninger og behandler dem.

Kort sagt, behandlingen sker ved at videresende anmodningerne til den relevante komponent ved hjælp af kortlægning af handler.

HandlerMapping er en grænseflade, der definerer en kortlægning mellem anmodninger og handlerobjekter. Mens Spring MVC framework giver nogle færdige implementeringer, kan grænsefladen implementeres af udviklere for at levere tilpasset kortlægningsstrategi.

Denne artikel diskuterer nogle af de implementeringer, der leveres af Spring MVC, nemlig BeanNameUrlHandlerMapping, SimpleUrlHandlerMapping, ControllerClassNameHandlerMapping, deres konfiguration og forskellene mellem dem.

2. BeanNameUrlHandlerMapping

BeanNameUrlHandlerMapping er standard HandlerMapping implementering. BeanNameUrlHandlerMapping kort anmodnings-URL'er til bønner med samme navn.

Denne særlige kortlægning understøtter direkte navneoverensstemmelse og også til mønstermatchning ved hjælp af "*" -mønsteret.

For eksempel en indgående URL “/ Foo” kort til en bøn, der kaldes “/ Foo”. Et eksempel på mønsterkortlægning er kortlægningsanmodninger til “/ Foo *” til bønner med navne der starter med “/ Foo” synes godt om “/ Foo2 /” eller “/ FooOne /”.

Lad os konfigurere dette eksempel her og registrere en bønne-controller, der håndterer anmodninger til “/ BeanNameUrl”:

@Configuration public class BeanNameUrlHandlerMappingConfig {@Bean BeanNameUrlHandlerMapping beanNameUrlHandlerMapping () {returner nyt BeanNameUrlHandlerMapping (); } @Bean ("/ beanNameUrl") offentlig WelcomeController velkommen () {returner ny WelcomeController (); }}

Dette er XML-ækvivalenten for ovenstående Java-baserede konfiguration:

Det er vigtigt at bemærke, at i begge disse konfigurationer, definerer en bønne til BeanNameUrlHandlerMapping er ikke påkrævet som det leveres af Spring MVC. Fjernelse af denne bønnedefinition medfører ingen problemer, og anmodninger kortlægges stadig til deres registrerede handlerbønner.

Nu alle anmodninger til “/ BeanNameUrl” vil blive videresendt af DispatcherServlet til "WelcomeController“. WelcomeController returnerer et visningsnavn kaldet “Velkommen“.

Følgende kode tester denne konfiguration og sørger for, at det korrekte visningsnavn returneres:

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

3. SimpleUrlHandlerMapping

Dernæst SimpleUrlHandlerMapping er den mest fleksible HandlerMapping implementering. Det giver mulighed for direkte og erklærende kortlægning mellem enten bønneinstanser og URL'er eller mellem bønnenavne og URL'er.

Lad os kortlægge anmodninger “/ SimpleUrlWelcome” og “/ * / SimpleUrlWelcome” til "Velkommen" bønne:

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

Alternativt er her den tilsvarende XML-konfiguration:

   / simpleUrlWelcome = velkommen / * / simpleUrlWelcome = velkommen 

Det er vigtigt at bemærke, at der i XML-konfigurationen er en kortlægning mellem “” tag skal udføres i en form, der accepteres af java.util.Ejendomme klasse, og den skal følge syntaksen: sti = Handler_Bean_Name.

URL-adressen skal normalt være med en skråstreg, men hvis stien ikke begynder med en, tilføjer Spring MVC den automatisk.

En anden måde at konfigurere ovenstående eksempel på i XML er at bruge "rekvisitter" ejendom i stedet for "værdi". Rekvisitter har en liste over "rekvisit" tag hvor hver definerer en kortlægning hvor "nøgle" henvist til den kortlagte URL, og værdien af ​​tagget er navnet på bønnen.

   velkommen velkommen 

Følgende testsag sørger for, at anmodninger om “/simpleUrlWelcome”Håndteres af“WelcomeController ” som returnerer et kaldet visningsnavn "Velkommen" :

offentlig klasse SimpleUrlMappingConfigTest {// ... @Test offentlig ugyldig nårSimpleUrlMapping_thenMappedOK () {mockMvc.perform (get ("/ simpleUrlWelcome")) .ogExpect (status (). isOk ()). ogExpect (view (). name (" Velkommen")); }}

4. ControllerClassNameHandlerMapping (fjernet om foråret 5)

Det ControllerClassNameHandlerMapping kortlægger URL til en registreret controllerbønne (eller en controller, der er kommenteret med @Kontrol kommentar), der har eller starter med det samme navn.

Det kan være mere praktisk i mange scenarier, især for enkle controllerimplementeringer, der håndterer en enkelt anmodningstype. Den konvention, der anvendes af Spring MVC, er at bruge klassens navn og fjerne “Controller” suffiks, skift derefter navnet til små bogstaver, og returner det som kortlægning med en ledende “/”.

For eksempel “WelcomeController” ville vende tilbage som kortlægning til "/Velkommen*", dvs. til enhver URL, der starter med "Velkommen".

Lad os konfigurere ControllerClassNameHandlerMapping:

@Configuration public class ControllerClassNameHandlerMappingConfig {@Bean public ControllerClassNameHandlerMapping controllerClassNameHandlerMapping () {returner ny ControllerClassNameHandlerMapping (); } @Bean offentlig WelcomeController velkommen () {returner ny WelcomeController (); }}

Noter det ControllerClassNameHandlerMapping er udfaset fra foråret 4.3 til fordel for annoteringsdrevne behandlingsmetoder.

En anden vigtig note er, at controllernavne altid returneres med små bogstaver (minus suffikset "Controller"). Så hvis vi har en controller kaldet “Velkommen BaeldungController“, Det vil kun håndtere anmodninger til “/ Welcomebaeldung” og ikke til “/ VelkommenBaeldung”.

I både Java config og XML config nedenfor definerer vi ControllerClassNameHandlerMapping bønner og registrer bønner til controllerne, som vi bruger til at håndtere anmodninger. Vi registrerer også en bønne af typen “WelcomeController” og den bønne håndterer alle anmodninger, der starter med "/Velkommen".

Her er den tilsvarende XML-konfiguration:

Når du bruger ovenstående konfiguration, anmodninger om at “/Velkommen”Håndteres af“WelcomeController“.

Følgende kode vil sikre, at anmodninger om “/Velkommen*" såsom "/velkomstprøve”Håndteres af“ WelcomeController ”som returnerer et visningsnavn kaldet“Velkommen“:

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

5. Konfiguration af prioriteter

Spring MVC framework tillader mere end en implementering af HandlerMapping interface på samme tid.

Lad os oprette en konfiguration og registrere to controllere, begge kortlagt til URL “/ velkomst”, kun ved hjælp af forskellige kortlægning og returnering af forskellige visningsnavne:

@Configuration public class HandlerMappingDefaultConfig {@Bean ("/ welcome") public BeanNameHandlerMappingController beanNameHandlerMapping () {returner ny BeanNameHandlerMappingController (); } @Bean offentlig WelcomeController velkommen () {returner ny WelcomeController (); }}

Uden eksplicit handler mapper er registreret, en standard BeanNameHandlerMapping vil blive brugt. Lad os hævde denne adfærd med testen:

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

Hvis vi eksplicit registrerer en anden handlermapper, tilsidesættes standardmapperen. Det er dog interessant at se, hvad der sker, når to kortlæggere er eksplicit registreret:

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

For at få kontrol over, hvilken kortlægning der bruges, indstilles prioriteterne ved hjælp af setOrder (int rækkefølge) metode. Denne metode tager en int parameter, hvor lavere værdi betyder højere prioritet.

I XML-konfiguration kan du konfigurere prioriteter ved hjælp af en egenskab kaldet "bestille":

Lad os tilføje bestille egenskaber til handler kortlægning bønner, via følgende beanNameUrlHandlerMapping.setOrder (1) og simpleUrlHandlerMapping.setOrder (0). Den lavere værdi af bestille ejendom afspejler højere prioritet. Lad os hævde ny adfærd med testen:

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

Når du tester ovenstående konfiguration, ser du, at anmodninger om "/Velkommen" vil blive håndteret af SimpleUrlHandlerMapping bønne, der kalder en SimpleUrlHandlerController og vender tilbage simple-url-handler-kortlægning udsigt. Vi kan nemt konfigurere BeanNameHandlerMapping at have forrang ved at justere værdierne af bestille ejendom.

6. Konklusion

I denne artikel diskuterede vi, hvordan URL-kortlægning håndteres i Spring MVC framework ved at udforske de forskellige implementeringer i rammen.

Koden, der ledsager denne artikel, kan findes på GitHub.