GenEvent pour la gestion des événements
Apprenez à utiliser GenEvent pour créer des systèmes de gestion d'événements découplés, permettant aux producteurs et aux abonnés d'interagir de manière asynchrone
GenEvent pour la gestion des événements est une leçon Erlang OTP: Distributed & Fault-Tolerant Systems Programming gratuite sur CoddyKit. Ceci est la leçon 2 sur 4. Tu peux lire la leçon complète ci-dessous gratuitement — puis la pratiquer en direct dans le navigateur avec un éditeur de code intégré et un tuteur IA 24/7. Elle fait partie du parcours d'apprentissage Erlang OTP: Distributed & Fault-Tolerant Systems Programming, et ta progression se synchronise sur le web et l'application CoddyKit. Le cours Erlang OTP: Distributed & Fault-Tolerant Systems Programming comprend 4 leçons au total.
Certaines parties de cette leçon n'ont pas encore été traduites et s'affichent en anglais.
Why Event Handling?
Imagine you have many parts of your application that need to react to something happening, like a user logging in.
If each part directly calls every other part, your code becomes tightly coupled and hard to change. This is where event handling comes in!
Introducing GenEvent
Erlang's OTP (Open Telecom Platform) provides a powerful behavior called gen_event for building decoupled event handling systems.
- It implements the publisher-subscriber pattern.
- Publishers send events without knowing who will receive them.
- Subscribers (called handlers) register to receive specific events.
- This promotes loose coupling and makes systems more flexible.
The Event Manager
At the heart of gen_event is an event manager. This is a special Erlang process that acts as a central hub:
- It receives events from publishers.
- It dispatches these events to all registered handlers.
You start an event manager just like other OTP behaviors:
-module(event_manager_starter).
-export([start/0]).
start() ->
% Start a local event manager named 'my_app_events'
{ok, Pid} = gen_event:start_link({local, my_app_events}),
io:format("Event manager started with PID: ~p~n", [Pid]),
ok.Event Handlers: The Listeners
An event handler is an Erlang module that implements the gen_event behavior. It defines callback functions that the event manager will call when an event occurs.
Think of handlers as specialized listeners, each interested in certain types of events or performing a specific action when an event is received.
Creating a Simple Handler
Here's the basic structure for an event handler module. The key callback is handle_event/2, where you process the incoming event.
-module(my_event_handler).
-behaviour(gen_event).
-export([init/1, handle_event/2, terminate/2]).
init(Args) ->
io:format("Handler initialized with args: ~p~n", [Args]),
{ok, []}. % Returns initial state
handle_event(Event, State) ->
io:format("Handler received event: ~p~n", [Event]),
% Here you'd process the event
{ok, State}. % Return new state
terminate(_Args, _State) ->
io:format("Handler terminating.~n", []),
ok.Adding Handlers to the Manager
After starting your event manager and defining your handler, you need to tell the manager about your handler. This is done using gen_event:add_handler/3.
You can add multiple handlers to the same manager, and each will receive the events.
-module(handler_adder).
-export([add_to_manager/1]).
add_to_manager(ManagerName) ->
% The handler module name (my_event_handler)
% and any initial arguments for its init/1 function ([] in this case)
gen_event:add_handler(ManagerName, my_event_handler, []),
io:format("Handler 'my_event_handler' added to '~p'.~n", [ManagerName]),
ok.Notifying the Manager (Publishing Events)
Once handlers are registered, any part of your application can send an event to the manager using gen_event:notify/2. The manager will then forward this event to all active handlers.
The publisher doesn't know (or care) how many handlers there are, or what they do. This is the power of decoupling!
-module(event_publisher).
-export([send_alert/2]).
send_alert(ManagerName, Message) ->
Event = {alert, Message, os:timestamp()},
io:format("Publisher sending event: ~p to manager '~p'.~n", [Event, ManagerName]),
gen_event:notify(ManagerName, Event).Full GenEvent Demo
Let's put it all together! This runnable example starts a manager, adds a simple handler, and then sends a few events. Watch the handler react!
-module(gen_event_demo).
-export([start/0]).
% --- Inline Handler Module for Demo ---
% In a real app, this would be a separate .erl file.
my_demo_handler() ->
% Compile and load a temporary handler module
code:delete(demo_handler_impl),
code:purge(demo_handler_impl),
{ok, _} = compile:forms([
'-module(demo_handler_impl).',
'-behaviour(gen_event).',
'-export([init/1, handle_event/2, terminate/2]).',
'init(Args) -> {ok, Args}.',
'handle_event(Event, State) ->',
' io:format("*** Handler received: ~p~n", [Event]),',
' {ok, State}.',
'terminate(_Args, _State) -> ok.'
], []),
demo_handler_impl.
% --- Main Application Logic ---
start() ->
ManagerName = my_system_events,
HandlerModule = my_demo_handler(),
io:format("--- Starting GenEvent Demo ---~n"),
% 1. Start the event manager
{ok, _ManagerPid} = gen_event:start_link({local, ManagerName}),
io:format("Manager '~p' started.~n", [ManagerName]),
% 2. Add the handler to the manager
gen_event:add_handler(ManagerName, HandlerModule, []),
io:format("Handler '~p' added.~n", [HandlerModule]),
% 3. Publish some events
io:format("Sending first event...~n"),
gen_event:notify(ManagerName, {user_logged_in, "Alice"}),
timer:sleep(100), % Give time for event processing
io:format("Sending second event...~n"),
gen_event:notify(ManagerName, {sensor_reading, 25.5}),
timer:sleep(100),
io:format("Sending third event...~n"),
gen_event:notify(ManagerName, {error_alert, "Disk_full"}),
timer:sleep(100),
% 4. Stop the manager (optional, for clean exit)
gen_event:stop(ManagerName),
io:format("--- GenEvent Demo Finished ---~n"),
ok.Advanced GenEvent Usage
gen_event is quite flexible:
- Handler State: Handlers can maintain their own internal state, updated with each event.
- Multiple Handlers: A single event manager can have many handlers, each processing events independently.
- Removing Handlers: Handlers can be dynamically removed using
gen_event:delete_handler/3. - Synchronous Calls: While primarily asynchronous,
gen_event:call/2allows synchronous calls to handlers (though less common for pure eventing).
GenEvent Quick Check
You've learned about GenEvent's core components and how they interact. Let's test your understanding!
Recap: GenEvent Essentials
Great job! You've learned how gen_event helps build flexible, decoupled systems:
- Event Manager: The central hub that dispatches events.
- Event Handlers: Modules that subscribe to and process events.
- Publishers: Send events to the manager using
gen_event:notify/2. - Decoupling: Key benefit, allowing parts of your system to evolve independently.
Next, you'll explore even more advanced OTP behaviors!
Questions Fréquemment Posées
La leçon « GenEvent pour la gestion des événements » est-elle gratuite ?
Oui — le texte complet de « GenEvent pour la gestion des événements » est gratuit à lire ici sur le web. Pour la pratiquer de manière interactive (un éditeur de code intégré et un tuteur IA 24/7) et déverrouiller le reste du cours Erlang OTP: Distributed & Fault-Tolerant Systems Programming, passe à CoddyKit PRO. Le cours Erlang OTP: Distributed & Fault-Tolerant Systems Programming comprend 4 leçons au total.
Qu'est-ce que j'apprendrai dans « GenEvent pour la gestion des événements » ?
Apprenez à utiliser GenEvent pour créer des systèmes de gestion d'événements découplés, permettant aux producteurs et aux abonnés d'interagir de manière asynchrone Tu pratiques Erlang OTP: Distributed & Fault-Tolerant Systems Programming avec du code pratique que tu exécutes directement dans le navigateur, et un tuteur IA 24/7 répond à tes questions au fur et à mesure que tu avances dans la leçon.
Dois-je avoir de l'expérience pour commencer Erlang OTP: Distributed & Fault-Tolerant Systems Programming ?
Aucune expérience préalable n'est requise. Erlang OTP: Distributed & Fault-Tolerant Systems Programming sur CoddyKit est structuré pour les débutants jusqu'aux apprenants avancés, donc tu peux commencer ici ou depuis le début et avancer à ton rythme. Ceci est la leçon 2 sur 4.
Combien de temps prend la leçon « GenEvent pour la gestion des événements » ?
La plupart des leçons CoddyKit prennent environ 5–10 minutes. Chacune est courte et interactive, tu progresses régulièrement et tu repiques exactement où tu t'es arrêté sur le web et l'app.
Peux-tu écrire et exécuter du code dans cette leçon Erlang OTP: Distributed & Fault-Tolerant Systems Programming ?
Oui. Chaque leçon Erlang OTP: Distributed & Fault-Tolerant Systems Programming inclut un éditeur de code intégré, tu écris et exécutes du vrai code directement dans ton navigateur et tu reçois des retours IA instantanés — aucune configuration locale requise.
Toutes les leçons de ce cours
- GenStatem pour la gestion de l'état
- GenEvent pour la gestion des événements
- Comportements OTP personnalisés
- Échange de code à chaud et mises à niveau en direct