Quelles sont les annotations de framework communes pour Spring Boot Rest ?

Prérequis pour démarrer avec Spring Boot Rest

La chose la plus importante à savoir est le conteneur Spring ou IOC. En plus de cela, vous devez avoir des connaissances de base sur les annotations Java. Parce que les applications Spring Boot regorgent d'annotations. Enfin et surtout, le concept de REST devrait être clarifié, au moins les concepts de base. Par exemple, GET, POST, PUT, DELETE et corps et réponse de la demande, en-têtes, etc.

Créer un projet Spring Boot dans Spring Initializer

La meilleure chose à propos de Spring Boot est qu'il dispose d'une application Web pour démarrer. Cliquez simplement sur quelques champs et boutons du formulaire et votre fichier de démarrage est prêt. Cela inclut les pompons. xml contenant toutes les dépendances requises. Accédez simplement à Spring Initializer : https://start.spring.io/. Remplissez les données appropriées comme indiqué dans la capture d'écran ci-dessous. Cliquez ensuite sur le bouton Ajouter des dépendances dans le coin supérieur droit. Tapez et sélectionnez Web. J'ajouterai également Lombok pour log et Pojo.

Une fois terminé, cliquez simplement sur le bouton Générer et un fichier zip (pom.xml) contenant ces fichiers sera téléchargé. Décompressez-le et ouvrez-le dans l'EDI. J'utiliserai IntelliJ IDEA. Cet IDE m'aide à profiter de diverses fonctionnalités pour améliorer mon efficacité de travail. Plug-ins couramment utilisés pour l'IDE

Annotations Spring Boot

L'ensemble de Spring Boot repose sur des annotations. Il existe diverses notes pour différents besoins et procédures. Le reste de la section comporte 4 à 5 notes principales. Examinons-les un par un et appliquons-les à notre exemple. L'annotation @RestController est utilisée sur la classe

@RestController

. Il définit la classe comme contrôleur pour Rest. Il s'agit d'une version RESTful du contrôleur qui ajoute la combinaison ResponseBy. De cette façon, votre réponse est automatiquement convertie en JSON, XML ou tout autre type de réponse défini sans avoir besoin d'une annotation ResponseBy distincte. @RestController注释。它将类定义为Rest的控制器。这是一个RESTful版本的控制器，添加了ResponseBy的组合。这样，您的响应就会自动转换为JSON、XML或任何已定义的响应类型，而无需单独使用ResponseBy注释。

@RestController
public class ArticleRestController {}

其余的注释在@RestController类下使用。

@RequestMapping

用于将特定端点映射到函数或方法。这有助于定义端点的路径、方法、响应类型、请求类型等。

@RequestMapping(value = "/articles", method = RequestMethod.GET,  produces = "application/json")
public List<Article> getArticles() { }

在上面的示例中，值表示它映射到的路径。例如，localhost:8080/articles。方法类型是GET，它生成“application/json”作为响应（不过，这是默认值，您可以跳过它）。

@RequestParam

URL中的查询参数，即？key=value&key1=value1由@RequestParam注释获取。这用于函数的参数。它有各种选项，如required、defaultValue等。然后将查询参数加载到指定的参数中。

@RequestMapping(value = "/article", method = RequestMethod.GET)
public Article getArticleByName(
   @RequestParam(value = "articleName", required = true) String articleName
) {}

在上面的例子中，如果我们调用URL GET localhost/article？articleName=springboot，将在articleName参数中加载“springboot”。我已经把reuired=true，所以如果我们不传递articleName，它将向用户抛出一个错误。

@PathVariable

有没有想过，在不传递查询参数的情况下，服务器如何知道要加载哪篇文章？看看这篇文章的网址 post URL不包含查询参数，而是一个普通的斜杠分隔字符串。服务器在PathVariable的帮助下读取它，它看起来是这样的，/article/{articleslaug}。替换{articleSlug}的任何字符串都将被视为PathVariable。

@RequestMapping(value = "/article/{articleSlug}", method = RequestMethod.GET)
public Article getArticle(@PathVariable("articleSlug") String articleSlug) {}

请记住，{articleSlug}在RequestMapping和PathVariable中应该是相同的（没有{}）。如果不匹配，则无法加载。

@RequestBody

对于POST或PUT方法，您不会通过URL获取所有数据，对吗？这些方法有一个适当的请求主体。RequestBody注释有助于将给定的请求正文自动映射到参数。主要是JSON到POJO。

@RequestMapping(value = "/article", method = RequestMethod.POST)
public Article createArticle(@RequestBody NewArticlePojo newArticle){}

请求主体将自动映射到NewArticlePojo类，并基于键填充字段。

REST方法的特定注释

在上面的解释中，您一定已经看到我使用特定的方法编写了RequestMapping。但这太多余了。为了解决这个问题，Spring Boot提供了预定义的方法映射。这些只是@RequestMapping的扩展。

@GetMapping

@GetMapping用于将RequestMapping替换为method=RequestMethod。获取参数。现在通过查看，我们知道这是一个GET请求。

@PostMapping和@PutMapping

PostMapping是用method=RequestMethod替换RequestMapping。类似地，PutMapping将用method=RequestMethod替换RequestMethod.PUT

@DeleteMapping

DeleteMapping用method=RequestMethod替换RequestMethod.DELETErrreee

Le reste des annotations est utilisé sous la classe @RestController. 🎜🎜@RequestMapping🎜🎜 est utilisé pour mapper un point de terminaison spécifique à une fonction ou une méthode. Cela permet de définir le chemin du point de terminaison, la méthode, le type de réponse, le type de demande, etc. 🎜rrreee🎜Dans l'exemple ci-dessus, la valeur représente le chemin auquel elle correspond. Par exemple, localhost:8080/articles. Le type de méthode est GET, qui génère "application/json" comme réponse (cependant, c'est la valeur par défaut et vous pouvez l'ignorer). 🎜🎜@RequestParam🎜🎜Le paramètre de requête dans l'URL, c'est-à-dire  ? key=value&key1=value1 est obtenu par l'annotation @RequestParam. Ceci est utilisé pour les paramètres des fonctions. Il propose diverses options telles que required, defaultValue, etc. Chargez ensuite les paramètres de requête dans les paramètres spécifiés. 🎜rrreee🎜Dans l'exemple ci-dessus, si nous appelons l'URL GET localhost/article ? articleName=springboot, "springboot" sera chargé dans le paramètre articleName. J'ai mis reuired=true donc si nous ne transmettons pas articleName, cela générera une erreur à l'utilisateur. 🎜🎜@PathVariable🎜🎜Vous êtes-vous déjà demandé comment le serveur sait quel article charger sans transmettre les paramètres de requête ? Jetez un œil à l'URL de cette publication. L'URL de la publication ne contient pas de paramètres de requête, mais une simple chaîne délimitée par des barres obliques. Le serveur le lit à l'aide de PathVariable et cela ressemble à ceci, /article/{articleslaug}. Toute chaîne qui remplace {articleSlug} sera traitée comme PathVariable. 🎜rrreee🎜N'oubliez pas que {articleSlug} doit être le même dans RequestMapping et PathVariable (sans {} > ). Si cela ne correspond pas, il ne se chargera pas. 🎜🎜@RequestBody🎜🎜Pour la méthode POST ou PUT, vous n'obtenez pas toutes les données via URL, n'est-ce pas ? Ces méthodes ont un corps de requête approprié. L'annotation RequestBody permet de mapper automatiquement un corps de requête donné aux paramètres. Principalement JSON vers POJO. 🎜rrreee🎜Le corps de la requête sera automatiquement mappé à la classe NewArticlePojo et les champs seront remplis en fonction de la clé. 🎜🎜Annotations spécifiques aux méthodes REST🎜🎜Dans l'explication ci-dessus, vous avez dû voir que j'ai écrit RequestMapping en utilisant une méthode spécifique. Mais c'est trop redondant. Pour résoudre ce problème, Spring Boot fournit des mappages de méthodes prédéfinis. Ce ne sont que des extensions de @RequestMapping. 🎜🎜@GetMapping🎜🎜@GetMapping est utilisé pour remplacer RequestMapping par method=RequestMethod. Obtenez les paramètres. Maintenant, en l'examinant, nous savons qu'il s'agit d'une requête GET. 🎜🎜@PostMapping et @PutMapping🎜🎜PostMapping remplace RequestMapping par method=RequestMethod. De même, PutMapping remplacera RequestMethod.PUT par method=RequestMethod🎜🎜@DeleteMapping🎜🎜DeleteMapping par method=RequestMethod code>Remplacer RequestMethod.DELETE🎜

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!