Elixir & Phoenix: Scalable Backend Development · Lektion

GenServer-Verhalten implementieren

Beherrschen Sie das `GenServer`-Verhalten, um robuste, zustandsbehaftete Serverprozesse zu erstellen, die Anfragen asynchron verarbeiten.

GenServer-Verhalten implementieren ist eine kostenlose Elixir & Phoenix: Scalable Backend Development-Lektion auf CoddyKit. Dies ist Lektion 2 von 4. Du kannst die komplette Lektion unten kostenlos lesen – dann übst du sie direkt im Browser mit einem integrierten Code-Editor und einem KI-Tutor rund um die Uhr. Sie ist Teil des Elixir & Phoenix: Scalable Backend Development-Lernpfads, und dein Fortschritt wird über Web und CoddyKit-App synchronisiert. Der Elixir & Phoenix: Scalable Backend Development-Kurs umfasst insgesamt 4 Lektionen.

Teile dieser Lektion wurden noch nicht übersetzt und werden auf Englisch angezeigt.

Meet the GenServer

Welcome to GenServer, a core building block in Elixir for creating robust, stateful processes!

You've learned about basic Elixir processes and message passing. GenServer is a special type of process that provides a standardized way to manage state and handle requests, making concurrent programming much easier.

It's part of Elixir's OTP (Open Telecom Platform) behaviors, offering fault tolerance and a clear structure for your server-like processes.

Why Use GenServer?

Using a GenServer offers several key advantages:

Standardized API: It provides a consistent interface for interacting with processes.
State Management: It simplifies holding and updating data over time within a process.
Fault Tolerance: When used with supervisors (covered later!), GenServers can be automatically restarted if they crash.
Concurrency: It allows multiple clients to interact with a single process safely.

Think of it as a reliable, single-threaded server for your data or operations.

Starting a GenServer: init/1

Every GenServer begins its life by calling GenServer.start_link/3, which then invokes its init/1 callback function. This is where you set up the initial state of your server.

Let's see a basic example:

defmodule MyGenServer do
  use GenServer

  # Client API: How others interact with our GenServer
  def start_link(initial_state) do
    GenServer.start_link(__MODULE__, initial_state, name: __MODULE__)
  end

  # Server Callbacks: What the GenServer does internally
  @impl true
  def init(initial_state) do
    IO.puts "[GenServer] Initializing with: #{inspect initial_state}"
    {:ok, initial_state} # Return {:ok, state} to indicate success
  end
end

# --- Main execution block for runnable example --- 
# Start the GenServer with 'Hello Elixir!' as its initial state
{:ok, pid} = MyGenServer.start_link("Hello Elixir!")
IO.puts "[Main] GenServer started with PID: #{inspect pid}"

# For a simple script, we just start it. In a real app, 
# it would be supervised and run in the background.

Getting Replies: handle_call

When you need to send a request to a GenServer and wait for a reply, you use GenServer.call/2. The GenServer handles this with the handle_call/3 callback.

This is a synchronous operation: your code waits until the GenServer processes the request and sends back a response.

defmodule MyGenServer do
  use GenServer

  # Client API
  def start_link(initial_state) do
    GenServer.start_link(__MODULE__, initial_state, name: __MODULE__)
  end

  def get_state do
    GenServer.call(__MODULE__, :get_state)
  end

  # Server Callbacks
  @impl true
  def init(initial_state) do
    {:ok, initial_state}
  end

  @impl true
  def handle_call(:get_state, _from, current_state) do
    IO.puts "[GenServer] Handling :get_state call."
    # {:reply, response_to_client, new_server_state}
    {:reply, current_state, current_state}
  end
end

# --- Main execution block ---
MyGenServer.start_link("Initial Data")
state = MyGenServer.get_state()
IO.puts "[Main] Received state from GenServer: #{inspect state}"

Fire & Forget: handle_cast

Sometimes you just want to send a message to a GenServer without waiting for a reply. This is where GenServer.cast/2 comes in handy, handled by the handle_cast/2 callback.

This is an asynchronous operation: your code sends the message and immediately continues, without waiting for the GenServer to process it.

defmodule MyGenServer do
  use GenServer

  # Client API
  def start_link(initial_state) do
    GenServer.start_link(__MODULE__, initial_state, name: __MODULE__)
  end

  def get_state do
    GenServer.call(__MODULE__, :get_state)
  end

  def set_state(new_state) do
    GenServer.cast(__MODULE__, {:set_state, new_state})
  end

  # Server Callbacks
  @impl true
  def init(initial_state) do
    {:ok, initial_state}
  end

  @impl true
  def handle_call(:get_state, _from, current_state) do
    {:reply, current_state, current_state}
  end

  @impl true
  def handle_cast({:set_state, new_state}, _current_state) do
    IO.puts "[GenServer] Handling {:set_state, ...} cast."
    # {:noreply, new_server_state}
    {:noreply, new_state}
  end
end

# --- Main execution block ---
MyGenServer.start_link("Initial Data")
IO.puts "[Main] Current state: #{MyGenServer.get_state()}"
MyGenServer.set_state("Updated Data")
Process.sleep(10) # Give cast a moment to process
IO.puts "[Main] New state after cast: #{MyGenServer.get_state()}"

GenServer's Internal State

The 'state' of a GenServer is just an Elixir term (like a number, map, or list) that is passed around between its callback functions.

init/1 returns the initial state.
handle_call/3 returns the current state as its third element.
handle_cast/2 returns the current state as its second element.

Each callback receives the current state as an argument and returns the new state. This simple mechanism allows your GenServer to maintain and update its internal data reliably.

Practical Example: A Counter

Let's put handle_call and handle_cast together to build a simple counter GenServer. It will allow us to increment the counter (async) and get its current value (sync).

defmodule Counter do
  use GenServer

  # Client API
  def start_link do
    GenServer.start_link(__MODULE__, 0, name: __MODULE__)
  end

  def increment do
    GenServer.cast(__MODULE__, :increment)
  end

  def get_count do
    GenServer.call(__MODULE__, :get_count)
  end

  # Server Callbacks
  @impl true
  def init(initial_count) do
    IO.puts "[Counter] Initialized to: #{initial_count}"
    {:ok, initial_count}
  end

  @impl true
  def handle_cast(:increment, current_count) do
    new_count = current_count + 1
    IO.puts "[Counter] Incremented to: #{new_count}"
    {:noreply, new_count}
  end

  @impl true
  def handle_call(:get_count, _from, current_count) do
    IO.puts "[Counter] Returning current count: #{current_count}"
    {:reply, current_count, current_count}
  end
end

# --- Main execution block ---
Counter.start_link()
IO.puts "[Main] Initial count: #{Counter.get_count()}"
Counter.increment()
Counter.increment()
Process.sleep(10) # Give casts time to process
IO.puts "[Main] Count after increments: #{Counter.get_count()}"

Beyond Call & Cast

While handle_call and handle_cast are the most common, GenServers have other callbacks:

handle_info/2: For handling general messages sent directly to the process (e.g., using send/2).
terminate/2: For cleanup code when the GenServer is about to stop.
code_change/3: For handling hot code upgrades without stopping the server.

These callbacks provide even more control over the GenServer's lifecycle and behavior.

GenServer Best Practices

To make your GenServers effective and maintainable, consider these tips:

Separate Client API: Keep the start_link, call, and cast functions separate from the @impl callbacks.
Small State: Try to keep the GenServer's internal state minimal and simple.
Avoid Long Operations: Don't perform time-consuming tasks directly in callbacks; this can block other requests. Use Elixir's Task module for such work.
Use Names: Register your GenServers with names (e.g., name: __MODULE__) for easy lookup across your application.

GenServer Check-up

Time for a quick question to check your understanding of GenServers!

GenServer: Key Takeaways

You've mastered the fundamentals of GenServer behavior!

GenServers are stateful processes that manage data and handle requests.
init/1 sets up the initial state.
GenServer.call/2 (handled by handle_call/3) is for synchronous requests that expect a reply.
GenServer.cast/2 (handled by handle_cast/2) is for asynchronous, 'fire-and-forget' messages.
The GenServer's state is passed between callbacks, allowing it to evolve over time.

GenServers are a powerful tool for building concurrent and fault-tolerant applications in Elixir.

Häufig gestellte Fragen

Ist die Lektion „GenServer-Verhalten implementieren“ kostenlos?

Ja — der vollständige Text von „GenServer-Verhalten implementieren“ ist hier im Web kostenlos zu lesen. Um sie interaktiv zu üben (integrierter Code-Editor und 24/7 KI-Tutor) und den Rest des Elixir & Phoenix: Scalable Backend Development-Kurses freizuschalten, upgrade auf CoddyKit PRO. Der Elixir & Phoenix: Scalable Backend Development-Kurs umfasst insgesamt 4 Lektionen.

Was lerne ich in „GenServer-Verhalten implementieren“?

Beherrschen Sie das `GenServer`-Verhalten, um robuste, zustandsbehaftete Serverprozesse zu erstellen, die Anfragen asynchron verarbeiten. Du übst Elixir & Phoenix: Scalable Backend Development mit praktischem Code, den du direkt im Browser ausführst, und ein 24/7 KI-Tutor beantwortet deine Fragen während du die Lektion bearbeitest.

Brauche ich Erfahrung, um Elixir & Phoenix: Scalable Backend Development zu starten?

Keine Vorkenntnisse erforderlich. Elixir & Phoenix: Scalable Backend Development auf CoddyKit ist für Anfänger bis fortgeschrittene Lernende strukturiert, sodass du hier starten oder von Anfang an beginnen und in deinem eigenen Tempo voranschreiten kannst. Dies ist Lektion 2 von 4.

Wie lange dauert die Lektion „GenServer-Verhalten implementieren“?

Die meisten CoddyKit-Lektionen dauern etwa 5–10 Minuten. Jede ist kompakt und interaktiv, sodass du stetig Fortschritte machst und genau dort weitermachst, wo du aufgehört hast – im Web und in der App.

Kann ich in dieser Elixir & Phoenix: Scalable Backend Development-Lektion Code schreiben und ausführen?

Ja. Jede Elixir & Phoenix: Scalable Backend Development-Lektion enthält einen integrierten Code-Editor, sodass du echten Code direkt in deinem Browser schreibst und ausführst und sofort KI-Feedback erhältst — ohne lokale Einrichtung erforderlich.

Alle Lektionen in diesem Kurs

Elixir-Prozesse und Nachrichtenübermittlung
GenServer-Verhalten implementieren
Supervisoren und Anwendungsstruktur
Nebenläufige Arbeit mit Task und Agent

← Zurück zu Elixir & Phoenix: Scalable Backend Development