<source id="4vppl"><ins id="4vppl"></ins></source>
<u id="4vppl"><sub id="4vppl"><label id="4vppl"></label></sub></u>
<object id="4vppl"></object>
  • <u id="4vppl"><li id="4vppl"><label id="4vppl"></label></li></u>

    <object id="4vppl"></object>
    <b id="4vppl"><sub id="4vppl"><tr id="4vppl"></tr></sub></b>

      <i id="4vppl"><thead id="4vppl"></thead></i>

      <thead id="4vppl"><li id="4vppl"><label id="4vppl"></label></li></thead>

      當前位置:首頁 > 網站舊欄目 > 學習園地 > 設計軟件教程 > Erlang:一個通用的網絡服務器

      Erlang:一個通用的網絡服務器
      2010-01-13 23:12:05  作者:  來源:
      前面幾篇文章里談到了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!
      安徽新華電腦學校專業職業規劃師為你提供更多幫助【在線咨詢
      国产午夜福三级在线播放_亚洲精品成a人片在线观看_亚洲自慰一区二区三区_久久棈精品久久久久久噜噜
      <source id="4vppl"><ins id="4vppl"></ins></source>
      <u id="4vppl"><sub id="4vppl"><label id="4vppl"></label></sub></u>
      <object id="4vppl"></object>
    1. <u id="4vppl"><li id="4vppl"><label id="4vppl"></label></li></u>

      <object id="4vppl"></object>
      <b id="4vppl"><sub id="4vppl"><tr id="4vppl"></tr></sub></b>

        <i id="4vppl"><thead id="4vppl"></thead></i>

        <thead id="4vppl"><li id="4vppl"><label id="4vppl"></label></li></thead>
        中文字幕精品免费 | 午夜福利波多野结衣黑人网站 | 中文字字幕在线中文乱码不 | 亚洲国产精品自产拍 | 亚洲欧美国产日韩综合久久 | 亚洲欧洲国产综合一 |