Elixir & Phoenix: Scalable Backend Development · 课时

在线状态与实时数据更新

为应用添加在线状态跟踪，并管理动态用户界面的实时数据更新。

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

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

What is User Presence?

In real-time applications, presence refers to tracking who is currently online, active, or viewing a specific resource.

Think of a chat application showing 'online' status.
Or a collaborative document editor indicating who else is viewing or editing.
It's crucial for dynamic, interactive user interfaces.

Phoenix.Presence Explained

Phoenix Framework provides a powerful, built-in module called Phoenix.Presence to manage presence information.

It leverages Elixir's concurrency and distribution features.
It automatically handles users joining, leaving, and even network disconnections.
This makes building robust presence features much simpler.

Integrating Presence in Channels

To use Phoenix.Presence, you typically integrate it into your Phoenix Channel modules.

First, ensure your UserSocket defines a pubsub_server (e.g., MyApp.PubSub). Then, within your channel module, you add use Phoenix.Presence.

This mixin provides helpers for tracking and retrieving presence data.

Tracking Users with `track/3`

The core function for adding a user to presence is Phoenix.Presence.track/3.

It takes the socket, a unique key (e.g., user ID), and metadata (e.g., username, status).
You usually call this in your channel's join/3 callback.
When a user joins a channel, they are tracked; when they leave, their presence is automatically removed.

Example: Basic Presence Track

Let's see how track/3 is called when a user joins a channel. We'll simulate a socket for this example.

defmodule MyRoomChannel do
  use Phoenix.Channel
  use Phoenix.Presence

  @impl true
  def join("room:lobby", _payload, socket) do
    # In a real app, user_id would come from auth
    user_id = "user_#{System.unique_integer([:positive])}"
    metadata = %{username: "Guest_#{user_id}", status: "online"}

    # Track the user's presence for this topic
    Phoenix.Presence.track(socket, user_id, metadata)
    IO.puts "User #{user_id} joined and tracked in room:lobby"
    {:ok, socket}
  end

  # Minimal run_example to simulate join
  def run_example do
    mock_socket = %{topic: "room:lobby", assigns: %{}}
    join("room:lobby", %{}, mock_socket)
  end
end

MyRoomChannel.run_example()

Accessing Presence Information

Once users are tracked, you can retrieve their presence information:

Phoenix.Presence.list(socket): Returns a map of all presences for the channel's topic.
Phoenix.Presence.get_by_key(socket, user_key): Retrieves presence data for a specific user key.

These functions allow you to build dynamic UI elements based on who is online.

Live Data Updates Concept

Beyond just knowing who is online, real-time apps often need to push live data updates to clients.

This could be a new chat message, a score update in a game, or a change in a shared item's status.
The key is to send structured data to all connected clients on a specific channel topic.
Clients then receive this data and update their UI accordingly.

Broadcasting Data with `broadcast!`

You can send live data updates using the broadcast!/3 function (or push/3 for direct messages) from your channel or another process.

broadcast!(socket, "event_name", %{data: "payload"}): Sends an event and payload to all clients subscribed to the socket's topic.
The "event_name" helps clients differentiate between types of updates.

This is how you keep all connected clients in sync with server-side changes.

Example: Broadcasting Live Data

Here's how you might broadcast a new message to all clients in a room. We simulate the broadcast call.

defmodule MyDataUpdater do
  # We use Phoenix.Channel for its broadcast! helper
  use Phoenix.Channel

  # Function to simulate sending an update
  def send_new_message(topic, sender, text) do
    event = "new_message"
    payload = %{sender: sender, text: text, timestamp: System.system_time(:second)}

    # In a real app, you'd call broadcast! from a channel context
    # or use Phoenix.PubSub.broadcast from a GenServer.
    # For this runnable example, we'll just demonstrate the payload.
    IO.puts "Simulating broadcast to '#{topic}' with event '#{event}' and payload:"
    IO.inspect payload
    :ok
  end

  # To run this example
  def run_example do
    send_new_message("room:lobby", "Alice", "Hello everyone!")
  end
end

MyDataUpdater.run_example()

Presence & Updates Check

Which of the following statements about Phoenix.Presence and live data updates are TRUE?

Summary: Presence & Live Data

Great job! You've learned how Phoenix.Presence simplifies tracking user activity in real-time applications.

We covered using Phoenix.Presence.track/3 to mark users as present.
You also saw how to retrieve presence information with list/1 and get_by_key/2.
Finally, we explored sending dynamic live data updates to clients using broadcast!/3 for interactive UIs.

These tools are fundamental for building engaging real-time features!

常见问题解答

「在线状态与实时数据更新」课时是免费的吗？

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

「在线状态与实时数据更新」这节课中我会学到什么？

为应用添加在线状态跟踪，并管理动态用户界面的实时数据更新。你通过在浏览器中直接运行的动手代码来练习 Elixir & Phoenix: Scalable Backend Development，全天候 AI 导师会在你学习这节课的过程中回答你的问题。

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

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

「在线状态与实时数据更新」课时需要多长时间？

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

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

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

此课程中的所有课时

← 返回 Elixir & Phoenix: Scalable Backend Development