Scala for Backend Engineering & Functional Programming · Lektion

RESTful APIs mit Play entwickeln

Entwerfen und implementieren Sie RESTful-Endpunkte, verarbeiten Sie Anfragen und verwalten Sie JSON-Daten mit Play-Controllern.

RESTful APIs mit Play entwickeln ist eine kostenlose Scala for Backend Engineering & Functional Programming-Lektion auf CoddyKit. Dies ist Lektion 2 von 3. Du kannst die komplette Lektion unten kostenlos lesen – dann übst du sie direkt im Browser mit einem integrierten Code-Editor und einem KI-Tutor rund um die Uhr. Sie ist Teil des Scala for Backend Engineering & Functional Programming-Lernpfads, und dein Fortschritt wird über Web und CoddyKit-App synchronisiert. Der Scala for Backend Engineering & Functional Programming-Kurs umfasst insgesamt 3 Lektionen.

Einführung in Play-REST-APIs

Willkommen! In dieser Lektion tauchen wir in die Entwicklung RESTful APIs mit dem Scala Play Framework ein. REST (Representational State Transfer) ist ein weit verbreiteter Architekturstil für die Entwicklung vernetzter Anwendungen.

Eine RESTful API ermöglicht es verschiedenen Softwaresystemen, über das Internet miteinander zu kommunizieren. Dazu werden normalerweise standardmäßige HTTP-Methoden wie GET, POST, PUT und DELETE verwendet, um Vorgänge mit Ressourcen auszuführen.

Play-Controller und -Aktionen

In Play werden eingehende HTTP-Anfragen von Controllern verarbeitet. Ein Controller ist ein Scala-Objekt oder eine Scala-Klasse, die Aktionsmethoden enthält.

Jede Aktionsmethode ist für die Verarbeitung einer bestimmten Anfrageart zuständig, z. B. das Abrufen von Daten oder das Erstellen eines neuen Elements, und gibt eine HTTP-Antwort zurück.

Routen in Play definieren

Play verwendet eine Datei conf/routes, um eingehende HTTP-Anfragen bestimmten Aktionsmethoden von Controllern zuzuordnen. Hier definieren Sie die Endpunkte Ihrer API.

Die grundlegende Syntax eines Routeneintrags lautet: HTTP_METHOD /path controllers.ControllerName.actionMethod(parameters).

Einen GET-Endpunkt implementieren

Erstellen wir einen einfachen GET-Endpunkt, der eine Begrüßung zurückgibt. In einer echten Play-Anwendung würde sich dieser in einem Controller befinden. Hier simulieren wir die Logik in einer main-Methode.

Versuchen Sie, dieses Beispiel auszuführen:

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")
  }
}

Pfadparameter extrahieren

Oft müssen Sie dynamische Werte aus dem URL-Pfad extrahieren, beispielsweise die ID eines Elements. Diese werden als Pfadparameter bezeichnet.

In der Datei routes definieren Sie sie mit einem Doppelpunkt (:). In Ihrer Controller-Aktion deklarieren Sie sie als Methodenparameter.

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 und JSON

Beim Erstellen oder Aktualisieren von Ressourcen senden Clients Daten im Request-Body. Bei RESTful APIs liegen diese Daten fast immer im Format JSON (JavaScript Object Notation) vor.

Play bietet eine hervorragende Unterstützung zum Parsen von JSON-Request-Bodies und ihrer Umwandlung in Scala-Case-Klassen.

Einen POST-Endpunkt erstellen

Simulieren wir einen POST-Endpunkt, der einen JSON-Body empfängt. In einer echten Play-Anwendung würden Sie die JSON-Bibliothek von Play zum Parsen der Anfrage verwenden. Für dieses ausführbare Beispiel prüfen wir den Inhalt auf eine einfache Zeichenkette.

Versuchen Sie, dieses Beispiel auszuführen:

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 und DELETE verarbeiten

Neben GET und POST verwenden RESTful APIs häufig auch:

PUT: Zum Aktualisieren einer vorhandenen Ressource. Erfordert normalerweise einen Pfadparameter (ID) und einen Request-Body (aktualisierte Daten).
DELETE: Zum Entfernen einer Ressource. Erfordert typischerweise nur einen Pfadparameter (ID).

Die Muster zum Definieren von Routen und zum Zugriff auf Parameter und Request-Bodies bei PUT und DELETE ähneln denen von POST und GET.

JSON-Antworten zurückgeben

Nach der Verarbeitung einer Anfrage muss Ihre API normalerweise eine Antwort zurücksenden, häufig im JSON-Format. Mit Play lassen sich JSON-Objekte einfach erstellen und zurücksenden.

In einem Controller würden Sie normalerweise Ok(Json.toJson(yourCaseClass)) verwenden. Hier simulieren wir das Erstellen einer JSON-Zeichenkette.

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 zur Routenzuordnung

Welche Play-Routendefinition würde korrekt zu einer Anfrage an GET /api/products/123 passen und 123 als Int an die Controller-Aktion übergeben?

Zusammenfassung und nächste Schritte

Großartige Arbeit! Sie haben die Grundlagen zum Erstellen von RESTful APIs mit dem Play Framework gelernt:

RESTful-Prinzipien und HTTP-Methoden verstehen.
Wie Play-Controller und -Aktionen Anfragen verarbeiten.
API-Routen definieren, um URLs auf Controller-Aktionen abzubilden.
Pfadparameter aus URLs extrahieren.
JSON-Anfragetexte für POST/PUT verarbeiten.
JSON-Antworten erstellen und zurückgeben.

Als Nächstes könnten Sie die Integration von Datenbanken in Ihre Play-Anwendung erkunden!

Häufig gestellte Fragen

Ist die Lektion „RESTful APIs mit Play entwickeln“ kostenlos?

Ja — der vollständige Text von „RESTful APIs mit Play entwickeln“ ist hier im Web kostenlos zu lesen. Um sie interaktiv zu üben (integrierter Code-Editor und 24/7 KI-Tutor) und den Rest des Scala for Backend Engineering & Functional Programming-Kurses freizuschalten, upgrade auf CoddyKit PRO. Der Scala for Backend Engineering & Functional Programming-Kurs umfasst insgesamt 3 Lektionen.

Was lerne ich in „RESTful APIs mit Play entwickeln“?

Entwerfen und implementieren Sie RESTful-Endpunkte, verarbeiten Sie Anfragen und verwalten Sie JSON-Daten mit Play-Controllern. Du übst Scala for Backend Engineering & Functional Programming mit praktischem Code, den du direkt im Browser ausführst, und ein 24/7 KI-Tutor beantwortet deine Fragen während du die Lektion bearbeitest.

Brauche ich Erfahrung, um Scala for Backend Engineering & Functional Programming zu starten?

Keine Vorkenntnisse erforderlich. Scala for Backend Engineering & Functional Programming auf CoddyKit ist für Anfänger bis fortgeschrittene Lernende strukturiert, sodass du hier starten oder von Anfang an beginnen und in deinem eigenen Tempo voranschreiten kannst. Dies ist Lektion 2 von 3.

Wie lange dauert die Lektion „RESTful APIs mit Play entwickeln“?

Die meisten CoddyKit-Lektionen dauern etwa 5–10 Minuten. Jede ist kompakt und interaktiv, sodass du stetig Fortschritte machst und genau dort weitermachst, wo du aufgehört hast – im Web und in der App.

Kann ich in dieser Scala for Backend Engineering & Functional Programming-Lektion Code schreiben und ausführen?

Ja. Jede Scala for Backend Engineering & Functional Programming-Lektion enthält einen integrierten Code-Editor, sodass du echten Code direkt in deinem Browser schreibst und ausführst und sofort KI-Feedback erhältst — ohne lokale Einrichtung erforderlich.

Alle Lektionen in diesem Kurs

← Zurück zu Scala for Backend Engineering & Functional Programming