Cloud-Lösungen der Zukunft - Testen!
Revolutionäre Cloud-Technologie, ganz ohne versteckte Kosten. Profitieren Sie von unserer Testphase und entdecken Sie umfassende Funktionen. Der Anmeldeprozess ist transparent und unkompliziert. Starten Sie jetzt Ihre Reise in die Cloud - Kostenfrei!
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.
Kostenlosen Account erstellen
Registrieren Sie sich jetzt und erhalten Sie exklusiven Zugang zu weiterführenden Ressourcen, individuellem Support und einer Community von Experten.
Aktuelle Beiträge
Jetzt Kostenlos Testen: Entdecken Sie die Möglichkeiten von Spring MVC!
Erleben Sie die Leistungsfähigkeit von Spring MVC in der Cloud. Nutzen Sie unsere benutzerfreundliche Plattform, um die @RequestMapping Annotation in Ihrer Spring-Anwendung optimal einzusetzen.