服务端实现

-module(server1).
-export([start/2, rpc/2]).%% 启动服务
start(Name, Mod) ->%% 注册进程名为Name, 并在启动进程时完成模块Mod的初始化并在调用loop进行监测register(Name, spawn(fun() ->loop(Name, Mod, Mod:init()) end)).%% 远程调用
rpc(Name, Request) ->%% 向指定的进程发送请求, 使用self()获得自身的Pid, 用于识别请求者Name ! {self(), Request},receive%% 接收到处理结果后输出{Name, Response} ->Responseend.loop(Name, Mod, State) ->receive%% 接收到请求后的处理{From, Request} ->%% 调用Mod的handle函数进行处理{Response, State1} = Mod:handle(Request, State),%% 将处理结果发送给请求者From ! {Name, Response},loop(Name, Mod, State1)end.

回调程序实现

-module(name_server).
-import(server1, [rpc/2]).
-export([init/0, add/2, whereis/1, handle/2]).%% 对外提供的功能函数, 会通过远程调用向指定的服务名发送请求
add(Name, Place) ->rpc(name_server, {add, Name, Place}).
whereis(Name)    ->rpc(name_server, {whereis, Name}).%% 模块初始化, 创建新的字典
init() ->dict:new().%% 处理函数, 添加和查询
handle({add, Name, Place}, Dict) ->{ok, dict:store(Name, Place, Dict)};
handle({whereis, Name}, Dict)    ->{dict:find(Name, Dict), Dict}.

运行结果

1> c(server1).
{ok,server1}
2> c(name_server).
{ok,name_server}
3> server1:start(name_server, name_server).
true
4> name_server:add(joe, "at home").
ok
5> name_server:whereis(joe).
{ok,"at home"}

处理流程:

1. server1:start(name_server, name_server).
启动进程, 完成name_server模块的初始化, 指定使用name_server的handle函数处理请求, 最后将进程注册为name_server2. name_server:add(joe, "at home").
功能函数相当于是一个接口, 将数据封装为{add, joe, "at home"}格式, 调用rpc提交请求3. rpc(Name, Request)Name ! {self(), Request}
获取自身进程ID后将数据发送给name_server进程4. loop(Name, Mod, State)
{Response, State1} = Mod:handle(Request, State)
接收到请求后调用name_server:handle处理请求5. handle({add, Name, Place}, Dict)
回调函数, 相当于接口的具体实现, 向字典中添加数据6. loop(Name, Mod, State)
From ! {Name, Response}
将处理结果发送给请求者7. rpc(Name, Request)
{Name, Response} -> Response
打印处理结果

服务端实现

-module(server2).
-export([start/2, rpc/2]).%% 启动服务
start(Name, Mod) ->%% 注册进程名为Name, 并在启动进程时完成模块Mod的初始化并在调用loop进行监测register(Name, spawn(fun() ->loop(Name, Mod, Mod:init()) end)).%% 远程调用
rpc(Name, Request) ->%% 向指定的进程发送请求, 使用self()获得自身的Pid, 用于识别请求者Name ! {self(), Request},receive%% 添加了出错处理{Name, crash}        ->exit(rpc);%% 接收到处理结果后输出{Name, ok, Response} ->Responseend.loop(Name, Mod, OldState) ->receive%% 接收到请求后的处理{From, Request} ->%% 对Mod的handle函数调用添加异常处理try Mod:handle(Request, OldState) of{Response, NewState} ->From ! {Name, ok, Response},loop(Name, Mod, NewState)catch_:Why ->%% 发生异常则打印异常信息log_the_error(Name, Request, Why),From ! {Name, crash},%% 保留旧的状态loop(Name, Mod, OldState)endend.log_the_error(Name, Request, Why) ->io:format("Server ~p request ~p ~n caused exception ~p~n", [Name, Request, Why]).

在服务端添加了替换代码的函数

swap_code(Name, Mod) ->rpc(Name, {swap_code, Mod}).loop(Name, Mod, OldState) ->receive{From, {swap_code, NewCallBackMod}} ->From ! {Name, ack},%% 改变loop循环用于处理请求的模块loop(Name, NewCallBackMod, OldState);{From, Request} ->{Response, NewState} = Mod:handle(Request, OldState),From ! {Name, Response},loop(Name, Mod, NewState)end.

运行结果:

1> server3:start(name_server, name_server1).
true
2> name_server1:add(joe, "at home").
ok
3> name_server1:add(helen, "at work").
ok
4> c(new_name_server).
{ok,new_name_server}
5> server3:swap_code(name_server, new_name_server).
ack
6> new_name_server:all_names().
[joe,helen]
7> new_name_server:delete(joe).
ok
8> new_name_server:all_names().
[helen]
9> new_name_server:whereis(helen).
{ok,"at work"}

显然, 将server2中的异常捕获处理添加到server3中即可。

空服务器的实现

-module(server5).
-export([start/0, rpc/2]).%% 启动进程
start() ->spawn(fun() ->wait() end).%% 等待接收指令成为某种服务
wait() ->receive{become, F} ->F()end.%% 远程调用
rpc(Pid, Q) ->%% 由服务进程处理请求Pid ! {self(), Q},receive%% 打印处理结果{Pid, Reply} ->Replyend.

具体服务的一个实现

-module(my_fac_server).
-export([loop/0]).%% 阶乘服务
loop() ->receive%% 可以接收数字计算其阶乘{From, {fac, N}} ->From ! {self(), fac(N)},loop();%% 也可以变成另外一种服务{become, Something} ->Something()end.fac(0) ->1;
fac(N) ->N * fac(N-1).

运行结果:

1> c(server5).
{ok,server5}
2> Pid = server5:start().
<0.52.0>
3> c(my_fac_server).
{ok,my_fac_server}
4> Pid ! {become, fun my_fac_server:loop/0}.
{become,#Fun<my_fac_server.loop.0>}
5> server5:rpc(Pid, {fac, 30}).
265252859812191058636308480000000

运行流程:

1. 启动进程, 等待接收指令成为某种服务
Pid = server5:start().
start() -> spawn(fun() -> wait() end).2. 接收指令, 成为可以计算阶乘的服务
Pid ! {become, fun my_fac_server:loop/0}. 3. 服务调用
server5:rpc(Pid, {fac, 30}).4. rpc(Pid, Q)
%% 由服务进程处理请求
Pid ! {self(), Q} 5. 处理请求
loop() ->receive{From, {fac, N}} ->From ! {self(), fac(N)}...
6. 接收结果并输出
rpc(Pid, Q)receive{Pid, Reply} -> Replyend.

模拟支付系统, 模块命名为my_bank

%% 启动本地服务器
%% gen_server:start_link({local, Name}, Mod, _)
start() ->gen_server:start_link({local, ?MODULE}, ?MODULE, [], []).%% 远程调用
%% gen_server:call(Name, Term)
stop()  ->gen_server:call(?MODULE, stop).%% 开一个新账户
new_account(Who)      ->gen_server:call(?MODULE, {new, Who}).
%% 存钱
deposit(Who, Amount)  ->gen_server:call(?MODULE, {add, Who, Amount}).
%% 取钱
withdraw(Who, Amount) ->gen_server:call(?MODULE, {remove, Who, AMount}).

%% init([]) -> {ok, State}
%% 必须实现的回调函数, 用于模块初始化
%% 这里返回一个ETS表
init([]) ->{ok, ets:new(?MODULE, [])}.%% handle_call(_Request, _From, State) -> {reply, Reply, State}
%% 必须实现的回调函数, 用于gen_server:call时回调使用%% 添加用户
handle_call({new, Who}, _From, Tab) ->%% 查询ETS表中相关用户是否存在%% 不存在则插入ETS表并提示欢迎信息%% 存在则提示已经存在此用户Reply = case ets:lookup(Tab, Who) of[]  ->ets:insert(Tab, {Who, 0}),{welcome, Who};[_] ->{Who, you_already_are_a_customer}end,{reply, Reply, Tab};%% 用户存钱
handle_call({add, Who, X}, _From, Tab) ->%% 首先查询用户是否存在%% 存在则将存款累加后重新插入ETS表并给出提示信息Reply = case ets:lookup(Tab, Who) of[] ->not_a_customer;[{Who, Balance}] ->NewBalance = Balance + X,ets:insert(Tab, {Who, NewBalance}),{thanks, Who, your_balance_is, NewBalance}end,{reply, Reply, Tab};%% 用户取钱
handle_call({remove, Who, X}, _From, Tab) ->%% 首先查询用户是否存在%% 存在则根据取款与存款的大小关系分别处理Reply = case ets:lookup(Tab, Who) of[] ->not_a_customer;[{Who, Balance}] when X =< Balance ->NewBalance = Balance - X,ets:insert(Tab, {Who, NewBalance}),{thanks, Who, your_balance_is, NewBalance};[{Who, Balance}] ->{sorry, Who, you_only_have, Balance, in_the_bank}end,{reply, Reply, Tab};%% 停止服务
handle_call(stop, _From, Tab) ->{stop, normal, stopped, Tab}.%% 其它必须实现的回调函数
handle_cast(_Msg, State) ->{noreply, State}.
handle_info(_Info, State) ->{noreply, State}.
terminate(_Reason, _State) ->ok.
code_change(_OldVsn, State, Extra) ->{ok, State}.

运行结果:

1> my_bank:start().
{ok,<0.70.0>}
2> my_bank:deposit("joe", 10).
not_a_customer
3> my_bank:new_account("joe").
{welcome,"joe"}
4> my_bank:deposit("joe", 10).
{thanks,"joe",your_balance_is,10}
5> my_bank:deposit("joe", 30).
{thanks,"joe",your_balance_is,40}
6> my_bank:withdraw("joe", 15).
{thanks,"joe",your_balance_is,25}
7> my_bank:withdraw("joe", 45).
{sorry,"joe",you_only_have,25,in_the_bank}
8> my_bank:stop().
stopped

%% 通过start_link启动
%% 创建名为Name的通用服务器程序
%% 回调模块为Mod
%% Opts控制服务器程序的行为
%% 调用Mod:init(InitArgs)启动服务器程序 
gen_server:start_link(Name, Mod, InitArgs, Opts)

%% 通过call调用服务端程序
%% 最终会调用回调模块中的handle_call/3函数 
gen_server:call(Name, Request)%% Request 请求信息
%% From    发起调用的客户端进程ID
%% State   客户端当前状态
Mod:handle_call(Request, From, State)

%% 通过cast实现通知
%% 最终会调用回调模块中的handle_cast/2函数 
gen_server:cast(Name, Name)%% Msg   发送的消息
%% State 状态 
Mod:handle_cast(Msg, State)

%% 接收其它进程或系统发送的消息 
Mod:handle_info(Info, State)

%% 这个标题, Joe真有点意思:）
Mod:terminate(Reason, NewState)

code_change(OldVsn, State, Extra)