0Pricing
Elixir & Phoenix: Scalable Backend Development · Lección

Difusión de mensajes y mensajería Pub/Sub

Implemente actualizaciones en tiempo real difundiendo mensajes a clientes conectados mediante el sistema Pub/Sub de Phoenix.

Difusión de mensajes y mensajería Pub/Sub es una lección gratuita de Elixir & Phoenix: Scalable Backend Development en CoddyKit. Esta es la lección 2 de 4. Puedes leer la lección completa abajo gratuitamente — luego la practicas en el navegador con un editor de código integrado y un tutor de IA 24/7. Forma parte de la ruta de aprendizaje de Elixir & Phoenix: Scalable Backend Development, y tu progreso se sincroniza en la web y la app de CoddyKit. El curso de Elixir & Phoenix: Scalable Backend Development incluye 4 lecciones en total.

Partes de esta lección aún no han sido traducidas y se muestran en inglés.

Real-time Updates & Broadcasting

Imagine a chat app or a live dashboard. How do all users see new messages or data instantly?

This magic happens through real-time updates, and a key technique behind it is broadcasting. Broadcasting means sending a message to many recipients at once.

Phoenix Pub/Sub Explained

Phoenix provides a powerful Pub/Sub (Publish/Subscribe) system, built on top of Erlang's distributed capabilities, called Phoenix.PubSub.

  • It allows different parts of your application (or even different nodes in a cluster!) to communicate without direct knowledge of each other.
  • Think of it as a central message broker: publishers send messages to 'topics', and subscribers receive messages from topics they're interested in.

Topics: Message Channels

In Pub/Sub, a topic is simply a string or atom that categorizes messages. It's like a channel or a subject line for your messages.

  • For a chat app, topics might be "chat_room:lobby" or "user:123:notifications".
  • Clients (via Phoenix Channels) subscribe to these topics to receive updates.

Subscribing to Topics

Before a process can receive broadcasted messages, it must subscribe to a topic. In Phoenix Channels, when a client joins a channel, the channel process itself often subscribes to relevant Pub/Sub topics.

The function for this is typically Phoenix.PubSub.subscribe(pubsub_server, topic).

Code: Subscribing (Mocked)

Here's how a process would conceptually subscribe to a topic. We use a mock to make it runnable, but Phoenix.PubSub.subscribe works similarly.

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

Publishing/Broadcasting Messages

Once processes are subscribed, any part of your application can broadcast a message to a topic. All processes subscribed to that topic will receive the message.

The key function is Phoenix.PubSub.broadcast(pubsub_server, topic, message).

  • pubsub_server: Usually YourApp.PubSub.
  • topic: The topic string or atom.
  • message: Any Elixir term (map, list, string, etc.) to send.

Code: Broadcasting (Mocked)

Let's see how easy it is to broadcast a message using our mock. In a real Phoenix app, you'd use YourApp.PubSub instead of 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

Channels & Pub/Sub Integration

Phoenix Channels often act as the bridge between client-side WebSockets and the server-side Pub/Sub system.

  • When a client sends a message to a channel (e.g., a new chat message), the channel receives it.
  • The channel then uses Phoenix.PubSub.broadcast/3 to send that message to the relevant topic.
  • All other channels subscribed to that topic will receive the broadcast and push it down to their connected clients.

Code: Channel Broadcasting Logic

This snippet shows the core logic within a Phoenix Channel's handle_in/3 callback. Remember, MockPubSub stands in for your actual 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

Pub/Sub Flow Check

Consider a Phoenix application. What is the correct sequence of events when a user sends a chat message that needs to be seen by all other users in the same chat room?

Recap: Broadcasting with Pub/Sub

You've learned how Phoenix's Pub/Sub system enables powerful real-time communication!

  • Broadcasting sends messages to many recipients via topics.
  • Phoenix.PubSub is the core module for this.
  • Processes (like Channels) subscribe to topics to receive messages.
  • Any part of your app can broadcast to a topic using Phoenix.PubSub.broadcast/3.
  • Phoenix Channels commonly integrate with Pub/Sub to pass client messages to other connected clients.

Next, we'll explore more advanced real-time features like presence tracking!

Preguntas frecuentes

¿La lección «Difusión de mensajes y mensajería Pub/Sub» es gratis?

Sí — el texto completo de «Difusión de mensajes y mensajería Pub/Sub» es gratis para leer aquí en la web. Para practicarla de forma interactiva (editor de código integrado y tutor de IA 24/7) y desbloquear el resto del curso de Elixir & Phoenix: Scalable Backend Development, actualiza a CoddyKit PRO. El curso de Elixir & Phoenix: Scalable Backend Development incluye 4 lecciones en total.

¿Qué aprenderé en «Difusión de mensajes y mensajería Pub/Sub»?

Implemente actualizaciones en tiempo real difundiendo mensajes a clientes conectados mediante el sistema Pub/Sub de Phoenix. Practicas Elixir & Phoenix: Scalable Backend Development con código real que ejecutas directamente en el navegador, y un tutor de IA 24/7 responde tus preguntas mientras trabajas en la lección.

¿Necesito experiencia previa para empezar Elixir & Phoenix: Scalable Backend Development?

No se requiere experiencia previa. Elixir & Phoenix: Scalable Backend Development en CoddyKit está estructurado para principiantes hasta estudiantes avanzados, así que puedes empezar aquí o desde el inicio y avanzar a tu ritmo. Esta es la lección 2 de 4.

¿Cuánto tiempo toma la lección «Difusión de mensajes y mensajería Pub/Sub»?

La mayoría de las lecciones de CoddyKit toman alrededor de 5–10 minutos. Cada una es compacta e interactiva, así que avanzas constantemente y retomas exactamente por donde dejaste en la web y la app.

¿Puedo escribir y ejecutar código en esta lección de Elixir & Phoenix: Scalable Backend Development?

Sí. Cada lección de Elixir & Phoenix: Scalable Backend Development incluye un editor de código integrado, así que escribes y ejecutas código real directamente en tu navegador y obtienes retroalimentación instantánea de IA — sin configuración local necesaria.

Todas las lecciones de este curso

  1. Introducción a Phoenix Channels
  2. Difusión de mensajes y mensajería Pub/Sub
  3. Presence y actualizaciones de datos en tiempo real
  4. Autenticación y autorización de canales
← Volver a Elixir & Phoenix: Scalable Backend Development