Erlang OTP: Distributed & Fault-Tolerant Systems Programming · درس

GenEvent لمعالجة الأحداث

تعلّم استخدام GenEvent لإنشاء أنظمة معالجة أحداث مفصولة، تتيح للناشرين والمشتركين التفاعل بشكل غير متزامن

الدرس 2 من 411 خطوة

GenEvent لمعالجة الأحداث درس مجاني في Erlang OTP: Distributed & Fault-Tolerant Systems Programming على CoddyKit. هذا هو الدرس 2 من أصل 4. يمكنك قراءة الدرس كاملاً أدناه مجاناً — ثم تمرن عليه مباشرة في المتصفح باستخدام محرر أكواد مدمج ومدرس ذكاء اصطناعي متاح 24/7. هذا الدرس جزء من مسار التعلم في Erlang OTP: Distributed & Fault-Tolerant Systems Programming، وتقدمك يتزامن عبر الويب وتطبيق CoddyKit. تتضمن دورة Erlang OTP: Distributed & Fault-Tolerant Systems Programming 4 دروس في المجموع.

بعض أجزاء هذا الدرس لم تُترجم بعد وتظهر باللغة الإنجليزية.

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/2 allows 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!

البدء مجانًا

تعلم Erlang مع معلم ذكاء اصطناعي — مجانًا

اكتب وقم بتشغيل أكوادك الفعلية في المتصفح، واحصل على مساعدة فورية من معلم ذكاء اصطناعي متاح 24/7، واستمر من حيث توقفت على الويب أو في التطبيق.

الدورات: 12
الدروس: 48

ابدأ التعلم مجانًا عرض الدورة الكاملة

الأسئلة الشائعة

هل درس «GenEvent لمعالجة الأحداث» مجاني؟

نعم — نص درس «GenEvent لمعالجة الأحداث» كامل متاح مجاناً هنا على الويب. لتمرينه بشكل تفاعلي (محرر أكواد مدمج ومدرس ذكاء اصطناعي متاح 24/7) وفتح باقي دورة Erlang OTP: Distributed & Fault-Tolerant Systems Programming، انتقل إلى CoddyKit PRO. تتضمن دورة Erlang OTP: Distributed & Fault-Tolerant Systems Programming 4 دروس في المجموع.

ماذا ستتعلم في «GenEvent لمعالجة الأحداث»؟

تعلّم استخدام GenEvent لإنشاء أنظمة معالجة أحداث مفصولة، تتيح للناشرين والمشتركين التفاعل بشكل غير متزامن تتمرن على Erlang OTP: Distributed & Fault-Tolerant Systems Programming مع أكواد عملية تشغلها مباشرة في المتصفح، ومدرس ذكاء اصطناعي متاح 24/7 يجيب على أسئلتك أثناء عملك.

هل أحتاج إلى خبرة سابقة لأبدأ Erlang OTP: Distributed & Fault-Tolerant Systems Programming؟

لا تُشترط خبرة سابقة. Erlang OTP: Distributed & Fault-Tolerant Systems Programming على CoddyKit منظم للمبتدئين حتى المتقدمين، لذا يمكنك البدء من هنا أو من البداية والتقدم بسرعتك الخاصة. هذا هو الدرس 2 من أصل 4.

كم من الوقت يستغرق درس «GenEvent لمعالجة الأحداث»؟

معظم دروس CoddyKit تستغرق حوالي 5–10 دقائق. كل منها موجز وتفاعلي، لذا تحرز تقدماً مستمراً وتستأنف من حيث توقفت عبر الويب والتطبيق.

هل يمكنني كتابة وتشغيل أكواد في درس Erlang OTP: Distributed & Fault-Tolerant Systems Programming هذا؟

نعم. كل درس في Erlang OTP: Distributed & Fault-Tolerant Systems Programming يتضمن محرر أكواد مدمج، لذا تكتب وتشغل أكواداً حقيقية مباشرة في متصفحك وتحصل على تعليقات فورية من الذكاء الاصطناعي — بدون إعداد محلي.

جميع الدروس في هذه الدورة

← العودة إلى Erlang OTP: Distributed & Fault-Tolerant Systems Programming