イベント処理のためのGenEvent
GenEventを使って疎結合なイベント処理システムを作成し、パブリッシャーとサブスクライバーが非同期に連携できるようにする方法を学びます。
「イベント処理のためのGenEvent」はCoddyKit上の無料Erlang OTP: Distributed & Fault-Tolerant Systems Programmingレッスンです。 これはレッスン2/4です。 下記で完全なレッスンを無料で読むことができます。その後、ブラウザ内の組み込みコードエディタと24時間対応のAIチューターでハンズオン演習できます。 これは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/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!
よくある質問
「イベント処理のためのGenEvent」レッスンは無料ですか？
はい。「イベント処理のためのGenEvent」の完全なテキストはこのウェブで無料で読めます。インタラクティブに演習し（組み込みコードエディタと24時間対応のAIチューター）、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時間対応のAIチューターがレッスンを進める中での質問に答えます。
Erlang OTP: Distributed & Fault-Tolerant Systems Programmingを始めるのに経験は必要ですか？
事前経験は必要ありません。CoddyKitのErlang OTP: Distributed & Fault-Tolerant Systems Programmingは初級者から上級者向けに構成されているため、ここから始めるか最初から始めて、自分のペースで進むことができます。 これはレッスン2/4です。
「イベント処理のためのGenEvent」レッスンにはどのくらい時間がかかりますか？
ほとんどのCoddyKitレッスンは約5～10分かかります。各レッスンはコンパクトでインタラクティブなので、着実に進歩し、ウェブとアプリ全体で正確に前回の場所から再開できます。
このErlang OTP: Distributed & Fault-Tolerant Systems Programmingレッスンでコードを書いて実行できますか？
はい。すべてのErlang OTP: Distributed & Fault-Tolerant Systems Programmingレッスンに組み込みコードエディタが含まれているため、ブラウザでリアルコードを書いて実行し、即座のAIフィードバックを取得できます。ローカル設定は不要です。
このコースのすべてのレッスン
- 状態管理のためのGenStatem
- イベント処理のためのGenEvent
- カスタムOTPビヘイビア
- ホットコードスワップとライブアップグレード