Construire des API RESTful avec Play
Concevez et mettez en œuvre des points de terminaison RESTful, gérez les requêtes et manipulez les données JSON avec les contrôleurs Play.
Construire des API RESTful avec Play est une leçon Scala for Backend Engineering & Functional Programming gratuite sur CoddyKit. Ceci est la leçon 2 sur 3. Tu peux lire la leçon complète ci-dessous gratuitement — puis la pratiquer en direct dans le navigateur avec un éditeur de code intégré et un tuteur IA 24/7. Elle fait partie du parcours d'apprentissage Scala for Backend Engineering & Functional Programming, et ta progression se synchronise sur le web et l'application CoddyKit. Le cours Scala for Backend Engineering & Functional Programming comprend 3 leçons au total.
Introduction aux API REST de Play
Bienvenue ! Dans cette leçon, nous allons découvrir comment créer des API RESTful avec le Play Framework de Scala. REST (Representational State Transfer) est un style architectural largement utilisé pour concevoir des applications en réseau.
Une API RESTful permet à différents systèmes logiciels de communiquer entre eux sur Internet, généralement à l’aide des méthodes HTTP standard GET, POST, PUT et DELETE pour effectuer des opérations sur des ressources.
Contrôleurs et actions Play
Dans Play, les requêtes HTTP entrantes sont traitées par des contrôleurs. Un contrôleur est un objet ou une classe Scala qui contient des méthodes d’action.
Chaque méthode d’action traite un type précis de requête (par exemple, récupérer des données ou créer un nouvel élément) et renvoie une réponse HTTP.
Définir des routes dans Play
Play utilise un fichier conf/routes pour associer les requêtes HTTP entrantes aux méthodes d’action spécifiques des contrôleurs. C’est ici que vous définissez les points d’accès de votre API.
La syntaxe de base d’une entrée de route est : HTTP_METHOD /path controllers.ControllerName.actionMethod(parameters).
Implémenter un point d’accès GET
Créons un point d’accès GET simple qui renvoie un message d’accueil. Dans une véritable application Play, ce code se trouverait dans un contrôleur. Ici, nous simulons la logique dans une méthode main.
Essayez d’exécuter cet exemple :
object GreetingController {
// This method simulates a Play controller action
def sayHello(): String = {
"Hello from your Play API!"
}
def main(args: Array[String]): Unit = {
// Simulate receiving a request and calling the action
val apiResponse = sayHello()
println(s"Simulated API Response: $apiResponse")
}
}Extraire les paramètres du chemin
Souvent, vous devez extraire des valeurs dynamiques du chemin URL, comme l’identifiant d’un élément. On les appelle des paramètres de chemin.
Dans le fichier routes, vous les définissez avec deux-points (:). Dans l’action de votre contrôleur, vous les déclarez comme paramètres de méthode.
object UserController {
// This action takes an 'id' as a path parameter
def getUser(id: Int): String = {
s"Fetching user details for ID: $id"
}
def main(args: Array[String]): Unit = {
// Simulate a request to /users/123
val userIdFromRequest = 123
val apiResponse = getUser(userIdFromRequest)
println(s"Simulated API Response: $apiResponse")
}
}Corps des requêtes et JSON
Pour créer ou mettre à jour des ressources, les clients envoient des données dans le corps de la requête. Pour les API RESTful, ces données sont presque toujours au format JSON (JavaScript Object Notation).
Play offre une excellente prise en charge de l’analyse des corps de requête JSON et de leur conversion en classes de cas Scala.
Créer un point d’accès POST
Simulons un point d’accès POST qui reçoit un corps JSON. Dans une véritable application Play, vous utiliseriez la bibliothèque JSON de Play pour analyser la requête. Pour cet exemple exécutable, nous vérifierons une simple chaîne de caractères.
Essayez d’exécuter cet exemple :
object ItemController {
// Simulate processing a JSON request body
def createItem(jsonBody: String): String = {
// In a real Play app: Json.parse(jsonBody).as[ItemCaseClass]
if (jsonBody.contains("name") && jsonBody.contains("price")) {
s"Item successfully created! Data: $jsonBody"
} else {
"Error: Invalid JSON format. 'name' and 'price' expected."
}
}
def main(args: Array[String]): Unit = {
// Simulate a POST request with a JSON body
val validJson = """{"name": "Smartphone", "price": 799.99}"""
println(s"Valid JSON Response: ${createItem(validJson)}")
val invalidJson = """{"product": "Tablet"}"""
println(s"Invalid JSON Response: ${createItem(invalidJson)}")
}
}Gérer PUT et DELETE
En plus de GET et POST, les API RESTful utilisent couramment :
- PUT : pour mettre à jour une ressource existante. Cette opération nécessite généralement un paramètre de chemin (ID) et un corps de requête (données mises à jour).
- DELETE : pour supprimer une ressource. Cette opération nécessite généralement uniquement un paramètre de chemin (ID).
Les règles de définition des routes et d’accès aux paramètres ou aux corps pour PUT et DELETE sont similaires à celles de POST et GET.
Renvoyer des réponses JSON
Après avoir traité une requête, votre API doit généralement renvoyer une réponse, souvent au format JSON. Play permet de construire facilement des objets JSON et de les renvoyer.
Dans un contrôleur, vous utiliseriez généralement Ok(Json.toJson(yourCaseClass)). Ici, nous simulons la création d’une chaîne JSON.
object ResponseGenerator {
// Simulate a case class for the response data
case class ApiResponse(status: String, message: String)
// Simulate converting the case class to a JSON string
def buildJsonResponse(response: ApiResponse): String = {
s"""{"status": "${response.status}", "message": "${response.message}"}"""
}
def main(args: Array[String]): Unit = {
val successResponse = ApiResponse("success", "Data retrieved successfully")
println(s"Simulated JSON Output:\n${buildJsonResponse(successResponse)}")
val errorResponse = ApiResponse("error", "Item not found")
println(s"Simulated JSON Output:\n${buildJsonResponse(errorResponse)}")
}
}Quiz sur la correspondance des routes
Quelle définition de route Play correspondrait correctement à une requête GET /api/products/123 et transmettrait 123 en tant que Int à l’action du contrôleur ?
Récapitulatif et prochaines étapes
Excellent travail ! Vous avez appris les fondamentaux de la création d’API RESTful avec Play Framework :
- Comprendre les principes RESTful et les méthodes HTTP.
- Comprendre comment les contrôleurs et actions Play traitent les requêtes.
- Définir des routes d’API pour associer des URL aux actions des contrôleurs.
- Extraire des paramètres de chemin à partir des URL.
- Traiter les corps de requête JSON pour POST/PUT.
- Construire et renvoyer des réponses JSON.
Vous pouvez maintenant explorer l’intégration de bases de données à votre application Play !
Questions Fréquemment Posées
La leçon « Construire des API RESTful avec Play » est-elle gratuite ?
Oui — le texte complet de « Construire des API RESTful avec Play » est gratuit à lire ici sur le web. Pour la pratiquer de manière interactive (un éditeur de code intégré et un tuteur IA 24/7) et déverrouiller le reste du cours Scala for Backend Engineering & Functional Programming, passe à CoddyKit PRO. Le cours Scala for Backend Engineering & Functional Programming comprend 3 leçons au total.
Qu'est-ce que j'apprendrai dans « Construire des API RESTful avec Play » ?
Concevez et mettez en œuvre des points de terminaison RESTful, gérez les requêtes et manipulez les données JSON avec les contrôleurs Play. Tu pratiques Scala for Backend Engineering & Functional Programming avec du code pratique que tu exécutes directement dans le navigateur, et un tuteur IA 24/7 répond à tes questions au fur et à mesure que tu avances dans la leçon.
Dois-je avoir de l'expérience pour commencer Scala for Backend Engineering & Functional Programming ?
Aucune expérience préalable n'est requise. Scala for Backend Engineering & Functional Programming sur CoddyKit est structuré pour les débutants jusqu'aux apprenants avancés, donc tu peux commencer ici ou depuis le début et avancer à ton rythme. Ceci est la leçon 2 sur 3.
Combien de temps prend la leçon « Construire des API RESTful avec Play » ?
La plupart des leçons CoddyKit prennent environ 5–10 minutes. Chacune est courte et interactive, tu progresses régulièrement et tu repiques exactement où tu t'es arrêté sur le web et l'app.
Peux-tu écrire et exécuter du code dans cette leçon Scala for Backend Engineering & Functional Programming ?
Oui. Chaque leçon Scala for Backend Engineering & Functional Programming inclut un éditeur de code intégré, tu écris et exécutes du vrai code directement dans ton navigateur et tu reçois des retours IA instantanés — aucune configuration locale requise.
Toutes les leçons de ce cours
- Principes fondamentaux de Play Framework
- Construire des API RESTful avec Play
- Intégration de bases de données avec Slick/Doobie