Routes och HttpRoutes
Definiera endpoints funktionellt.
Routes och HttpRoutes är en gratis lektion i Scala för backendutveckling och funktionell programmering på CoddyKit. Detta är lektion 1 av 4. 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 4 lektioner.
Vad http4s är
http4s är ett rent funktionellt HTTP-bibliotek för Scala, byggt på cats-effect och fs2-strömmar. Requests och responses är oföränderliga värden, och effekter kapslas in i en polymorf effekttyp F[_], till exempel IO.
I stället för att ändra en servlet beskriver du en HTTP-tjänst som en funktion från en request till en effektfull valfri response.
Typen HttpRoutes
Kärnabstraktionen är HttpRoutes[F], ett alias för Kleisli[OptionT[F, *], Request[F], Response[F]]. OptionT modellerar en route som kanske inte matchar och då inte returnerar någon response.
Du skriver sällan den signaturen för hand. I stället bygger du routes med konstruktorn HttpRoutes.of och en partiell funktion.
import cats.effect.IO
import org.http4s._
import org.http4s.dsl.io._
val routes: HttpRoutes[IO] = HttpRoutes.of[IO] {
case GET -> Root / "hello" => Ok("hi")
}DSL:en i http4s
DSL-importen org.http4s.dsl.io._ tar in mönsterextraktorer som GET, Root och sökvägsavgränsaren /, samt response-byggare som Ok och NotFound.
En route är en PartialFunction[Request[F], F[Response[F]]]. Fall som inte matchar går helt enkelt vidare.
import org.http4s.dsl.io._
HttpRoutes.of[IO] {
case GET -> Root => Ok("root")
case GET -> Root / "ping" => Ok("pong")
}Matcha sökvägar
Sökvägsmönster läses från vänster till höger. Root är det inledande snedstrecket, och varje / "segment" matchar ett bokstavligt sökvägssegment.
Pilen -> skiljer HTTP-metoden från sökvägen. GET -> Root / "users" matchar alltså GET /users.
HttpRoutes.of[IO] {
case GET -> Root / "users" => Ok("all users")
case GET -> Root / "users" / "me" => Ok("current user")
}Sökvägsvariabler
En obunden identifierare med små bokstäver i en sökväg fångar segmentet som en String. Här binder id det som står efter /users/.
Fångade segment är alltid strängar; du tolkar dem själv till mer avancerade typer eller använder extraktorobjekten som visas härnäst.
HttpRoutes.of[IO] {
case GET -> Root / "users" / id =>
Ok(s"user $id")
}Typade sökvägsextraktorer
http4s tillhandahåller extraktorer som IntVar och LongVar, vilka endast matchar när segmentet kan tolkas som den typen. Ett icke-numeriskt segment gör att fallet går vidare till nästa.
Du kan definiera anpassade extraktorer med en unapply för domäntyper som UUID:er.
HttpRoutes.of[IO] {
case GET -> Root / "users" / IntVar(id) =>
Ok(s"numeric user $id")
}Matchning av metoder
Metodextraktorn före -> kan vara exempelvis GET, POST, PUT, DELETE eller PATCH. Samma sökväg med olika metoder blir separata fall.
Om sökvägen matchar men metoden inte gör det svarar http4s automatiskt med 405 Method Not Allowed.
HttpRoutes.of[IO] {
case GET -> Root / "items" => Ok("list")
case POST -> Root / "items" => Created("made")
case DELETE -> Root / "items" / IntVar(i) => NoContent()
}Kombinera routes
Eftersom HttpRoutes[F] bildar en SemigroupK kombinerar du flera route-grupper med operatorn <+>. Den första gruppen som producerar en response vinner.
Det gör att du kan dela upp routes efter funktion i separata värden och slå ihop dem på ett ställe.
import cats.syntax.semigroupk._
val all = userRoutes <+> itemRoutes <+> healthRoutesFrån routes till HttpApp
En server behöver en total funktion, inte en partiell. HttpRoutes[F] omvandlas till HttpApp[F] med .orNotFound, som tillhandahåller 404 när ingen route matchar.
HttpApp[F] är Kleisli[F, Request[F], Response[F]] — den returnerar alltid en response.
import org.http4s.HttpApp
val app: HttpApp[IO] = routes.orNotFoundOmslutning med middleware
Middleware är funktioner av typen HttpRoutes[F] => HttpRoutes[F] (eller motsvarande för HttpApp). De omsluter en tjänst för att lägga till loggning, CORS, gzip eller autentisering utan att ändra routelogiken.
Inbyggda exempel är Logger, CORS och GZip från org.http4s.server.middleware.
import org.http4s.server.middleware.Logger
val logged = Logger.httpApp(logHeaders = true, logBody = false)(app)Frågeparametrar i routes
Frågeparametrar matchas med matcharobjekt som utökar QueryParamDecoderMatcher. De placeras efter :? i sökvägsmönstret.
Använd OptionalQueryParamDecoderMatcher för parametrar som kan saknas; resultatet blir då en Option.
object NameParam extends QueryParamDecoderMatcher[String]("name")
HttpRoutes.of[IO] {
case GET -> Root / "hi" :? NameParam(n) => Ok(s"hi $n")
}Snabbtest
Testa din förståelse av hur routes kombineras.
Sammanfattning
Du byggde routes med HttpRoutes.of och DSL:en, matchade metoder och sökvägar, fångade variabler med IntVar och matchare och kombinerade grupper med <+>.
Routes är partiella; .orNotFound gör dem till en total HttpApp, och middleware omsluter tjänster för övergripande funktioner.
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 ”Routes och HttpRoutes” gratis?
Ja – hela texten till ”Routes och HttpRoutes” 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 4 lektioner.
Vad lär jag mig i ”Routes och HttpRoutes”?
Definiera endpoints funktionellt. 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 1 av 4.
Hur lång tid tar lektionen ”Routes och HttpRoutes”?
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
- Routes och HttpRoutes
- Anrop och svar
- JSON-endpoints
- Tillhandahåll applikationen