01.3.2.6 适配器模式
所属:全栈开发面试题库 / 01 计算机基础与通用工程 / 01.3 设计模式与架构基础 / 01.3.2 常用设计模式多语言详解
覆盖范围
- 适配器的意图、三个角色与适用边界
- 类适配器(继承)与对象适配器(组合)的取舍
- Go / Rust / TypeScript 偏好对象适配的语言根因
- 双向适配器与双向接口转换
- 防腐层(Anti-Corruption Layer, ACL)与第三方 SDK 隔离
- Java
InputStreamReader字节流到字符流的适配实例 - Go
io.Reader/io.Writer接口的组合与适配 - Rust newtype 与
From/Into的零成本适配 - TypeScript 类型适配与 schema(如 Zod)转换
- PHP 适配器与 Laravel Facade 的本质区别
- C# 接口适配与
HttpClient包装 - 适配器与外观、代理、装饰器的区分
- 适配器滥用的信号与领域模型反思
面试题索引
| 编号 | 题目 | 难度 | 状态 | 备注 |
|---|---|---|---|---|
| 01.3.2.6-001 | 适配器解决什么问题?类适配器与对象适配器怎么选? | 基础 | 已完成 | 意图与角色 |
| 01.3.2.6-002 | 为什么 Go / Rust / TypeScript 几乎只用对象适配器? | 进阶 | 已完成 | 语言机制 |
| 01.3.2.6-003 | 双向适配器什么时候才需要?怎么实现? | 进阶 | 已完成 | 双向转换 |
| 01.3.2.6-004 | 防腐层(ACL)和适配器是什么关系?怎么隔离第三方 SDK? | 进阶 | 已完成 | DDD 上下文 |
| 01.3.2.6-005 | Java 的 InputStreamReader 怎么体现适配器? | 进阶 | 已完成 | JDK 实例 |
| 01.3.2.6-006 | Go 的 io.Reader / io.Writer 接口如何被适配? | 进阶 | 已完成 | 鸭子类型 |
| 01.3.2.6-007 | Rust 的 newtype 与 From / Into 怎么做适配? | 高级 | 已完成 | 类型系统 |
| 01.3.2.6-008 | TypeScript 的类型适配与 schema 转换怎么做? | 进阶 | 已完成 | Zod 等 |
| 01.3.2.6-009 | PHP 适配器与 Laravel Facade 有什么区别? | 进阶 | 已完成 | 框架语义 |
| 01.3.2.6-010 | C# 怎么用接口适配包装 HttpClient? | 进阶 | 已完成 | 基础设施 |
| 01.3.2.6-011 | 适配器、外观、代理、装饰器怎么一句话区分? | 基础 | 已完成 | 结构型辨析 |
| 01.3.2.6-012 | 适配器滥用有哪些信号? | 高级 | 已完成 | 领域反思 |
| 01.3.2.6-013 | 适配器里要不要放业务逻辑?边界在哪? | 进阶 | 已完成 | 职责边界 |
01.3.2.6-001 适配器解决什么问题?类适配器与对象适配器怎么选?
一句话结论
适配器把一个已有接口转换成使用方期望的接口,在不改既有代码的前提下让接口不兼容的类协同工作;类适配器靠继承、对象适配器靠组合,现代代码几乎一律选对象适配器。
概念解释
- 目标接口(Target):使用方期望的接口。
- 适配者(Adaptee):已有但签名不匹配的类或第三方 SDK。
- 适配器(Adapter):实现目标接口,内部调用适配者。
- 类适配器:同时继承适配者并实现目标接口,靠复用父类方法。
- 对象适配器:持有适配者实例,在方法里做参数转换后委托调用。
原理流程
- 识别使用方期望的接口与已有类接口之间的差距。
- 判断差距是签名、参数、返回值还是异常模型。
- 写适配器做一对一映射;类适配器只能适配可被继承的具体类。
- 上层只依赖目标接口,不感知适配者存在。
代码或图示
// 目标接口
public interface Payment { void pay(BigDecimal amount); }
// 已有第三方 SDK(接口不匹配)
public class ThirdPartyGateway {
public String charge(String yuan) { return "ok"; }
}
// 对象适配器(推荐)
public class GatewayAdapter implements Payment {
private final ThirdPartyGateway gw = new ThirdPartyGateway();
public void pay(BigDecimal amount) {
gw.charge(amount.toPlainString());
}
}
类适配器:Adapter extends Adaptee implements Target
—— 靠继承,不能适配 final 类、也不能适配被 final 方法锁死的接口
对象适配器:Adapter holds Adaptee and implements Target
—— 靠组合,可包装任何实现,运行期可换适配者
常见误区
- 把适配器当「新功能入口」:适配器只做接口转换,不应承载业务规则。
- 类适配器可以多继承适配者:Java / C# 单继承下类适配器只能适配一个父类,而对象适配器可持有多个适配者。
- 认为适配器一定要「包住」第三方类:适配者也可以是本地旧模块,只要接口与新期望不一致就适配。
追问
- 类适配器唯一的优势是什么?答:可以重写父类的个别方法,在不持有实例的情况下微调行为;但现代语言几乎都不选这条路。
- 对象适配器怎么处理适配者构造昂贵?答:把适配者通过构造器注入,由工厂或容器管理生命周期,不要在适配器内部
new。
01.3.2.6-002 为什么 Go / Rust / TypeScript 几乎只用对象适配器?
一句话结论
Go 没有继承、Rust 没有类继承、TypeScript 也只支持接口继承,类适配器依赖的「同时继承适配者并实现目标接口」在这些语言里根本不成立;再加上组合在运行期更灵活,对象适配器就成了唯一选择。
概念解释
- Go:结构体通过嵌入组合,接口靠隐式实现,没有
extends。 - Rust:用 trait 做接口、用 newtype 包装,没有类继承,trait 不能为外部类型实现(孤儿规则)。
- TypeScript:
class extends只能继承一个类,且接口只声明不实现,类适配器的双继承结构很难写。 - 三者共同偏好组合:持有一个字段引用,比改继承层级更可控。
原理流程
- 定义目标接口(Go 的 interface、Rust 的 trait、TS 的 interface)。
- 在适配器类型里持有适配者实例。
- 每个目标方法内部做参数转换后调用适配者。
- 需要切换适配者时只换构造器传入的实例。
代码或图示
// Go:目标接口 + 持有适配者
type Payment interface {
Pay(amount float64) error
}
type AliSDK struct{}
func (a *AliSDK) Charge(yuan string) error { return nil }
type AliAdapter struct {
sdk *AliSDK
}
func (x *AliAdapter) Pay(amount float64) error {
return x.sdk.Charge(strconv.FormatFloat(amount, 'f', 2, 64))
}
// Rust:newtype + 持有适配者
struct AliSDK;
impl AliSDK {
fn charge(&self, yuan: &str) -> Result<(), String> { Ok(()) }
}
trait Payment {
fn pay(&self, amount: f64) -> Result<(), String>;
}
struct AliAdapter(AliSDK);
impl Payment for AliAdapter {
fn pay(&self, amount: f64) -> Result<(), String> {
self.0.charge(&format!("{:.2}", amount))
}
}
// TypeScript:对象适配器
interface Payment { pay(amount: number): Promise<void>; }
class AliSDK { async charge(yuan: string): Promise<void> {} }
class AliAdapter implements Payment {
constructor(private sdk: AliSDK = new AliSDK()) {}
async pay(amount: number): Promise<void> {
await this.sdk.charge(amount.toFixed(2));
}
}
常见误区
- 以为 Go 嵌入接口等于类适配器:嵌入是字段组合,不是继承;被嵌入接口的方法集被提升,但实现仍然是组合语义。
- Rust 里为外部类型直接
impl Trait for ExternalType:受孤儿规则限制,必须用 newtype 包一层。 - TypeScript 用
extends AliSDK implements Payment:看似类适配器,但只能继承一个类,且 AliSDK 的私有状态会被一并继承,运行期不易替换。
追问
- Go 里怎么同时适配多个 SDK?答:一个适配器持有多个适配者字段,或按策略选择其中一个;不要靠继承拼。
- Rust 的 newtype 有运行时开销吗?答:
struct AliAdapter(AliSDK)在 Rust 里是零成本抽象,编译后与内部类型同布局。
01.3.2.6-003 双向适配器什么时候才需要?怎么实现?
一句话结论
当系统 A 要按 A 的接口被调用、系统 B 要按 B 的接口被调用,而两边都不能改时,双向适配器同时实现两个接口、内部互相映射;它是过渡形态,不应长期存在。
概念解释
- 双向适配器:同时实现 Target 与 Adaptee 两个接口。
- 适用场景:遗留系统与新系统互相调用、协议转换网关、测试替身需要同时扮演两边。
- 不适用场景:单向调用链,写两个单向适配器即可。
原理流程
- 确认两边都需要「被对方接口调用」。
- 写一个类同时实现两个接口。
- 每个方法把参数按对面的语义转换后调用另一侧。
- 长期看应推动其中一侧统一接口,消除双向。
代码或图示
// 老系统接口
public interface LegacyOrder { String getOrderId(); }
// 新系统接口
public interface ModernOrder { String id(); }
// 双向适配器
public class OrderAdapter implements LegacyOrder, ModernOrder {
private final String id;
public OrderAdapter(String id) { this.id = id; }
public String getOrderId() { return id; }
public String id() { return id; }
}
常见误区
- 把双向适配器当常规设计:绝大多数场景只需要单向适配,双向意味着两边都在妥协。
- 双向适配器里放状态同步:状态映射应是纯转换,不要在两个接口之间缓存可变字段。
追问
- 双向适配器和「两个单向适配器」怎么选?答:单向调用链用两个单向适配器;只有当同一个对象实例需要同时被两边使用时,才用双向适配器。
- 网关协议转换是双向适配器吗?答:更接近「转换器 + 编排」,因为网关通常有独立的数据模型,不是简单包装同一个对象。
01.3.2.6-004 防腐层(ACL)和适配器是什么关系?怎么隔离第三方 SDK?
一句话结论
防腐层是一组适配器与转换器的集合,目的是让外部模型(第三方 SDK、旧系统、外部 API)的概念不污染领域模型;单个适配器是 ACL 的一个实现单元。
概念解释
- ACL(Anti-Corruption Layer):DDD 中的模式,位于领域层与外部系统之间。
- 适配器:ACL 的最小单元,负责接口签名与协议转换。
- 转换器:负责 DTO 与领域对象之间的字段映射。
- 异常翻译:外部异常统一映射为领域异常,不让 SDK 异常类型渗透到核心。
原理流程
- 领域层定义自己的仓库接口与领域模型。
- 为每个外部系统写一个 ACL 模块,对外暴露领域接口。
- ACL 内部调用 SDK、映射 DTO、翻译异常、管理重试与熔断。
- 核心业务代码只依赖领域接口,不 import SDK 的包。
代码或图示
// 领域层定义
type PaymentGateway interface {
Charge(ctx context.Context, orderID string, amount Money) error
}
// ACL 内部(不可被领域层直接 import SDK 包)
type AliACL struct {
client *alipay.Client // SDK 类型,仅在 ACL 包内可见
}
func (a *AliACL) Charge(ctx context.Context, orderID string, m Money) error {
resp, err := a.client.TradePay(ctx, &alipay.TradePayReq{
OutTradeNo: orderID,
TotalAmount: m.Yuan(),
})
if err != nil {
return translateAliError(err) // 翻译成领域错误
}
if resp.Code != "10000" {
return ErrPaymentDeclined
}
return nil
}
常见误区
- 把 SDK 的 DTO 直接当领域对象用:SDK 版本升级或换 SDK 时,核心模型被穿透修改。
- ACL 里放业务规则:ACL 只做协议与模型转换,业务规则仍在领域层。
- 一个 ACL 适配所有 SDK:不同外部系统应各自一个 ACL,避免包互相污染。
追问
- ACL 和「外部服务客户端」有什么区别?答:客户端只负责调远程 API;ACL 还负责模型转换、异常翻译与接口对齐,让领域层不感知外部。
- 微服务里的 BFF 是 ACL 吗?答:BFF 更多是面向前端的聚合层,不一定做防腐;如果它把下游服务模型翻译成前端模型,则兼具 ACL 特征。
01.3.2.6-005 Java 的 InputStreamReader 怎么体现适配器?
一句话结论
InputStreamReader 把字节流(InputStream)适配成字符流(Reader),内部按 charset 解码字节再按字符返回,是 JDK 里最经典的对象适配器实例。
概念解释
- 适配者:
InputStream,以字节为单位读取。 - 目标接口:
Reader,以字符为单位读取。 - 适配器:
InputStreamReader,持有InputStream并按 charset 做字节到字符的转换。 - 反向:
OutputStreamWriter把字符流适配回字节流。
原理流程
- 上层按
ReaderAPI 读字符。 InputStreamReader内部缓冲字节,按 charset 解码器解码。- 解码器从底层
InputStream拉取字节。 - 关闭外层
Reader会级联关闭底层流。
代码或图示
try (Reader r = new InputStreamReader(
new FileInputStream("a.txt"), StandardCharsets.UTF_8)) {
int c;
while ((c = r.read()) != -1) {
char ch = (char) c;
}
}
Reader (字符) ──> InputStreamReader ──> InputStream (字节)
│
└─ CharsetDecoder:按 UTF-8 / GBK 等解码
常见误区
- 认为
InputStreamReader是装饰器:它确实继承自Reader,但它的核心职责是字节到字符的接口转换,而非叠加能力;装饰器与适配器在 JDK 里经常结合出现。 - 不指定 charset:默认 charset 随平台变化,跨环境部署会乱码。
追问
BufferedReader包在InputStreamReader外面是什么模式?答:外层是装饰器(加缓冲),内层是适配器(字节转字符),两者常组合。- 为什么不直接让
InputStream提供readChar?答:字节到字符需要 charset,解码器状态必须被持有;把解码逻辑独立到适配器符合单一职责。
01.3.2.6-006 Go 的 io.Reader / io.Writer 接口如何被适配?
一句话结论
Go 的 io.Reader 与 io.Writer 是最小接口,大量标准库与第三方库都返回这两个类型;适配的常用手法是「包一层实现接口」或用 io.Pipe、io.TeeReader、io.MultiReader 等现成适配器组合。
概念解释
io.Reader:只有Read(p []byte) (n int, err error)。io.Writer:只有Write(p []byte) (n int, err error)。- 适配方向:把其他类型(文件、网络、压缩、哈希)桥接到
io.Reader/io.Writer。 - 现成适配器:
io.PipeReader/Writer、io.TeeReader、io.MultiReader、bufio包。
原理流程
- 接受
io.Reader的函数不需要知道数据源是什么。 - 要适配一个具体数据源时,写一个结构体实现
Read方法。 - 多个
io.Reader拼接用io.MultiReader,不需要自己写循环。 - 需要一边读一边写时用
io.TeeReader或io.Pipe。
代码或图示
import (
"compress/gzip"
"io"
"strings"
)
// 把字符串适配成 io.Reader
r := strings.NewReader("hello")
// 把 gzip.Reader 适配成 io.Reader(本身就实现了)
gr, _ := gzip.NewReader(strings.NewReader("..."))
// 链式:把多个 reader 拼成一个
combined := io.MultiReader(r, gr)
// 边读边写到另一个 writer(TeeReader)
tr := io.TeeReader(r, os.Stdout)
// 自定义适配:把字节切片的反向迭代做成 Reader
type reversedReader struct {
src []byte
pos int
}
func (r *reversedReader) Read(p []byte) (int, error) {
if r.pos >= len(r.src) {
return 0, io.EOF
}
n := copy(p, r.src[len(r.src)-1-r.pos:])
r.pos += n
return n, nil
}
常见误区
- 实现
Read时不返回io.EOF:调用方无法判断流结束,会一直阻塞或死循环。 - 把
io.Reader当「可重复读」使用:接口是流式的,读过即丢,需要重读时要包一层io.TeeReader或缓存到bytes.Buffer。
追问
io.Pipe是适配器吗?答:它是同步内存通道,把 Writer 端的数据转成 Reader 端流,本质是接口桥接。- 为什么 Go 的适配都强调「小接口」?答:接口越小,越容易被各种类型满足,适配成本越低;这是 Go 组合优于继承的体现。
01.3.2.6-007 Rust 的 newtype 与 From / Into 怎么做适配?
一句话结论
Rust 用 newtype(struct Wrapper(Inner))包外部类型,再为 newtype 实现本地 trait;From / Into 提供零成本的类型转换,替代传统的对象适配器。
概念解释
- newtype:零大小开销的包装类型,用来绕过孤儿规则(不能为外部类型实现外部 trait)。
From<T> for U:定义从 T 到 U 的转换,自动获得Into<U>。TryFrom:可能失败的转换。- 与 Go 的接口适配相比,Rust 在编译期完成「接口对齐」,没有运行时包装对象。
原理流程
- 定义领域类型(如
Money、OrderID)。 - 为外部 DTO 实现
From<ExternalDTO> for Domain。 - 业务代码用
.into()或Money::from(dto)做转换。 - 失败的转换用
TryFrom,显式返回Result。
代码或图示
// 外部 SDK 的 DTO(假设来自外部 crate)
struct AliPaymentResp { code: String, amount: String }
// 领域类型
struct Money { yuan: f64 }
enum PayError { Declined, InvalidAmount }
impl TryFrom<AliPaymentResp> for Money {
type Error = PayError;
fn try_from(r: AliPaymentResp) -> Result<Self, Self::Error> {
if r.code != "10000" {
return Err(PayError::Declined);
}
let v: f64 = r.amount.parse().map_err(|_| PayError::InvalidAmount)?;
Ok(Money { yuan: v })
}
}
// 使用
let resp = AliPaymentResp { code: "10000".into(), amount: "12.00".into() };
let money: Money = resp.try_into()?;
// newtype 绕过孤儿规则
struct AliSDK;
trait Payment { fn pay(&self, amount: f64) -> Result<(), String>; }
// 错误:不能直接为外部类型实现外部 trait
// impl Payment for AliSDK {}
// 正确:newtype 包一层
struct AliAdapter(AliSDK);
impl Payment for AliAdapter {
fn pay(&self, amount: f64) -> Result<(), String> { Ok(()) }
}
常见误区
- 为外部类型直接
impl Trait:违反孤儿规则,编译失败。 - 在
From里做可能失败的转换:From必须 infallible,可能失败的转换用TryFrom。 - 滥用 newtype 导致类型层级爆炸:newtype 应只在确实需要类型安全或 trait 实现时引入。
追问
- newtype 有运行时成本吗?答:单个字段的 newtype 在 Rust 里与内部类型同布局,
enum/struct包装通常零成本。 - Rust 的「适配器」和 Java 的适配器有什么本质不同?答:Rust 在编译期通过类型系统完成接口对齐,没有运行时对象包装;Java 需要一个对象实例持有适配者。
01.3.2.6-008 TypeScript 的类型适配与 schema 转换怎么做?
一句话结论
TypeScript 既需要运行时把外部 JSON 转成领域类型,也需要在编译期保证类型一致;惯用做法是用 Zod / io-valibot 等 schema 库在边界处做运行时校验与类型推导,适配器函数把 DTO 映射成领域对象。
概念解释
- 类型层面:
interface/type只在编译期存在,运行时被擦除。 - 运行时边界:HTTP 响应、localStorage、第三方 SDK 返回的是
any/unknown。 - schema 库:在运行时校验 JSON,同时推断 TypeScript 类型。
- 适配器函数:纯函数,输入 DTO、输出领域对象,便于单测。
原理流程
- 定义领域类型与 DTO schema。
- 在边界用 schema 解析外部数据,失败则抛领域错误。
- 写
toDomain(dto): Domain与toDTO(domain): DTO。 - 业务代码只接触领域类型,不直接读 DTO 字段。
代码或图示
import { z } from "zod";
// 外部 DTO schema
const AliOrderSchema = z.object({
trade_no: z.string(),
total_amount: z.string(),
status: z.enum(["TRADE_SUCCESS", "TRADE_CLOSED"]),
});
type AliOrderDTO = z.infer<typeof AliOrderSchema>;
// 领域模型
type OrderStatus = "paid" | "closed";
interface Order {
id: string;
amountYuan: number;
status: OrderStatus;
}
// 适配器:DTO -> 领域
function toOrder(dto: AliOrderDTO): Order {
return {
id: dto.trade_no,
amountYuan: Number.parseFloat(dto.total_amount),
status: dto.status === "TRADE_SUCCESS" ? "paid" : "closed",
};
}
// 边界使用
const raw: unknown = await resp.json();
const dto = AliOrderSchema.parse(raw);
const order = toOrder(dto);
常见误区
- 直接
as Order强转外部 JSON:编译期过、运行时字段可能缺,导致线上报错。 - 在业务组件里散落
dto.xxx:外部字段名穿透到 UI 层,换 SDK 时改不动。 - schema 校验放在业务深处:校验应在边界(HTTP handler、worker)就完成,内部代码只处理已校验的类型。
追问
- Zod 这类库是「适配器」吗?答:它更像「运行时类型校验 + 类型推导」,与适配器函数配合完成 DTO 到领域的转换。
- TypeScript 里怎么处理两个方向的转换?答:写一对
toDomain与toDTO,纯函数,单测覆盖每个字段映射。
01.3.2.6-009 PHP 适配器与 Laravel Facade 有什么区别?
一句话结论
适配器转换接口,让不兼容的类协同工作;Laravel Facade 是通过静态代理访问容器中实例的语法糖,两者都「包了一层」,但 Facade 不改接口、也不做协议转换。
概念解释
- 适配器:实现目标接口,内部调用适配者,做签名与参数转换。
- Facade:用
ClassName::method()的静态调用形式,代理到容器中绑定的对象。 - Facade 的本质:
__callStatic+ 容器解析,是访问方式的变化,不是接口转换。 - 常见混淆:Facade 看起来像「包了一层」,但它不改变被包装对象的方法签名。
原理流程
- 适配器:写一个类实现目标接口,方法体里调用第三方 SDK。
- Facade:定义一个 Facade 类,重写
getFacadeAccessor返回容器绑定 key。 - 调用方用静态方式调用,容器在运行期解析出真实对象并转发。
代码或图示
// 适配器:把 SDK 接口转成领域接口
interface Payment {
public function pay(float $amount): void;
}
class AliAdapter implements Payment {
public function __construct(private AliSDK $sdk) {}
public function pay(float $amount): void {
$this->sdk->charge(number_format($amount, 2, '.', ''));
}
}
// Laravel Facade:静态代理到容器
use Illuminate\Support\Facades\Cache;
// 实际等价于:app('cache')->get('key')
$value = Cache::get('key');
// Facade 类的本质
class Cache extends \Illuminate\Support\Facades\Facade {
protected static function getFacadeAccessor() { return 'cache'; }
}
常见误区
- 把 Facade 当适配器:Facade 不转换接口,它只是「静态调用语法糖」。
- 在业务代码里到处用 Facade:隐藏了依赖关系,单测替换困难,应优先构造器注入。
- 认为 Facade 比适配器更「高级」:两者解决的问题不同,没有优劣。
追问
- Laravel 的
Auth::user()是适配器吗?答:不是,它是 Facade,背后是guard()实例;如果要把 Guard 接口换成自研鉴权,才需要写适配器。 - Facade 和单例什么关系?答:Facade 通常代理到容器中的单例,但 Facade 本身不保证单例,单例由容器作用域决定。
01.3.2.6-010 C# 怎么用接口适配包装 HttpClient?
一句话结论
C# 里把 HttpClient 包装成领域接口(如 IPaymentClient),用适配器方法把领域请求翻译成 HTTP 请求、把 HTTP 响应翻译成领域响应,便于单元测试与多环境切换。
概念解释
HttpClient是基础设施,不适合在业务代码里直接new。- 领域接口:业务层依赖
IPaymentClient,不关心是 HTTP 还是 gRPC。 - 适配器:实现
IPaymentClient,内部用HttpClient发请求。 - DI 注册:
AddHttpClient<IPaymentClient, PaymentClientAdapter>()。
原理流程
- 定义领域接口与请求/响应模型。
- 写适配器类,构造器注入
HttpClient。 - 方法内做 URL 拼装、序列化、错误码翻译。
- 在 DI 容器注册,业务层只依赖接口。
代码或图示
public interface IPaymentClient
{
Task<PayResult> PayAsync(PayRequest req, CancellationToken ct);
}
public class PaymentClientAdapter : IPaymentClient
{
private readonly HttpClient _http;
public PaymentClientAdapter(HttpClient http) { _http = http; }
public async Task<PayResult> PayAsync(PayRequest req, CancellationToken ct)
{
var resp = await _http.PostAsJsonAsync("/pay", req, ct);
if (!resp.IsSuccessStatusCode)
throw new PaymentDeclinedException();
var dto = await resp.Content.ReadFromJsonAsync<PayDTO>(ct);
return new PayResult(dto.TradeNo, dto.Paid);
}
}
// DI 注册
builder.Services.AddHttpClient<IPaymentClient, PaymentClientAdapter>(c =>
c.BaseAddress = new Uri("https://api.example.com/"));
常见误区
- 在适配器里用
new HttpClient():导致 socket 耗尽,应通过 DI 注入或IHttpClientFactory。 - 把
HttpResponseMessage暴露到业务层:HTTP 细节穿透到领域层。 - 适配器里放业务规则:业务规则应在领域服务,适配器只做协议翻译。
追问
AddHttpClient解决了什么?答:它管理HttpClient的生命周期与HttpClientHandler复用,避免直接using var client = new()造成的 socket 耗尽。- C# 的
Refit是什么?答:它把接口自动实现成 HTTP 客户端,本质是「编译器生成适配器」,仍然是适配模式。
01.3.2.6-011 适配器、外观、代理、装饰器怎么一句话区分?
一句话结论
适配器改接口以对齐期望;外观简化子系统入口;代理不改接口只控制访问;装饰器不改接口只叠加能力;四者都持有被包装对象,区别在「改什么、为什么包装」。
概念解释
- 适配器:接口不一致 → 转换。
- 外观:多个子系统 → 一个简化入口。
- 代理:接口一致 → 控制访问(懒加载、权限、远程)。
- 装饰器:接口一致 → 叠加能力(日志、缓存、压缩)。
原理流程
- 先看接口是否一致:不一致归适配器。
- 一致再看是否「聚合多个子系统」:是则外观。
- 一致且只包一个对象:看意图,控制访问归代理,叠加能力归装饰器。
代码或图示
接口不一致 ──> 适配器(转换签名/参数)
多个子系统 ──> 外观(聚合为一个高层入口)
接口一致 ──> 代理(放行/懒加载/权限/远程)
接口一致 ──> 装饰器(日志/缓存/压缩叠加)
常见误区
- 凭代码结构归类:四者都是「持有被包装对象」,结构相似,必须结合调用方期望与包装意图判断。
- 把参数转换写进代理或装饰器:签名转换属于适配器职责。
- 外观里再调外部 SDK:外观只编排内部子系统,外部 SDK 应先经适配器进入领域层。
追问
- 接入旧短信 SDK 加日志用哪种?答:先写适配器对齐领域接口,再在外层叠日志装饰器;不要把签名转换和日志混在一个类里。
- 统一多套支付接口怎么设计?答:先定义领域
Payment接口,每个 SDK 写一个适配器,上层通过领域接口调用;需要编排多步流程时再写外观。
01.3.2.6-012 适配器滥用有哪些信号?
一句话结论
到处写 Adapter、Adapter 之间互相调用、Adapter 里堆满业务规则、新增一个 SDK 要改一堆业务代码——这些都是领域模型没建好的信号,而不是「适配器用得不够」。
概念解释
- 信号一:业务代码里出现
XxxAdapter数量与领域服务数量相当。 - 信号二:Adapter 内部互相 import,形成 Adapter 链。
- 信号三:Adapter 里包含「如果是 A 厂商就走这个分支」的业务规则。
- 信号四:换一个 SDK 时,要修改业务层而不是只新增一个 Adapter。
原理流程
- 先问:业务层依赖的是不是一个稳定的领域接口?
- 如果业务层直接依赖 SDK 类型,说明领域接口缺失。
- 如果 Adapter 里有业务分支,说明业务规则下沉位置错误。
- 正确做法:先定义稳定领域接口,再让每个外部系统有自己的 Adapter。
代码或图示
反例:
OrderService → AliOrderAdapter → WeChatOrderAdapter → ...
业务代码里 if (provider == "ali") { ... }
正例:
OrderService → OrderRepository(领域接口)
↑
AliOrderAdapter WeChatOrderAdapter
(只做协议/模型转换,无业务分支)
常见误区
- 认为「Adapter 越多说明架构越分层」:分层是手段,不是目的;Adapter 数量应与外部系统数量成正比,而不是与业务功能成正比。
- 把 Adapter 当「新业务入口」:新业务应落在领域层,不是落在 Adapter 里。
追问
- 怎么判断领域接口是否稳定?答:换一个外部系统时,业务层代码不需要修改;如果要改,说明领域接口泄漏了外部概念。
- Adapter 层要不要做单元测试?答:要,且应测每个字段映射与异常翻译;但不要在 Adapter 里 mock 业务规则。
01.3.2.6-013 适配器里要不要放业务逻辑?边界在哪?
一句话结论
适配器只放「接口与协议转换」:参数映射、序列化、异常翻译、重试策略;业务规则(什么时候允许支付、金额怎么算)必须留在领域层。
概念解释
- 适配职责:DTO ↔ 领域对象、字段名转换、错误码映射、HTTP 状态码翻译。
- 非适配职责:金额计算、状态机流转、业务校验、权限判断。
- 灰区:重试、超时、熔断——属于基础设施策略,可放在适配器侧,但要可配置。
原理流程
- 列出适配器里每个方法。
- 判断它是否只是「翻译」:是则留。
- 判断它是否包含业务规则:是则搬到领域服务。
- 基础设施策略(重试、熔断)保留在适配器,但用配置控制。
代码或图示
// 适配器里:只做转换
public PayResult pay(PayRequest req) {
AliReq r = new AliReq();
r.setOutTradeNo(req.orderId());
r.setTotalAmount(req.amount().toPlainString());
AliResp resp = client.pay(r);
if (!"10000".equals(resp.getCode())) {
throw new PaymentDeclinedException();
}
return new PayResult(resp.getTradeNo(), true);
}
// 错误:业务规则写进适配器
public PayResult pay(PayRequest req) {
if (req.amount().compareTo(new BigDecimal("1000")) > 0) {
throw new BusinessException("超过单笔限额"); // 业务规则,应在领域层
}
// ...
}
常见误区
- 把「金额超过 1000 要二次确认」写在适配器:这是业务规则,换一个 SDK 也应该保留,应该在领域服务里。
- 适配器里做超时与重试不可配置:策略应可独立调整,不要硬编码在方法里。
- 适配器里直接抛 SDK 异常类型:应翻译成领域异常,避免 SDK 类型渗透。
追问
- 重试属于适配器还是领域层?答:属于基础设施策略,放在适配器侧或用横切(如 Polly)包装,业务层不感知。
- 怎么区分「转换」与「业务规则」?答:换一个外部系统时仍然成立的规则是业务规则;只在当前 SDK 下成立的是适配细节。
跨语言差异对照
| 语言 | 惯用实现 | 差异要点 |
|---|---|---|
| Java | 对象适配器(持有适配者字段)+ JDK 实例如 InputStreamReader |
唯一支持类适配器(继承)的主流语言,但现代代码仍选组合;反射与序列化能力强,需防泄漏 |
| Go | 接口隐式实现 + 结构体持有适配者;io.Reader / io.Writer 是最小接口 |
无继承,类适配器不成立;小接口让「适配」退化为「写一个方法集」 |
| Python | 对象适配器( duck typing );常用函数包装与 functools.partial |
动态语言无类型约束,适配器常以函数而非类形式出现;协议不一致时可在运行期动态代理 |
| PHP | 适配器类实现领域接口,构造器注入 SDK;Laravel Facade 是另一套机制 | Facade 不是适配器,它是静态代理;FPM 生命周期下适配器应无状态 |
| C# | 接口适配器 + AddHttpClient<T> 注入;Refit 自动生成适配器 |
DI 容器管理生命周期,适配器通常薄;HttpClient 必须通过工厂注入 |
| TypeScript | 接口 + 纯函数 DTO 转换;Zod schema 做运行时校验 | 编译期类型与运行时数据分离,必须在边界做校验;适配器通常是函数而非类 |
| Rust | newtype + From / TryFrom;trait 对象做运行时接口对齐 |
编译期完成接口对齐,零成本;孤儿规则迫使外部类型必须用 newtype 包装 |
跨语言差异
- Java 是唯一系统讨论「类适配器 vs 对象适配器」的语言,因为它是主流语言中唯一支持双继承语义的;其他语言直接选对象适配器。
- Go 的接口是隐式实现,「适配」经常退化为「写一个方法签名匹配」,不需要显式 Adapter 类。
- Rust 把适配从「运行时包装对象」变成「编译期类型转换」,
From/Into是零成本抽象。 - TypeScript / Python 是动态语言,适配器常以函数形式存在,类适配器几乎没有意义。
- C# / Java 这类静态类型语言更强调「领域接口 + DI 容器」,适配器是容器注入的普通 Bean。
- PHP 的 Laravel Facade 容易被误认成适配器,但它是静态访问语法糖,不做协议转换。
- 所有语言的共同结论:适配器只做接口与模型转换,业务规则留在领域层。
待整理清单
- [ ] 补充 Kotlin
typealias与扩展函数对适配模式的影响 - [ ] 补充 gRPC / 消息队列消费者场景下的适配器写法
- [ ] 补充多个 SDK 同时存在时的「路由适配器」与策略模式结合
- [ ] 补充 Rust 中
dyn Trait与泛型两种适配路径的取舍