Présentation des méthodes d'annotation couramment utilisées dans Spring MVC

Cet article présente principalement les annotations courantes de spring mvc, et présente en détail des annotations similaires telles que @RequestMapping, @RequestParam, @ModelAttribute et ainsi de suite. Ceux qui sont intéressés peuvent en apprendre davantage

Spring start. à partir de la version 2.5 Pour introduire des annotations dans la programmation, les utilisateurs peuvent utiliser des annotations similaires telles que @RequestMapping, @RequestParam, @ModelAttribute, etc. Jusqu'à présent, bien que la version Spring ait subi de grands changements, les fonctionnalités des annotations ont été poursuivies et continuellement étendues, ce qui facilite la tâche des développeurs. Ceci est indissociable de la puissance de la fonction d'annotation. Nous allons aujourd'hui examiner les annotations. couramment utilisé dans Spring MVC 4.

1. @Controller

Le contrôleur est un comportement qui permet d'accéder à l'application définie via l'interface du service. entrée, la convertit en modèle, puis restitue la vue à l'utilisateur. Spring MVC utilise @Controller pour définir les contrôleurs, ce qui permet également aux composants définis sur le chemin de classe d'être automatiquement détectés et automatiquement enregistrés. Si vous souhaitez que la détection automatique prenne effet, vous devez introduire spring-context sous le fichier d'en-tête XML :

 <?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.

Nous pouvons utiliser l'annotation @RequestMapping pour mapper une URL comme "/favsoft" à la classe entière ou à une méthode de traitement spécifique. De manière générale, les annotations au niveau de la classe mappent un chemin de requête spécifique au contrôleur de formulaire, tandis que les annotations au niveau de la méthode mappent simplement à une requête de méthode HTTP spécifique ("GET", "POST", etc.) ou à des paramètres de requête HTTP.

@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 peut agir à la fois au niveau de la classe et au niveau de la méthode. Lorsqu'il est défini au niveau de la classe, il indique que toutes les requêtes traitées par ce contrôleur sont mappées sur le chemin /favsoft. Vous pouvez utiliser l'attribut méthode dans @RequestMapping pour marquer les types de méthode qu'il accepte. Si vous ne spécifiez pas le type de méthode, vous pouvez utiliser la méthode HTTP GET/POST pour demander des données. Cependant, une fois le type de méthode spécifié, vous pouvez. utilisez uniquement ce type pour obtenir des données.

@RequestMapping Vous pouvez utiliser @Validated et BindingResult pour vérifier conjointement les paramètres d'entrée et renvoyer respectivement différentes vues lorsque la vérification réussit ou échoue.

@RequestMapping prend en charge l'utilisation de modèles d'URI pour accéder aux URL. Un modèle d'URI est une chaîne de type URL composée d'un ou plusieurs noms de variables. Lorsque ces variables ont des valeurs, elle devient un URI.

3. @PathVariable

Dans Spring MVC, vous pouvez utiliser @PathVariable pour annoter les paramètres de méthode et les lier à la valeur des variables du modèle URI. Comme indiqué dans le code suivant :

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

Modèle d'URI "favusers/{favUserId}" spécifie le nom de la variable favUserId. Lorsque le contrôleur traite cette requête, le la valeur de favUserId sera définie dans l’URI. Par exemple, lorsqu'il y a une requête du type « favusers/favccxx », la valeur de favUserId est favccxx.

@PathVariable peut avoir plusieurs annotations, comme les suivantes :

@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";
}

Les paramètres dans @PathVariable peuvent être n'importe quels simples types, tels que int, long, Date, etc. Spring le convertira automatiquement dans le type approprié ou lancera une TypeMismatchException. Bien entendu, nous pouvons également nous inscrire pour prendre en charge des types de données supplémentaires.

Si @PathVariable utilise les paramètres de type Map, Map sera renseigné dans toutes les variables du modèle URI.

@PathVariable prend en charge l'utilisation d'expressions régulières, qui déterminent ses propriétés super puissantes. Il peut utiliser des espaces réservés dans les modèles de chemin et définir une correspondance de préfixe spécifique, une correspondance de suffixe, etc. Définissez le format.

@PathVariable prend également en charge les variables matricielles. Parce qu'elles ne sont pas beaucoup utilisées dans les scénarios réels, je ne les présenterai pas en détail. Si vous avez besoin de chaussures pour enfants, veuillez consulter la documentation du site officiel.

4. @RequestParam

@RequestParam lie les paramètres demandés aux paramètres de la méthode, comme indiqué dans le code suivant. En effet, même si ce paramètre n'est pas configuré, l'annotation utilisera ce paramètre par défaut. Si vous souhaitez personnaliser les paramètres spécifiés, définissez l'attribut obligatoire de @RequestParam sur false (par exemple @RequestParam(value="id",required=false)).

5. @RequestBody

@RequestBody signifie que les paramètres de la méthode doivent être liés au corps de la requête HTTP.

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

Si vous pensez que @RequestBody n'est pas aussi bon que @RequestParam, nous pouvons utiliser HttpMessageConverter pour transférer le corps de la requête vers les paramètres de la méthode HttMessageConverser. transférer le message de requête HTTP entre les objets Objet. Convertir entre eux, mais cela n'est généralement pas fait. Il s'avère que @RequestBody présente de plus grands avantages que @RequestParam lors de la création d'une architecture REST.

6. @ResponseBody

@ResponseBody est similaire à @RequestBody Sa fonction est de saisir le type de retour directement dans le corps de la réponse HTTP. . @ResponseBody est souvent utilisé lors de la sortie de données au format JSON. Le code est présenté ci-dessous :

@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模板变量和类型转换器检索属性。

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!