Erlang OTP: Programmering av distribuerade och feltoleranta system · Lektion

Anpassade OTP-behaviors

Förstå strukturen hos OTP-behaviors och hur ni skapar egna anpassade generiska behaviors för att kapsla in vanliga mönster.

Lektion 3 av 411 steg

Anpassade OTP-behaviors är en gratis lektion i Erlang OTP: Programmering av distribuerade och feltoleranta system på CoddyKit. Detta är lektion 3 av 4. Du kan läsa vilka 3 lektioner som helst i den här lärvägen kostnadsfritt i sin helhet – därefter låser CoddyKit PRO upp alla lektioner, plus praktisk övning med en inbyggd kodredigerare och en AI-lärare dygnet runt. Den ingår i lärvägen för Erlang OTP: Programmering av distribuerade och feltoleranta system, och Era framsteg synkroniseras mellan webben och CoddyKit-appen. Kursen i Erlang OTP: Programmering av distribuerade och feltoleranta system innehåller totalt 4 lektioner.

Introduktion: Vad är OTP-beteenden?

Ni har lärt er om OTP-beteenden som GenServer och GenStatem. De tillhandahåller ett standardiserat sätt att bygga robusta och feltåliga komponenter.

Men vad gör ni om ni har ett återkommande mönster som inte täcks helt av de befintliga beteendena? Då kommer anpassade OTP-beteenden till användning!

De låter er definiera en egen struktur för generiska komponenter.

Varför anpassade beteenden?

Att skapa anpassade beteenden har flera viktiga fördelar:

Återanvändning av kod: Kapsla in gemensam logik en gång och återanvänd den i många moduler.
Konsekvens: Säkerställ att alla komponenter som följer ert beteende följer ett specifikt gränssnitt och en specifik struktur.
Abstraktion: Dölj komplexa interna detaljer och exponera ett enklare API för användarna.
Underhållbarhet: Ändringar i kärnlogiken behöver bara göras på ett ställe.

Ett beteendes uppbyggnad

Ett OTP-beteende består vanligtvis av två huvuddelar:

Beteendemodulen: Den här modulen definierar det publika gränssnittet (funktionerna som användarna anropar) och tillhandahåller ofta hjälpfunktioner för callback-modulen. Den använder attributet -behaviour(gen_server) eller ett liknande attribut för att koppla till en generisk server.
Callback-modulen: Det är här den faktiska logiken finns. Den implementerar callback-funktionerna (som init/1 och handle_call/3) som beteendemodulen kräver.

Tänk på det som ett kontrakt mellan de två.

Beteendemodul: gränssnitt

Det är mot "beteendemodulen" som andra moduler använder -behaviour(...). För anpassade beteenden definierar ni ofta en modul som omsluter ett befintligt generiskt beteende (som gen_server) men lägger till ert specifika API.

Den fungerar som gränssnitt på klientsidan för användare av ert anpassade beteende.

Viktiga delar:

Definierar de publika funktionerna (till exempel start_link/0 och my_action/1).
Dessa funktioner anropar vanligtvis gen_server:start_link/3 eller gen_server:call/2 internt.
Anger callback-modulen med attributet -callback.

Callback-modul: logik

Det är i "callback-modulen" som kärnfunktionaliteten för ert anpassade beteende finns. Det är modulen som faktiskt implementerar de funktioner som krävs av det underliggande generiska beteendet (som gen_server eller gen_statem).

Den måste implementera funktioner som init/1, handle_call/3, handle_cast/2 och så vidare.
Dessa funktioner hanterar tillståndet och svarar på meddelanden.
Det är den här modulen som beteendemodulen (till exempel gen_server) anropar direkt.

Counter-beteende: start

Nu skapar vi ett enkelt anpassat counter-beteende. Vi omsluter en gen_server för att hantera ett heltal som räknare.

Först definierar vi beteendemodulen, som fungerar som klient-API och startar den underliggande gen_server.

-module(my_counter).
-behaviour(gen_server). % We wrap gen_server

-export([start_link/0, get_count/0, increment/0, decrement/0]).
-export([init/1, handle_call/3, handle_cast/2, handle_info/2,
         terminate/2, code_change/3]).

% Public API for starting the counter
start_link() ->
    gen_server:start_link({local, ?MODULE}, ?MODULE, [], []).

% --- gen_server callbacks (for *this* module acting as callback) ---
% This is where the initial state is set
init([]) ->
    {ok, 0}. % Initial count is 0

Counter-beteende: funktioner

Nu lägger vi till de publika funktionerna för att interagera med vår räknare (increment, decrement och get_count) och implementerar motsvarande logik i handle_call.

Dessa publika funktioner använder gen_server:call/2 för att skicka begäranden till den faktiska räknarprocessen.

-module(my_counter).
-behaviour(gen_server).

-export([start_link/0, get_count/0, increment/0, decrement/0]).
-export([init/1, handle_call/3, handle_cast/2, handle_info/2,
         terminate/2, code_change/3]).

start_link() ->
    gen_server:start_link({local, ?MODULE}, ?MODULE, [], []).

% Public API for interacting with the counter
get_count() ->
    gen_server:call(?MODULE, get_count).

increment() ->
    gen_server:call(?MODULE, increment).

drcrement() ->
    gen_server:call(?MODULE, decrement).

% --- gen_server callbacks ---
init([]) ->
    {ok, 0}.

handle_call(get_count, _From, State) ->
    {reply, State, State};
handle_call(increment, _From, State) ->
    NewState = State + 1,
    {reply, NewState, NewState};
handle_call(decrement, _From, State) ->
    NewState = State - 1,
    {reply, NewState, NewState};
handle_call(_Request, _From, State) ->
    {reply, {error, unknown_request}, State}.

handle_cast(_Msg, State) ->
    {noreply, State}.

handle_info(_Info, State) ->
    {noreply, State}.

terminate(_Reason, _State) ->
    ok.

code_change(_OldVsn, State, _Extra) ->
    {ok, State}.

Använda den anpassade räknaren

När beteendet my_counter är definierat kan vi enkelt använda det från ett Erlang-skal eller en annan modul. Lägg märke till hur enkel koden på klientsidan är!

Ni behöver inte känna till detaljerna i gen_server; ni använder bara API:t för det anpassade beteendet.

-module(counter_app).
-export([run/0]).

run() ->
    % Start our custom counter behavior
    io:format("Starting counter...~n"),
    my_counter:start_link(),

    io:format("Current count: ~p~n", [my_counter:get_count()]),

    io:format("Incrementing...~n"),
    my_counter:increment(),
    io:format("Current count: ~p~n", [my_counter:get_count()]),

    io:format("Decrementing...~n"),
    my_counter:decrement(),
    io:format("Current count: ~p~n", [my_counter:get_count()]),

    % Stop the counter (optional, usually supervisors handle this)
    gen_server:stop(my_counter),
    io:format("Counter stopped.~n").

När ska anpassade beteenden användas?

Anpassade OTP-beteenden är kraftfulla, men alla komponenter behöver inte ett eget beteende. Överväg att skapa ett anpassat beteende när:

Ni upprepade gånger skriver liknande standardkod för gen_server eller gen_statem.
Ni vill framtvinga ett specifikt mönster eller gränssnitt för flera komponenter.
Ni behöver tillhandahålla ett enklare API på högre nivå för en komplex underliggande process.
Ni bygger ett återanvändbart bibliotek eller en komponent för ett ramverk.

Snabbkontroll

Ni har lärt er om anpassade OTP-beteenden. Nu testar vi era kunskaper.

Besvara frågan i den interaktiva lektionen

Repetition och nästa steg

Ni har utforskat världen av anpassade OTP-beteenden!

Vi såg att anpassade beteenden gör det möjligt att kapsla in gemensamma mönster.
De består vanligtvis av en **beteendemodul** (publikt API) och en **callback-modul** (logik).
Genom att omsluta befintliga beteenden som gen_server kan ni skapa kraftfulla och återanvändbara komponenter.

Genom att behärska anpassade beteenden kan ni bygga mycket modulära och konsekventa Erlang-applikationer.

Gratis att börja

Lär dig Erlang med en AI-lärare – gratis

Skriv och kör riktig kod i webbläsaren, få omedelbar hjälp av en AI-lärare dygnet runt och fortsätt där du slutade – på webben eller i appen.

Kurser: 12
Lektioner: 48

Börja lära dig gratis Visa hela kursen

Vanliga frågor

Är lektionen ”Anpassade OTP-behaviors” gratis?

Ja – du kan läsa vilka 3 lektioner som helst i lärvägen Erlang OTP: Programmering av distribuerade och feltoleranta system, inklusive ”Anpassade OTP-behaviors”, kostnadsfritt i sin helhet här på webben. Därefter låser CoddyKit PRO upp alla lektioner, plus interaktiv övning med en inbyggd kodredigerare och en AI-lärare dygnet runt. Kursen i Erlang OTP: Programmering av distribuerade och feltoleranta system innehåller totalt 4 lektioner.

Vad lär jag mig i ”Anpassade OTP-behaviors”?

Förstå strukturen hos OTP-behaviors och hur ni skapar egna anpassade generiska behaviors för att kapsla in vanliga mönster. Ni övar på Erlang OTP: Programmering av distribuerade och feltoleranta system med praktisk kod som körs direkt i webbläsaren, medan en AI-handledare som är tillgänglig dygnet runt svarar på Era frågor under lektionen.

Behöver jag någon erfarenhet för att börja lära mig Erlang OTP: Programmering av distribuerade och feltoleranta system?

Du behöver inga förkunskaper. Utbildningen i Erlang OTP: Programmering av distribuerade och feltoleranta system på CoddyKit är upplagd för allt från nybörjare till avancerade elever, så att du kan börja här eller från början och gå fram i din egen takt. Detta är lektion 3 av 4.

Hur lång tid tar lektionen ”Anpassade OTP-behaviors”?

De flesta CoddyKit-lektioner tar cirka 5–10 minuter. Varje lektion är kort och interaktiv, så att du gör stadiga framsteg och kan fortsätta precis där du slutade – på webben eller i appen.

Kan jag skriva och köra kod i den här Erlang OTP: Programmering av distribuerade och feltoleranta system-lektionen?

Ja. Varje Erlang OTP: Programmering av distribuerade och feltoleranta system-lektion innehåller en inbyggd kodredigerare, så att du kan skriva och köra riktig kod direkt i webbläsaren och få omedelbar AI-feedback – utan lokal installation.

Alla lektioner i den här kursen

← Tillbaka till Erlang OTP: Programmering av distribuerade och feltoleranta system