gen_event模块¶

回调函数:

gen_event module                   Callback module
----------------                   ---------------
gen_event:start
gen_event:start_link       ----->  -

gen_event:add_handler
gen_event:add_sup_handler  ----->  Module:init/1

gen_event:notify
gen_event:sync_notify      ----->  Module:handle_event/2

gen_event:call             ----->  Module:handle_call/2

-                          ----->  Module:handle_info/2

gen_event:delete_handler   ----->  Module:terminate/2

gen_event:swap_handler
gen_event:swap_sup_handler ----->  Module1:terminate/2
                                   Module2:init/1

gen_event:which_handlers   ----->  -

gen_event:stop             ----->  Module:terminate/2

-                          ----->  Module:code_change/3

add_handler/3¶

结构:

add_handler(EventMgrRef, Handler, Args) -> Result
类型:
EventMgrRef = Name | {Name,Node} | {global,GlobalName} | {via,Module,ViaName} | pid()
Handler = Module | {Module,Id}
Args = term()
Result = ok | {'EXIT',Reason} | term()
   Reason = term()

Handler:

Module: 回调模块
{Module,Id}: 当多个event handler用同一个回调模块时，用于指定event handler的唯一标识
Args: Module:init/1函数的传参

add_sup_handler/3¶

结构:

add_sup_handler(EventMgrRef, Handler, Args) -> Result
类型
EventMgrRef = Name | {Name,Node} | {global,GlobalName} | {via,Module,ViaName} | pid()
Handler = Module | {Module,Id}
Args = term()
Result = ok | {'EXIT',Reason} | term()

说明:

类似add_handler/3
不同:
  1.当调用进程以Reason原因终止时,
  event manager会用参数为{stop,Reason}的方法Module:terminate/2删除此event handler
  2.当event handler之后被删除时,
  event manager会发送消息{gen_event_EXIT,Handler,Reason}给调用进程
  其中,Reason有:
    normal
    shutdown
    {swapped,NewHandler,Pid}
    error()

call/3/4¶

结构:

call(EventMgrRef, Handler, Request) -> Result
call(EventMgrRef, Handler, Request, Timeout) -> Result
类型:
EventMgrRef = Name | {Name,Node} | {global,GlobalName} | {via,Module,ViaName} | pid()
   Name = Node = atom()
   GlobalName = ViaName = term()
Handler = Module | {Module,Id}
   Module = atom()
   Id = term()
Request = term()
Timeout = int()>0 | infinity
Result = Reply | {error,Error}
   Reply = term()
   Error = bad_module | {'EXIT',Reason} | term()
      Reason = term()

说明:

发送一个同步请求,等待返回值或超时发生
EventMgrRef, Handler: 参见add_handler/3
Request: 转发给handle_call函数
Timeout: 默认为5000
Result:
   {error, bad_module}: % If the specified event handler is not installed,
   {error, {'EXIT', Reason}}: % If the callback function fails with Reason
   {error, Term}: % If the callback function returns an unexpected value Term

delete_handler/3¶

结构:

delete_handler(EventMgrRef, Handler, Args) -> Result
类型:
EventMgrRef = Name | {Name,Node} | {global,GlobalName} | {via,Module,ViaName} | pid()
   Name = Node = atom()
   GlobalName = ViaName = term()
Handler = Module | {Module,Id}
   Module = atom()
   Id = term()
Args = term()
Result = term() | {error,module_not_found} | {'EXIT',Reason}

说明:

从事件管理EventMgrRef中删除event handler
Args: 此参数会传给Module:terminate/2的第1个参数
返回值: 是函数Module:terminate/2的返回值

Result:

{error,module_not_found}: 如果没有安装此handler
{'EXIT',Reason}: 如果回调函数失败

notify/2¶

参见sync_notify/2

sync_notify/2¶

结构:

notify(EventMgrRef, Event) -> ok
sync_notify(EventMgrRef, Event) -> ok
类型:
EventMgrRef = Name | {Name,Node} | {global,GlobalName} | {via,Module,ViaName} | pid()
Event = term()

说明:

event manager EventMgrRef会调用每个安装了此event的event handler
  的回调函数Module:handle_event/2
notify是异步请求,立即返回
sync_notify/2是同步请求,在所有的event handlers都处理完后返回ok

其他:

notify/1 does not fail even if the specified event manager does not exist,
   unless it is specified as Name.

which_handlers/1¶

结构:

which_handlers(EventMgrRef) -> [Handler]
类型:
EventMgrRef = Name | {Name,Node} | {global,GlobalName} | {via,Module,ViaName} | pid()
   Name = Node = atom()
   GlobalName = ViaName = term()
Handler = Module | {Module,Id}
   Module = atom()
   Id = term()

实例¶

terminal_logger.erl:

-module(terminal_logger).
-behaviour(gen_event).

-export([init/1, handle_event/2, terminate/2]).

init(_Args) ->
    {ok, []}.

handle_event(ErrorMsg, State) ->
    io:format("***Error*** ~p~n", [ErrorMsg]),
    {ok, State}.

terminate(_Args, _State) ->
    ok.

file_logger.erl:

-module(file_logger).
-behaviour(gen_event).

-export([init/1, handle_event/2, terminate/2]).

init(File) ->
    {ok, Fd} = file:open(File, read),
    {ok, Fd}.

handle_event(ErrorMsg, Fd) ->
    io:format(Fd, "***Error*** ~p~n", [ErrorMsg]),
    {ok, Fd}.

terminate(_Args, Fd) ->
    file:close(Fd).

启动:

// start_link通常用于supervisor监控树
// start通常用于单独的事件管理
1> gen_event:start({local, error_man}).
{ok,<0.31.0>}
// 此函数会调用terminal_logger:init([])
2> gen_event:add_handler(error_man, terminal_logger, []).
ok
// 对file_logger类事件来说, 会调用
// terminal_logger:init([])

增加handler:

3> gen_event:add_handler(error_man, file_logger, ["/tmp/file.txt"]).
// 会调用
// file_logger:init(["/tmp/file.txt"])

消息发送:

4> gen_event:notify(error_man, no_reply).
// 会调用回调函数
1.对terminal_logger:
handle_event(ErrorMsg, State) ->
  io:format("***Error*** ~p~n", [ErrorMsg]),
  {ok, State}.
2.对file_logger:
handle_event(ErrorMsg, Fd) ->
  io:format(Fd, "***Error*** ~p~n", [ErrorMsg]),
  {ok, Fd}.

删除handler:

5> gen_event:delete_handler(error_man, terminal_logger, []).
ok
6> gen_event:delete_handler(error_man, file_logger, []).
ok

停止:

> gen_event:stop(error_man).
ok

处理其他消息:

handle_info({'EXIT', Pid, Reason}, State) ->
  ..code to handle exits here..
  {ok, NewState}.

code_change(OldVsn, State, Extra) ->
  ..code to convert state (and more) during code change
  {ok, NewState}