Docker本质

Erlang 封装的概念与实现

在 Erlang 中，封装主要通过 模块(module) 和 进程(process) 实现，体现函数式编程的核心思想：数据不可变性与行为隔离。以下是核心概念与实现方式：

---

一、封装的核心概念

1. 模块级封装

使用 `-export` 控制函数可见性

私有函数仅在模块内部可用

示例：仅公开接口函数，隐藏实现细节

erlang

-module(bank_account).

-export([create/0, deposit/3, withdraw/3]). % 公开接口

% 私有实现（外部不可访问）

validate_amount(Amount) when Amount > 0 -> true.

2. 进程级封装

每个进程维护独立状态

通过消息传递修改状态（遵守 Actor 模型）

状态存储在进程邮箱中，外部无法直接访问

3. 数据封装原则

所有数据通过函数参数传递

禁止全局可写状态

状态更新返回新副本（如 ETS 表、进程字典）

---

二、封装实现方式

#1. 基础模块封装

erlang

-module(geometry).

-export([area/1]). % 只暴露 area/1

% 私有函数（外部无法调用）

calculate_rectangle({rect, W, H}) -> W * H.

% 公开接口

area(Shape) ->

case Shape of

{circle, R} -> math:pi() * R * R;

{square, S} -> S * S;

Rect = {rect, _, _} -> calculate_rectangle(Rect)

end.

#2. 进程状态封装（典型 Actor 模式）

erlang

-module(counter).

-export([start/0, increment/1, get_value/1]).

start() ->

spawn(fun() -> loop(0) end). % 进程初始状态=0

loop(State) ->

receive

{increment, Pid} ->

NewState = State 1,

Pid ! {ok, NewState},

loop(NewState);

{get, Pid} ->

Pid ! {value, State},

loop(State)

end.

% 客户端接口

increment(CounterPid) ->

CounterPid ! {increment, self()},

receive {ok, _} -> ok end.

get_value(CounterPid) ->

CounterPid ! {get, self()},

receive {value, V} -> V end.

#3. 数据抽象（通过函数封装结构）

erlang

-module(person).

-export([new/2, get_name/1, get_age/1]).

% 结构隐藏：使用元组但对外透明

new(Name, Age) -> {person, Name, Age}.

get_name({person, Name, _}) -> Name.

get_age({person, _, Age}) -> Age.

% 使用示例：

% > P = person:new(Alice).

% > person:get_name(P). % 输出 n

---

三、封装的关键优势

1. 隔离性

模块错误不影响系统整体（放任崩溃）

进程崩溃通过监督树恢复

2. 并发安全

进程间无共享内存

消息传递是状态修改唯一途径

3. 热代码升级

封装允许运行时替换模块

状态进程可迁移到新版本

---

四、高级封装模式

1. 行为(behaviour)封装

如 `gen_server` 规范：

erlang

-module(my_server).

-behaviour(gen_server).

-export([init/1, handle_call/3]).

init(State) -> {ok, State}.

handle_call(get, _From, State) ->

{reply, State, State}. % 状态封装在回调中

2. 参数化模块（Erlang 特有）

erlang

-module(id_generator, [Seed]).

-export([next/0]).

next() -> Seed 1. % 隐式维护状态

---

总结

Erlang 的封装本质是 通过函数和消息传递控制访问边界：

- 模块是静态封装单元

- 进程是动态状态容器

- 遵守 共享数据，仅传递消息 原则

这种设计天然支持高并发和容错，是 Erlang 系统可靠性的基石。

Erlang 中的封装概念与实现

一、封装的核心概念

在 Erlang 中，封装主要通过以下方式实现：

1. 模块化设计

模块是 Erlang 的基本代码单元，通过导出函数控制接口访问权限：

erlang

-module(bank_account).

-export([create/0, deposit/2, withdraw/2]). % 公开接口

% 私有函数（仅模块内访问）

validate_amount(Amount) when Amount > 0 -> ok.

2. 数据隐藏

使用抽象数据类型（ADT）隐藏实现细节：

erlang

% bank_account.hrl

-record(account, {

id :: integer(),

balance :: float(),

history = [] :: list()

}).

二、封装实现模式

#1. 函数式封装

erlang

create() ->

#account{id = generate_id(), balance = 0.0}.

deposit(Account = #account{balance = B}, Amount) ->

case validate_amount(Amount) of

ok -> Account#account{balance = B Amount};

{error, Reason} -> {error, Reason}

end.

% 私有函数

generate_id() -> erlang:unique_integer([positive]).

#2. 进程封装（Actor 模型）

erlang

start() ->

spawn(fun() -> loop(#account{}) end).

loop(State) ->

receive

{deposit, Amount, Pid} ->

NewState = deposit(State, Amount),

Pid ! {ok, NewState},

loop(NewState);

{get_balance, Pid} ->

Pid ! {balance, State#account.balance},

loop(State)

end.

三、封装的关键特性

1. 访问控制

导出函数：公共 API

未导出函数：私有实现

头文件：通过 `.hrl` 文件定义数据结构

2. 不变性保障

Erlang 的数据不可变性天然支持封装：

erlang

% 修改操作返回新副本，原始数据不变

UpdatedAccount = Account#account{balance = NewBalance}

3. 类型规范

使用 Dialyzer 增强接口约束：

erlang

-spec withdraw(#account{}, float()) ->

{ok, #account{}} | {error, insufficient_funds}.

四、封装优势

1. 实现隔离

修改内部数据结构不影响调用方：

erlang

% 旧版本

-record(account_v1, {id, balance}).

% 新版本

-record(account_v2, {uuid, balance, currency}).

% 接口保持不变

deposit(Account, Amount) -> ...

2. 安全边界

进程封装提供内存隔离：

$$ text{进程A} xrightarrow{text{消息}} text{进程B} $$

错误不会跨进程传播

3. 热代码升级

封装支持运行时更新：

erlang

% 系统指令

code:load_file(bank_account). % 无需停止服务

五、最佳实践

1. 最小化接口

仅导出必要函数：

erlang

-export([start/0, stop/0, transfer/3]). % 严格限制

2. 行为规范

使用 `-callback` 定义抽象接口：

erlang

-behaviour(gen_server).

-callback handle_call(Request, From, State) ->

{reply, Reply, NewState}

3. 基于属性的测试

用 PropEr 验证封装完整性：

erlang

prop_deposit_invariant() ->

?FORALL(Account, account_gen(),

begin

NewAccount = deposit(Account, 100),

NewAccount#account.balance >= 0 % 不变式验证

end).

> 总结：Erlang 通过模块化、进程隔离和函数式范式实现高效封装，核心是控制接口暴露和保持数据不可变性。这种设计既满足封装需求，又符合 Erlang 的并发哲学，为构建高容错系统提供坚实基础。