Einführung in häufig verwendete Annotationsmethoden in Spring MVC

In diesem Artikel werden hauptsächlich die allgemeinen Annotationen von Spring MVC vorgestellt und ähnliche Annotationen wie @RequestMapping, @RequestParam, @ModelAttribute usw. im Detail vorgestellt.

Der Frühling beginnt ab Version 2.5 Um Annotationen in die Programmierung einzuführen, können Benutzer ähnliche Annotationen wie @RequestMapping, @RequestParam, @ModelAttribute usw. verwenden. Obwohl die Spring-Version bisher große Änderungen erfahren hat, wurden die Funktionen von Annotationen fortgesetzt und kontinuierlich erweitert, was die Hände der Entwickler einfacher macht. Dies ist untrennbar mit der Leistungsfähigkeit der Annotation-Funktion verbunden Wird häufig in Spring MVC 4 verwendet.

1. @Controller

Controller ist ein Verhalten, das den Zugriff auf die über die Serviceschnittstelle definierte Anwendung ermöglicht. Es interpretiert die Einstellungen des Benutzers Eingabe, wandelt sie in ein Modell um und rendert dann die Ansicht für den Benutzer. Spring MVC verwendet @Controller zum Definieren von Controllern, wodurch auch im Klassenpfad definierte Komponenten automatisch erkannt und registriert werden können. Wenn die automatische Erkennung wirksam werden soll, müssen Sie Spring-Context unter der XML-Header-Datei einführen:

 <?xml version="1.0" encoding="UTF-8"?><beans xmlns="http://www.springframework.org/schema/beans"
  xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
  xmlns:p="http://www.springframework.org/schema/p"
  xmlns:context="http://www.springframework.org/schema/context"
  xsi:schemaLocation="
    http://www.springframework.org/schema/beans
    http://www.springframework.org/schema/beans/spring-beans.xsd
    http://www.springframework.org/schema/context
    http://www.springframework.org/schema/context/spring-context.xsd">
 
  <context:component-scan base-package="org.springframework.samples.petclinic.web"/>
 
  <!-- ... --></beans>

2

Wir können die Annotation @RequestMapping verwenden, um eine URL wie „/favsoft“ der gesamten Klasse oder einer bestimmten Verarbeitungsmethode zuzuordnen. Im Allgemeinen ordnen Annotationen auf Klassenebene einen bestimmten Anforderungspfad dem Formularcontroller zu, während Annotationen auf Methodenebene einfach einer bestimmten HTTP-Methodenanforderung („GET“, „POST“ usw.) oder HTTP-Anforderungsparametern zuordnen.

@Controller
@RequestMapping("/favsoft")
public class AnnotationController {
   
  @RequestMapping(method=RequestMethod.GET)
  public String get(){
    return "";
  }
   
  @RequestMapping(value="/getName", method = RequestMethod.GET)
  public String getName(String userName) {
    return userName;
  }
   
  @RequestMapping(value="/{day}", method=RequestMethod.GET)
  public String getDay(Date day){
    DateFormat df = new SimpleDateFormat("yyyy-MM-dd");
    return df.format(day);
  }
   
  @RequestMapping(value="/addUser", method=RequestMethod.GET)
  public String addFavUser(@Validated FavUser favUser,BindingResult result){
    if(result.hasErrors()){
      return "favUser";
    }
    //favUserService.addFavUser(favUser);
    return "redirect:/favlist";
  }
 
  @RequestMapping("/test")
  @ResponseBody
  public String test(){
    return "aa";
  }
   
}

@RequestMapping kann sowohl auf Klassenebene als auch auf Methodenebene agieren. Wenn es auf Klassenebene definiert wird, zeigt es an, dass alle von diesem Controller verarbeiteten Anforderungen dem Pfad /favsoft zugeordnet werden. Sie können das Methodenattribut in @RequestMapping verwenden, um die akzeptierten Methodentypen zu markieren. Wenn Sie den Methodentyp nicht angeben, können Sie die HTTP-Methode GET/POST zum Anfordern von Daten verwenden Verwenden Sie diesen Typ nur zum Abrufen von Daten.

@RequestMapping Sie können @Validated und BindingResult verwenden, um die Eingabeparameter gemeinsam zu überprüfen und jeweils unterschiedliche Ansichten zurückzugeben, wenn die Überprüfung erfolgreich ist oder fehlschlägt.

@RequestMapping unterstützt die Verwendung von URI-Vorlagen für den Zugriff auf URLs. Eine URI-Vorlage ist eine URL-ähnliche Zeichenfolge, die aus einem oder mehreren Variablennamen besteht. Wenn diese Variablen Werte haben, wird daraus ein URI.

3. @PathVariable

In Spring MVC können Sie @PathVariable verwenden, um Methodenparameter mit Anmerkungen zu versehen und sie an den Wert der URI-Vorlagenvariablen zu binden. Wie im folgenden Code gezeigt:

 String findOwner( String , Model model) {
  FavUser favUser = favUserService.findFavUser();
  model.addAttribute(
   ;
}

URI-Vorlage „favusers/{favUserId}“ gibt den Namen der Variablen favUserId an Der Wert von favUserId wird in den URI gesetzt. Wenn es beispielsweise eine Anfrage wie „favusers/favccxx“ gibt, ist der Wert von favUserId favccxx.

@PathVariable kann mehrere Anmerkungen haben, wie die folgenden:

@RequestMapping(value="/owners/{ownerId}/pets/{petId}", method=RequestMethod.GET)public String findPet(@PathVariable String ownerId, @PathVariable String petId, Model model) {
  Owner owner = ownerService.findOwner(ownerId);
  Pet pet = owner.getPet(petId);
  model.addAttribute("pet", pet);  return "displayPet";
}

Die Parameter in @PathVariable können beliebig einfach sein Typen wie int, long, Date usw. Spring konvertiert es automatisch in den entsprechenden Typ oder löst eine TypeMismatchException aus. Selbstverständlich können wir uns auch für die Unterstützung weiterer Datentypen registrieren.

Wenn @PathVariable Parameter vom Typ Map05ad6303f369fc4ccec4412db2772d19 verwendet, wird Map in alle URI-Vorlagenvariablen gefüllt.

@PathVariable unterstützt die Verwendung regulärer Ausdrücke, die seine äußerst leistungsstarken Eigenschaften bestimmen. Es kann Platzhalter in Pfadvorlagen verwenden und spezifische Präfixübereinstimmungen, Suffixübereinstimmungen usw. festlegen. Definieren Sie das Format.

@PathVariable unterstützt auch Matrixvariablen, da sie in realen Szenarien nicht häufig verwendet werden. Wenn Sie Kinderschuhe benötigen, lesen Sie bitte die Dokumentation der offiziellen Website.

4. @RequestParam

@RequestParam bindet die angeforderten Parameter an die Parameter in der Methode, wie im folgenden Code gezeigt. Selbst wenn dieser Parameter nicht konfiguriert ist, verwendet die Annotation diesen Parameter standardmäßig. Wenn Sie die angegebenen Parameter anpassen möchten, setzen Sie das erforderliche Attribut von @RequestParam auf false (z. B. @RequestParam(value="id",required=false)).

5. @RequestBody

@RequestBody bedeutet, dass die Methodenparameter an den HTTP-Anfragetext gebunden werden sollen.

@RequestMapping(value = "/something", method = RequestMethod.PUT)public void handle(@RequestBody String body, Writer writer) throws IOException {
  writer.write(body);
}

Wenn Sie der Meinung sind, dass @RequestBody nicht so gut ist wie @RequestParam, können wir HttpMessageConverter verwenden, um den Hauptteil der Anfrage an die Methodenparameter HttMessageConverser zu übertragen Übertragen Sie die HTTP-Anforderungsnachricht zwischen den Objektobjekten. Dies erfolgt jedoch im Allgemeinen nicht. Es stellt sich heraus, dass @RequestBody beim Aufbau einer REST-Architektur größere Vorteile hat als @RequestParam.

6. @ResponseBody

@ResponseBody ähnelt @RequestBody. Seine Funktion besteht darin, den Rückgabetyp direkt in den HTTP-Antworttext einzugeben . @ResponseBody wird häufig bei der Ausgabe von Daten im JSON-Format verwendet. Der Code wird unten angezeigt:

@RequestMapping(value = "/something", method = RequestMethod.PUT)@ResponseBodypublic String helloWorld() {  return "Hello World";
}

7 🎜>

我们经常见到一些控制器实现了REST的API，只为服务于JSON，XML或其它自定义的类型内容，@RestController用来创建REST类型的控制器，与@Controller类型。@RestController就是这样一种类型，它避免了你重复的写@RequestMapping与@ResponseBody。

@RestController
public class FavRestfulController {
 
@RequestMapping(value="/getUserName",method=RequestMethod.POST)
public String getUserName(@RequestParam(value="name") String name){
return name;
}
}

8. HttpEntity

HttpEntity除了能获得request请求和response响应之外，它还能访问请求和响应头，如下所示：

@RequestMapping("/something")public ResponseEntity<String> handle(HttpEntity<byte[]> requestEntity) throws UnsupportedEncodingException {
  String requestHeader = requestEntity.getHeaders().getFirst("MyRequestHeader"));  byte[] requestBody = requestEntity.getBody();  // do something with request header and body

  HttpHeaders responseHeaders = new HttpHeaders();
  responseHeaders.set("MyResponseHeader", "MyValue");  return new ResponseEntity<String>("Hello World", responseHeaders, HttpStatus.CREATED);
}

9. @ModelAttribute

@ModelAttribute可以作用在方法或方法参数上，当它作用在方法上时，标明该方法的目的是添加一个或多个模型属性（model attributes）。该方法支持与@RequestMapping一样的参数类型，但并不能直接映射成请求。控制器中的@ModelAttribute方法会在@RequestMapping方法调用之前而调用，示例如下：

@ModelAttribute
public Account addAccount(@RequestParam String number) {
  return accountManager.findAccount(number);
}

@ModelAttribute
public void populateModel(@RequestParam String number, Model model) {
  model.addAttribute(accountManager.findAccount(number));  
  // add more ...
}

@ModelAttribute方法用来在model中填充属性，如填充下拉列表、宠物类型或检索一个命令对象比如账户（用来在HTML表单上呈现数据）。

@ModelAttribute方法有两种风格：一种是添加隐形属性并返回它。另一种是该方法接受一个模型并添加任意数量的模型属性。用户可以根据自己的需要选择对应的风格。

@ModelAttribute作用在方法参数上

当@ModelAttribute作用在方法参数上时，表明该参数可以在方法模型中检索到。如果该参数不在当前模型中，该参数先被实例化然后添加到模型中。一旦模型中有了该参数，该参数的字段应该填充所有请求参数匹配的名称中。这是Spring MVC中重要的数据绑定机制，它省去了单独解析每个表单字段的时间。

@ModelAttribute是一种很常见的从数据库中检索属性的方法，它通过@SessionAttributes使用request请求存储。在一些情况下，可以很方便的通过URI模板变量和类型转换器检索属性。

Das obige ist der detaillierte Inhalt vonEinführung in häufig verwendete Annotationsmethoden in Spring MVC. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!