01.3.2.7 外观组合桥接与享元
所属:全栈开发面试题库 / 01 计算机基础与通用工程 / 01.3 设计模式与架构基础 / 01.3.2 常用设计模式多语言详解
覆盖范围
- Facade 简化子系统与分层边界
- Facade 与中介者、代理、适配器的区别
- Composite 树形结构与递归遍历
- Composite 在 UI 菜单、组织架构、文件系统中的落地
- Bridge 抽象维度与实现维度双解耦
- Bridge 与策略、适配器的区别
- Flyweight 内部状态与外部状态拆分
- Flyweight 与对象池、缓存的区别
- Java
Integer.valueOf缓存与 String 常量池作为享元实例 - Go
sync.Pool为什么不是享元 - 前端虚拟列表中的享元思想
- 四者的互斥与组合使用
- 「为组合而组合」的误用信号
面试题索引
| 编号 | 题目 | 难度 | 状态 | 备注 |
|---|---|---|---|---|
| 01.3.2.7-001 | Facade 怎么简化子系统?分层边界怎么划? | 基础 | 已完成 | 外观意图 |
| 01.3.2.7-002 | Facade 与中介者、代理、适配器怎么区分? | 进阶 | 已完成 | 结构型辨析 |
| 01.3.2.7-003 | Composite 怎么用统一接口处理树形结构? | 基础 | 已完成 | 组合模式 |
| 01.3.2.7-004 | Composite 在 UI 菜单、组织架构、文件系统中怎么落地? | 进阶 | 已完成 | 真实场景 |
| 01.3.2.7-005 | Bridge 怎么解耦抽象维度与实现维度? | 进阶 | 已完成 | 桥接意图 |
| 01.3.2.7-006 | Bridge 与策略、适配器有什么区别? | 进阶 | 已完成 | 模式辨析 |
| 01.3.2.7-007 | Flyweight 的内部状态与外部状态怎么拆? | 进阶 | 已完成 | 享元意图 |
| 01.3.2.7-008 | Flyweight 与对象池、缓存有什么区别? | 进阶 | 已完成 | 复用辨析 |
| 01.3.2.7-009 | Java Integer.valueOf 缓存与 String 常量池怎么体现享元? | 进阶 | 已完成 | JDK 实例 |
| 01.3.2.7-010 | Go 的 sync.Pool 为什么不是享元? | 高级 | 已完成 | 并发原语 |
| 01.3.2.7-011 | 前端虚拟列表如何体现享元思想? | 进阶 | 已完成 | 工程实践 |
| 01.3.2.7-012 | Facade / Composite / Bridge / Flyweight 四者怎么组合使用? | 高级 | 已完成 | 模式组合 |
| 01.3.2.7-013 | 「为组合而组合」的误用有哪些信号? | 高级 | 已完成 | 滥用反思 |
01.3.2.7-001 Facade 怎么简化子系统?分层边界怎么划?
一句话结论
Facade 为复杂子系统提供一个统一的高层入口,把多个子模块的调用顺序与协作封装在一个类里,让外部调用方只依赖一个粗粒度接口;它位于外部层与子系统之间,不封装业务规则。
概念解释
- Facade:对外的统一入口,编排多个子系统调用。
- 子系统:内部多个模块,各自可被独立调用与测试。
- 分层边界:Facade 在业务层与基础设施层之间,不承载业务规则。
- 价值:降低调用方理解成本、屏蔽内部重构、提供粗粒度 API。
原理流程
- 梳理外部常用的子系统调用组合。
- 写 Facade 类,按固定顺序编排子系统调用。
- 外部调用方只依赖 Facade,不直接调用子系统。
- 子系统内部重构不影响 Facade 契约。
代码或图示
public class OrderFacade {
private final StockService stock;
private final PayService pay;
private final DeliveryService delivery;
public OrderFacade(StockService s, PayService p, DeliveryService d) {
this.stock = s; this.pay = p; this.delivery = d;
}
public void place(Order order) {
stock.lock(order);
pay.charge(order);
delivery.dispatch(order);
}
}
// C#:Facade 通过 DI 注入多个子系统
public class OrderFacade
{
private readonly StockService _stock;
private readonly PayService _pay;
private readonly DeliveryService _delivery;
public OrderFacade(StockService stock, PayService pay, DeliveryService delivery)
{
_stock = stock; _pay = pay; _delivery = delivery;
}
public void Place(Order order)
{
_stock.Lock(order);
_pay.Charge(order);
_delivery.Dispatch(order);
}
}
外部调用方 ──> OrderFacade
├─ StockService
├─ PayService
└─ DeliveryService
子系统内部仍可被独立调用与测试
常见误区
- 把 Facade 写成「上帝类」:所有业务都堆进去,Facade 变成业务规则的承担者。
- Facade 取代所有子系统接口:子系统应仍可被独立测试与调用。
- Facade 里做跨模块事务:事务边界应由领域服务或编排层管理,Facade 只做流程编排。
追问
- Facade 和 DDD 中的领域服务怎么区分?答:Facade 编排已有子系统、不产生新业务规则;领域服务承载业务规则与状态流转。
- Facade 接口设计要点?答:粗粒度、参数稳定、异常归一化;内部子系统变更不破坏 Facade 契约。
01.3.2.7-002 Facade 与中介者、代理、适配器怎么区分?
一句话结论
Facade 对外简化多个子系统;中介者对内解耦多个同事对象之间的网状通信;代理不改接口只控制访问;适配器改接口对齐期望;四者都「包了一层」,但位置与意图完全不同。
概念解释
- Facade:外部 → 子系统,单向简化。
- 中介者:同事 ↔ 中介者 ↔ 同事,集中交互。
- 代理:调用方 → 代理 → 真实对象,控制访问。
- 适配器:调用方期望接口 → 适配者实际接口。
原理流程
- 看调用方是谁:外部调用子系统选 Facade。
- 看对象间通信:同事对象互相引用收敛到中介者。
- 看接口是否一致:不一致选适配器;一致再看是控制访问还是简化入口。
代码或图示
Facade: Client ──> Facade ──> SubsystemA, SubsystemB, SubsystemC
中介者: ColleagueA ↔ Mediator ↔ ColleagueB(同事不直接互调)
代理: Client ──> Proxy ──> RealSubject(接口相同)
适配器: Client ──> Target <── Adapter ──> Adaptee(接口不同)
常见误区
- 把 Facade 当中介者:Facade 是「对外门面」,中介者是「对内解耦」;一个订单流程中,对外下单入口用 Facade,内部库存/支付/物流协作可结合领域服务,而不是让所有同事直接互调。
- 代理做简化:代理不提供新接口,只控制是否放行;提供新接口归 Facade。
追问
- 聊天室成员互相发消息用哪种?答:中介者,成员只认识聊天室对象,由聊天室转发。
- 微服务 BFF 是 Facade 吗?答:BFF 兼具 Facade(聚合下游多个服务)与适配器(模型转换)特征,本质是面向前端的外观层。
01.3.2.7-003 Composite 怎么用统一接口处理树形结构?
一句话结论
Composite 把容器与叶子节点抽象为同一接口,让调用方一致对待单个对象与组合对象,递归处理树形结构时不需要 if (instanceof) 判断节点类型。
概念解释
- 抽象构件:声明叶子与容器的共同接口。
- 叶子:无子节点,实现自身行为。
- 容器:持有子构件列表,递归聚合行为。
- 透明式:接口统一含子节点管理方法;安全式:叶子不暴露 add/remove。
原理流程
- 定义构件接口(如
show、count)。 - 叶子实现终止行为。
- 容器维护子列表,行为方法递归遍历子节点。
- 调用方对任意节点调用同一接口,不关心具体类型。
代码或图示
public interface Node {
long size();
}
public class FileNode implements Node {
private final long size;
public FileNode(long s) { this.size = s; }
public long size() { return size; }
}
public class FolderNode implements Node {
private final List<Node> children = new ArrayList<>();
public void add(Node n) { children.add(n); }
public long size() {
long total = 0;
for (Node c : children) total += c.size();
return total;
}
}
# Python:Composite 用鸭子类型,不需要显式接口
class FileNode:
def __init__(self, name: str, size: int):
self.name = name
self._size = size
def size(self) -> int:
return self._size
class FolderNode:
def __init__(self, name: str):
self.name = name
self.children: list = []
def add(self, node) -> None:
self.children.append(node)
def size(self) -> int:
return sum(c.size() for c in self.children)
# 调用方不关心是 File 还是 Folder
root = FolderNode("root")
root.add(FileNode("a.txt", 100))
sub = FolderNode("sub")
sub.add(FileNode("b.txt", 200))
root.add(sub)
print(root.size()) # 300
Folder
├─ File (1KB)
└─ Folder
├─ File (2KB)
└─ File (3KB)
递归:Folder.size() = 1 + (2 + 3) = 6
常见误区
- 叶子也继承容器的 add/remove:透明式方便但类型不安全,安全式让叶子不暴露修改方法。
- 递归不防环:节点互相引用会栈溢出,需 visited 集合或深度上限。
- 树深度很大仍用方法递归:深树改用栈/队列迭代,避免栈溢出。
追问
- 透明式与安全式怎么选?答:节点类型明确、调用方知道谁是容器时选安全式;需要调用方无差别处理任意节点时选透明式。
- Composite 和装饰器结构相似吗?答:结构都是持有子对象,但装饰器是单链包装、增强能力;Composite 是树状聚合、统一对待。
01.3.2.7-004 Composite 在 UI 菜单、组织架构、文件系统中怎么落地?
一句话结论
UI 菜单树、组织架构树、文件目录树都是典型树形结构,Composite 让「菜单项与菜单组」「员工与部门」「文件与文件夹」实现同一接口,递归渲染与统计。
概念解释
- UI 菜单:叶子是菜单项,容器是菜单组。
- 组织架构:叶子是员工,容器是部门。
- 文件系统:叶子是文件,容器是文件夹。
- 共同特征:统一的
render/size/count行为,递归聚合。
原理流程
- 定义统一构件接口(如
render、count、size)。 - 叶子实现终止行为。
- 容器持有子列表,递归调用子节点的同一接口。
- 调用方从根节点开始,一次调用完成整树处理。
代码或图示
// UI 菜单
interface MenuNode {
render(indent: string): void;
}
class MenuItem implements MenuNode {
constructor(private label: string) {}
render(indent: string): void { console.log(indent + "- " + this.label); }
}
class MenuGroup implements MenuNode {
private children: MenuNode[] = [];
constructor(private label: string) {}
add(n: MenuNode) { this.children.push(n); }
render(indent: string): void {
console.log(indent + "# " + this.label);
for (const c of this.children) c.render(indent + " ");
}
}
// 组织架构:员工与部门
type OrgNode interface {
Headcount() int
}
type Employee struct{ name string }
func (e *Employee) Headcount() int { return 1 }
type Department struct {
name string
children []OrgNode
}
func (d *Department) Headcount() int {
total := 0
for _, c := range d.children { total += c.Headcount() }
return total
}
常见误区
- 把「是否可展开」作为叶子与容器的判断依据:应通过接口类型区分,而不是运行时
instanceof。 - 递归渲染时不维护缩进/层级:展示类行为需要把上下文(缩进、深度)作为参数传入。
- 数据库里用邻接表存树,加载到内存后才做 Composite:大数据量应改用路径枚举或闭包表,避免递归加载整树。
追问
- 前端组件库(如 Vue / React)的组件树是 Composite 吗?答:是思想落地——组件递归渲染子组件,父组件不关心子组件是叶子还是容器。
- 树深度 10000 层怎么办?答:改用迭代式遍历(栈/队列),或按懒加载分段加载,避免递归栈溢出。
01.3.2.7-005 Bridge 怎么解耦抽象维度与实现维度?
一句话结论
Bridge 把「高层抽象」与「底层实现」两个独立变化维度分离,用组合代替继承,让两个维度可以各自扩展;典型场景是形状与颜色、消息类型与发送渠道这种多维度交叉。
概念解释
- 抽象维度:高层逻辑(如形状、消息类型)。
- 实现维度:底层渠道(如颜色、发送方式)。
- 桥接:抽象层持有实现层接口引用,组合而非继承。
- 收益:两个维度独立扩展,避免子类数量爆炸。
原理流程
- 识别两个会独立变化的维度。
- 各维度定义接口。
- 抽象层组合实现接口,沿两个方向扩展子类。
- 运行期把实现注入抽象,组合出具体对象。
代码或图示
// 实现维度:颜色
interface Color { String fill(); }
class Red implements Color { public String fill() { return "red"; } }
class Blue implements Color { public String fill() { return "blue"; } }
// 抽象维度:形状,持有 Color 引用
abstract class Shape {
protected Color color;
public Shape(Color c) { this.color = c; }
abstract void draw();
}
class Circle extends Shape {
public Circle(Color c) { super(c); }
public void draw() { System.out.println("circle " + color.fill()); }
}
继承方案:CircleRed / CircleBlue / SquareRed / SquareBlue = 4 个子类
桥接方案:Shape(2 个子类)× Color(2 个实现)= 2 + 2,扩展时只加一个类
常见误区
- 把 Bridge 当普通组合:组合是手段,Bridge 强调两个独立变化维度的结构解耦。
- 维度交叉很少也上 Bridge:组合数有限时继承更直白。
- 在抽象层里硬编码实现:实现应通过构造器注入,运行期可替换。
追问
- 消息通知怎么用 Bridge?答:消息类型(通知/营销)为抽象维度,发送渠道(短信/邮件/推送)为实现维度,各自扩展。
- Bridge 和「依赖倒置」什么关系?答:Bridge 是 DIP 的具体应用——抽象层依赖实现层接口,不依赖具体实现。
01.3.2.7-006 Bridge 与策略、适配器有什么区别?
一句话结论
Bridge 是两个维度的结构性分离,长期共存;策略是算法可替换,运行期选择;适配器是接口对齐,过渡形态;三者都用组合,但意图与生命周期不同。
概念解释
- Bridge:抽象与实现两个维度都在演进,结构上长期分离。
- 策略:同一接口下多个算法实现,运行期按场景选择。
- 适配器:接口不匹配时转换,通常是过渡形态。
原理流程
- 看是否两个维度都在长期扩展:是则 Bridge。
- 看是否同一接口下多个可替换算法:是则策略。
- 看是否接口不匹配需要转换:是则适配器。
代码或图示
Bridge: AbstractionA/B × ImplementorA/B(两个维度都在扩展)
策略: Context ──> Strategy(同一接口,运行期选一个)
适配器: Client ──> Target <── Adapter ──> Adaptee(接口转换)
常见误区
- 把策略当 Bridge:策略是「同一维度下的算法替换」,Bridge 是「两个维度结构分离」。
- 把适配器当 Bridge:适配器是临时转换,Bridge 是长期架构。
- 用 Bridge 解决接口不匹配:接口不匹配应选适配器,Bridge 不解决接口对齐问题。
追问
- 日志系统:日志级别 + 输出目的地,是 Bridge 吗?答:是,两个维度独立扩展;但如果只有一个目的地在换,更像策略。
- Bridge 的实现侧可以是策略吗?答:可以,实现侧本身就是一个策略接口;Bridge 是更宏观的结构,策略是其中一侧的实现手法。
01.3.2.7-007 Flyweight 的内部状态与外部状态怎么拆?
一句话结论
Flyweight 把对象拆成「不可变内部状态」(可共享,存在享元对象内)与「可变外部状态」(随上下文变化,使用时传入),通过共享大量细粒度对象减少内存占用。
概念解释
- 内部状态:不可变、可共享,如字体名、字号、颜色。
- 外部状态:随上下文变化,如文本内容、位置,使用时传入方法参数。
- 享元工厂:按 key 缓存内部状态相同的对象。
- 前提:对象数量巨大、内部状态可枚举且可共享。
原理流程
- 拆分对象的可共享部分与可变部分。
- 把可共享部分做成享元对象,放进工厂缓存。
- 可变部分作为方法参数传入。
- 调用方从工厂获取享元,传入外部状态执行。
代码或图示
// 内部状态:字体名 + 字号(不可变)
public final class Font {
private final String name;
private final int size;
public Font(String n, int s) { name = n; size = s; }
}
// 工厂:缓存相同 Font
public final class FontFactory {
private static final Map<String, Font> CACHE = new ConcurrentHashMap<>();
public static Font get(String name, int size) {
return CACHE.computeIfAbsent(name + size, k -> new Font(name, size));
}
}
// 外部状态:文本内容、位置,使用时传入
public void draw(String text, int x, int y, Font f) { }
// Rust:Flyweight 用 HashMap 缓存不可变对象
use std::collections::HashMap;
use std::sync::Mutex;
#[derive(Clone, Hash, Eq, PartialEq)]
struct FontKey { name: String, size: u32 }
#[derive(Clone)]
struct Font { name: String, size: u32 }
struct FontFactory {
cache: Mutex<HashMap<FontKey, Font>>,
}
impl FontFactory {
fn get(&self, name: &str, size: u32) -> Font {
let key = FontKey { name: name.to_string(), size };
let mut cache = self.cache.lock().unwrap();
cache.entry(key).or_insert_with(|| Font {
name: name.to_string(), size,
}).clone()
}
}
常见误区
- 把可变状态放进享元对象:共享对象被多线程/多请求修改会串数据。
- 为微小对象强行享元:缓存本身占内存,对象数量不大时直接创建更划算。
- 外部状态不通过参数传,而是塞进享元对象:破坏可共享性。
追问
- 享元对象可以有状态吗?答:只能有不可变状态;任何可变字段都会破坏共享。
- 享元工厂要考虑淘汰吗?答:内部状态种类有限时不需要淘汰;如果 key 空间大(如用户 ID),应改用缓存而非享元。
01.3.2.7-008 Flyweight 与对象池、缓存有什么区别?
一句话结论
Flyweight 共享不可变内部状态,减少对象数量;对象池复用可变实例并控制并发上限;缓存保存计算结果以避免重复计算;三者都有复用目的,但复用内容、可变性与生命周期不同。
概念解释
- Flyweight:内部状态不可变,外部状态传入,对象本身无状态。
- 对象池:实例可变,借出归还,使用前需重置状态。
- 缓存:按 key 存结果,可过期淘汰,内容是计算结果。
原理流程
- 识别复用对象是不可变状态、可变资源还是计算结果。
- 不可变 → 享元;可变资源 → 对象池;计算结果 → 缓存。
- 注意共享对象的线程安全与淘汰策略。
代码或图示
享元: 相同不可变对象共享(字体/样式/常量)
对象池: 可变实例借出归还(连接/线程/缓冲区)
缓存: 结果 key → value,可过期淘汰(热点数据/查询结果)
// PHP:享元工厂(请求级缓存,FPM 下不跨请求)
final class FontFactory {
/** @var array<string, Font> */
private static array $cache = [];
public static function get(string $name, int $size): Font {
$key = "$name@$size";
return self::$cache[$key] ??= new Font($name, $size);
}
}
常见误区
- 把可变资源当享元共享:多请求改同一实例导致串数据。
- 把缓存当连接池:缓存不管理资源占用与归还。
- 用对象池复用无状态轻量对象:无状态对象直接创建即可,池化反而增加管理成本。
追问
- 字符串常量池属于哪类?答:享元,字符串不可变所以可安全共享。
- 线程池和享元冲突吗?答:线程是可变执行资源,用对象池思路复用,不是享元。
01.3.2.7-009 Java Integer.valueOf 缓存与 String 常量池怎么体现享元?
一句话结论
Integer.valueOf(int) 对 -128 到 127 之间的值返回缓存实例;字符串字面量在常量池中共享——两者都是 JDK 内部的享元实现,共享的是不可变对象。
概念解释
Integer.valueOf:内部维护IntegerCache,对小范围数值返回同一实例。- String 常量池:编译期字符串字面量在运行期共享同一
String对象。 - 共同特征:内部状态(数值、字符序列)不可变,可安全共享。
- 注意:
new Integer(1)不会走缓存,new String("a")也不会入常量池。
原理流程
- 调用
Integer.valueOf(100)时,先查缓存。 - 命中则返回既有实例,未命中才新建。
- 字符串字面量在类加载时进入常量池,相同字面量共享。
- 因为
Integer与String都不可变,共享安全。
代码或图示
Integer a = Integer.valueOf(100);
Integer b = Integer.valueOf(100);
System.out.println(a == b); // true(命中缓存)
Integer c = Integer.valueOf(1000);
Integer d = Integer.valueOf(1000);
System.out.println(c == d); // false(超出缓存范围)
String s1 = "hello";
String s2 = "hello";
System.out.println(s1 == s2); // true(常量池共享)
常见误区
- 用
==比较Integer:超出缓存范围时==返回 false,应用equals。 - 认为
new Integer(1)走缓存:new永远新建对象,不走缓存。 - 认为 String 常量池是「字符串池化」:它是享元思想,共享不可变对象,不是连接池。
追问
IntegerCache上限可调吗?答:可通过-XX:AutoBoxCacheMax调整 high 端(具体以所用 JDK 版本为准,待确认),low 端固定为 -128。- 字符串
intern()是什么?答:手动把字符串放入常量池,返回共享引用;滥用会导致常量池膨胀。
01.3.2.7-010 Go 的 sync.Pool 为什么不是享元?
一句话结论
sync.Pool 复用的是「可变对象实例」(如缓冲区),使用后需重置,且会被 GC 随时清理;享元共享的是「不可变内部状态」,生命周期长且不会被回收。两者复用内容完全不同。
概念解释
sync.Pool:临时对象池,复用分配成本高但状态可重置的对象(如[]byte、http.Request)。- 享元:共享不可变对象,外部状态传入,不重置。
- GC 行为:
sync.Pool在 GC 时会清空,享元不会被清理。 - 用途:
sync.Pool降低 GC 压力,享元减少对象数量。
原理流程
- 从
Pool.Get()取对象。 - 使用后
Put()归还,归还前重置状态。 - GC 触发时 Pool 中的对象可能被回收。
- 享元对象按 key 长期缓存,不归还、不重置。
代码或图示
var bufPool = sync.Pool{
New: func() any {
b := make([]byte, 0, 4096)
return &b
},
}
func handle() {
buf := bufPool.Get().(*[]byte)
defer func() {
*buf = (*buf)[:0] // 重置长度,保留容量
bufPool.Put(buf)
}()
// 使用 buf ...
}
sync.Pool:可变对象借出归还,GC 可回收,降低分配开销
享元: 不可变对象按 key 共享,长期存在,减少对象数量
常见误区
- 把
sync.Pool当「长期缓存」:GC 会清空 Pool,不能用来存需要长期存在的对象。 - 从 Pool 取出对象不重置:上一次使用的残留数据会被下一次读到,串数据。
- 用 Pool 复用有业务状态的对象:Pool 只适合无业务语义的可变资源(缓冲区)。
追问
sync.Pool适合存连接吗?答:不适合,连接有状态且需长期管理,应用连接池(如database/sql)。- Go 的
http.Request为什么用 Pool?答:Request对象分配频繁且可重置,Pool 降低 GC 压力,这是典型的对象池思路而非享元。
01.3.2.7-011 前端虚拟列表如何体现享元思想?
一句话结论
虚拟列表只渲染可视区域内的 DOM 节点,滚动时复用同一批 DOM 元素、更新内容(外部状态),而不是为每条数据新建 DOM;这正是「共享内部结构、传入外部状态」的享元思想。
概念解释
- 内部状态:DOM 元素结构(如一个
<div class="row">)。 - 外部状态:行数据、位置、样式。
- 复用:滚动时创建/回收 DOM 节点,不随数据量增长。
- 收益:万级数据列表仍只渲染几十个 DOM,避免 DOM 节点爆炸。
原理流程
- 固定可视区域高度,计算可视数据范围。
- 只渲染可视范围内的行 DOM。
- 滚动时回收离开可视区的 DOM,复用给新进入的行。
- 更新复用 DOM 的内容与位置(外部状态)。
代码或图示
// 简化的虚拟列表思路
function renderVirtualList(items: Item[], container: HTMLElement) {
const rowHeight = 40;
const visibleCount = Math.ceil(container.clientHeight / rowHeight);
const startIndex = Math.floor(container.scrollTop / rowHeight);
// 只渲染可视区域的行
for (let i = startIndex; i < startIndex + visibleCount; i++) {
const row = getOrCreateRow(i); // 复用 DOM
row.textContent = items[i].text; // 外部状态:内容
row.style.transform = `translateY(${i * rowHeight}px)`; // 外部状态:位置
}
}
享元:DOM 结构共享(内部状态),行数据/位置作为外部状态传入
对象池:复用 DOM 节点,离开可视区后归还
常见误区
- 把所有数据都渲染成 DOM:万级数据会导致 DOM 节点爆炸,页面卡顿。
- 复用 DOM 时不重置内容:上一行的残留内容会闪现。
- 把虚拟列表当「缓存」:它是 DOM 复用,不是数据缓存。
追问
- 虚拟列表和窗口化(windowing)是一回事吗?答:是,虚拟列表也叫窗口化渲染,核心是只渲染可视窗口。
- 变长行高怎么处理?答:需要动态测量每行高度,或用预估高度 + 滚动校正,复杂度上升。
01.3.2.7-012 Facade / Composite / Bridge / Flyweight 四者怎么组合使用?
一句话结论
四者解决不同问题,经常在同一系统中组合:Facade 对外提供入口,Composite 组织树形数据,Bridge 解耦多维度,Flyweight 优化大量细粒度对象;但不要为「组合而组合」。
概念解释
- Facade:对外简化入口,与其他模式正交。
- Composite:组织树结构,与 Flyweight 可组合(树节点共享样式享元)。
- Bridge:解耦维度,与 Strategy 常组合。
- Flyweight:优化内存,与 Composite 可组合(大量节点共享样式)。
原理流程
- 先识别系统中的真实问题:子系统复杂?树形?多维?大量细粒度对象?
- 按问题选对应模式,不要预设要「用齐四个」。
- 组合时每层只承担一个职责,包装层级可解释。
代码或图示
外部调用方 ──> Facade(订单门面)
├─ Composite(菜单树/组织树)
│ └─ Flyweight(共享字体/样式)
└─ Bridge(通知类型 × 发送渠道)
└─ Strategy(具体发送算法)
常见误区
- 把四个模式都塞进一个模块:每层包装只透传不做实事,导致代码难以理解。
- 模式之间互相嵌套超过三层:说明职责划分有问题。
- 为「设计模式齐全」而引入模式:没有真实问题就不要加。
追问
- 一个文档编辑器怎么组合?答:Composite 组织文档树,Flyweight 共享字符格式,Facade 提供「打开/保存/打印」入口,Bridge 处理导出格式(PDF/HTML)。
- 怎么判断组合是否过度?答:调用一个方法要追五六层透传才到业务,说明结构冗余。
01.3.2.7-013 「为组合而组合」的误用有哪些信号?
一句话结论
到处是 Adapter / Facade / Composite 但没有真实问题、每层包装只透传、新功能要改一堆模式类、新人读代码要追五层才到业务——这些都是过度设计的信号,应回归简单方案。
概念解释
- 信号一:没有真实接口差距却写 Adapter。
- 信号二:没有复杂子系统却写 Facade。
- 信号三:没有树形结构却引入 Composite。
- 信号四:两个维度都固定却上 Bridge。
- 信号五:对象数量不大却做 Flyweight。
原理流程
- 先问:这个模式解决的真实问题是什么?
- 如果回答是「为了符合设计模式」,删掉。
- 优先用简单方案(直接调用、函数、普通类),遇到真实问题再引入模式。
- 模式是重构工具,不是设计目标。
代码或图示
反例:
BusinessService → OrderFacade → OrderAdapter → OrderRepository
每层只透传,没有真实转换/简化/控制
正例:
BusinessService → OrderRepository(直接调用)
只有当子系统真的复杂、接口真的不匹配时,才引入对应模式
常见误区
- 认为「用了设计模式就是好架构」:模式是手段,不是目的。
- 在 CRUD 业务里强行套模式:CRUD 用普通三层结构足够。
- 过度设计后难以维护:新人读代码成本高,修改一个功能要改多个模式类。
追问
- 怎么判断「刚好够用」?答:没有模式时代码能清晰表达业务;只有出现真实的接口差距、复杂度、树形结构、多维变化时,才引入对应模式。
- 重构时什么时候引入模式?答:先写最简单的代码,当出现重复、扩展困难、层级混乱时,再用模式重构;不要预先设计。
跨语言差异对照
| 语言 | 惯用实现 | 差异要点 |
|---|---|---|
| Java | Facade 用普通类;Composite 用接口 + 容器列表;Bridge 用抽象类持有实现接口;Flyweight 用 ConcurrentHashMap 缓存 |
JDK 自带享元实例(Integer 缓存、String 常量池);Composite 最常用,Bridge 较少用 |
| Go | Facade 用包级函数;Composite 用 interface + 递归;Bridge 用接口组合;Flyweight 用 sync.Map 缓存 |
无继承,Bridge 只能靠接口组合;sync.Pool 是对象池不是享元 |
| Python | Facade 用类或模块;Composite 用鸭子类型;Flyweight 用字典缓存 | 动态语言,Composite 不需要显式接口;__slots__ 可优化内存 |
| PHP | Facade 在 Laravel 中是静态代理;Composite 用接口;Flyweight 用静态数组缓存 | Laravel Facade 容易被误认成外观模式;FPM 生命周期下享元缓存不跨请求 |
| C# | Facade 用 DI 注入的服务;Composite 用接口;Flyweight 用 ConcurrentDictionary;HttpClient 用 AddHttpClient 包装 |
依赖注入容器让 Facade 与适配器更自然;ArrayPool<T> 是对象池不是享元 |
| TypeScript | Facade 用类;Composite 用 interface + 递归;Flyweight 用于虚拟列表 DOM 复用 | 前端 Composite 体现在组件树;虚拟列表是享元思想的典型工程落地 |
| Rust | Facade 用结构体;Composite 用 trait + Vec<Box<dyn Trait>>;Flyweight 用 HashMap 缓存 |
编译期静态分发优先,dyn Trait 用于运行时多态;Rc/Arc 管理共享 |
跨语言差异
- Java 是唯一系统讨论「类适配器 vs 对象适配器」的语言,也是 JDK 自带享元实例最多的语言(
Integer缓存、String 常量池、Boolean缓存)。 - Go 没有继承,Bridge 只能靠接口组合;
sync.Pool是对象池而非享元,这是 Go 特有的并发原语与享元的区别。 - Rust 用 trait 与
dyn Trait实现 Composite 与 Bridge,编译期静态分发优先,运行时多态有成本。 - TypeScript 的 Composite 体现在前端组件树与虚拟列表,Flyweight 体现在 DOM 节点复用。
- PHP 的 Laravel Facade 是静态代理,不是 GoF 的外观模式,这是 PHP 特有的框架语义。
- Python 的动态类型让 Composite 不需要显式接口,鸭子类型即可。
- 所有语言的共同结论:模式是解决真实问题的工具,不是设计目标;过度设计比不设计更难维护。
待整理清单
- [ ] 补充 Kotlin
sealed class对 Composite 模式的类型安全优化 - [ ] 补充 Rust
dyn Trait与泛型在 Composite / Bridge 中的取舍 - [ ] 补充 React / Vue 虚拟列表的具体实现库(react-window、vue-virtual-scroller)对照
- [ ] 补充 Flutter
RenderObject树中的 Composite 与 Flyweight 思想