Elixir & Phoenix: Scalable Backend Development · 课时

广播与发布/订阅消息

通过 Phoenix 的 Pub/Sub 系统向已连接的客户端广播消息，实现实时更新。

广播与发布/订阅消息 是 CoddyKit 上的免费 Elixir & Phoenix: Scalable Backend Development 课时。这是第 2 节课，共 4 节。你可以在下方免费阅读本课时的完整内容 — 然后在浏览器中使用内置代码编辑器和全天候 AI 导师进行实践。这是 Elixir & Phoenix: Scalable Backend Development 学习路径的一部分，你的进度在网页和 CoddyKit 应用中同步。 Elixir & Phoenix: Scalable Backend Development 课程共包含 4 节课。

本课时的部分内容尚未翻译，以英文显示。

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!

常见问题解答

「广播与发布/订阅消息」课时是免费的吗？

是的 — 「广播与发布/订阅消息」的完整文本可在网页上免费阅读。要进行交互式练习（内置代码编辑器和全天候 AI 导师）并解锁 Elixir & Phoenix: Scalable Backend Development 课程的其余内容，请升级到 CoddyKit PRO。 Elixir & Phoenix: Scalable Backend Development 课程共包含 4 节课。

「广播与发布/订阅消息」这节课中我会学到什么？

通过 Phoenix 的 Pub/Sub 系统向已连接的客户端广播消息，实现实时更新。你通过在浏览器中直接运行的动手代码来练习 Elixir & Phoenix: Scalable Backend Development，全天候 AI 导师会在你学习这节课的过程中回答你的问题。

学习 Elixir & Phoenix: Scalable Backend Development 需要有经验吗？

无需任何先前经验。CoddyKit 上的 Elixir & Phoenix: Scalable Backend Development 课程适合初学者到高级学习者，你可以从这里开始或从头开始，按照自己的节奏学习。这是第 2 节课，共 4 节。

「广播与发布/订阅消息」课时需要多长时间？

大多数 CoddyKit 课程大约需要 5–10 分钟。每节课都很精短且互动，所以你能稳步进步，并在网页和应用中从离开的地方继续。

我能在这节 Elixir & Phoenix: Scalable Backend Development 课中编写并运行代码吗？

能。每节 Elixir & Phoenix: Scalable Backend Development 课都包含内置代码编辑器，你可以在浏览器中直接编写并运行真实代码，并获得即时 AI 反馈 — 无需本地设置。

此课程中的所有课时

← 返回 Elixir & Phoenix: Scalable Backend Development