Bygg RESTful-API:er med Play
Designa och implementera RESTful-slutpunkter, hantera förfrågningar och behandla JSON-data med Play-kontrollers.
Bygg RESTful-API:er med Play är en gratis lektion i Scala för backendutveckling och funktionell programmering på CoddyKit. Detta är lektion 2 av 3. Ni kan läsa hela lektionen gratis nedan och sedan öva praktiskt i webbläsaren med en inbyggd kodredigerare och en AI-handledare som är tillgänglig dygnet runt. Den ingår i lärvägen för Scala för backendutveckling och funktionell programmering, och Era framsteg synkroniseras mellan webben och CoddyKit-appen. Kursen i Scala för backendutveckling och funktionell programmering innehåller totalt 3 lektioner.
Introduktion till REST API:er i Play
Välkommen! I den här lektionen går vi igenom hur man bygger RESTful API:er med Scala-ramverket Play. REST (Representational State Transfer) är en välanvänd arkitekturstil för att utforma nätverksanslutna applikationer.
Ett RESTful API gör det möjligt för olika programvarusystem att kommunicera med varandra över internet, vanligtvis med standardiserade HTTP-metoder som GET, POST, PUT och DELETE för att utföra operationer på resurser.
Play-controllers och åtgärder
I Play hanteras inkommande HTTP-förfrågningar av controllers. En controller är ett Scala-objekt eller en Scala-klass som innehåller åtgärdsmetoder.
Varje åtgärdsmetod ansvarar för att bearbeta en viss typ av förfrågan (t.ex. hämta data eller skapa ett nytt objekt) och returnera ett HTTP-svar.
Definiera routes i Play
Play använder filen conf/routes för att mappa inkommande HTTP-förfrågningar till specifika åtgärdsmetoder i controllers. Det är här du definierar API:ets endpoints.
Den grundläggande syntaxen för en route-post är: HTTP_METHOD /path controllers.ControllerName.actionMethod(parameters).
Implementera en GET-endpoint
Nu skapar vi en enkel GET-endpoint som returnerar en hälsning. I en riktig Play-applikation skulle detta finnas i en controller. Här simulerar vi logiken i en main-metod.
Prova att köra det här exemplet:
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")
}
}Hämta sökvägsparametrar
Ofta behöver du hämta dynamiska värden från URL-sökvägen, till exempel ett objekts ID. Dessa kallas sökvägsparametrar.
I filen routes definierar du dem med ett kolon (:). I controller-åtgärden deklarerar du dem som metodparametrar.
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")
}
}Request bodies och JSON
När klienter skapar eller uppdaterar resurser skickar de data i request body. För RESTful API:er är dessa data nästan alltid i formatet JSON (JavaScript Object Notation).
Play har utmärkt stöd för att tolka JSON-baserade request bodies och omvandla dem till Scala case classes.
Bygga en POST-endpoint
Nu simulerar vi en POST-endpoint som tar emot en JSON-body. I en riktig Play-applikation skulle du använda Plays JSON-bibliotek för att tolka förfrågan. I det här körbara exemplet kontrollerar vi enkelt stränginnehåll.
Prova att köra det här exemplet:
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)}")
}
}Hantera PUT och DELETE
Utöver GET och POST använder RESTful API:er ofta:
- PUT: För att uppdatera en befintlig resurs. Kräver vanligtvis en sökvägsparameter (ID) och en request body (uppdaterade data).
- DELETE: För att ta bort en resurs. Kräver vanligtvis endast en sökvägsparameter (ID).
Mönstren för att definiera routes och komma åt parametrar och bodies för PUT och DELETE liknar dem för POST och GET.
Returnera JSON-svar
När API:et har bearbetat en förfrågan behöver det vanligtvis skicka tillbaka ett svar, ofta i JSON-format. Play gör det enkelt att skapa JSON-objekt och skicka tillbaka dem.
I en controller skulle du vanligtvis använda Ok(Json.toJson(yourCaseClass)). Här simulerar vi skapandet av en JSON-sträng.
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)}")
}
}Frågesport om route-matchning
Vilken Play-routedefinition matchar korrekt en begäran till GET /api/products/123 och skickar 123 som en Int till controller-metoden?
Sammanfattning och nästa steg
Utmärkt arbete! Ni har lärt er grunderna i att bygga RESTful API:er med Play Framework:
- Förstå RESTful-principer och HTTP-metoder.
- Hur Play-controllers och actions behandlar begäranden.
- Definiera API-routes för att koppla URL:er till controller-metoder.
- Extrahera path-parametrar från URL:er.
- Hantera JSON-begärandekroppar för POST/PUT.
- Skapa och returnera JSON-svar.
Som nästa steg kan ni utforska hur databaser integreras med er Play-applikation!
Lär dig Scala med en AI-lärare – gratis
Skriv och kör riktig kod i webbläsaren, få omedelbar hjälp av en AI-lärare dygnet runt och fortsätt där du slutade – på webben eller i appen.
- Kurser
- 39
- Lektioner
- 143
Vanliga frågor
Är lektionen ”Bygg RESTful-API:er med Play” gratis?
Ja – hela texten till ”Bygg RESTful-API:er med Play” kan läsas gratis här på webben. Om Ni vill öva interaktivt med en inbyggd kodredigerare och en AI-handledare som är tillgänglig dygnet runt och låsa upp resten av kursen i Scala för backendutveckling och funktionell programmering, kan Ni uppgradera till CoddyKit PRO. Kursen i Scala för backendutveckling och funktionell programmering innehåller totalt 3 lektioner.
Vad lär jag mig i ”Bygg RESTful-API:er med Play”?
Designa och implementera RESTful-slutpunkter, hantera förfrågningar och behandla JSON-data med Play-kontrollers. Ni övar på Scala för backendutveckling och funktionell programmering med praktisk kod som körs direkt i webbläsaren, medan en AI-handledare som är tillgänglig dygnet runt svarar på Era frågor under lektionen.
Behöver jag någon erfarenhet för att börja lära mig Scala för backendutveckling och funktionell programmering?
Du behöver inga förkunskaper. Utbildningen i Scala för backendutveckling och funktionell programmering på CoddyKit är upplagd för allt från nybörjare till avancerade elever, så att du kan börja här eller från början och gå fram i din egen takt. Detta är lektion 2 av 3.
Hur lång tid tar lektionen ”Bygg RESTful-API:er med Play”?
De flesta CoddyKit-lektioner tar cirka 5–10 minuter. Varje lektion är kort och interaktiv, så att du gör stadiga framsteg och kan fortsätta precis där du slutade – på webben eller i appen.
Kan jag skriva och köra kod i den här Scala för backendutveckling och funktionell programmering-lektionen?
Ja. Varje Scala för backendutveckling och funktionell programmering-lektion innehåller en inbyggd kodredigerare, så att du kan skriva och köra riktig kod direkt i webbläsaren och få omedelbar AI-feedback – utan lokal installation.
Alla lektioner i den här kursen
- Grunderna i Play Framework
- Bygg RESTful-API:er med Play
- Databasintegration med Slick/Doobie