Spring @RequestMapping Nieuwe snelkoppelingsannotaties

1. Overzicht

Lente 4.3. introduceerde een aantal zeer coole op methode-niveau samengestelde annotaties om de afhandeling te vergemakkelijken @RequestMapping in typische Spring MVC-projecten.

In dit artikel zullen we leren hoe u ze op een efficiënte manier kunt gebruiken.

2. Nieuwe annotaties

Typisch, als we de URL-handler willen implementeren met traditionele @RequestMapping annotatie, zou het ongeveer zo zijn geweest:

@RequestMapping (value = "/ get / {id}", method = RequestMethod.GET)

De nieuwe aanpak maakt het mogelijk om dit simpelweg in te korten tot:

@GetMapping ("/ get / {id}")

Spring ondersteunt momenteel vijf soorten ingebouwde annotaties voor het afhandelen van verschillende soorten inkomende HTTP-verzoekmethoden, namelijk KRIJGEN, PLAATSEN, PLAATSEN, VERWIJDEREN en PATCH. Deze annotaties zijn:

  • @GetMapping
  • @PostMapping
  • @PutMapping
  • @DeleteMapping
  • @PatchMapping

Uit de naamgevingsconventie kunnen we zien dat elke annotatie bedoeld is om het respectievelijke type inkomende verzoekmethode af te handelen, d.w.z. @GetMapping wordt gebruikt om te behandelen KRIJGEN type verzoekmethode, @PostMapping wordt gebruikt om te behandelen POST type verzoekmethode, etc.

3. Hoe het werkt

Alle bovenstaande annotaties zijn al intern geannoteerd met @RequestMapping en de respectieve waarde in de methode element.

Als we bijvoorbeeld kijken naar de broncode van @GetMapping annotatie, kunnen we zien dat deze al is geannoteerd met RequestMethod.GET op de volgende manier:

@Target ({java.lang.annotation.ElementType.METHOD}) @Retention (RetentionPolicy.RUNTIME) @Documented @RequestMapping (method = {RequestMethod.GET}) openbaar @interface GetMapping {// abstracte codes}

Alle andere annotaties worden op dezelfde manier gemaakt, d.w.z. @PostMapping is geannoteerd met RequestMethod.POST, @PutMapping is geannoteerd met RequestMethod.PUT, enz.

De volledige broncode van de annotaties is hier beschikbaar.

4. Implementatie

Laten we proberen deze annotaties te gebruiken om een ​​snelle REST-applicatie te bouwen.

Houd er rekening mee dat aangezien we Maven zouden gebruiken om het project te bouwen en Spring MVC om onze applicatie te maken, we de nodige afhankelijkheden moeten toevoegen in de pom.xml:

 org.springframework spring-webmvc 5.2.2.RELEASE 

De nieuwste versie van lente-webmvc is beschikbaar in de Central Maven Repository.

Nu moeten we de controller maken om de inkomende aanvraag-URL in kaart te brengen. Binnen deze controller zouden we al deze annotaties een voor een gebruiken.

4.1. @GetMapping

@GetMapping ("/ get") openbaar @ResponseBody ResponseEntity get () {retourneer nieuwe ResponseEntity ("GET Response", HttpStatus.OK); } 
@GetMapping ("/ get / {id}") openbaar @ResponseBody ResponseEntity getById (@PathVariable String id) {retourneer nieuwe ResponseEntity ("GET Response:" + id, HttpStatus.OK); }

4.2. @PostMapping

@PostMapping ("/ post") openbaar @ResponseBody ResponseEntity post () {retourneer nieuwe ResponseEntity ("POST Response", HttpStatus.OK); }

4.3. @PutMapping

@PutMapping ("/ put") openbaar @ResponseBody ResponseEntity put () {retourneer nieuwe ResponseEntity ("PUT Response", HttpStatus.OK); }

4.4. @DeleteMapping

@DeleteMapping ("/ delete") openbaar @ResponseBody ResponseEntity delete () {retourneer nieuwe ResponseEntity ("DELETE Response", HttpStatus.OK); }

4.5. @PatchMapping

@PatchMapping ("/ patch") openbaar @ResponseBody ResponseEntity patch () {retourneer nieuwe ResponseEntity ("PATCH Response", HttpStatus.OK); }

Aandachtspunten:

  • We hebben de nodige annotaties gebruikt om de juiste inkomende HTTP-methoden met URI te verwerken. Bijvoorbeeld, @GetMapping om de "/ get" URI af te handelen, @PostMapping om "/ post" URI af te handelen, enzovoort

  • Omdat we een op REST gebaseerde applicatie maken, retourneren we een constante string (uniek voor elk verzoektype) met 200 responscode om de applicatie te vereenvoudigen. We hebben Spring's gebruikt @ResponseBody annotatie in dit geval.
  • Als we een URL-padvariabele zouden moeten afhandelen, kunnen we dit gewoon op veel minder manier doen dan vroeger in het geval van gebruik @RequestMapping.

5. Testen van de applicatie

Om de applicatie te testen, moeten we een aantal testcases maken met JUnit. We zouden gebruiken SpringJUnit4ClassRunner om de testles te starten. We zouden vijf verschillende testcases maken om elke annotatie en elke handler die we in de controller hebben gedeclareerd, te testen.

Laten we het voorbeeldtestgeval van @GetMapping:

@Test public void giventUrl_whenGetRequest_thenFindGetResponse () gooit uitzondering {MockHttpServletRequestBuilder builder = MockMvcRequestBuilders .get ("/ get"); ResultMatcher contentMatcher = MockMvcResultMatchers.content () .string ("GET Response"); this.mockMvc.perform (builder) .andExpect (contentMatcher) .andExpect (MockMvcResultMatchers.status (). isOk ()); }

Zoals we kunnen zien, verwachten we een constante reeks "Reactie terug krijgen“, Zodra we de KRIJGEN URL "/ get".

Laten we nu de testcase maken om te testen @PostMapping:

@Test openbare leegte gegevenUrl_whenPostRequest_thenFindPostResponse () gooit uitzondering {MockHttpServletRequestBuilder builder = MockMvcRequestBuilders .post ("/ post"); ResultMatcher contentMatcher = MockMvcResultMatchers.content () .string ("POST Response"); this.mockMvc.perform (builder) .andExpect (contentMatcher) .andExpect (MockMvcResultMatchers.status (). isOk ()); }

Op dezelfde manier hebben we de rest van de testcases gemaakt om alle HTTP-methoden te testen.

Als alternatief kunnen we altijd een gewone REST-client gebruiken, bijvoorbeeld PostMan, RESTClient enz., Om onze applicatie te testen. In dat geval moeten we een beetje voorzichtig zijn om het juiste type HTTP-methode te kiezen tijdens het gebruik van de rest-client. Anders zou het de 405-foutstatus genereren.

6. Conclusie

In dit artikel hebben we een korte inleiding gehad tot de verschillende soorten @RequestMapping snelkoppelingen voor snelle webontwikkeling met behulp van het traditionele Spring MVC-framework. We kunnen deze snelle snelkoppelingen gebruiken om een ​​schone codebasis te creëren.

Zoals altijd kun je de broncode voor deze tutorial vinden in het Github-project.