Elixir en Phoenix: schaalbare backendontwikkeling · Les

Broadcasting en Pub/Sub-berichten

Implementeer realtime-updates door berichten naar verbonden clients te broadcasten met het Pub/Sub-systeem van Phoenix.

Les 2 van 411 stappen

Broadcasting en Pub/Sub-berichten 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.

Realtime-updates en uitzenden

Stel je een chatapp of een live dashboard voor. Hoe zien alle gebruikers nieuwe berichten of gegevens onmiddellijk?

Dit gebeurt dankzij realtime-updates, en een belangrijke techniek daarachter is uitzenden. Uitzenden betekent dat je een bericht tegelijk naar veel ontvangers stuurt.

Phoenix Pub/Sub uitgelegd

Phoenix biedt een krachtig Pub/Sub-systeem (Publish/Subscribe), dat is gebouwd boven op de gedistribueerde mogelijkheden van Erlang en Phoenix.PubSub wordt genoemd.

Hiermee kunnen verschillende onderdelen van je applicatie (of zelfs verschillende nodes in een cluster!) met elkaar communiceren zonder directe kennis van elkaar.
Je kunt het zien als een centrale berichtenbroker: uitgevers sturen berichten naar 'topics' en abonnees ontvangen berichten van topics waarin ze geïnteresseerd zijn.

Topics: berichtkanalen

In Pub/Sub is een topic simpelweg een tekenreeks of atom die berichten categoriseert. Het is vergelijkbaar met een kanaal of onderwerpregel voor je berichten.

Voor een chatapp kunnen topics bijvoorbeeld "chat_room:lobby" of "user:123:notifications" zijn.
Clients abonneren zich via Phoenix Channels op deze topics om updates te ontvangen.

Abonneren op topics

Voordat een proces uitgezonden berichten kan ontvangen, moet het zich abonneren op een onderwerp. In Phoenix Channels abonneert het kanaalproces zelf zich vaak op relevante Pub/Sub-onderwerpen wanneer een client lid wordt van een kanaal.

De functie hiervoor is meestal Phoenix.PubSub.subscribe(pubsub_server, topic).

Code: Abonneren (gesimuleerd)

Zo zou een proces zich conceptueel op een onderwerp abonneren. We gebruiken een mock om het uitvoerbaar te maken, maar Phoenix.PubSub.subscribe werkt op vergelijkbare wijze.

defmodule MockPubSub do
  def subscribe(topic) do
    IO.puts "  [MockPubSub] Process #{inspect(self())} subscribing to :#{topic}"
    # In a real Phoenix.PubSub, this registers the process.
    :ok
  end

  def broadcast(topic, message) do
    IO.puts "  [MockPubSub] Broadcasting '#{message}' to :#{topic}"
    :ok
  end
end

defmodule Main do
  def main() do
    IO.puts "Starting Subscription Demo..."

    # Simulate a process subscribing
    spawn(fn -> 
      MockPubSub.subscribe(:news_feed)
      # In a real app, this process would now await messages
    end)

    Process.sleep(100) # Give time for spawn
    IO.puts "Demo complete."
  end
end

Berichten publiceren en uitzenden

Zodra processen geabonneerd zijn, kan elk onderdeel van je toepassing een bericht naar een onderwerp uitzenden. Alle processen die op dat onderwerp zijn geabonneerd, ontvangen het bericht.

De belangrijkste functie is Phoenix.PubSub.broadcast(pubsub_server, topic, message).

pubsub_server: Meestal YourApp.PubSub.
topic: De tekenreeks of atom van het onderwerp.
message: Elke Elixir-term (map, lijst, tekenreeks enzovoort) die je wilt verzenden.

Code: Uitzenden (gesimuleerd)

Bekijk hoe eenvoudig het is om een bericht uit te zenden met onze mock. In een echte Phoenix-toepassing zou je YourApp.PubSub gebruiken in plaats van MockPubSub.

defmodule MockPubSub do
  def subscribe(topic) do
    IO.puts "  [MockPubSub] Process #{inspect(self())} subscribing to :#{topic}"
    :ok
  end

  def broadcast(topic, message) do
    IO.puts "  [MockPubSub] Broadcasting '#{message}' to :#{topic}"
    :ok
  end
end

defmodule Main do
  def main() do
    IO.puts "Starting Broadcast Demo..."

    # Simulate broadcasting a message to a 'chat_room:general' topic
    MockPubSub.broadcast(:"chat_room:general", "Hello everyone in the chat!")

    # Another example: sending a notification
    MockPubSub.broadcast(:"user:123:notifications", %{type: :new_message, from: "Alice"})

    IO.puts "Demo complete."
  end
end

Integratie van Channels en Pub/Sub

Phoenix Channels fungeren vaak als brug tussen WebSockets aan de clientzijde en het Pub/Sub-systeem aan de serverzijde.

Wanneer een client een bericht naar een kanaal stuurt (bijvoorbeeld een nieuw chatbericht), ontvangt het kanaal dit.
Het kanaal gebruikt vervolgens Phoenix.PubSub.broadcast/3 om dat bericht naar het relevante onderwerp te sturen.
Alle andere kanalen die op dat onderwerp zijn geabonneerd, ontvangen de uitzending en sturen die door naar hun verbonden clients.

Code: Logica voor uitzenden vanuit een kanaal

Dit fragment toont de kernlogica binnen de handle_in/3-callback van een Phoenix Channel. Denk eraan dat MockPubSub een vervanging is voor je echte YourApp.PubSub-module.

defmodule MockPubSub do
  def broadcast(topic, message) do
    IO.puts "  [MockPubSub] Broadcasting '#{inspect(message)}' to :#{topic}"
    :ok
  end
end

defmodule MyAppWeb.ChatChannel do
  # This simulates a Phoenix Channel module

  @doc "Handles incoming client messages and broadcasts them."
  def handle_in("new_msg", %{"body" => msg_body}, socket) do
    room_id = "general"
    topic = "chat_room:#{room_id}"

    # Construct the message to broadcast
    full_message = %{sender: "client_user", body: msg_body, timestamp: System.system_time(:millisecond)}

    # Broadcast the message to all subscribers of this topic
    MockPubSub.broadcast(topic, full_message)

    # Acknowledge receipt to the client (in a real channel, this is `{:reply, ...}` or `{:noreply, ...}`)
    IO.puts "Channel received message: \"#{msg_body}\". Broadcasting..."
    {:noreply, socket} # In a real channel, this would be the return value
  end

  def main() do
    IO.puts "Simulating a client sending a message to a channel..."
    # Simulate a call to handle_in
    handle_in("new_msg", %{"body" => "Hello from the client!"}, :some_socket_state)
    IO.puts "Demo complete."
  end
end

Controle van de Pub/Sub-stroom

Stel je een Phoenix-toepassing voor. Wat is de juiste volgorde van gebeurtenissen wanneer een gebruiker een chatbericht verstuurt dat door alle andere gebruikers in dezelfde chatruimte moet worden gezien?

Beantwoord dit in de interactieve les

Samenvatting: uitzenden met Pub/Sub

Je hebt geleerd hoe het Pub/Sub-systeem van Phoenix krachtige realtimecommunicatie mogelijk maakt!

Uitzenden stuurt berichten naar veel ontvangers via onderwerpen.
Phoenix.PubSub is de belangrijkste module hiervoor.
Processen (zoals Channels) abonneren zich op onderwerpen om berichten te ontvangen.
Elk onderdeel van je toepassing kan met Phoenix.PubSub.broadcast/3 een bericht naar een onderwerp uitzenden.
Phoenix Channels worden vaak geïntegreerd met Pub/Sub om berichten van clients door te geven aan andere verbonden clients.

Vervolgens bekijken we geavanceerdere realtimefuncties, zoals het bijhouden van aanwezigheid!

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 “Broadcasting en Pub/Sub-berichten” gratis?

Ja — de volledige tekst van “Broadcasting en Pub/Sub-berichten” 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 “Broadcasting en Pub/Sub-berichten”?

Implementeer realtime-updates door berichten naar verbonden clients te broadcasten met het Pub/Sub-systeem van Phoenix. 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 “Broadcasting en Pub/Sub-berichten”?

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

Inleiding tot Phoenix Channels
Broadcasting en Pub/Sub-berichten
Presence en livegegevensupdates
Authenticatie en autorisatie van channels

← Terug naar Elixir en Phoenix: schaalbare backendontwikkeling