Elixir ja Phoenix: skaalautuva backend-kehitys · Oppitunti

GenServer-käyttäytymisen toteuttaminen

Ottakaa `GenServer`-käyttäytyminen haltuun rakentaaksenne vankkoja, tilallisia palvelinprosesseja, jotka käsittelevät pyynnöt asynkronisesti.

Oppitunti 2/411 vaihetta

GenServer-käyttäytymisen toteuttaminen on ilmainen Elixir ja Phoenix: skaalautuva backend-kehitys-oppitunti CoddyKitissä. Tämä on oppitunti 2/4. Voit lukea koko oppitunnin alta ilmaiseksi ja harjoitella sen jälkeen käytännössä selaimessa sisäänrakennetulla koodieditorilla ja ympäri vuorokauden käytettävissä olevan tekoälytuutorin avulla. Oppitunti kuuluu Elixir ja Phoenix: skaalautuva backend-kehitys-oppimispolkuun, ja edistymisesi synkronoituu verkon ja CoddyKit-sovelluksen välillä. Elixir ja Phoenix: skaalautuva backend-kehitys-kurssilla on yhteensä 4 oppituntia.

Tutustutaan GenServeriin

Tervetuloa tutustumaan GenServeriin, joka on Elixirin keskeinen rakennuspalikka vankkojen, tilallisten prosessien luomiseen!

Olette oppineet Elixirin perusprosesseista ja viestinvälityksestä. GenServer on erityinen prosessityyppi, joka tarjoaa standardoidun tavan tilan hallintaan ja pyyntöjen käsittelyyn, mikä helpottaa rinnakkaista ohjelmointia huomattavasti.

Se kuuluu Elixirin OTP:n (Open Telecom Platform) käyttäytymismalleihin ja tarjoaa vikasietoisuutta sekä selkeän rakenteen palvelintyyppisille prosesseille.

Miksi käyttää GenServeria?

GenServerin käytöllä on useita keskeisiä etuja:

Standardoitu rajapinta: Se tarjoaa yhdenmukaisen rajapinnan prosessien kanssa toimimiseen.
Tilan hallinta: Se yksinkertaistaa tietojen säilyttämistä ja päivittämistä prosessin aikana.
Vikasietoisuus: Supervisoreiden kanssa käytettynä (käsittelemme ne myöhemmin!) GenServerit voidaan käynnistää automaattisesti uudelleen kaatumisen jälkeen.
Rinnakkaisuus: Se mahdollistaa useiden asiakkaiden turvallisen vuorovaikutuksen yhden prosessin kanssa.

Ajatelkaa sitä luotettavana yksisäikeisenä palvelimena tiedoillenne tai toiminnoillenne.

GenServerin käynnistäminen: init/1

Jokainen GenServer aloittaa toimintansa kutsulla GenServer.start_link/3, joka kutsuu sen init/1-takaisinkutsufunktiota. Tässä määritetään palvelimen alkutila.

Tarkastellaan perusesimerkkiä:

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.

Vastausten vastaanottaminen: handle_call

Kun GenServerille on lähetettävä pyyntö ja odotettava vastausta, käytetään funktiota GenServer.call/2. GenServer käsittelee pyynnön handle_call/3-takaisinkutsulla.

Tämä on synkroninen toiminto: koodinne odottaa, kunnes GenServer käsittelee pyynnön ja lähettää vastauksen.

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}"

Lähetä ja unohda: handle_cast

Joskus GenServerille halutaan vain lähettää viesti odottamatta vastausta. Tällöin hyödyksi tulee GenServer.cast/2, jota käsitellään handle_cast/2-takaisinkutsulla.

Tämä on asynkroninen toiminto: koodinne lähettää viestin ja jatkaa välittömästi suorittamista odottamatta, että GenServer käsittelee viestin.

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()}"

GenServerin sisäinen tila

GenServerin ”tila” on vain Elixir-termi, kuten luku, map-rakenne tai lista, joka välitetään sen takaisinkutsufunktioiden välillä.

init/1 palauttaa alkutilan.
handle_call/3 palauttaa nykyisen tilan kolmantena alkiona.
handle_cast/2 palauttaa nykyisen tilan toisena alkiona.

Jokainen takaisinkutsu vastaanottaa nykyisen tilan argumenttina ja palauttaa uuden tilan. Tämän yksinkertaisen mekanismin ansiosta GenServer voi ylläpitää ja päivittää sisäisiä tietojaan luotettavasti.

Käytännön esimerkki: laskuri

Yhdistetään handle_call ja handle_cast yksinkertaisen laskuri-GenServerin rakentamiseksi. Sen avulla laskuria voidaan kasvattaa (asynkronisesti) ja sen nykyinen arvo voidaan hakea (synkronisesti).

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()}"

Call- ja cast-toimintojen lisäksi

Vaikka handle_call ja handle_cast ovat yleisimpiä, GenServerilla on myös muita takaisinkutsuja:

handle_info/2: Prosessille suoraan lähetettyjen yleisten viestien käsittelyyn (esimerkiksi send/2-funktion avulla).
terminate/2: Siivouskoodin suorittamiseen, kun GenServer on pysähtymässä.
code_change/3: Kuumien koodipäivitysten käsittelyyn palvelinta pysäyttämättä.

Nämä takaisinkutsut antavat entistä paremman hallinnan GenServerin elinkaareen ja toimintaan.

GenServerin parhaat käytännöt

GenServerien tehokkuuden ja ylläpidettävyyden varmistamiseksi kannattaa huomioida seuraavat vinkit:

Erota asiakasrajapinta: Pidä funktiot start_link, call ja cast erillään @impl-takaisinkutsuista.
Pidä tila pienenä: Pyri pitämään GenServerin sisäinen tila mahdollisimman pienenä ja yksinkertaisena.
Vältä pitkiä toimintoja: Älä suorita aikaa vieviä tehtäviä suoraan takaisinkutsuissa, sillä ne voivat estää muiden pyyntöjen käsittelyn. Käytä tällaisiin tehtäviin Elixirin Task-moduulia.
Käytä nimiä: Rekisteröi GenServerit nimillä (esimerkiksi name: __MODULE__), jotta ne on helppo löytää sovelluksen eri osista.

GenServer-tietojen tarkistus

On aika testata nopeasti, miten hyvin ymmärrätte GenServerit!

Vastaa interaktiivisessa oppitunnissa

GenServer: tärkeimmät opit

Olette hallinneet GenServer-käyttäytymisen perusteet!

GenServerit ovat tilallisia prosesseja, jotka hallitsevat tietoja ja käsittelevät pyyntöjä.
init/1 määrittää alkutilan.
GenServer.call/2 (jonka käsittelee handle_call/3) on tarkoitettu synkronisiin pyyntöihin, jotka odottavat vastausta.
GenServer.cast/2 (jonka käsittelee handle_cast/2) on tarkoitettu asynkronisiin ”lähetä ja unohda” -viesteihin.
GenServerin tila välitetään takaisinkutsujen välillä, joten se voi muuttua ajan kuluessa.

GenServerit ovat tehokas työkalu rinnakkaisten ja vikasietoisten Elixir-sovellusten rakentamiseen.

Aloita maksutta

Opi Elixir tekoälytuutorin avulla — ilmaiseksi

Kirjoita ja suorita oikeaa koodia selaimessa, saa välitöntä apua tekoälytuutorilta ympäri vuorokauden ja jatka siitä, mihin jäit, verkossa tai sovelluksessa.

Kurssit: 12
Oppitunnit: 48

Aloita opiskelu maksutta Näytä koko kurssi

Usein kysytyt kysymykset

Onko oppitunti ”GenServer-käyttäytymisen toteuttaminen” ilmainen?

Kyllä – oppitunnin ”GenServer-käyttäytymisen toteuttaminen” koko tekstin voi lukea täällä verkossa ilmaiseksi. Jos haluat harjoitella interaktiivisesti sisäänrakennetulla koodieditorilla ja ympäri vuorokauden käytettävissä olevan tekoälytuutorin avulla sekä avata koko Elixir ja Phoenix: skaalautuva backend-kehitys-kurssin, päivitä CoddyKit PROhon. Elixir ja Phoenix: skaalautuva backend-kehitys-kurssilla on yhteensä 4 oppituntia.

Mitä opin oppitunnilla ”GenServer-käyttäytymisen toteuttaminen”?

Ottakaa `GenServer`-käyttäytyminen haltuun rakentaaksenne vankkoja, tilallisia palvelinprosesseja, jotka käsittelevät pyynnöt asynkronisesti. Harjoittelet Elixir ja Phoenix: skaalautuva backend-kehitys-aihetta koodilla, jonka suoritat suoraan selaimessa. Ympäri vuorokauden käytettävissä oleva tekoälytuutori vastaa kysymyksiisi oppitunnin aikana.

Tarvitsenko kokemusta aloittaakseni Elixir ja Phoenix: skaalautuva backend-kehitys-opiskelun?

Aiempi kokemus ei ole tarpeen. CoddyKitin Elixir ja Phoenix: skaalautuva backend-kehitys-oppimispolku sopii vasta-alkajista edistyneisiin, joten voit aloittaa tästä tai alusta ja edetä omaan tahtiisi. Tämä on oppitunti 2/4.

Kuinka kauan ”GenServer-käyttäytymisen toteuttaminen”-oppitunnin suorittaminen kestää?

Useimmat CoddyKitin oppitunnit kestävät noin 5–10 minuuttia. Jokainen oppitunti on lyhyt ja interaktiivinen, joten edistyt tasaisesti ja voit jatkaa siitä, mihin jäit – sekä verkossa että sovelluksessa.

Voinko kirjoittaa ja suorittaa koodia tällä Elixir ja Phoenix: skaalautuva backend-kehitys-oppitunnilla?

Kyllä. Jokainen Elixir ja Phoenix: skaalautuva backend-kehitys-oppitunti sisältää sisäänrakennetun koodieditorin, joten voit kirjoittaa ja suorittaa oikeaa koodia suoraan selaimessa ja saada välitöntä palautetta tekoälyltä – paikallista asennusta ei tarvita.

Kaikki tämän kurssin oppitunnit

Elixirin prosessit ja viestinvälitys
GenServer-käyttäytymisen toteuttaminen
Supervisors-prosessit ja sovellusrakenne
Samanaikainen työ Task- ja Agent-abstraktioilla

← Takaisin: Elixir ja Phoenix: skaalautuva backend-kehitys