Explication détaillée des annotations @RequestBody et @RequestParam

@RequestParam

@RequestParam : reçu de RequestHeader, c'est-à-dire l'en-tête de la requête. Généralement utilisé pour les requêtes GET, par exemple : http://localhost:8080/hello/name=admin&age=18

@Target({ElementType.PARAMETER})
@Retention(RetentionPolicy.RUNTIME)
@Documented
public @interface RequestParam {
    @AliasFor("name")
    String value() default "";

    @AliasFor("value")
    String name() default "";

    boolean required() default true;

    String defaultValue() default "\n\t\t\n\t\t\n\ue000\ue001\ue002\n\t\t\t\t\n";
}

OBTENIR la requête

  	@GetMapping("/hello")
    public String hello(@RequestParam(name = "id") Long id){
        System.out.println("hello " + id);
        return "hello message";
    }

@RequestParam est utilisé pour traiter le contenu encodéContent-Type , qui utilise par défaut cette propriétéapplication/x-www-form-undencodedContent-Type

@RequestParam peut également être utilisé pour d'autres types de requêtes, telles que : POST, DELETE et autres requêtes .

Demande POST

Étant donné que @RequestParam est utilisé pour Content-Typetraiter application/x-www-form-urlencodedle contenu encodé en tant que , dans postman, le type de corps doit être sélectionné en tant que , afin qu'il passe automatiquement en : format d'encodage x-www-form-urlencodeddans les en-têtes . Comme indiqué ci-dessous:Content-Typeapplication/x-www-form-urlencoded

	@PostMapping("/save")
    public String hello(@RequestParam(name = "id") Long id,
                        @RequestParam("name") String name,
        				@RequestParam("password") String password){
   		System.out.println(user);
        return "hello message";
    }

Si les paramètres passés par la réception ne sont pas trois, mais dix, si nous continuons à utiliser @RequestParam pour recevoir des paramètres de requête, nous avons besoin de dix @RequestParam, notre lisibilité du code deviendra très mauvaise, et lorsque les paramètres Lorsque les types sont les même, il est très sujet aux erreurs. Utilisez donc la classe d'entité pour recevoir les paramètres passés, mais @RequestParam ne prend pas en charge la manière de passer directement la classe d'entité

@Data
public class User {

    @NotNull(message = "id不能为空")
    private Long id;

    @NotBlank(message = "名字不能为空")
    private String name;

    @NotBlank(message = "密码不能为空")
    private String password;
}

// @RequestParam 不支持直接传递实体类的方式，所以可以在实体类中做数据校验，使用 @Validated 注解使得作用在实体类属性上的注解生效
@PostMapping("/save")
public String save(@Validated User user){
    System.out.println(user);
    return "hello success";
}
// console result: User(id=110, name=admin, password=123456)

Si vous utilisez jsonune chaîne pour transmettre la valeur à la place, définissez le type sur application/json, et si vous cliquez sur envoyer, une erreur sera signalée et la valeur ne pourra pas être reçue en arrière-plan, ce qui estnull

// console result: User(id=null, name=null, password=null)

@RequestBody

Les paramètres reçus par l'annotation @RequestBody proviennent de requestBody , c'est-à-dire du corps de la requête . Il est généralement utilisé pour traiter des données dans des formats non Content-Type: application/x-www-form-urlencodedcodés , tels que : application/json, application/xmlet d'autres types de données.

En application/jsonce qui concerne le type de données, utilisez l'annotation @RequestBody pour transférer toutes les données json du corps vers le backend, puis le backend les analysera.

@PostMapping("/saveBatch")
public String saveBatch(@RequestBody @Validated List<User> list){
    list.forEach(System.out::println);
    return "saveBatch success";
}

// console result： 
// User(id=1, name=admin, password=123456)
// User(id=2, name=cheny, password=cheny)

passé à la carte

@PostMapping("/listMap")
public String saveMap(@RequestBody List<Map<String, String>> listMap){
    for (Map<String, String> map : listMap) {
        System.out.println(map);
    }
    return "listMap success";
}

// console result：
// {id=1, name=admin}
// {id=2, age=18}

Résumer

Les paramètres reçus par l'annotation @RequestParam proviennent de requestHeader , c'est-à-dire de l'en-tête de la requête . Habituellement utilisé pour les requêtes GET , d'autres types de requêtes comme POST, DELETE, etc. peuvent également être utilisés.

Dans les requêtes GET, @RequestBody ne peut pas être utilisé.
Dans les requêtes POST, @RequestBody et @RequestParam peuvent être utilisés, mais si @RequestBody est utilisé, la configuration de la conversion des paramètres doit être unifiée.
Plusieurs @RequestParam peuvent être utilisés pour obtenir des données, @RequestBody ne peut pas

Par exemple, dans la pile de traitement HttpMessageConverters configurée dans SpringMVC, spécifiez le format de conversion json, tel que Date est converti en 'aaaa-MM-jj', et si le champ contenu dans l'objet de réception de paramètre est de type Date, il peut être transmis uniquement par le client Le format est année, mois, jour et heures, minutes et secondes ne peuvent pas être transmis. En raison des différentes interfaces, ses paramètres peuvent avoir des exigences de format différentes pour les paramètres de temps, ce qui rendra les collègues de l'appel client un peu confus quant au format des paramètres, de sorte que l'évolutivité n'est pas élevée.

Si vous utilisez @RequestParam pour accepter des paramètres, vous pouvez définir @DateFormat dans le modèle qui accepte les paramètres pour spécifier le format dont vous avez besoin pour accepter les paramètres d'heure.

De plus, les paramètres acceptés par @RequestBody ne seront pas convertis par Servlet et placés dans le jeu de paramètres Param de l'objet de requête, @RequestParam est possible.

Pour résumer, en général, il est recommandé d'utiliser l'annotation @RequestParam pour accepter les paramètres de requête Http.

les références

Scénarios d'utilisation de l'annotation @RequestParam et @RequestBody - Tencent Cloud Developer Community - Tencent Cloud

La différence entre @RequestBody et @RequestParam est complète et détaillée