Erlang行为 #

-module(my_behaviour).
-callback init(Args :: term()) -> {ok, State :: term()} | {error, Reason :: term()}.
-callback handle_request(Request :: term(), State :: term()) -> 
    {reply, Reply :: term(), NewState :: term()} |
    {noreply, NewState :: term()} |
    {stop, Reason :: term(), NewState :: term()}.
-callback terminate(Reason :: term(), State :: term()) -> ok.

-module(my_behaviour_impl).
-behaviour(my_behaviour).
-export([init/1, handle_request/2, terminate/2]).

init(Args) ->
    {ok, #{args => Args}}.

handle_request({get, Key}, State) ->
    {reply, maps:get(Key, State, undefined), State};
handle_request({set, Key, Value}, State) ->
    {reply, ok, State#{Key => Value}}.

terminate(_Reason, _State) ->
    ok.

-module(my_gen_server).
-behaviour(gen_server).
-export([start_link/0, stop/0, get_state/0, set_value/2]).
-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, [], []).

stop() ->
    gen_server:stop(?MODULE).

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

set_value(Key, Value) ->
    gen_server:cast(?MODULE, {set_value, Key, Value}).

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

handle_call(get_state, _From, State) ->
    {reply, State, State};
handle_call({get, Key}, _From, State) ->
    {reply, maps:get(Key, State, undefined), State};
handle_call(_Request, _From, State) ->
    {reply, {error, unknown_request}, State}.

handle_cast({set_value, Key, Value}, State) ->
    {noreply, State#{Key => Value}};
handle_cast(_Request, State) ->
    {noreply, State}.

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

terminate(_Reason, _State) ->
    ok.

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

-module(my_statem).
-behaviour(gen_statem).
-export([start_link/0, connect/0, disconnect/0, send_data/1]).
-export([init/1, callback_mode/0, terminate/3, code_change/4]).
-export([idle/3, connected/3]).

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

connect() ->
    gen_statem:call(?MODULE, connect).

disconnect() ->
    gen_statem:cast(?MODULE, disconnect).

send_data(Data) ->
    gen_statem:cast(?MODULE, {send_data, Data}).

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

callback_mode() -> state_functions.

idle({call, From}, connect, State) ->
    {next_state, connected, State, [{reply, From, ok}]};
idle(_, _, State) ->
    {keep_state, State}.

connected(cast, disconnect, State) ->
    {next_state, idle, State};
connected(cast, {send_data, Data}, State) ->
    io:format("Sending: ~p~n", [Data]),
    {keep_state, State};
connected(_, _, State) ->
    {keep_state, State}.

terminate(_Reason, _State, _Data) ->
    ok.

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

-module(my_event_handler).
-behaviour(gen_event).
-export([init/1, handle_event/2, handle_call/2, terminate/2]).

init(Args) ->
    {ok, #{args => Args}}.

handle_event({log, Message}, State) ->
    io:format("Log: ~p~n", [Message]),
    {ok, State};
handle_event({error, Error}, State) ->
    io:format("Error: ~p~n", [Error]),
    {ok, State};
handle_event(_, State) ->
    {ok, State}.

handle_call(get_state, State) ->
    {ok, State, State};
handle_call(_, State) ->
    {ok, {error, unknown_call}, State}.

terminate(_Reason, _State) ->
    ok.

-module(event_manager).
-export([start/0, add_handler/1, notify/1]).

start() ->
    gen_event:start_link({local, my_event_manager}).

add_handler(Handler) ->
    gen_event:add_handler(my_event_manager, Handler, []).

notify(Event) ->
    gen_event:notify(my_event_manager, Event).

-module(my_supervisor).
-behaviour(supervisor).
-export([start_link/0, init/1]).

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

init([]) ->
    Children = [
        #{id => my_gen_server,
          start => {my_gen_server, start_link, []},
          restart => permanent,
          shutdown => 5000,
          type => worker,
          modules => [my_gen_server]}
    ],
    {ok, {#{strategy => one_for_one, intensity => 1, period => 5}, Children}}.

#{id => ChildId,
  start => {Module, Function, Args},
  restart => permanent | transient | temporary,
  shutdown => brutal_kill | integer() | infinity,
  type => worker | supervisor,
  modules => [Module] | dynamic}

my_app/
├── src/
│   ├── my_app.app.src
│   ├── my_app_app.erl
│   └── my_app_sup.erl
├── ebin/
├── priv/
└── test/

{application, my_app,
 [{description, "My Erlang Application"},
  {vsn, "1.0.0"},
  {registered, []},
  {mod, {my_app_app, []}},
  {applications,
   [kernel,
    stdlib
   ]},
  {env,[]},
  {modules, [my_app_app, my_app_sup]},
  {licenses, ["MIT"]},
  {links, []}
 ]}.

-module(my_app_app).
-behaviour(application).
-export([start/2, stop/1]).

start(_Type, _Args) ->
    my_app_sup:start_link().

stop(_State) ->
    ok.

-module(cache_behaviour).
-callback init(Options :: term()) -> {ok, State :: term()} | {error, Reason :: term()}.
-callback get(Key :: term(), State :: term()) -> {ok, Value :: term()} | not_found.
-callback put(Key :: term(), Value :: term(), State :: term()) -> {ok, NewState :: term()}.
-callback delete(Key :: term(), State :: term()) -> {ok, NewState :: term()}.
-callback terminate(State :: term()) -> ok.

-module(map_cache).
-behaviour(cache_behaviour).
-export([init/1, get/2, put/3, delete/2, terminate/1]).

init(_Options) ->
    {ok, #{}}.

get(Key, State) ->
    case maps:find(Key, State) of
        {ok, Value} -> {ok, Value};
        error -> not_found
    end.

put(Key, Value, State) ->
    {ok, State#{Key => Value}}.

delete(Key, State) ->
    {ok, maps:remove(Key, State)}.

terminate(_State) ->
    ok.