Elixir en Phoenix: schaalbare backendontwikkeling · Les

Routing, controllers en plugs

Definieer routes, implementeer controlleracties en gebruik Plugs om modulaire en herbruikbare request-pipelines te bouwen.

Les 2 van 411 stappen

Routing, controllers en plugs is een gratis Elixir en Phoenix: schaalbare backendontwikkeling-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 Elixir en Phoenix: schaalbare backendontwikkeling. Je voortgang wordt gesynchroniseerd op het web en in de CoddyKit-app. De cursus Elixir en Phoenix: schaalbare backendontwikkeling bevat in totaal 4 lessen.

Je webverzoeken koppelen

Welkom bij routering in Phoenix! Je kunt routering zien als de verkeersregelaar van je applicatie. Wanneer een gebruiker een URL bezoekt, bepaalt de router welk deel van je code dat verzoek moet afhandelen.

Zo koppelt Phoenix een binnenkomend webadres (zoals /users) aan een specifieke functie in je applicatie.

Het bestand `router.ex`

In Phoenix worden al je routes gedefinieerd in het bestand lib/my_app_web/router.ex. Dit bestand gebruikt speciale macro's om vast te leggen hoe verschillende HTTP-methoden (GET, POST, PUT, DELETE) aan de logica van je applicatie worden gekoppeld.

Je ziet routes vaak gegroepeerd in bereiken en verwerkt door verwerkingspijplijnen, die gemeenschappelijk gedrag toepassen.

Een eenvoudige route definiëren

Laten we bekijken hoe je een eenvoudige route definieert. Hier wordt een GET-verzoek naar het basispad / gekoppeld aan de functie index binnen PageController.

Let op pipe_through :browser, waarmee een reeks gemeenschappelijke gedragingen op browserverzoeken wordt toegepast.

defmodule MyPhoenixAppWeb.Router do
  use MyPhoenixAppWeb, :router

  pipeline :browser do
    plug :accepts, ["html"]
    # ... other plugs for sessions, security, etc.
  end

  scope "/", MyPhoenixAppWeb do
    pipe_through :browser

    # Maps GET / to MyPhoenixAppWeb.PageController.index
    get "/", PageController, :index

    # Maps GET /hello to MyPhoenixAppWeb.PageController.hello
    get "/hello", PageController, :hello
  end
end

Controllers: verzoeken afhandelen

Zodra de router een verzoek doorstuurt, neemt een controller het over. Controllers zijn Elixir-modules met acties (functies) die verantwoordelijk zijn voor het afhandelen van specifieke verzoeken.

Hun belangrijkste taken zijn:

Verzoekparameters ontvangen.
De benodigde bedrijfslogica uitvoeren (bijvoorbeeld gegevens ophalen).
Een antwoord voorbereiden, vaak door een sjabloon weer te geven.

Je eerste controlleractie

Controlleracties zijn gewoon functies die twee argumenten accepteren: conn (de verbindingsstructuur) en params (verzoekparameters).

Hier zie je een eenvoudige PageController met een index-actie die een index.html-sjabloon weergeeft.

defmodule MyPhoenixAppWeb.PageController do
  use MyPhoenixAppWeb, :controller

  # This action handles requests for the root path "/"
  def index(conn, _params) do
    # The render function looks for a template like page/index.html.heex
    render(conn, "index.html")
  end

  # This action handles requests for "/hello"
  def hello(conn, _params) do
    text(conn, "Hello from Phoenix!")
  end
end

Padhelpers: URL's genereren

In plaats van URL's rechtstreeks in je sjablonen of code te schrijven, biedt Phoenix padhelpers. Dit zijn functies die URL's genereren op basis van je gedefinieerde routes.

Met padhelpers blijven je koppelingen robuust. Als je het pad van een route wijzigt, hoef je dit alleen in router.ex aan te passen en worden alle gegenereerde koppelingen automatisch bijgewerkt.

Zo genereert ~p"/" bijvoorbeeld het basispad.

Plugs: middleware voor verzoeken

Plugs zijn samenstelbare functies of modules die de Plug.Conn-structuur (de verbinding) verwerken. Ze werken als middleware, zodat je verzoeken kunt onderscheppen en aanpassen voordat ze een controller bereiken, of antwoorden kunt aanpassen nadat ze een controller hebben verlaten.

Je kunt ze zien als een reeks stappen die een verzoek doorloopt. Elke plug kan het verzoek transformeren (of de verwerking stoppen) en het doorgeven aan de volgende plug in de verwerkingspijplijn.

Een aangepaste plug maken

Plugs zijn eenvoudige Elixir-modules die de functies init/1 en call/2 implementeren. init/1 is bedoeld voor configuratie en call/2 voert het eigenlijke werk uit.

Hier zie je een plug die het pad van het verzoek logt en een aangepaste header aan het antwoord toevoegt:

defmodule MyPhoenixAppWeb.Plugs.MyLogger do
  import Plug.Conn

  def init(opts), do: opts

  def call(conn, _opts) do
    IO.puts("Request received for path: #{conn.request_path}")
    put_resp_header(conn, "X-Custom-Header", "Hello from Plug!")
  end
end

Een aangepaste plug gebruiken

Om je aangepaste plug te gebruiken, voeg je deze toe aan een verwerkingspijplijn in het bestand router.ex. Alle verzoeken die door die pijplijn gaan, worden vervolgens door je plug verwerkt.

Als je bijvoorbeeld plug MyPhoenixAppWeb.Plugs.MyLogger toevoegt aan de :browser-pijplijn, wordt deze plug bij elk browserverzoek uitgevoerd.

Plug.Parsers: Parseert verzoekteksten (JSON, formulieren).
Plug.Logger: Logt gegevens over verzoeken.
Plug.Static: Biedt statische assets aan, zoals CSS en JavaScript.

Korte controle: verzoekstroom in Phoenix

Laten we testen of je begrijpt hoe Phoenix webverzoeken afhandelt.

Beantwoord dit in de interactieve les

Samenvatting: routering, controllers en plugs

In deze les heb je de belangrijkste onderdelen geleerd die webverzoeken in Phoenix afhandelen:

Routes (in router.ex) koppelen binnenkomende URL's aan controlleracties.
Controllers bevatten acties (functies) die bedrijfslogica uitvoeren en antwoorden voorbereiden.
Plugs zijn herbruikbare onderdelen die de verzoekverbinding (Plug.Conn) in een verwerkingspijplijn verwerken, vóór of na de controller.

Samen vormen deze onderdelen een krachtig en flexibel systeem voor het bouwen van webapplicaties.

Gratis beginnen

Leer Elixir 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: 12
Lessen: 48

Gratis beginnen met leren Bekijk de volledige cursus

Veelgestelde vragen

Is de les “Routing, controllers en plugs” gratis?

Ja — de volledige tekst van “Routing, controllers en plugs” 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 Elixir en Phoenix: schaalbare backendontwikkeling wilt ontgrendelen, kun je upgraden naar CoddyKit PRO. De cursus Elixir en Phoenix: schaalbare backendontwikkeling bevat in totaal 4 lessen.

Wat leer ik in “Routing, controllers en plugs”?

Definieer routes, implementeer controlleracties en gebruik Plugs om modulaire en herbruikbare request-pipelines te bouwen. Je oefent met Elixir en Phoenix: schaalbare backendontwikkeling 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 Elixir en Phoenix: schaalbare backendontwikkeling te beginnen?

Ervaring vooraf is niet nodig. Elixir en Phoenix: schaalbare backendontwikkeling 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 “Routing, controllers en plugs”?

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 Elixir en Phoenix: schaalbare backendontwikkeling?

Ja. Elke les over Elixir en Phoenix: schaalbare backendontwikkeling 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

Phoenix-project instellen en structureren
Routing, controllers en plugs
Views, templates en de basis van LiveView
Realtimefuncties met Phoenix Channels

← Terug naar Elixir en Phoenix: schaalbare backendontwikkeling