Elixir & Phoenix: Pembangunan Bahagian Belakang Boleh Skala · Pelajaran

Pengenalan kepada Saluran Phoenix

Fahami seni bina Saluran Phoenix, cara saluran tersebut menggunakan WebSockets serta peranannya dalam aplikasi masa nyata.

Pelajaran 1 daripada 411 langkah

Pengenalan kepada Saluran Phoenix ialah pelajaran Elixir & Phoenix: Pembangunan Bahagian Belakang Boleh Skala percuma di CoddyKit. Ini ialah pelajaran 1 daripada 4. Anda boleh membaca keseluruhan pelajaran di bawah secara percuma — kemudian berlatih secara praktikal dalam pelayar menggunakan penyunting kod terbina dalam dan tutor kecerdasan buatan 24/7. Pelajaran ini merupakan sebahagian daripada laluan pembelajaran Elixir & Phoenix: Pembangunan Bahagian Belakang Boleh Skala, dan kemajuan anda disegerakkan merentas web serta aplikasi CoddyKit. Kursus Elixir & Phoenix: Pembangunan Bahagian Belakang Boleh Skala merangkumi sejumlah 4 pelajaran.

Masa Nyata dengan Saluran Phoenix

Selamat datang ke Saluran Phoenix! Dalam pelajaran ini, kita akan meneroka cara Elixir dan Phoenix membolehkan komunikasi masa nyata dalam aplikasi web.

Bayangkan masa nyata sebagai kemas kini serta-merta: mesej sembang muncul dengan segera, suapan data langsung atau penyuntingan secara kolaboratif. Saluran ialah penyelesaian elegan Phoenix untuk membina ciri dinamik ini.

Cabaran HTTP

Aplikasi web tradisional bergantung pada HTTP (Protokol Pemindahan Hiperteks). HTTP sangat baik untuk meminta halaman web atau menghantar data borang, tetapi mempunyai keterbatasan untuk masa nyata:

Tanpa keadaan: Setiap permintaan adalah bebas.
Dimulakan klien: Klien sentiasa meminta data daripada pelayan.
Tinjauan berkala: Untuk mendapatkan kemas kini 'masa nyata', klien sering perlu bertanya kepada pelayan berulang kali, yang tidak cekap.

Kita memerlukan pendekatan yang berbeza untuk komunikasi segera yang sebenar.

Memperkenalkan WebSockets

WebSockets ialah teknologi asas yang menjadikan komunikasi masa nyata cekap. Berbeza daripada HTTP, WebSockets menyediakan saluran komunikasi dua hala yang berterusan antara klien dan pelayan.

Dupleks penuh: Klien dan pelayan boleh menghantar mesej secara bebas pada bila-bila masa.
Berterusan: Setelah diwujudkan, sambungan kekal terbuka.
Overhed lebih rendah: Kurang data dihantar bagi setiap mesej berbanding permintaan HTTP.

Hal ini membolehkan pertukaran data yang serta-merta dan berterusan.

Saluran: Lapisan Masa Nyata Elixir

Saluran Phoenix menyediakan abstraksi yang kukuh dan mesra Elixir di atas WebSockets mentah. Saluran ini disepadukan dengan lancar ke dalam rangka kerja Phoenix dan memanfaatkan model keserentakan Elixir (OTP).

Saluran membolehkan anda:

Menentukan bilik komunikasi logik (topik).
Mengendalikan mesej masuk dan keluar (peristiwa).
Mengurus sambungan dan kebenaran klien.

Saluran memudahkan pembinaan ciri masa nyata yang kompleks.

Penerangan tentang Topik dan Peristiwa

Dua konsep teras dalam Saluran Phoenix ialah Topik dan Peristiwa:

Topik: Saluran atau 'bilik' bernama yang boleh dilanggan oleh klien. Contohnya, "room:lobby" atau "user:123". Klien hanya menerima mesej untuk topik yang telah disertainya.
Peristiwa: Jenis mesej khusus yang dihantar dalam topik. Contohnya, peristiwa "new_message" dalam bilik sembang atau peristiwa "user_joined".

Struktur ini membantu menyusun dan menghala data masa nyata dengan berkesan.

Titik Masuk UserSocket

Setiap aplikasi Phoenix yang menggunakan Saluran mempunyai modul UserSocket. Modul ini bertindak sebagai pintu masuk awal untuk semua sambungan WebSocket.

Di sinilah anda menentukan:

Cara klien bersambung (contohnya, pengesahan).
Topik yang dibenarkan untuk disertai oleh klien.

Berikut ialah contoh ringkas UserSocket:

defmodule MyAppWeb.UserSocket do
  use Phoenix.Socket

  ## Channels
  channel "room:*", MyAppWeb.RoomChannel
  channel "user:*", MyAppWeb.UserChannel

  ## Transports
  transport :websocket, Phoenix.Transports.WebSocket
  # transport :longpoll, Phoenix.Transports.LongPoll

  def connect(_params, socket) do
    # Authenticate and assign user to socket
    # For now, let's just allow all connections
    {:ok, socket}
  end

  def id(_socket), do: nil
end

Menentukan Modul Saluran

Selepas bersambung melalui UserSocket, klien boleh menyertai saluran tertentu. Setiap saluran ditentukan oleh modulnya sendiri, seperti RoomChannel atau UserChannel.

Modul ini mengendalikan:

Logik untuk menyertai topik.
Pemprosesan mesej yang dihantar kepada topik tersebut.
Penyiaran mesej kepada semua pelanggan topik.

Berikut ialah definisi asas RoomChannel:

defmodule MyAppWeb.RoomChannel do
  use Phoenix.Channel

  # Handles when a client tries to join a topic
  def join("room:lobby", _params, socket) do
    # You can add authorization logic here
    # For now, let's allow everyone to join the lobby
    {:ok, socket}
  end

  def join("room:private", _params, _socket) do
    # This topic might require authentication
    {:error, %{reason: "unauthorized"}}
  end

  # Handles incoming messages (events) from the client
  def handle_in("new_msg", %{"body" => body}, socket) do
    # Process the message and broadcast it
    broadcast! socket, "new_msg", %{body: body, sender: "guest"}
    {:noreply, socket}
  end
end

Sambungan pada Pihak Klien

Klien (seperti pelayar web) menggunakan pustaka JavaScript untuk bersambung ke Saluran Phoenix. Mula-mula mereka mewujudkan sambungan WebSocket, kemudian menyertai topik tertentu.

Contoh ini menunjukkan cara klien JavaScript bersambung ke topik "room:lobby":

import { Socket } from "phoenix";

let socket = new Socket("/socket", {params: {token: window.userToken}});
socket.connect();

// Now join a specific channel/topic
let channel = socket.channel("room:lobby", {});

channel.on("new_msg", payload => {
  console.log("NEW MESSAGE:", payload.body);
});

channel.join()
  .receive("ok", resp => { console.log("Joined successfully", resp); })
  .receive("error", resp => { console.log("Unable to join", resp); });

// Send a message to the channel
// channel.push("new_msg", {body: "Hello from client!"});

Kitar Hayat Saluran: Bersambung & Menyertai

Penting untuk memahami dua peringkat utama sambungan Saluran:

connect/2 dalam UserSocket: Fungsi ini dipanggil sekali apabila sambungan WebSocket awal diwujudkan. Fungsi ini digunakan untuk kebenaran global (contohnya, sama ada pengguna ini dibenarkan menggunakan WebSockets langsung).
join/3 dalam Modul Saluran: Fungsi ini dipanggil setiap kali klien cuba melanggan topik tertentu (contohnya, "room:lobby"). Fungsi ini digunakan untuk kebenaran khusus topik.

Anggap connect sebagai memasuki bangunan, dan join sebagai memasuki bilik tertentu dalam bangunan tersebut.

Semakan Pantas: Peranan Saluran

Saluran Phoenix menggunakan dua modul utama untuk mengurus komunikasi masa nyata. Pernyataan manakah yang berikut menerangkan dengan betul peranan UserSocket dan modul Saluran tertentu (contohnya, RoomChannel)?

Jawab dalam pelajaran interaktif

Imbas Kembali: Saluran Didedahkan

Syabas! Dalam pelajaran ini, anda telah memperoleh pemahaman asas tentang Saluran Phoenix:

Kita melihat cara WebSockets mengatasi keterbatasan HTTP untuk masa nyata.
Anda mempelajari bahawa Saluran Phoenix menyediakan abstraksi Elixir untuk WebSockets.
Kita meneroka konsep utama seperti Topik dan Peristiwa.
Anda memahami peranan UserSocket dalam mengendalikan sambungan awal dan modul Saluran khusus untuk komunikasi berasaskan topik.

Seterusnya, kita akan mendalami penyiaran mesej dan pengendalian peristiwa!

Percuma untuk bermula

Pelajari Elixir dengan tutor kecerdasan buatan — percuma

Tulis dan jalankan kod sebenar dalam pelayar anda, dapatkan bantuan segera daripada tutor kecerdasan buatan yang tersedia 24/7, dan sambung semula dari tempat anda berhenti di web atau dalam aplikasi.

Kursus: 12
Pelajaran: 48

Mula belajar secara percuma Lihat kursus penuh

Soalan Lazim

Adakah pelajaran “Pengenalan kepada Saluran Phoenix” percuma?

Ya — teks penuh “Pengenalan kepada Saluran Phoenix” boleh dibaca secara percuma di web ini. Untuk berlatih secara interaktif menggunakan penyunting kod terbina dalam dan tutor kecerdasan buatan 24/7, serta membuka kunci baki kursus Elixir & Phoenix: Pembangunan Bahagian Belakang Boleh Skala, tingkat taraf kepada CoddyKit PRO. Kursus Elixir & Phoenix: Pembangunan Bahagian Belakang Boleh Skala merangkumi sejumlah 4 pelajaran.

Apakah yang akan saya pelajari dalam “Pengenalan kepada Saluran Phoenix”?

Fahami seni bina Saluran Phoenix, cara saluran tersebut menggunakan WebSockets serta peranannya dalam aplikasi masa nyata. Anda berlatih Elixir & Phoenix: Pembangunan Bahagian Belakang Boleh Skala menggunakan kod praktikal yang dijalankan terus dalam pelayar, manakala tutor kecerdasan buatan 24/7 menjawab soalan anda semasa anda mengikuti pelajaran.

Adakah saya memerlukan pengalaman untuk memulakan Elixir & Phoenix: Pembangunan Bahagian Belakang Boleh Skala?

Tiada pengalaman terdahulu diperlukan. Pembelajaran Elixir & Phoenix: Pembangunan Bahagian Belakang Boleh Skala di CoddyKit disusun untuk pelajar daripada peringkat pemula hingga lanjutan, jadi anda boleh bermula di sini atau dari awal dan belajar mengikut kadar anda sendiri. Ini ialah pelajaran 1 daripada 4.

Berapa lamakah pelajaran “Pengenalan kepada Saluran Phoenix” diambil?

Kebanyakan pelajaran CoddyKit mengambil masa kira-kira 5–10 minit. Setiap pelajaran ringkas dan interaktif, jadi anda boleh membuat kemajuan secara berterusan dan menyambung tepat dari tempat anda berhenti di web atau aplikasi.

Bolehkah saya menulis dan menjalankan kod dalam pelajaran Elixir & Phoenix: Pembangunan Bahagian Belakang Boleh Skala ini?

Ya. Setiap pelajaran Elixir & Phoenix: Pembangunan Bahagian Belakang Boleh Skala menyertakan penyunting kod terbina dalam, jadi anda boleh menulis dan menjalankan kod sebenar terus dalam pelayar serta menerima maklum balas kecerdasan buatan serta-merta — tanpa memerlukan persediaan setempat.

Semua pelajaran dalam kursus ini

← Kembali ke Elixir & Phoenix: Pembangunan Bahagian Belakang Boleh Skala