OTP设计原则学习笔记（1）

 

1、概述

OTP设计原则，是对编写进程、模块、目录等结构化程序代码的一般要求。

1.1 监管树（Supervision Trees）

Erlang/OTP的一个基本概念是监督管理树。它是结构化进程的模型，它的理论基础是“执行人”和“监管人”的监管执行机制。

● 执行人是从事实际运算工作的进程。

● 监管人是监督管理执行人具体工作的进程。发生执行错误，监管人可以命令执行人重新开始工作。

● 监管树把监管人与执行人的关系，组织成分层有序的结构，具有容错机制。

1.2 行为（Behaviours）

监督树中的许多进程，结构相同，模式相同。例如，监督人的结构十分相似，唯一的区别是其监管着不同的子进程。同样，许多执行人的工作是向客户提供服务，或者，充当有限状态机，以及事件处理器譬如书写差错日志。

行为的概念，是对上述工作模式的进一步抽象。目的是为了把进程代码分成2部分，一般属性（行为模块）和具体行动（响应模块）。

行为模块是Erlang/OTP的组成部分。为了实现进程，如监管人，程序员必须实现行动模块，导出预定义的响应函数。

下面的例子，把进程代码分成了2部分：一个简单的服务器，跟踪着许多“通道”。其他进程可以调用函数alloc/0或free/1，分配或释放这些通道。

-module(ch1).

-export([start/0]).

-export([alloc/0, free/1]).

-export([init/0]).

start() ->

    spawn(ch1, init, []).

alloc() ->

    ch1 ! {self(), alloc},

    receive

        {ch1, Res} ->

            Res

    end.

free(Ch) ->

    ch1 ! {free, Ch},

    ok.

init() ->

    register(ch1, self()),

    Chs = channels(),

    loop(Chs).

loop(Chs) ->

    receive

        {From, alloc} ->

            {Ch, Chs2} = alloc(Chs),

            From ! {ch1, Ch},

            loop(Chs2);

        {free, Ch} ->

            Chs2 = free(Ch, Chs),

            loop(Chs2)

    end.

服务器的代码，作为一般属性部分，可以写入文件server.erl: 

-module(server).

-export([start/1]).

-export([call/2, cast/2]).

-export([init/1]).

start(Mod) ->

    spawn(server, init, [Mod]).

call(Name, Req) ->

    Name ! {call, self(), Req},

    receive

        {Name, Res} ->

            Res

    end.

cast(Name, Req) ->

    Name ! {cast, Req},

    ok.

init(Mod) ->

    register(Mod, self()),

    State = Mod:init(),

    loop(Mod, State).

loop(Mod, State) ->

    receive

        {call, From, Req} ->

            {Res, State2} = Mod:handle_call(Req, State),

            From ! {Mod, Res},

            loop(Mod, State2);

        {cast, Req} ->

            State2 = Mod:handle_cast(Req, State),

            loop(Mod, State2)

    end.

第二部分是响应模块 ch2.erl: 

-module(ch2).

-export([start/0]).

-export([alloc/0, free/1]).

-export([init/0, handle_call/2, handle_cast/2]).

start() ->

    server:start(ch2).

alloc() ->

    server:call(ch2, alloc).

free(Ch) ->

    server:cast(ch2, {free, Ch}).

init() ->

    channels().

handle_call(alloc, Chs) ->

    alloc(Chs). % => {Ch,Chs2}

handle_cast({free, Ch}, Chs) ->

    free(Ch, Chs). % => Chs2

注意：

● 上述服务器代码，可用于建设许多不同类型的服务器；

● 例中服务器的名字ch2，对于其服务对象的函数是看不到的，因此，可以改变名字；

● 服务器收发消息的协议，也是调用它的函数不知道的。这是好的编程习惯，它让我们用接口函数改变协议。

● 我们可以扩展server.erl中函数的功能，而不必修改ch2.erl和其他响应模块。

（在ch1.erl和ch2.erl中，有意忽视函数channels/0, alloc/1 和free/2，似乎它们可有可无。其实，完整的函数在后面。这里只是个示例，而实际的程序必须能够处理复杂情况，如分配完成任务的通道，等等。）

channels() ->

   {_Allocated = [], _Free = lists:seq(1,100)}.

alloc({Allocated, [H|T] = _Free}) ->

   {H, {[H|Allocated], T}}.

free(Ch, {Alloc, Free} = Channels) ->

   case lists:member(Ch, Alloc) of

      true ->

         {lists:delete(Ch, Alloc), [Ch|Free]};

      false ->

         Channels

   end.        

不用行为模式的程序代码可能效率更高，但总体代价也大。十分重要的是，要在系统中统一管理全部应用程序。

使用行为模式，有利于程序代码易读易懂。执行效率高的代码，往往难以看懂。

模块server.erl，类似Erlang/OTP 的行为模式 gen_server，但做了极大简化。 

Erlang/OTP的标准行为模式包括：

gen_server 

    实现client-server关系中的服务器；

gen_fsm 

    实现有限状态机；

gen_event 

    实现事件处理功能；

supervisor 

    在监管树中实现监管人。

如果定义了 -behaviour(Behaviour) 而没有定义响应函数，编译器会发出警告：

-module(chs3).

-behaviour(gen_server).

...

3> c(chs3).

./chs3.erl:10: Warning: undefined call-back function handle_call/3

{ok,chs3}

1.3 代码部件applications

Erlang/OTP有许多代码部件，分别实现特定功能。这些部件的术语叫applications，如Mnesia、Debugger。在Erlang/OTP 基础之上建立的最小系统，其applications是Kernel 和 STDLIB。

应用程序的概念有2层含义，程序结构（进程）和目录结构（模块）。

最简单的应用程序没有进程，只有一些函数组成的模块。它就是库程序，例如STDLIB。

应用程序最简单的实现，是用标准的行为模式，做成监管树。

如何具体编程，后面会讲。

1.4 发布的版本

发布的版本，是指由Erlang/OTP的系统子程序发展出来的、结合用户提供的应用程序组成的完整系统。

如何编制发行的版本，后面会讲。

如何在大型环境中安装发布的版本，后面会讲。

1.5 版本管理

版本管理，是指在发布版本之间的升级（更新）和降级（复旧）。具体如何做，后面会讲。