Scala voor backend-engineering en functioneel programmeren · Les

Requests en responses

Lees invoer en geef uitvoer terug.

Les 2 van 413 stappen

Requests en responses is een gratis Scala voor backend-engineering en functioneel programmeren-les op CoddyKit. Dit is les 2 van 4. 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 4 lessen.

De aanvraag als waarde

In http4s is een Request[F] een onveranderlijke waarde met de methode, URI, headers, HTTP-versie en een streaming body. Je inspecteert deze met pure toegangsfuncties en wijzigt hem nooit rechtstreeks.

Als je een aanvraag wilt wijzigen, maak je een kopie met withHeaders, withUri of vergelijkbare combinatiefuncties.

val r: Request[IO] = Request[IO](
  method = Method.GET,
  uri = uri"/health"
)

De streaming body

De body van een aanvraag of antwoord is een fs2.Stream[F, Byte]. Deze wordt lui en met effecten verwerkt, zodat grote ladingen nooit volledig in het geheugen hoeven te staan.

Meestal werk je niet met ruwe bytes; een EntityDecoder verzorgt het decoderen voor je.

// raw access (rarely needed)
val bytes: fs2.Stream[IO, Byte] = request.body

De body decoderen

Een EntityDecoder[F, A] weet hoe de bodystream naar een A moet worden omgezet. Roep req.as[A] aan om te decoderen; dit geeft F[A] terug en laat het effect mislukken bij een ongeldige body.

Er is een ingebouwde decoder voor String; rijkere decoders komen uit JSON-modules.

HttpRoutes.of[IO] {
  case req @ POST -> Root / "echo" =>
    req.as[String].flatMap(body => Ok(body))
}

De aanvraag binden

Om binnen een geval toegang te krijgen tot het aanvraagobject, bind je het met @. Hier verwijst req naar de volledige aanvraag, terwijl het patroon nog steeds methode en pad matcht.

Zonder de binder heb je alleen de gedeconstrueerde onderdelen en kun je de body of headers niet lezen.

HttpRoutes.of[IO] {
  case req @ PUT -> Root / "name" =>
    req.as[String].flatMap(n => Ok(s"set $n"))
}

Headers lezen

Headers staan in request.headers. Gebruik headers.get[H] met een getypeerd headermodel, of headers.get(CIString("X-Custom")) voor willekeurige namen.

Getypeerde headers zoals Authorization en Content-Type parsen en valideren hun waarden voor je.

import org.http4s.headers.Authorization

val auth: Option[Authorization] =
  request.headers.get[Authorization]

Antwoorden bouwen

De antwoordbouwers van de DSL, zoals Ok, Created en NotFound, zijn functies die F[Response[F]] teruggeven. Als je een argument doorgeeft, stel je de body in via een EntityEncoder.

Elke bouwer komt overeen met een statuscode, dus Created(...) levert 201 op.

Ok("all good")          // 200
Created("made it")      // 201
NotFound("missing")     // 404

Statuscodes rechtstreeks

Voor een status zonder handige bouwer, of om aanpassingen te doen, maak je een Response[F] met een expliciete Status en gebruik je daarna withEntity.

Zo heb je in één expressie volledige controle over status, headers en body.

import org.http4s.{Response, Status}

Response[IO](Status.Accepted)
  .withEntity("queued")
  .pure[IO]

Bodies coderen

Een EntityEncoder[F, A] serialiseert een waarde naar de antwoordbody en stelt de Content-Type in. Encoders voor String en bytes zijn ingebouwd; JSON-encoders komen uit circe.

Wanneer je een waarde doorgeeft aan Ok(value), zoekt http4s de encoder impliciet op.

// String encoder is implicit; sets text/plain
val resp: IO[Response[IO]] = Ok("plain text body")

Antwoordheaders instellen

Voeg headers toe door ze als extra argumenten aan een bouwer door te geven, of gebruik .map(_.putHeaders(...)) op het antwoordeffect.

Getypeerde headermodellen zorgen voor correct opgemaakte waarden, bijvoorbeeld een Location-header bij een 201 Created.

import org.http4s.headers.Location

Created("ok").map(_.putHeaders(
  Location(uri"/items/42")
))

Decodeerfouten afhandelen

req.as[A] laat het F-effect mislukken wanneer de body niet kan worden gedecodeerd. Gebruik req.attemptAs[A].value om een F[Either[DecodeFailure, A]] te krijgen en antwoord met 400 bij de linkerkant.

Zo blijft de afhandeling van ongeldige invoer expliciet en totaal.

req.attemptAs[String].value.flatMap {
  case Right(b) => Ok(b)
  case Left(_)  => BadRequest("bad body")
}

Cookies en omleidingen

Stel cookies in met response.addCookie(ResponseCookie(name, value)). Gebruik voor omleidingen een 3xx-bouwer en een Location-header.

SeeOther(Location(uri)) voert een 303 uit: de gebruikelijke reactie voor post-redirect-get.

import org.http4s.headers.Location

SeeOther(Location(uri"/login"))
  .map(_.addCookie("sid", "abc123"))

Korte controle

Denk na over het veilig decoderen van bodies.

Beantwoord dit in de interactieve les

Samenvatting

Verzoeken en antwoorden zijn onveranderlijke waarden met streaming-bodies van fs2. Je decodeert ze met as/attemptAs via EntityDecoder en codeert ze met EntityEncoder.

Builders stellen statuscodes in, getypeerde headers blijven veilig en cookies en omleidingen zijn gewoon transformaties van antwoorden.

Gratis beginnen

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

Gratis beginnen met leren Bekijk de volledige cursus

Veelgestelde vragen

Is de les “Requests en responses” gratis?

Ja — de volledige tekst van “Requests en responses” 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 4 lessen.

Wat leer ik in “Requests en responses”?

Lees invoer en geef uitvoer terug. 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 4.

Hoe lang duurt de les “Requests en responses”?

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

← Terug naar Scala voor backend-engineering en functioneel programmeren