[转]Erlang：一个通用的网络服务器

    前面几篇文章里谈到了Erlang的gen_tcp网络编程和Erlang/OPT的gen_server模块，现在让我们将它们两者绑定在一起

    大多数人认为“服务器”意味着网络服务器，但Erlang使用这个术语时表达的是更抽象的意义
    gen_serer在Erlang里是基于它的消息传递协议来操作的服务器，我们可以在此基础上嫁接一个TCP服务器，但这需要一些工作

    网络服务器的结构
    大部分网络服务器有相似的架构
    首先它们创建一个监听socket来监听接收的连接
    然后它们进入一个接收状态，在这里一直循环接收新的连接，直到结束（结束表示连接已经到达并开始真正的client/server工作）

    先看看前面网络编程里的echo server的例子：
    Java代码
    1. -module(echo). 
    2. -author('Jesse E.I. Farmer <jesse@20bits.com>'). 
    3. -export([listen/1]). 
    4.  
    5. -define(TCP_OPTIONS, [binary, {packet, 0}, {active, false}, {reuseaddr, true}]). 
    6.  
    7. % Call echo:listen(Port) to start the service. 
    8. listen(Port) -> 
    9.     {ok, LSocket} = gen_tcp:listen(Port, ?TCP_OPTIONS), 
    10.     accept(LSocket). 
    11.  
    12. % Wait for incoming connections and spawn the echo loop when we get one. 
    13. accept(LSocket) -> 
    14.     {ok, Socket} = gen_tcp:accept(LSocket), 
    15.     spawn(fun() -> loop(Socket) end), 
    16.     accept(LSocket). 
    17.  
    18. % Echo back whatever data we receive on Socket. 
    19. loop(Socket) -> 
    20.     case gen_tcp:recv(Socket, 0) of 
    21.         {ok, Data} -> 
    22.             gen_tcp:send(Socket, Data), 
    23.             loop(Socket); 
    24.         {error, closed} -> 
    25.             ok 
    26.     end. 

    你可以看到，listen会创建一个监听socket并马上调用accept
    accept会等待进来的连接，创建一个新的worker（loop）来处理真正的工作，然后等待下一个连接

    在这部分代码里，父进程拥有listen socket和accept loop两者
    后面我们会看到，如果我们集成accept/listen loop和gen_server的话这样做并不好

    抽象网络服务器
    网络服务器有两部分：连接处理和业务逻辑
    上面讲到，连接处理对每个网络服务器都是几乎一样的
    理想状态下我们可以这样做：
    Java代码
    1. -module(my_server). 
    2. start(Port) -> 
    3.   connection_handler:start(my_server, Port, businees_logic). 
    4.  
    5. business_logic(Socket) -> 
    6.   % Read data from the network socket and do our thang! 

    让我们继续完成它

    实现一个通用网络服务器
    使用gen_server来实现一个网络服务器的问题是，gen_tcp:accept调用是堵塞的
    如果我们在服务器的初始化例程里调用它，那么整个gen_server机制都会堵塞，直到客户端建立连接

    有两种方式来绕过这个问题
    一种方式为使用低级连接机制来支持非堵塞（或异步）accept
    有许多方法来支持这样做，最值得注意的是gen_tcp:controlling_process，它帮你管理当客户端建立连接时谁接受了什么消息

    我认为另一种比较简单而更优雅的方式是，一个单独的进程来监听socket
    该进程做两件事：监听“接收连接”消息以及分配新的接收器
    当它接收一条新的“接收连接”的消息时，就知道该分配新的接收器了

    接收器可以任意调用堵塞的gen_tcp:accept，因为它允许在自己的进程里
    当它接受一个连接后，它发出一条异步消息传回给父进程，并且立即调用业务逻辑方法

    这里是代码，我加了一些注释，希望可读性还可以：
    Java代码
    1. -module(socket_server). 
    2. -author('Jesse E.I. Farmer <jesse@20bits.com>'). 
    3. -behavior(gen_server). 
    4.  
    5. -export([init/1, code_change/3, handle_call/3, handle_cast/2, handle_info/2, terminate/2]). 
    6. -export([accept_loop/1]). 
    7. -export([start/3]). 
    8.  
    9. -define(TCP_OPTIONS, [binary, {packet, 0}, {active, false}, {reuseaddr, true}]). 
    10.  
    11. -record(server_state, { 
    12.         port, 
    13.         loop, 
    14.         ip=any, 
    15.         lsocket=null}). 
    16.  
    17. start(Name, Port, Loop) -> 
    18.     State = #server_state{port = Port, loop = Loop}, 
    19.     gen_server:start_link({local, Name}, ?MODULE, State, []). 
    20.  
    21. init(State = #server_state{port=Port}) -> 
    22.     case gen_tcp:listen(Port, ?TCP_OPTIONS) of 
    23.         {ok, LSocket} -> 
    24.             NewState = State#server_state{lsocket = LSocket}, 
    25.             {ok, accept(NewState)}; 
    26.         {error, Reason} -> 
    27.             {stop, Reason} 
    28.     end. 
    29.  
    30. handle_cast({accepted, _Pid}, State=#server_state{}) -> 
    31.     {noreply, accept(State)}. 
    32.  
    33. accept_loop({Server, LSocket, {M, F}}) -> 
    34.     {ok, Socket} = gen_tcp:accept(LSocket), 
    35.     % Let the server spawn a new process and replace this loop 
    36.     % with the echo loop, to avoid blocking 
    37.     gen_server:cast(Server, {accepted, self()}), 
    38.     M:F(Socket). 
    39.     
    40. % To be more robust we should be using spawn_link and trapping exits 
    41. accept(State = #server_state{lsocket=LSocket, loop = Loop}) -> 
    42.     proc_lib:spawn(?MODULE, accept_loop, [{self(), LSocket, Loop}]), 
    43.     State. 
    44.  
    45. % These are just here to suppress warnings. 
    46. handle_call(_Msg, _Caller, State) -> {noreply, State}. 
    47. handle_info(_Msg, Library) -> {noreply, Library}. 
    48. terminate(_Reason, _Library) -> ok. 
    49. code_change(_OldVersion, Library, _Extra) -> {ok, Library}. 

    我们使用gen_server:cast来传递异步消息给监听进程，当监听进程接受accepted消息后，它分配一个新的接收器

    目前，这个服务器不是很健壮，因为如果无论什么原因活动的接收器失败以后，服务器会停止接收新的连接
    为了让它变得更像OTP，我们因该捕获异常退出并且在连接失败时分配新的接收器

    一个通用的echo服务器
    echo服务器是最简单的服务器，让我们使用我们新的抽象socket服务器来写它:
    Java代码
    1. -module(echo_server). 
    2. -author('Jesse E.I. Farmer <jesse@20bits.com>'). 
    3.  
    4. -export([start/0, loop/1]). 
    5.  
    6. % echo_server specific code 
    7. start() -> 
    8.     socket_server:start(?MODULE, 7000, {?MODULE, loop}). 
    9. loop(Socket) -> 
    10.     case gen_tcp:recv(Socket, 0) of 
    11.         {ok, Data} -> 
    12.             gen_tcp:send(Socket, Data), 
    13.             loop(Socket); 
    14.         {error, closed} -> 
    15.             ok 
    16.     end. 

    你可以看到，服务器只含有自己的业务逻辑
    连接处理被封装到socket_server里面
    而这里的loop方法也和最初的echo服务器一样

    希望你可以从中学到点什么，我觉得我开始理解Erlang了

    欢迎回复，特别关于是如何改进我的代码，cheers！ 
【推广】 免费学中医，健康全家人
原文地址：https://www.cnblogs.com/freebird92/p/2302392.html