Spring MVC @RequestMapping Annotation Beispiel
@RequestMapping ist eine der am häufigsten verwendeten Spring MVC Annotations. Die org.springframework.web.bind.annotation.RequestMapping Annotation wird verwendet, um Webanfragen auf spezifische Handlerklassen und/oder Handlermethoden abzubilden.
@RequestMapping kann sowohl auf die Controller-Klasse als auch auf Methoden angewendet werden. Heute werden wir uns verschiedene Verwendungen dieser Annotation anhand von Beispielen und anderen Annotationen wie @PathVariable und @RequestParam anschauen.
Spring MVC @RequestMapping Annotation
@RequestMapping mit Klasse
Wir können es mit Klassendefinition verwenden, um die Basis-URI zu erstellen. Zum Beispiel:
@Controller
@RequestMapping("/home")
public class HomeController {
}
Jetzt wird /home die URI sein, für die dieser Controller verwendet wird. Dieses Konzept ist sehr ähnlich dem Servlet-Kontext einer Webanwendung.
@RequestMapping mit Methode
Wir können es mit einer Methode verwenden, um das URI-Muster bereitzustellen, für das die Handlermethode verwendet wird. Zum Beispiel:
@RequestMapping(value="/method0")
@ResponseBody
public String method0() {
return "method0";
}
Die oben genannte Annotation kann auch als @RequestMapping(„/method0“) geschrieben werden. Nebenbei bemerkt, verwende ich @ResponseBody, um die String-Antwort für diese Webanfrage zu senden, um das Beispiel einfach zu halten. Ich werde diese Methoden in einer Spring MVC-Anwendung verwenden und sie mit einem einfachen Programm oder Skript testen.
@RequestMapping mit mehreren URIs
Wir können eine einzelne Methode verwenden, um mehrere URIs zu behandeln, zum Beispiel:
@RequestMapping(value={"/method1", "/method1/second"})
@ResponseBody
public String method1() {
return "method1";
}
Wenn Sie sich den Quellcode der RequestMapping-Annotation ansehen, werden Sie feststellen, dass alle ihre Variablen Arrays sind. Wir können ein String-Array für die URI-Zuordnungen für die Handlermethode erstellen.
@RequestMapping mit HTTP-Methode
Manchmal möchten wir verschiedene Operationen basierend auf der verwendeten HTTP-Methode durchführen, auch wenn die Anfrage-URI gleich bleibt. Wir können die @RequestMapping Methodenvariable verwenden, um die HTTP-Methoden einzugrenzen, für die diese Methode aufgerufen wird. Zum Beispiel:
@RequestMapping(value="/method2", method=RequestMethod.POST)
@ResponseBody
public String method2() {
return "method2";
}
@RequestMapping(value="/method3", method={RequestMethod.POST, RequestMethod.GET})
@ResponseBody
public String method3() {
return "method3";
}
@RequestMapping mit Headern
Wir können die Header spezifizieren, die vorhanden sein sollten, um die Handlermethode aufzurufen. Zum Beispiel:
@RequestMapping(value="/method4", headers="name=pankaj")
@ResponseBody
public String method4() {
return "method4";
}
@RequestMapping(value="/method5", headers={"name=pankaj", "id=1"})
@ResponseBody
public String method5() {
return "method5";
}
@RequestMapping mit Produces und Consumes
Wir können die Header Content-Type und Accept verwenden, um den Inhalt der Anfrage und die gewünschte MIME-Nachricht in der Antwort herauszufinden. Zur Verdeutlichung bietet @RequestMapping die Variablen ‚produces‘ und ‚consumes‘, bei denen wir den Content-Type der Anfrage spezifizieren können, für den die Methode aufgerufen wird, sowie den Content-Type der Antwort. Zum Beispiel:
@RequestMapping(value="/method6", produces={"application/json", "application/xml"}, consumes="text/html")
@ResponseBody
public String method6() {
return "method6";
}
Die oben genannte Methode kann eine Nachricht nur mit Content-Type als text/html verarbeiten und ist in der Lage, Nachrichten vom Typ application/json und application/xml zu erzeugen.
Spring @PathVariable
@RequestMapping mit @PathVariable: Die RequestMapping-Annotation kann verwendet werden, um dynamische URIs zu handhaben, bei denen einer oder mehrere der URI-Werte als Parameter fungieren. Wir können sogar einen regulären Ausdruck für den dynamischen URI-Parameter angeben, um nur bestimmte Arten von Eingaben zu akzeptieren. Es funktioniert mit der @PathVariable-Annotation, durch die wir die URI-Variable einem der Methodenargumente zuordnen können. Zum Beispiel:
@RequestMapping(value="/method7/{id}")
@ResponseBody
public String method7(@PathVariable("id") int id){
return "method7 with id="+id;
}
@RequestMapping(value="/method8/{id:[\\d]+}/{name}")
@ResponseBody
public String method8(@PathVariable("id") long id, @PathVariable("name") String name){
return "method8 with id= "+id+" and name="+name;
}
Spring @RequestParam
@RequestMapping mit @RequestParam für URL-Parameter: Manchmal erhalten wir Parameter in der Anfrage-URL, meistens bei GET-Anfragen. Wir können @RequestMapping mit der @RequestParam-Annotation verwenden, um den URL-Parameter abzurufen und ihn einem Methodenargument zuzuordnen. Zum Beispiel:
@RequestMapping(value="/method9")
@ResponseBody
public String method9(@RequestParam("id") int id){
return "method9 with id= "+id;
}
Damit diese Methode funktioniert, sollte der Parametername „id“ sein und er sollte vom Typ int sein.
@RequestMapping Standardmethode
@RequestMapping Standardmethode: Wenn der Wert für eine Methode leer ist, fungiert sie als Standardmethode für die Controller-Klasse. Zum Beispiel:
@RequestMapping()
@ResponseBody
public String defaultMethod(){
return "default method";
}
Wie Sie oben gesehen haben, haben wir `/home` dem `HomeController` zugeordnet, diese Methode wird für die Standard-URI-Anfragen verwendet.
@RequestMapping Fallback-Methode
@RequestMapping Fallback-Methode: Wir können eine Fallback-Methode für die Controller-Klasse erstellen, um sicherzustellen, dass wir alle Client-Anfragen erfassen, auch wenn es keine passenden Handlermethoden gibt. Dies ist nützlich, um benutzerdefinierte 404-Antwortseiten an Benutzer zu senden, wenn es keine Handlermethoden für die Anfrage gibt.
@RequestMapping("*")
@ResponseBody
public String fallbackMethod(){
return "fallback method";
}
Spring RestMapping Testprogramm
Wir können Spring RestTemplate verwenden, um die verschiedenen oben genannten Methoden zu testen, aber heute werde ich cURL-Befehle verwenden, um diese Methoden zu testen, da diese einfach sind und nicht viele Daten übertragen werden. Ich habe ein einfaches Shell-Skript springTest.sh erstellt, um alle oben genannten Methoden aufzurufen und deren Ausgabe zu drucken. Es sieht wie folgt aus.
#!/bin/bash
echo "curl https://localhost:9090/SpringRequestMappingExample/home/method0";
curl https://localhost:9090/SpringRequestMappingExample/home/method0;
printf "\n\n*****\n\n";
echo "curl https://localhost:9090/SpringRequestMappingExample/home";
curl https://localhost:9090/SpringRequestMappingExample/home;
printf "\n\n*****\n\n";
echo "curl https://localhost:9090/SpringRequestMappingExample/home/xyz";
curl https://localhost:9090/SpringRequestMappingExample/home/xyz;
printf "\n\n*****\n\n";
echo "curl https://localhost:9090/SpringRequestMappingExample/home/method1";
curl https://localhost:9090/SpringRequestMappingExample/home/method1;
printf "\n\n*****\n\n";
echo "curl https://localhost:9090/SpringRequestMappingExample/home/method1/second";
curl https://localhost:9090/SpringRequestMappingExample/home/method1/second;
printf "\n\n*****\n\n";
echo "curl -X POST https://localhost:9090/SpringRequestMappingExample/home/method2";
curl -X POST https://localhost:9090/SpringRequestMappingExample/home/method2;
printf "\n\n*****\n\n";
echo "curl -X POST https://localhost:9090/SpringRequestMappingExample/home/method3";
curl -X POST https://localhost:9090/SpringRequestMappingExample/home/method3;
printf "\n\n*****\n\n";
echo "curl -X GET https://localhost:9090/SpringRequestMappingExample/home/method3";
curl -X GET https://localhost:9090/SpringRequestMappingExample/home/method3;
printf "\n\n*****\n\n";
echo "curl -H "name:pankaj" https://localhost:9090/SpringRequestMappingExample/home/method4";
curl -H "name:pankaj" https://localhost:9090/SpringRequestMappingExample/home/method4;
printf "\n\n*****\n\n";
echo "curl -H "name:pankaj" -H "id:1" https://localhost:9090/SpringRequestMappingExample/home/method5";
curl -H "name:pankaj" -H "id:1" https://localhost:9090/SpringRequestMappingExample/home/method5;
printf "\n\n*****\n\n";
echo "curl -H "Content-Type:text/html" https://localhost:9090/SpringRequestMappingExample/home/method6";
curl -H "Content-Type:text/html" https://localhost:9090/SpringRequestMappingExample/home/method6;
printf "\n\n*****\n\n";
echo "curl https://localhost:9090/SpringRequestMappingExample/home/method6";
curl https://localhost:9090/SpringRequestMappingExample/home/method6;
printf "\n\n*****\n\n";
echo "curl -H "Content-Type:text/html" -H "Accept:application/json" -i https://localhost:9090/SpringRequestMappingExample/home/method6";
curl -H "Content-Type:text/html" -H "Accept:application/json" -i https://localhost:9090/SpringRequestMappingExample/home/method6;
printf "\n\n*****\n\n";
echo "curl -H "Content-Type:text/html" -H "Accept:application/xml" -i https://localhost:9090/SpringRequestMappingExample/home/method6";
curl -H "Content-Type:text/html" -H "Accept:application/xml" -i https://localhost:9090/SpringRequestMappingExample/home/method6;
printf "\n\n*****\n\n";
echo "curl https://localhost:9090/SpringRequestMappingExample/home/method7/1";
curl https://localhost:9090/SpringRequestMappingExample/home/method7/1;
printf "\n\n*****\n\n";
echo "curl https://localhost:9090/SpringRequestMappingExample/home/method8/10/Lisa";
curl https://localhost:9090/SpringRequestMappingExample/home/method8/10/Lisa;
printf "\n\n*****\n\n";
echo "curl https://localhost:9090/SpringRequestMappingExample/home/method9?id=20";
curl https://localhost:9090/SpringRequestMappingExample/home/method9?id=20;
printf "\n\n*****DONE*****\n\n";
Beachten Sie, dass ich meine Webanwendung auf Tomcat-7 bereitgestellt habe und sie auf Port 9090 läuft. SpringRequestMappingExample ist der Servlet-Kontext der Anwendung. Wenn ich dieses Skript über die Kommandozeile ausführe, erhalte ich folgende Ausgabe.
pankaj:~ pankaj$ ./springTest.sh
curl https://localhost:9090/SpringRequestMappingExample/home/method0
method0
*****
curl https://localhost:9090/SpringRequestMappingExample/home
default method
*****
curl https://localhost:9090/SpringRequestMappingExample/home/xyz
fallback method
*****
curl https://localhost:9090/SpringRequestMappingExample/home/method1
method1
*****
curl https://localhost:9090/SpringRequestMappingExample/home/method1/second
method1
*****
curl -X POST https://localhost:9090/SpringRequestMappingExample/home/method2
method2
*****
curl -X POST https://localhost:9090/SpringRequestMappingExample/home/method3
method3
*****
curl -X GET https://localhost:9090/SpringRequestMappingExample/home/method3
method3
*****
curl -H name:pankaj https://localhost:9090/SpringRequestMappingExample/home/method4
method4
*****
curl -H name:pankaj -H id:1 https://localhost:9090/SpringRequestMappingExample/home/method5
method5
*****
curl -H Content-Type:text/html https://localhost:9090/SpringRequestMappingExample/home/method6
method6
*****
curl https://localhost:9090/SpringRequestMappingExample/home/method6
fallback method
*****
curl -H Content-Type:text/html -H Accept:application/json -i https://localhost:9090/SpringRequestMappingExample/home/method6
HTTP/1.1 200 OK
Server: Apache-Coyote/1.1
Content-Type: application/json
Content-Length: 7
Date: Thu, 03 Jul 2014 18:14:10 GMT
method6
*****
curl -H Content-Type:text/html -H Accept:application/xml -i https://localhost:9090/SpringRequestMappingExample/home/method6
HTTP/1.1 200 OK
Server: Apache-Coyote/1.1
Content-Type: application/xml
Content-Length: 7
Date: Thu, 03 Jul 2014 18:14:10 GMT
method6
*****
curl https://localhost:9090/SpringRequestMappingExample/home/method7/1
method7 with id=1
*****
curl https://localhost:9090/SpringRequestMappingExample/home/method8/10/Lisa
method8 with id= 10 and name=Lisa
*****
curl https://localhost:9090/SpringRequestMappingExample/home/method9?id=20
method9 with id= 20
*****DONE*****
pankaj:~ pankaj$
Die meisten davon sind selbsterklärend, obwohl Sie vielleicht die Standard- und Fallback-Methoden überprüfen möchten. Das ist alles zum Spring RequestMapping-Beispiel, ich hoffe, es hilft Ihnen, diese Annotation und ihre verschiedenen Funktionen zu verstehen.
