RESTful API's bouwen met Play
Ontwerp en implementeer RESTful endpoints, verwerk requests en beheer JSON-gegevens met Play-controllers.
RESTful API's bouwen met Play is een gratis Scala voor backend-engineering en functioneel programmeren-les op CoddyKit. Dit is les 2 van 3. Je kunt de volledige les hieronder gratis lezen en daarna in de browser praktisch oefenen met een ingebouwde code-editor en een AI-begeleider die 24/7 beschikbaar is. Deze les maakt deel uit van het leertraject Scala voor backend-engineering en functioneel programmeren. Je voortgang wordt gesynchroniseerd op het web en in de CoddyKit-app. De cursus Scala voor backend-engineering en functioneel programmeren bevat in totaal 3 lessen.
Introductie tot Play REST API's
Welkom! In deze les gaan we dieper in op het bouwen van RESTful API's met het Scala Play Framework. REST (Representational State Transfer) is een veelgebruikte architectuurstijl voor het ontwerpen van applicaties die via een netwerk werken.
Met een RESTful API kunnen verschillende softwaresystemen via internet met elkaar communiceren. Daarbij worden doorgaans standaard-HTTP-methoden zoals GET, POST, PUT en DELETE gebruikt om bewerkingen op bronnen uit te voeren.
Play-controllers en -acties
In Play worden binnenkomende HTTP-aanvragen verwerkt door controllers. Een controller is een Scala-object of -klasse die actiemethoden bevat.
Elke actiemethode is verantwoordelijk voor het verwerken van een specifiek type aanvraag (bijvoorbeeld gegevens ophalen of een nieuw item maken) en het retourneren van een HTTP-reactie.
Routes definiëren in Play
Play gebruikt een bestand conf/routes om binnenkomende HTTP-aanvragen te koppelen aan specifieke actiemethoden van controllers. Hier definieer je de eindpunten van je API.
De basissyntaxis voor een route-item is: HTTP_METHOD /path controllers.ControllerName.actionMethod(parameters).
Een GET-eindpunt implementeren
Laten we een eenvoudig GET-eindpunt maken dat een begroeting retourneert. In een echte Play-app zou dit in een controller staan. Hier simuleren we de logica in een main-methode.
Probeer dit voorbeeld uit te voeren:
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")
}
}Padparameters uitlezen
Vaak moet je dynamische waarden uit het URL-pad uitlezen, zoals een item-ID. Dit worden padparameters genoemd.
In het bestand routes definieer je deze met een dubbele punt (:). In je controlleractie declareer je ze als methodeparameters.
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")
}
}Aanvraagteksten en JSON
Voor het maken of bijwerken van bronnen sturen clients gegevens in de aanvraagtekst. Bij RESTful API's staan deze gegevens vrijwel altijd in de indeling JSON (JavaScript Object Notation).
Play biedt uitstekende ondersteuning voor het parseren van JSON-aanvraagteksten en het omzetten ervan naar Scala-caseklassen.
Een POST-eindpunt bouwen
Laten we een POST-eindpunt simuleren dat een JSON-tekst ontvangt. In een echte Play-app zou je de JSON-bibliotheek van Play gebruiken om de aanvraag te parseren. In dit uitvoerbare voorbeeld controleren we eenvoudige tekenreeksinhoud.
Probeer dit voorbeeld uit te voeren:
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)}")
}
}PUT en DELETE verwerken
Naast GET en POST gebruiken RESTful API's vaak:
- PUT: Om een bestaande bron bij te werken. Hiervoor zijn meestal een padparameter (ID) en een aanvraagtekst (bijgewerkte gegevens) nodig.
- DELETE: Om een bron te verwijderen. Hiervoor is doorgaans alleen een padparameter (ID) nodig.
De patronen voor het definiëren van routes en het benaderen van parameters en aanvraagteksten voor PUT en DELETE lijken op die voor POST en GET.
JSON-reacties retourneren
Na het verwerken van een aanvraag moet je API meestal een reactie terugsturen, vaak in JSON-indeling. Play maakt het eenvoudig om JSON-objecten te maken en terug te sturen.
In een controller gebruik je doorgaans Ok(Json.toJson(yourCaseClass)). Hier simuleren we het maken van een JSON-tekenreeks.
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 over routekoppeling
Welke Play-routedefinitie komt correct overeen met een verzoek naar GET /api/products/123 en geeft 123 als een Int door aan de controlleractie?
Samenvatting en volgende stappen
Goed gedaan! Je hebt de basisprincipes geleerd voor het bouwen van RESTful API's met Play Framework:
- Inzicht in RESTful-principes en HTTP-methoden.
- Hoe Play-controllers en -acties verzoeken verwerken.
- API-routes definiëren om URL's aan controlleracties te koppelen.
- Padparameters uit URL's halen.
- JSON-verzoeklichamen verwerken voor POST/PUT.
- JSON-antwoorden samenstellen en retourneren.
Vervolgens kun je onderzoeken hoe je databases integreert met je Play-toepassing!
Leer Scala met een AI-tutor — gratis
Schrijf echte code en voer die uit in je browser, krijg direct hulp van een AI-tutor die 24/7 beschikbaar is en ga verder waar je gebleven bent op het web of in de app.
- Cursussen
- 39
- Lessen
- 143
Veelgestelde vragen
Is de les “RESTful API's bouwen met Play” gratis?
Ja — de volledige tekst van “RESTful API's bouwen met Play” kun je hier gratis op het web lezen. Als je interactief wilt oefenen met een ingebouwde code-editor en een AI-begeleider die 24/7 beschikbaar is, en de rest van de cursus Scala voor backend-engineering en functioneel programmeren wilt ontgrendelen, kun je upgraden naar CoddyKit PRO. De cursus Scala voor backend-engineering en functioneel programmeren bevat in totaal 3 lessen.
Wat leer ik in “RESTful API's bouwen met Play”?
Ontwerp en implementeer RESTful endpoints, verwerk requests en beheer JSON-gegevens met Play-controllers. Je oefent met Scala voor backend-engineering en functioneel programmeren door code rechtstreeks in de browser uit te voeren. Een AI-begeleider die 24/7 beschikbaar is beantwoordt je vragen terwijl je de les doorwerkt.
Heb ik ervaring nodig om met Scala voor backend-engineering en functioneel programmeren te beginnen?
Ervaring vooraf is niet nodig. Scala voor backend-engineering en functioneel programmeren op CoddyKit is opgebouwd voor beginners tot gevorderden, zodat je hier of bij het begin kunt starten en in je eigen tempo kunt leren. Dit is les 2 van 3.
Hoe lang duurt de les “RESTful API's bouwen met Play”?
De meeste lessen van CoddyKit duren ongeveer 5–10 minuten. Elke les is kort en interactief, zodat je gestaag vooruitgaat en op het web en in de app precies verdergaat waar je was gebleven.
Kan ik code schrijven en uitvoeren in deze les over Scala voor backend-engineering en functioneel programmeren?
Ja. Elke les over Scala voor backend-engineering en functioneel programmeren bevat een ingebouwde code-editor, zodat je rechtstreeks in je browser echte code kunt schrijven en uitvoeren en direct feedback van AI krijgt — lokale installatie is niet nodig.
Alle lessen in deze cursus
- Grondbeginselen van Play Framework
- RESTful API's bouwen met Play
- Database-integratie met Slick/Doobie